file_name
stringlengths 3
137
| prefix
stringlengths 0
918k
| suffix
stringlengths 0
962k
| middle
stringlengths 0
812k
|
|---|---|---|---|
product.py | from web3 import Web3
from brownie import Contract
from brownie.convert import to_bytes
from brownie.network import accounts
from brownie.network.account import Account
from brownie import (
Wei,
Contract,
# Registry,
# RegistryController,
License,
LicenseController,
Policy,
PolicyController,
QueryController,
ProductService,
OracleService,
ComponentOwnerService,
PolicyFlowDefault,
InstanceOperatorService,
TestOracle,
TestProduct,
)
from scripts.const import (
ORACLE_INPUT_FORMAT,
ORACLE_OUTPUT_FORMAT,
ORACLE_NAME,
PRODUCT_NAME,
)
from scripts.util import (
get_account,
encode_function_data,
# s2h,
s2b32,
deployGifModule,
deployGifService,
)
from scripts.instance import (
GifInstance,
)
class GifTestOracle(object):
def __init__(self, instance: GifInstance, oracleOwner: Account):
operatorService = instance.getInstanceOperatorService()
componentOwnerService = instance.getComponentOwnerService()
oracleService = instance.getOracleService()
# 1) add oracle provider role to owner
opRole = operatorService.oracleProviderRole()
operatorService.addRoleToAccount(oracleOwner, opRole)
# 2) oracle owner creates oracle
self.oracle = TestOracle.deploy(
s2b32(ORACLE_NAME),
instance.getRegistry(),
{'from': oracleOwner})
# 3) oracle owner proposes oracle to instance
componentOwnerService.propose(
self.oracle,
{'from': oracleOwner})
# 4) instance operator approves oracle
operatorService.approveOracle(
self.oracle.getId(),
{'from': instance.getOwner()})
def getOracleId(self) -> int:
return self.oracle.getId()
def getOracleContract(self) -> TestOracle:
return self.oracle
class GifTestProduct(object):
def __init__(self, instance: GifInstance, oracle: GifTestOracle, productOwner: Account):
self.policyController = instance.getPolicyController()
operatorService = instance.getInstanceOperatorService()
productService = instance.getProductService()
self.product = TestProduct.deploy(
productService,
s2b32(PRODUCT_NAME),
oracle.getOracleId(),
{'from': productOwner})
operatorService.approveProduct(
self.product.getId(),
{'from': instance.getOwner()})
def getProductId(self) -> int:
return self.product.getId()
def getProductContract(self) -> TestProduct:
return self.product
def | (self, policyId: str):
return self.policyController.getPolicy(policyId) | getPolicy |
fscore_test.py | # 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.
"""Tests for the fscore metric."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from absl.testing import parameterized
import numpy as np
from tensorflow_graphics.nn.metric import fscore
from tensorflow_graphics.nn.metric import precision
from tensorflow_graphics.nn.metric import recall
from tensorflow_graphics.util import test_case
def random_tensor(tensor_shape):
return np.random.uniform(low=0.0, high=1.0, size=tensor_shape)
def random_tensor_shape():
tensor_size = np.random.randint(5) + 1
return np.random.randint(1, 10, size=(tensor_size)).tolist()
def binary_precision_function(ground_truth, predictions):
return precision.evaluate(ground_truth, predictions, classes=[1])
def | (ground_truth, predictions):
return recall.evaluate(ground_truth, predictions, classes=[1])
class FscoreTest(test_case.TestCase):
@parameterized.parameters(
# Precision = 0.5, Recall = 0.25.
((0, 1, 1, 1, 1), (1, 1, 0, 0, 0), 2 * (0.5 * 0.25) / (0.5 + 0.25)),
# Precision = 1, Recall = 1.
((0, 0, 0, 1, 1, 1, 0, 1), (0, 0, 0, 1, 1, 1, 0, 1), 1),
# Precision = 0, Recall = 0.
((0, 1, 0, 0, 0, 0), (0, 0, 0, 0, 0, 0), 0))
def test_evaluate_preset(self, ground_truth, predictions, expected_fscore):
tensor_shape = random_tensor_shape()
ground_truth_labels = np.tile(ground_truth, tensor_shape + [1])
predicted_labels = np.tile(predictions, tensor_shape + [1])
expected = np.tile(expected_fscore, tensor_shape)
result = fscore.evaluate(
ground_truth_labels,
predicted_labels,
precision_function=binary_precision_function,
recall_function=binary_recall_function)
self.assertAllClose(expected, result)
@parameterized.parameters(
("Not all batch dimensions are broadcast-compatible.", (1, 5, 3), (4, 3)),
("Not all batch dimensions are broadcast-compatible.", (3, 4), (2, 4, 5)),
)
def test_evaluate_shape_exception_raised(self, error_msg, *shape):
"""Tests that the shape exception is raised."""
self.assert_exception_is_raised(fscore.evaluate, error_msg, shape)
@parameterized.parameters(
((1, 5, 3), (2, 5, 1)),
((None, 2, 6), (4, 2, None)),
((3, 1, 1, 2), (3, 5, 8, 2)),
)
def test_evaluate_shape_exception_not_raised(self, *shapes):
"""Tests that the shape exceptions are not raised."""
self.assert_exception_is_not_raised(fscore.evaluate, shapes)
if __name__ == "__main__":
test_case.main()
| binary_recall_function |
test.rs | // Copyright 2017 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// Check that `#[test]` works with extern-absolute-paths enabled.
// |
// compile-flags: --test
#![feature(extern_absolute_paths)]
#[test]
fn test() {
} | // Regression test for #47075. |
skiper-user-invoice.service.spec.ts | import { Test, TestingModule } from '@nestjs/testing';
import { SkiperUserInvoiceService } from './skiper-user-invoice.service';
describe('SkiperUserInvoiceService', () => {
let service: SkiperUserInvoiceService; | }).compile();
service = module.get<SkiperUserInvoiceService>(SkiperUserInvoiceService);
});
it('should be defined', () => {
expect(service).toBeDefined();
});
}); |
beforeEach(async () => {
const module: TestingModule = await Test.createTestingModule({
providers: [SkiperUserInvoiceService], |
furcode.js | function | (code) {
var cmd = code.split(' ').slice(0,1)
if (cmd == "owo") {
var owoText = code.replace("owo ","");
console.log(owoText)
}
if (cmd == "uwu") {
var uwuArgs = code.replace("uwu ","");
var arg1 = uwuArgs.split(" ").slice(0,1)
var arg2 = uwuArgs.split(" ").slice(1,2)
var lastuwuoutput = uwuArgs.split(" ").slice(2);
if (arg1.toString() == arg2.toString()) {
console.log(lastuwuoutput.toString())
}
}
if (cmd == "uwuEval") {
var uwuArgs = code.replace("uwuEval ","");
var arg1 = uwuArgs.split(" ").slice(0,1)
var arg2 = uwuArgs.split(" ").slice(1,2)
var lastuwuoutput = uwuArgs.split(" ").slice(2);
if (arg1.toString() == arg2.toString()) {
eval(lastuwuoutput.toString())
}
}
if (cmd == "fursuit") {
var uwuArgs = code.replace("fursuit ","");
var arg1 = uwuArgs.split(" ").slice(0,1)
var arg2 = uwuArgs.split(" ").slice(1,2)
var lastuwuoutput = uwuArgs.split(" ").slice(2);
if (arg1.toString() != arg2.toString()) {
console.log(lastuwuoutput.toString())
}
}
if (cmd == "fursuitEval") {
var uwuArgs = code.replace("fursuitEval ","");
var arg1 = uwuArgs.split(" ").slice(0,1)
var arg2 = uwuArgs.split(" ").slice(1,2)
var lastuwuoutput = uwuArgs.split(" ").slice(2);
if (arg1.toString() != arg2.toString()) {
eval(lastuwuoutput.toString())
}
}
}
| fureval |
speech.py | def rec():
r = sr.Recognizer()
with sr.Microphone() as source:
audio = r.listen(source)
try:
text = r.recognize_google(audio)
return(text)
except:
return("Sorry, couldn't recognize your voice. Please try again.") | import speech_recognition as sr
|
|
graphics_file.py | # -*- coding: utf-8 -*-
"""
Wrapper for Graphics Files
"""
import os
import six
from sage.misc.temporary_file import tmp_filename
from sage.structure.sage_object import SageObject
import sage.doctest
class Mime(object):
TEXT = u'text/plain'
HTML = u'text/html'
LATEX = u'text/latex'
JSON = u'application/json'
JAVASCRIPT = u'application/javascript'
PDF = u'application/pdf'
PNG = u'image/png'
JPG = u'image/jpeg'
SVG = u'image/svg+xml'
JMOL = u'application/jmol'
@classmethod
def validate(cls, value):
"""
Check that input is known mime type
INPUT:
- ``value`` -- string.
OUTPUT:
Unicode string of that mime type. A ``ValueError`` is raised
if input is incorrect / unknown.
EXAMPLES::
sage: from sage.structure.graphics_file import Mime
sage: Mime.validate('image/png')
u'image/png'
sage: Mime.validate('foo/bar')
Traceback (most recent call last):
...
ValueError: unknown mime type
"""
value = str(value).lower()
for k, v in cls.__dict__.items():
if isinstance(v, six.string_types) and v == value:
return v
raise ValueError('unknown mime type')
@classmethod
def extension(cls, mime_type):
"""
Return file extension.
INPUT:
- ``mime_type`` -- mime type as string.
OUTPUT:
String containing the usual file extension for that type of
file. Excludes ``os.extsep``.
EXAMPLES::
sage: from sage.structure.graphics_file import Mime
sage: Mime.extension('image/png')
'png'
"""
try:
return preferred_filename_ext[mime_type]
except KeyError:
raise ValueError('no known extension for mime type')
preferred_filename_ext = {
Mime.TEXT: 'txt',
Mime.HTML: 'html',
Mime.LATEX: 'tex',
Mime.JSON: 'json',
Mime.JAVASCRIPT: 'js',
Mime.PDF: 'pdf',
Mime.PNG: 'png',
Mime.JPG: 'jpg',
Mime.SVG: 'svg',
Mime.JMOL: 'spt.zip',
}
mimetype_for_ext = dict(
(value, key) for (key, value) in preferred_filename_ext.items()
)
class GraphicsFile(SageObject):
def __init__(self, filename, mime_type=None):
"""
Wrapper around a graphics file.
"""
self._filename = filename
if mime_type is None:
mime_type = self._guess_mime_type(filename)
self._mime = Mime.validate(mime_type)
def _guess_mime_type(self, filename):
"""
Guess mime type from file extension
"""
ext = os.path.splitext(filename)[1]
ext = ext.lstrip(os.path.extsep)
try:
return mimetype_for_ext[ext]
except KeyError:
raise ValueError('unknown file extension, please specify mime type')
def _repr_(self):
|
def filename(self):
return self._filename
def save_as(self, filename):
"""
Make the file available under a new filename.
INPUT:
- ``filename`` -- string. The new filename.
The newly-created ``filename`` will be a hardlink if
possible. If not, an independent copy is created.
"""
try:
os.link(self.filename(), filename)
except OSError:
import shutil
shutil.copy2(self.filename(), filename)
def mime(self):
return self._mime
def data(self):
"""
Return a byte string containing the image file.
"""
with open(self._filename, 'rb') as f:
return f.read()
def launch_viewer(self):
"""
Launch external viewer for the graphics file.
.. note::
Does not actually launch a new process when doctesting.
EXAMPLES::
sage: from sage.structure.graphics_file import GraphicsFile
sage: g = GraphicsFile('/tmp/test.png', 'image/png')
sage: g.launch_viewer()
"""
if sage.doctest.DOCTEST_MODE:
return
from sage.plot.plot import EMBEDDED_MODE
if EMBEDDED_MODE:
raise RuntimeError('should never launch viewer in embedded mode')
if self.mime() == Mime.JMOL:
return self._launch_jmol()
from sage.misc.viewer import viewer
command = viewer(preferred_filename_ext[self.mime()])
os.system('{0} {1} 2>/dev/null 1>/dev/null &'
.format(command, self.filename()))
# TODO: keep track of opened processes...
def _launch_jmol(self):
launch_script = tmp_filename(ext='.spt')
with open(launch_script, 'w') as f:
f.write('set defaultdirectory "{0}"\n'.format(self.filename()))
f.write('script SCRIPT\n')
from sage.env import SAGE_LOCAL
JMOL = os.path.join(SAGE_LOCAL, 'bin', 'jmol')
os.system('{0} {1} 2>/dev/null 1>/dev/null &'
.format(JMOL, launch_script))
def sagenb_embedding(self):
"""
Embed in SageNB
This amounts to just placing the file in the cell
directory. The notebook will then try to guess what we want
with it.
"""
from sage.misc.temporary_file import graphics_filename
ext = "." + Mime.extension(self.mime())
fn = graphics_filename(ext=ext)
self.save_as(fn)
# Client-server sagenb requires this to be world-readable.
# See Trac #17755.
os.chmod(fn, 0o644)
def graphics_from_save(save_function, preferred_mime_types,
allowed_mime_types=None, figsize=None, dpi=None):
"""
Helper function to construct a graphics file.
INPUT:
- ``save_function`` -- callable that can save graphics to a file
and accepts options like
:meth:`sage.plot.graphics.Graphics.save``.
- ``preferred_mime_types`` -- list of mime types. The graphics
output mime types in order of preference (i.e. best quality to
worst).
- ``allowed_mime_types`` -- set of mime types (as strings). The
graphics types that we can display. Output, if any, will be one
of those.
- ``figsize`` -- pair of integers (optional). The desired graphics
size in pixels. Suggested, but need not be respected by the
output.
- ``dpi`` -- integer (optional). The desired resolution in dots
per inch. Suggested, but need not be respected by the output.
OUTPUT:
Return an instance of
:class:`sage.structure.graphics_file.GraphicsFile` encapsulating a
suitable image file. Image is one of the
``preferred_mime_types``. If ``allowed_mime_types`` is specified,
the resulting file format matches one of these.
Alternatively, this function can return ``None`` to indicate that
textual representation is preferable and/or no graphics with the
desired mime type can be generated.
"""
# Figure out best mime type
mime = None
if allowed_mime_types is None:
mime = Mime.PNG
else:
# order of preference
for m in preferred_mime_types:
if m in allowed_mime_types:
mime = m
break
if mime is None:
return None # don't know how to generate suitable graphics
# Generate suitable temp file
filename = tmp_filename(ext=os.path.extsep + Mime.extension(mime))
# Call the save_function with the right arguments
kwds = {}
if figsize is not None:
kwds['figsize'] = figsize
if dpi is not None:
kwds['dpi'] = dpi
save_function(filename, **kwds)
return GraphicsFile(filename, mime)
| """
Return a string representation.
"""
return 'Graphics file {0}'.format(self.mime()) |
views.py | import logging
import csv
import re
from openpyxl import Workbook
from openpyxl.styles import Font
from tempfile import NamedTemporaryFile
from datetime import datetime
import operator
from django.contrib.auth.models import User
from django.conf import settings
from django.contrib import messages
from django.core.exceptions import ValidationError, PermissionDenied
from django.urls import reverse
from django.db.models import Q, Count
from django.http import HttpResponseRedirect, StreamingHttpResponse, HttpResponse, FileResponse, QueryDict
from django.shortcuts import render, get_object_or_404
from django.views.decorators.cache import cache_page
from django.utils import timezone
from time import strftime
from django.contrib.admin.utils import NestedObjects
from django.db import DEFAULT_DB_ALIAS
from dojo.engagement.services import close_engagement, reopen_engagement
from dojo.filters import EngagementFilter, EngagementDirectFilter, EngagementTestFilter
from dojo.forms import CheckForm, \
UploadThreatForm, RiskAcceptanceForm, NoteForm, DoneForm, \
EngForm, TestForm, ReplaceRiskAcceptanceProofForm, AddFindingsRiskAcceptanceForm, DeleteEngagementForm, ImportScanForm, \
CredMappingForm, JIRAEngagementForm, JIRAImportScanForm, TypedNoteForm, JIRAProjectForm, \
EditRiskAcceptanceForm
from dojo.models import Finding, Product, Engagement, Test, \
Check_List, Test_Import, Notes, \
Risk_Acceptance, Development_Environment, Endpoint, \
Cred_Mapping, Dojo_User, System_Settings, Note_Type, Product_API_Scan_Configuration
from dojo.tools.factory import get_scan_types_sorted
from dojo.utils import add_error_message_to_response, add_success_message_to_response, get_page_items, add_breadcrumb, handle_uploaded_threat, \
FileIterWrapper, get_cal_event, Product_Tab, is_scan_file_too_large, \
get_system_setting, redirect_to_return_url_or_else, get_return_url
from dojo.notifications.helper import create_notification
from dojo.finding.views import find_available_notetypes
from functools import reduce
from django.db.models.query import Prefetch, QuerySet
import dojo.jira_link.helper as jira_helper
import dojo.risk_acceptance.helper as ra_helper
from dojo.risk_acceptance.helper import prefetch_for_expiration
from dojo.finding.helper import NOT_ACCEPTED_FINDINGS_QUERY
from django.views.decorators.vary import vary_on_cookie
from dojo.authorization.authorization import user_has_permission_or_403
from dojo.authorization.roles_permissions import Permissions
from dojo.product.queries import get_authorized_products
from dojo.engagement.queries import get_authorized_engagements
from dojo.authorization.authorization_decorators import user_is_authorized
from dojo.importers.importer.importer import DojoDefaultImporter as Importer
import dojo.notifications.helper as notifications_helper
from dojo.endpoint.utils import save_endpoints_to_add
logger = logging.getLogger(__name__)
@cache_page(60 * 5) # cache for 5 minutes
@vary_on_cookie
def engagement_calendar(request):
if 'lead' not in request.GET or '0' in request.GET.getlist('lead'):
engagements = get_authorized_engagements(Permissions.Engagement_View)
else:
filters = []
leads = request.GET.getlist('lead', '')
if '-1' in request.GET.getlist('lead'):
leads.remove('-1')
filters.append(Q(lead__isnull=True))
filters.append(Q(lead__in=leads))
engagements = get_authorized_engagements(Permissions.Engagement_View).filter(reduce(operator.or_, filters))
engagements = engagements.select_related('lead')
engagements = engagements.prefetch_related('product')
add_breadcrumb(
title="Engagement Calendar", top_level=True, request=request)
return render(
request, 'dojo/calendar.html', {
'caltype': 'engagements',
'leads': request.GET.getlist('lead', ''),
'engagements': engagements,
'users': Dojo_User.objects.all()
})
def get_filtered_engagements(request, view):
if view not in ['all', 'active']:
raise ValidationError(f'View {view} is not allowed')
engagements = get_authorized_engagements(Permissions.Engagement_View).order_by('-target_start')
if view == 'active':
engagements = engagements.filter(active=True)
engagements = engagements.select_related('product', 'product__prod_type') \
.prefetch_related('lead', 'tags', 'product__tags')
if System_Settings.objects.get().enable_jira:
engagements = engagements.prefetch_related(
'jira_project__jira_instance',
'product__jira_project_set__jira_instance'
)
engagements = EngagementDirectFilter(request.GET, queryset=engagements)
return engagements
def get_test_counts(engagements):
# Get the test counts per engagement. As a separate query, this is much
# faster than annotating the above `engagements` query.
engagement_test_counts = {
test['engagement']: test['test_count']
for test in Test.objects.filter(
engagement__in=engagements
).values(
'engagement'
).annotate(
test_count=Count('engagement')
)
}
return engagement_test_counts
def engagements(request, view):
if not view:
view = 'active'
filtered_engagements = get_filtered_engagements(request, view)
engs = get_page_items(request, filtered_engagements.qs, 25)
product_name_words = sorted(get_authorized_products(Permissions.Product_View).values_list('name', flat=True))
engagement_name_words = sorted(get_authorized_engagements(Permissions.Engagement_View).values_list('name', flat=True).distinct())
add_breadcrumb(
title=f"{view.capitalize()} Engagements",
top_level=not len(request.GET),
request=request)
return render(
request, 'dojo/engagement.html', {
'engagements': engs,
'engagement_test_counts': get_test_counts(filtered_engagements.qs),
'filter_form': filtered_engagements.form,
'product_name_words': product_name_words,
'engagement_name_words': engagement_name_words,
'view': view.capitalize(),
})
def engagements_all(request):
products_with_engagements = get_authorized_products(Permissions.Engagement_View)
products_with_engagements = products_with_engagements.filter(~Q(engagement=None)).distinct()
# count using prefetch instead of just using 'engagement__set_test_test` to avoid loading all test in memory just to count them
filter_qs = products_with_engagements.prefetch_related(
Prefetch('engagement_set', queryset=Engagement.objects.all().annotate(test_count=Count('test__id')))
)
filter_qs = filter_qs.prefetch_related(
'engagement_set__tags',
'prod_type',
'engagement_set__lead',
'tags',
)
if System_Settings.objects.get().enable_jira:
filter_qs = filter_qs.prefetch_related(
'engagement_set__jira_project__jira_instance',
'jira_project_set__jira_instance'
)
filtered = EngagementFilter(
request.GET,
queryset=filter_qs
)
prods = get_page_items(request, filtered.qs, 25)
name_words = products_with_engagements.values_list('name', flat=True)
eng_words = get_authorized_engagements(Permissions.Engagement_View).values_list('name', flat=True).distinct()
add_breadcrumb(
title="All Engagements",
top_level=not len(request.GET),
request=request)
return render(
request, 'dojo/engagements_all.html', {
'products': prods,
'filter_form': filtered.form,
'name_words': sorted(set(name_words)),
'eng_words': sorted(set(eng_words)),
})
@user_is_authorized(Engagement, Permissions.Engagement_Edit, 'eid')
def edit_engagement(request, eid):
engagement = Engagement.objects.get(pk=eid)
is_ci_cd = engagement.engagement_type == "CI/CD"
jira_project_form = None
jira_epic_form = None
jira_project = None
jira_error = False
if request.method == 'POST':
form = EngForm(request.POST, instance=engagement, cicd=is_ci_cd, product=engagement.product, user=request.user)
jira_project = jira_helper.get_jira_project(engagement, use_inheritance=False)
if form.is_valid():
# first save engagement details
new_status = form.cleaned_data.get('status')
engagement = form.save(commit=False)
if (new_status == "Cancelled" or new_status == "Completed"):
engagement.active = False
create_notification(event='close_engagement',
title='Closure of %s' % engagement.name,
description='The engagement "%s" was closed' % (engagement.name),
engagement=engagement, url=reverse('engagement_all_findings', args=(engagement.id, ))),
else:
engagement.active = True
engagement.save()
form.save_m2m()
messages.add_message(
request,
messages.SUCCESS,
'Engagement updated successfully.',
extra_tags='alert-success')
success, jira_project_form = jira_helper.process_jira_project_form(request, instance=jira_project, target='engagement', engagement=engagement, product=engagement.product)
error = not success
success, jira_epic_form = jira_helper.process_jira_epic_form(request, engagement=engagement)
error = error or not success
if not error:
if '_Add Tests' in request.POST:
return HttpResponseRedirect(
reverse('add_tests', args=(engagement.id, )))
else:
return HttpResponseRedirect(
reverse('view_engagement', args=(engagement.id, )))
else:
logger.debug(form.errors)
else:
form = EngForm(initial={'product': engagement.product}, instance=engagement, cicd=is_ci_cd, product=engagement.product, user=request.user)
jira_epic_form = None
if get_system_setting('enable_jira'):
jira_project = jira_helper.get_jira_project(engagement, use_inheritance=False)
jira_project_form = JIRAProjectForm(instance=jira_project, target='engagement', product=engagement.product)
logger.debug('showing jira-epic-form')
jira_epic_form = JIRAEngagementForm(instance=engagement)
if is_ci_cd:
title = 'Edit CI/CD Engagement'
else:
title = 'Edit Interactive Engagement'
product_tab = Product_Tab(engagement.product.id, title=title, tab="engagements")
product_tab.setEngagement(engagement)
return render(request, 'dojo/new_eng.html', {
'product_tab': product_tab,
'title': title,
'form': form,
'edit': True,
'jira_epic_form': jira_epic_form,
'jira_project_form': jira_project_form,
'engagement': engagement,
})
@user_is_authorized(Engagement, Permissions.Engagement_Delete, 'eid')
def delete_engagement(request, eid):
engagement = get_object_or_404(Engagement, pk=eid)
product = engagement.product
form = DeleteEngagementForm(instance=engagement)
if request.method == 'POST':
if 'id' in request.POST and str(engagement.id) == request.POST['id']:
form = DeleteEngagementForm(request.POST, instance=engagement)
if form.is_valid():
product = engagement.product
engagement.delete()
messages.add_message(
request,
messages.SUCCESS,
'Engagement and relationships removed.',
extra_tags='alert-success')
create_notification(event='other',
title='Deletion of %s' % engagement.name,
product=product,
description='The engagement "%s" was deleted by %s' % (engagement.name, request.user),
url=request.build_absolute_uri(reverse('view_engagements', args=(product.id, ))),
recipients=[engagement.lead],
icon="exclamation-triangle")
return HttpResponseRedirect(reverse("view_engagements", args=(product.id, )))
collector = NestedObjects(using=DEFAULT_DB_ALIAS)
collector.collect([engagement])
rels = collector.nested()
product_tab = Product_Tab(product.id, title="Delete Engagement", tab="engagements")
product_tab.setEngagement(engagement)
return render(request, 'dojo/delete_engagement.html', {
'product_tab': product_tab,
'engagement': engagement,
'form': form,
'rels': rels,
})
@user_is_authorized(Engagement, Permissions.Engagement_View, 'eid')
def view_engagement(request, eid):
eng = get_object_or_404(Engagement, id=eid)
tests = eng.test_set.all().order_by('test_type__name', '-updated')
default_page_num = 10
tests_filter = EngagementTestFilter(request.GET, queryset=tests, engagement=eng)
paged_tests = get_page_items(request, tests_filter.qs, default_page_num)
# prefetch only after creating the filters to avoid https://code.djangoproject.com/ticket/23771 and https://code.djangoproject.com/ticket/25375
paged_tests.object_list = prefetch_for_view_tests(paged_tests.object_list)
prod = eng.product
risks_accepted = eng.risk_acceptance.all().select_related('owner').annotate(accepted_findings_count=Count('accepted_findings__id'))
preset_test_type = None
network = None
if eng.preset:
preset_test_type = eng.preset.test_type.all()
network = eng.preset.network_locations.all()
system_settings = System_Settings.objects.get()
jissue = jira_helper.get_jira_issue(eng)
jira_project = jira_helper.get_jira_project(eng)
try:
check = Check_List.objects.get(engagement=eng)
except:
check = None
pass
notes = eng.notes.all()
note_type_activation = Note_Type.objects.filter(is_active=True).count()
if note_type_activation:
available_note_types = find_available_notetypes(notes)
form = DoneForm()
files = eng.files.all()
if request.method == 'POST':
user_has_permission_or_403(request.user, eng, Permissions.Note_Add)
eng.progress = 'check_list'
eng.save()
if note_type_activation:
form = TypedNoteForm(request.POST, available_note_types=available_note_types)
else:
form = NoteForm(request.POST)
if form.is_valid():
new_note = form.save(commit=False)
new_note.author = request.user
new_note.date = timezone.now()
new_note.save()
eng.notes.add(new_note)
if note_type_activation:
form = TypedNoteForm(available_note_types=available_note_types)
else:
form = NoteForm()
url = request.build_absolute_uri(reverse("view_engagement", args=(eng.id,)))
title = "Engagement: %s on %s" % (eng.name, eng.product.name)
messages.add_message(request,
messages.SUCCESS,
'Note added successfully.',
extra_tags='alert-success')
else:
if note_type_activation:
form = TypedNoteForm(available_note_types=available_note_types)
else:
form = NoteForm()
creds = Cred_Mapping.objects.filter(
product=eng.product).select_related('cred_id').order_by('cred_id')
cred_eng = Cred_Mapping.objects.filter(
engagement=eng.id).select_related('cred_id').order_by('cred_id')
add_breadcrumb(parent=eng, top_level=False, request=request)
title = ""
if eng.engagement_type == "CI/CD":
title = " CI/CD"
product_tab = Product_Tab(prod.id, title="View" + title + " Engagement", tab="engagements")
product_tab.setEngagement(eng)
return render(
request, 'dojo/view_eng.html', {
'eng': eng, | 'filter': tests_filter,
'check': check,
'threat': eng.tmodel_path,
'form': form,
'notes': notes,
'files': files,
'risks_accepted': risks_accepted,
'jissue': jissue,
'jira_project': jira_project,
'creds': creds,
'cred_eng': cred_eng,
'network': network,
'preset_test_type': preset_test_type
})
def prefetch_for_view_tests(tests):
prefetched = tests
if isinstance(tests,
QuerySet): # old code can arrive here with prods being a list because the query was already executed
prefetched = prefetched.select_related('lead')
prefetched = prefetched.prefetch_related('tags', 'test_type', 'notes')
prefetched = prefetched.annotate(count_findings_test_all=Count('finding__id', distinct=True))
prefetched = prefetched.annotate(count_findings_test_active=Count('finding__id', filter=Q(finding__active=True), distinct=True))
prefetched = prefetched.annotate(count_findings_test_active_verified=Count('finding__id', filter=Q(finding__active=True) & Q(finding__verified=True), distinct=True))
prefetched = prefetched.annotate(count_findings_test_mitigated=Count('finding__id', filter=Q(finding__is_mitigated=True), distinct=True))
prefetched = prefetched.annotate(count_findings_test_dups=Count('finding__id', filter=Q(finding__duplicate=True), distinct=True))
prefetched = prefetched.annotate(total_reimport_count=Count('test_import__id', filter=Q(test_import__type=Test_Import.REIMPORT_TYPE), distinct=True))
else:
logger.warn('unable to prefetch because query was already executed')
return prefetched
@user_is_authorized(Engagement, Permissions.Test_Add, 'eid')
def add_tests(request, eid):
eng = Engagement.objects.get(id=eid)
cred_form = CredMappingForm()
cred_form.fields["cred_user"].queryset = Cred_Mapping.objects.filter(
engagement=eng).order_by('cred_id')
if request.method == 'POST':
form = TestForm(request.POST, engagement=eng)
cred_form = CredMappingForm(request.POST)
cred_form.fields["cred_user"].queryset = Cred_Mapping.objects.filter(
engagement=eng).order_by('cred_id')
if form.is_valid():
new_test = form.save(commit=False)
# set default scan_type as it's used in reimport
new_test.scan_type = new_test.test_type.name
new_test.engagement = eng
try:
new_test.lead = User.objects.get(id=form['lead'].value())
except:
new_test.lead = None
pass
# Set status to in progress if a test is added
if eng.status != "In Progress" and eng.active is True:
eng.status = "In Progress"
eng.save()
new_test.save()
# Save the credential to the test
if cred_form.is_valid():
if cred_form.cleaned_data['cred_user']:
# Select the credential mapping object from the selected list and only allow if the credential is associated with the product
cred_user = Cred_Mapping.objects.filter(
pk=cred_form.cleaned_data['cred_user'].id,
engagement=eid).first()
new_f = cred_form.save(commit=False)
new_f.test = new_test
new_f.cred_id = cred_user.cred_id
new_f.save()
messages.add_message(
request,
messages.SUCCESS,
'Test added successfully.',
extra_tags='alert-success')
notifications_helper.notify_test_created(new_test)
if '_Add Another Test' in request.POST:
return HttpResponseRedirect(
reverse('add_tests', args=(eng.id, )))
elif '_Add Findings' in request.POST:
return HttpResponseRedirect(
reverse('add_findings', args=(new_test.id, )))
elif '_Finished' in request.POST:
return HttpResponseRedirect(
reverse('view_engagement', args=(eng.id, )))
else:
form = TestForm(engagement=eng)
form.initial['target_start'] = eng.target_start
form.initial['target_end'] = eng.target_end
form.initial['lead'] = request.user
add_breadcrumb(
parent=eng, title="Add Tests", top_level=False, request=request)
product_tab = Product_Tab(eng.product.id, title="Add Tests", tab="engagements")
product_tab.setEngagement(eng)
return render(request, 'dojo/add_tests.html', {
'product_tab': product_tab,
'form': form,
'cred_form': cred_form,
'eid': eid,
'eng': eng
})
# Cant use the easy decorator because of the potential for either eid/pid being used
def import_scan_results(request, eid=None, pid=None):
engagement = None
form = ImportScanForm()
cred_form = CredMappingForm()
finding_count = 0
jform = None
user = request.user
if eid:
engagement = get_object_or_404(Engagement, id=eid)
engagement_or_product = engagement
cred_form.fields["cred_user"].queryset = Cred_Mapping.objects.filter(engagement=engagement).order_by('cred_id')
elif pid:
product = get_object_or_404(Product, id=pid)
engagement_or_product = product
elif not user.is_staff:
raise PermissionDenied
user_has_permission_or_403(user, engagement_or_product, Permissions.Import_Scan_Result)
push_all_jira_issues = jira_helper.is_push_all_issues(engagement_or_product)
if request.method == "POST":
form = ImportScanForm(request.POST, request.FILES)
cred_form = CredMappingForm(request.POST)
cred_form.fields["cred_user"].queryset = Cred_Mapping.objects.filter(
engagement=engagement).order_by('cred_id')
if jira_helper.get_jira_project(engagement_or_product):
jform = JIRAImportScanForm(request.POST, push_all=push_all_jira_issues, prefix='jiraform')
logger.debug('jform valid: %s', jform.is_valid())
logger.debug('jform errors: %s', jform.errors)
if form.is_valid() and (jform is None or jform.is_valid()):
scan = request.FILES.get('file', None)
scan_date = form.cleaned_data['scan_date']
minimum_severity = form.cleaned_data['minimum_severity']
active = form.cleaned_data['active']
verified = form.cleaned_data['verified']
scan_type = request.POST['scan_type']
tags = form.cleaned_data['tags']
version = form.cleaned_data['version']
branch_tag = form.cleaned_data.get('branch_tag', None)
build_id = form.cleaned_data.get('build_id', None)
commit_hash = form.cleaned_data.get('commit_hash', None)
api_scan_configuration = form.cleaned_data.get('api_scan_configuration', None)
service = form.cleaned_data.get('service', None)
close_old_findings = form.cleaned_data.get('close_old_findings', None)
# Will save in the provided environment or in the `Development` one if absent
environment_id = request.POST.get('environment', 'Development')
environment = Development_Environment.objects.get(id=environment_id)
group_by = form.cleaned_data.get('group_by', None)
# TODO move to form validation?
if scan and is_scan_file_too_large(scan):
messages.add_message(request,
messages.ERROR,
"Report file is too large. Maximum supported size is {} MB".format(settings.SCAN_FILE_MAX_SIZE),
extra_tags='alert-danger')
return HttpResponseRedirect(reverse('import_scan_results', args=(engagement,)))
# Allows for a test to be imported with an engagement created on the fly
if engagement is None:
engagement = Engagement()
engagement.name = "AdHoc Import - " + strftime("%a, %d %b %Y %X", timezone.now().timetuple())
engagement.threat_model = False
engagement.api_test = False
engagement.pen_test = False
engagement.check_list = False
engagement.target_start = timezone.now().date()
engagement.target_end = timezone.now().date()
engagement.product = product
engagement.active = True
engagement.status = 'In Progress'
engagement.version = version
engagement.branch_tag = branch_tag
engagement.build_id = build_id
engagement.commit_hash = commit_hash
engagement.save()
# can't use helper as when push_all_jira_issues is True, the checkbox gets disabled and is always false
# push_to_jira = jira_helper.is_push_to_jira(new_finding, jform.cleaned_data.get('push_to_jira'))
push_to_jira = push_all_jira_issues or (jform and jform.cleaned_data.get('push_to_jira'))
error = False
# Save newly added endpoints
added_endpoints = save_endpoints_to_add(form.endpoints_to_add_list, engagement.product)
try:
importer = Importer()
test, finding_count, closed_finding_count = importer.import_scan(scan, scan_type, engagement, user, environment, active=active, verified=verified, tags=tags,
minimum_severity=minimum_severity, endpoints_to_add=list(form.cleaned_data['endpoints']) + added_endpoints, scan_date=scan_date,
version=version, branch_tag=branch_tag, build_id=build_id, commit_hash=commit_hash, push_to_jira=push_to_jira,
close_old_findings=close_old_findings, group_by=group_by, api_scan_configuration=api_scan_configuration, service=service)
message = f'{scan_type} processed a total of {finding_count} findings'
if close_old_findings:
message = message + ' and closed %d findings' % (closed_finding_count)
message = message + "."
add_success_message_to_response(message)
except Exception as e:
logger.exception(e)
add_error_message_to_response('An exception error occurred during the report import:%s' % str(e))
error = True
# Save the credential to the test
if cred_form.is_valid():
if cred_form.cleaned_data['cred_user']:
# Select the credential mapping object from the selected list and only allow if the credential is associated with the product
cred_user = Cred_Mapping.objects.filter(
pk=cred_form.cleaned_data['cred_user'].id,
engagement=eid).first()
new_f = cred_form.save(commit=False)
new_f.test = test
new_f.cred_id = cred_user.cred_id
new_f.save()
if not error:
return HttpResponseRedirect(
reverse('product_open_findings', args=(pid, )))
prod_id = None
custom_breadcrumb = None
title = "Import Scan Results"
if engagement:
prod_id = engagement.product.id
product_tab = Product_Tab(prod_id, title=title, tab="engagements")
product_tab.setEngagement(engagement)
else:
prod_id = pid
custom_breadcrumb = {"", ""}
product_tab = Product_Tab(prod_id, title=title, tab="findings")
if jira_helper.get_jira_project(engagement_or_product):
jform = JIRAImportScanForm(push_all=push_all_jira_issues, prefix='jiraform')
form.fields['endpoints'].queryset = Endpoint.objects.filter(product__id=product_tab.product.id)
form.fields['api_scan_configuration'].queryset = Product_API_Scan_Configuration.objects.filter(product__id=product_tab.product.id)
return render(request,
'dojo/import_scan_results.html',
{'form': form,
'product_tab': product_tab,
'engagement_or_product': engagement_or_product,
'custom_breadcrumb': custom_breadcrumb,
'title': title,
'cred_form': cred_form,
'jform': jform,
'scan_types': get_scan_types_sorted(),
})
@user_is_authorized(Engagement, Permissions.Engagement_Edit, 'eid')
def close_eng(request, eid):
eng = Engagement.objects.get(id=eid)
close_engagement(eng)
messages.add_message(
request,
messages.SUCCESS,
'Engagement closed successfully.',
extra_tags='alert-success')
create_notification(event='close_engagement',
title='Closure of %s' % eng.name,
description='The engagement "%s" was closed' % (eng.name),
engagement=eng, url=reverse('engagement_all_findings', args=(eng.id, ))),
return HttpResponseRedirect(reverse("view_engagements", args=(eng.product.id, )))
@user_is_authorized(Engagement, Permissions.Engagement_Edit, 'eid')
def reopen_eng(request, eid):
eng = Engagement.objects.get(id=eid)
reopen_engagement(eng)
messages.add_message(
request,
messages.SUCCESS,
'Engagement reopened successfully.',
extra_tags='alert-success')
create_notification(event='other',
title='Reopening of %s' % eng.name,
engagement=eng,
description='The engagement "%s" was reopened' % (eng.name),
url=reverse('view_engagement', args=(eng.id, ))),
return HttpResponseRedirect(reverse("view_engagements", args=(eng.product.id, )))
"""
Greg:
status: in production
method to complete checklists from the engagement view
"""
@user_is_authorized(Engagement, Permissions.Engagement_Edit, 'eid')
def complete_checklist(request, eid):
eng = get_object_or_404(Engagement, id=eid)
try:
checklist = Check_List.objects.get(engagement=eng)
except:
checklist = None
pass
add_breadcrumb(
parent=eng,
title="Complete checklist",
top_level=False,
request=request)
if request.method == 'POST':
tests = Test.objects.filter(engagement=eng)
findings = Finding.objects.filter(test__in=tests).all()
form = CheckForm(request.POST, instance=checklist, findings=findings)
if form.is_valid():
cl = form.save(commit=False)
try:
check_l = Check_List.objects.get(engagement=eng)
cl.id = check_l.id
cl.save()
form.save_m2m()
except:
cl.engagement = eng
cl.save()
form.save_m2m()
pass
messages.add_message(
request,
messages.SUCCESS,
'Checklist saved.',
extra_tags='alert-success')
return HttpResponseRedirect(
reverse('view_engagement', args=(eid, )))
else:
tests = Test.objects.filter(engagement=eng)
findings = Finding.objects.filter(test__in=tests).all()
form = CheckForm(instance=checklist, findings=findings)
product_tab = Product_Tab(eng.product.id, title="Checklist", tab="engagements")
product_tab.setEngagement(eng)
return render(request, 'dojo/checklist.html', {
'form': form,
'product_tab': product_tab,
'eid': eng.id,
'findings': findings,
})
@user_is_authorized(Engagement, Permissions.Risk_Acceptance, 'eid')
def add_risk_acceptance(request, eid, fid=None):
eng = get_object_or_404(Engagement, id=eid)
finding = None
if fid:
finding = get_object_or_404(Finding, id=fid)
if not eng.product.enable_full_risk_acceptance:
raise PermissionDenied()
if request.method == 'POST':
form = RiskAcceptanceForm(request.POST, request.FILES)
if form.is_valid():
# first capture notes param as it cannot be saved directly as m2m
notes = None
if form.cleaned_data['notes']:
notes = Notes(
entry=form.cleaned_data['notes'],
author=request.user,
date=timezone.now())
notes.save()
del form.cleaned_data['notes']
try:
# we sometimes see a weird exception here, but are unable to reproduce.
# we add some logging in case it happens
risk_acceptance = form.save()
except Exception as e:
logger.debug(vars(request.POST))
logger.error(vars(form))
logger.exception(e)
raise
# attach note to risk acceptance object now in database
if notes:
risk_acceptance.notes.add(notes)
eng.risk_acceptance.add(risk_acceptance)
findings = form.cleaned_data['accepted_findings']
risk_acceptance = ra_helper.add_findings_to_risk_acceptance(risk_acceptance, findings)
messages.add_message(
request,
messages.SUCCESS,
'Risk acceptance saved.',
extra_tags='alert-success')
return redirect_to_return_url_or_else(request, reverse('view_engagement', args=(eid, )))
else:
risk_acceptance_title_suggestion = 'Accept: %s' % finding
form = RiskAcceptanceForm(initial={'owner': request.user, 'name': risk_acceptance_title_suggestion})
finding_choices = Finding.objects.filter(duplicate=False, test__engagement=eng).filter(NOT_ACCEPTED_FINDINGS_QUERY).order_by('title')
form.fields['accepted_findings'].queryset = finding_choices
if fid:
form.fields['accepted_findings'].initial = {fid}
product_tab = Product_Tab(eng.product.id, title="Risk Acceptance", tab="engagements")
product_tab.setEngagement(eng)
return render(request, 'dojo/add_risk_acceptance.html', {
'eng': eng,
'product_tab': product_tab,
'form': form
})
@user_is_authorized(Engagement, Permissions.Engagement_View, 'eid')
def view_risk_acceptance(request, eid, raid):
return view_edit_risk_acceptance(request, eid=eid, raid=raid, edit_mode=False)
@user_is_authorized(Engagement, Permissions.Risk_Acceptance, 'eid')
def edit_risk_acceptance(request, eid, raid):
return view_edit_risk_acceptance(request, eid=eid, raid=raid, edit_mode=True)
# will only be called by view_risk_acceptance and edit_risk_acceptance
def view_edit_risk_acceptance(request, eid, raid, edit_mode=False):
risk_acceptance = get_object_or_404(Risk_Acceptance, pk=raid)
eng = get_object_or_404(Engagement, pk=eid)
if edit_mode and not eng.product.enable_full_risk_acceptance:
raise PermissionDenied()
risk_acceptance_form = None
errors = False
if request.method == 'POST':
# deleting before instantiating the form otherwise django messes up and we end up with an empty path value
if len(request.FILES) > 0:
logger.debug('new proof uploaded')
risk_acceptance.path.delete()
if 'decision' in request.POST:
old_expiration_date = risk_acceptance.expiration_date
risk_acceptance_form = EditRiskAcceptanceForm(request.POST, request.FILES, instance=risk_acceptance)
errors = errors or not risk_acceptance_form.is_valid()
if not errors:
logger.debug('path: %s', risk_acceptance_form.cleaned_data['path'])
risk_acceptance_form.save()
if risk_acceptance.expiration_date != old_expiration_date:
# risk acceptance was changed, check if risk acceptance needs to be reinstated and findings made accepted again
ra_helper.reinstate(risk_acceptance, old_expiration_date)
messages.add_message(
request,
messages.SUCCESS,
'Risk Acceptance saved successfully.',
extra_tags='alert-success')
if 'entry' in request.POST:
note_form = NoteForm(request.POST)
errors = errors or not note_form.is_valid()
if not errors:
new_note = note_form.save(commit=False)
new_note.author = request.user
new_note.date = timezone.now()
new_note.save()
risk_acceptance.notes.add(new_note)
messages.add_message(
request,
messages.SUCCESS,
'Note added successfully.',
extra_tags='alert-success')
if 'delete_note' in request.POST:
note = get_object_or_404(Notes, pk=request.POST['delete_note_id'])
if note.author.username == request.user.username:
risk_acceptance.notes.remove(note)
note.delete()
messages.add_message(
request,
messages.SUCCESS,
'Note deleted successfully.',
extra_tags='alert-success')
else:
messages.add_message(
request,
messages.ERROR,
"Since you are not the note's author, it was not deleted.",
extra_tags='alert-danger')
if 'remove_finding' in request.POST:
finding = get_object_or_404(
Finding, pk=request.POST['remove_finding_id'])
ra_helper.remove_finding_from_risk_acceptance(risk_acceptance, finding)
messages.add_message(
request,
messages.SUCCESS,
'Finding removed successfully from risk acceptance.',
extra_tags='alert-success')
if 'replace_file' in request.POST:
replace_form = ReplaceRiskAcceptanceProofForm(
request.POST, request.FILES, instance=risk_acceptance)
errors = errors or not replace_form.is_valid()
if not errors:
replace_form.save()
messages.add_message(
request,
messages.SUCCESS,
'New Proof uploaded successfully.',
extra_tags='alert-success')
else:
logger.error(replace_form.errors)
if 'add_findings' in request.POST:
add_findings_form = AddFindingsRiskAcceptanceForm(
request.POST, request.FILES, instance=risk_acceptance)
errors = errors or not add_findings_form.is_valid()
if not errors:
findings = add_findings_form.cleaned_data['accepted_findings']
ra_helper.add_findings_to_risk_acceptance(risk_acceptance, findings)
messages.add_message(
request,
messages.SUCCESS,
'Finding%s added successfully.' % ('s' if len(findings) > 1
else ''),
extra_tags='alert-success')
if not errors:
logger.debug('redirecting to return_url')
return redirect_to_return_url_or_else(request, reverse("view_risk_acceptance", args=(eid, raid)))
else:
logger.error('errors found')
else:
if edit_mode:
risk_acceptance_form = EditRiskAcceptanceForm(instance=risk_acceptance)
note_form = NoteForm()
replace_form = ReplaceRiskAcceptanceProofForm(instance=risk_acceptance)
add_findings_form = AddFindingsRiskAcceptanceForm(instance=risk_acceptance)
accepted_findings = risk_acceptance.accepted_findings.order_by('numerical_severity')
fpage = get_page_items(request, accepted_findings, 15)
unaccepted_findings = Finding.objects.filter(test__in=eng.test_set.all()) \
.exclude(id__in=accepted_findings).order_by("title")
add_fpage = get_page_items(request, unaccepted_findings, 10, 'apage')
# on this page we need to add unaccepted findings as possible findings to add as accepted
add_findings_form.fields[
"accepted_findings"].queryset = add_fpage.object_list
product_tab = Product_Tab(eng.product.id, title="Risk Acceptance", tab="engagements")
product_tab.setEngagement(eng)
return render(
request, 'dojo/view_risk_acceptance.html', {
'risk_acceptance': risk_acceptance,
'engagement': eng,
'product_tab': product_tab,
'accepted_findings': fpage,
'notes': risk_acceptance.notes.all(),
'eng': eng,
'edit_mode': edit_mode,
'risk_acceptance_form': risk_acceptance_form,
'note_form': note_form,
'replace_form': replace_form,
'add_findings_form': add_findings_form,
# 'show_add_findings_form': len(unaccepted_findings),
'request': request,
'add_findings': add_fpage,
'return_url': get_return_url(request),
})
@user_is_authorized(Engagement, Permissions.Risk_Acceptance, 'eid')
def expire_risk_acceptance(request, eid, raid):
risk_acceptance = get_object_or_404(prefetch_for_expiration(Risk_Acceptance.objects.all()), pk=raid)
eng = get_object_or_404(Engagement, pk=eid)
ra_helper.expire_now(risk_acceptance)
return redirect_to_return_url_or_else(request, reverse("view_risk_acceptance", args=(eid, raid)))
@user_is_authorized(Engagement, Permissions.Risk_Acceptance, 'eid')
def reinstate_risk_acceptance(request, eid, raid):
risk_acceptance = get_object_or_404(prefetch_for_expiration(Risk_Acceptance.objects.all()), pk=raid)
eng = get_object_or_404(Engagement, pk=eid)
if not eng.product.enable_full_risk_acceptance:
raise PermissionDenied()
ra_helper.reinstate(risk_acceptance, risk_acceptance.expiration_date)
return redirect_to_return_url_or_else(request, reverse("view_risk_acceptance", args=(eid, raid)))
@user_is_authorized(Engagement, Permissions.Risk_Acceptance, 'eid')
def delete_risk_acceptance(request, eid, raid):
risk_acceptance = get_object_or_404(Risk_Acceptance, pk=raid)
eng = get_object_or_404(Engagement, pk=eid)
ra_helper.delete(eng, risk_acceptance)
messages.add_message(
request,
messages.SUCCESS,
'Risk acceptance deleted successfully.',
extra_tags='alert-success')
return HttpResponseRedirect(reverse("view_engagement", args=(eng.id, )))
@user_is_authorized(Engagement, Permissions.Engagement_View, 'eid')
def download_risk_acceptance(request, eid, raid):
import mimetypes
mimetypes.init()
risk_acceptance = get_object_or_404(Risk_Acceptance, pk=raid)
response = StreamingHttpResponse(
FileIterWrapper(
open(settings.MEDIA_ROOT + "/" + risk_acceptance.path.name, mode='rb')))
response['Content-Disposition'] = 'attachment; filename="%s"' \
% risk_acceptance.filename()
mimetype, encoding = mimetypes.guess_type(risk_acceptance.path.name)
response['Content-Type'] = mimetype
return response
"""
Greg
status: in production
Upload a threat model at the engagement level. Threat models are stored
under media folder
"""
@user_is_authorized(Engagement, Permissions.Engagement_Edit, 'eid')
def upload_threatmodel(request, eid):
eng = Engagement.objects.get(id=eid)
add_breadcrumb(
parent=eng,
title="Upload a threat model",
top_level=False,
request=request)
if request.method == 'POST':
form = UploadThreatForm(request.POST, request.FILES)
if form.is_valid():
handle_uploaded_threat(request.FILES['file'], eng)
eng.progress = 'other'
eng.threat_model = True
eng.save()
messages.add_message(
request,
messages.SUCCESS,
'Threat model saved.',
extra_tags='alert-success')
return HttpResponseRedirect(
reverse('view_engagement', args=(eid, )))
else:
form = UploadThreatForm()
product_tab = Product_Tab(eng.product.id, title="Upload Threat Model", tab="engagements")
return render(request, 'dojo/up_threat.html', {
'form': form,
'product_tab': product_tab,
'eng': eng,
})
@user_is_authorized(Engagement, Permissions.Engagement_View, 'eid')
def view_threatmodel(request, eid):
eng = get_object_or_404(Engagement, pk=eid)
response = FileResponse(open(eng.tmodel_path, 'rb'))
return response
@user_is_authorized(Engagement, Permissions.Engagement_View, 'eid')
def engagement_ics(request, eid):
eng = get_object_or_404(Engagement, id=eid)
start_date = datetime.combine(eng.target_start, datetime.min.time())
end_date = datetime.combine(eng.target_end, datetime.max.time())
uid = "dojo_eng_%d_%d" % (eng.id, eng.product.id)
cal = get_cal_event(
start_date, end_date,
"Engagement: %s (%s)" % (eng.name, eng.product.name),
"Set aside for engagement %s, on product %s. Additional detail can be found at %s"
% (eng.name, eng.product.name,
request.build_absolute_uri(
(reverse("view_engagement", args=(eng.id, ))))), uid)
output = cal.serialize()
response = HttpResponse(content=output)
response['Content-Type'] = 'text/calendar'
response['Content-Disposition'] = 'attachment; filename=%s.ics' % eng.name
return response
def get_list_index(list, index):
try:
element = list[index]
except Exception as e:
element = None
return element
def get_engagements(request):
url = request.META.get('QUERY_STRING')
if not url:
raise ValidationError('Please use the export button when exporting engagements')
else:
if url.startswith('url='):
url = url[4:]
path_items = list(filter(None, re.split('/|\?', url))) # noqa W605
if not path_items or path_items[0] != 'engagement':
raise ValidationError('URL is not an engagement view')
view = query = None
if get_list_index(path_items, 1) in ['active', 'all']:
view = get_list_index(path_items, 1)
query = get_list_index(path_items, 2)
else:
view = 'active'
query = get_list_index(path_items, 1)
request.GET = QueryDict(query)
engagements = get_filtered_engagements(request, view).qs
test_counts = get_test_counts(engagements)
return engagements, test_counts
def get_excludes():
return ['is_ci_cd', 'jira_issue', 'jira_project', 'objects', 'unaccepted_open_findings']
def get_foreign_keys():
return ['build_server', 'lead', 'orchestration_engine', 'preset', 'product',
'report_type', 'requester', 'source_code_management_server']
def csv_export(request):
engagements, test_counts = get_engagements(request)
response = HttpResponse(content_type='text/csv')
response['Content-Disposition'] = 'attachment; filename=engagements.csv'
writer = csv.writer(response)
first_row = True
for engagement in engagements:
if first_row:
fields = []
for key in dir(engagement):
if key not in get_excludes() and not callable(getattr(engagement, key)) and not key.startswith('_'):
fields.append(key)
fields.append('tests')
writer.writerow(fields)
first_row = False
if not first_row:
fields = []
for key in dir(engagement):
if key not in get_excludes() and not callable(getattr(engagement, key)) and not key.startswith('_'):
value = engagement.__dict__.get(key)
if key in get_foreign_keys() and getattr(engagement, key):
value = str(getattr(engagement, key))
if value and isinstance(value, str):
value = value.replace('\n', ' NEWLINE ').replace('\r', '')
fields.append(value)
fields.append(test_counts.get(engagement.id, 0))
writer.writerow(fields)
return response
def excel_export(request):
engagements, test_counts = get_engagements(request)
workbook = Workbook()
workbook.iso_dates = True
worksheet = workbook.active
worksheet.title = 'Engagements'
font_bold = Font(bold=True)
row_num = 1
for engagement in engagements:
if row_num == 1:
col_num = 1
for key in dir(engagement):
if key not in get_excludes() and not callable(getattr(engagement, key)) and not key.startswith('_'):
cell = worksheet.cell(row=row_num, column=col_num, value=key)
cell.font = font_bold
col_num += 1
cell = worksheet.cell(row=row_num, column=col_num, value='tests')
cell.font = font_bold
row_num = 2
if row_num > 1:
col_num = 1
for key in dir(engagement):
if key not in get_excludes() and not callable(getattr(engagement, key)) and not key.startswith('_'):
value = engagement.__dict__.get(key)
if key in get_foreign_keys() and getattr(engagement, key):
value = str(getattr(engagement, key))
if value and isinstance(value, datetime):
value = value.replace(tzinfo=None)
worksheet.cell(row=row_num, column=col_num, value=value)
col_num += 1
worksheet.cell(row=row_num, column=col_num, value=test_counts.get(engagement.id, 0))
row_num += 1
with NamedTemporaryFile() as tmp:
workbook.save(tmp.name)
tmp.seek(0)
stream = tmp.read()
response = HttpResponse(
content=stream,
content_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
)
response['Content-Disposition'] = 'attachment; filename=engagements.xlsx'
return response | 'product_tab': product_tab,
'system_settings': system_settings,
'tests': paged_tests, |
hash.rs | /*!
# `CheckSame` - Hasher
*/
use super::CheckSameError;
use blake3::{
Hash,
Hasher,
};
use rayon::{
iter::{
IntoParallelIterator,
ParallelIterator,
},
slice::ParallelSliceMut,
};
use std::{
fmt,
fs::File,
os::unix::ffi::OsStrExt,
path::{
Path,
PathBuf,
},
};
/// # Reset First.
///
/// When set, all existing `CheckSame` cache files will be deleted. When
/// combined with [`FLAG_CACHE`], the result will always look "new".
pub(super) const FLAG_RESET: u8 = 0b0001;
/// # Cache Mode.
///
/// Print the change status rather than the hash. This is either -1, 1, or 0,
/// indicating no previous cache, something changed, or all's the same,
/// respectively.
pub(super) const FLAG_CACHE: u8 = 0b0010;
#[derive(Debug, Clone, Copy)]
/// # Status.
///
/// This is a list of cache statuses, used internally by [`CheckSame`].
enum CheckedSame {
/// # We aren't worried about caching.
Noop,
/// # No change.
Same,
/// # The cache changed.
Changed,
/// # No previous cache.
New,
}
#[derive(Debug)]
/// # `CheckSame`.
///
/// This struct holds the hash data for a set of paths. The only public-facing
/// method is [`CheckSame::new`], which does all the work.
///
/// The resulting object can be sent to any formatted writer accepting
/// `Display`. If [`FLAG_CACHE`] is set, this will print the status; otherwise
/// the hash is printed.
pub(super) struct | {
/// # Key Hash.
///
/// This hash is used to calculate a unique file path for the set. It is
/// calculated by hashing all of the file paths in order.
key: Hash,
/// # Hash.
///
/// This is the cumulative `Blake3` hash of all included files. It is
/// calculated by hashing each file individually, in order, then hashing
/// those hashes.
///
/// This avoids the overhead of having to keep all file contents in memory
/// long enough to come up with a single hash.
hash: Hash,
/// # Cache status.
///
/// This holds the cache status of the set. When not in cache mode, this is
/// always [`CheckedSame::Noop`] and serves no purpose.
status: CheckedSame,
}
impl fmt::Display for CheckSame {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self.status {
CheckedSame::Noop => f.write_str(&self.hash.to_hex()),
CheckedSame::Same => f.write_str("0"),
CheckedSame::Changed => f.write_str("1"),
CheckedSame::New => f.write_str("-1"),
}
}
}
impl From<Vec<PathBuf>> for CheckSame {
fn from(paths: Vec<PathBuf>) -> Self {
// First pass, hash all the files, consuming the original vector.
let mut raw: Vec<(PathBuf, Option<[u8; 32]>)> = paths.into_par_iter()
.map(|p| {
let hash = hash_file(&p);
(p, hash)
})
.collect();
// Resort by path for consistency.
raw.par_sort_by(|(a, _), (b, _)| a.cmp(b));
// Second pass, build the cumulative file/key hashes.
let mut all_h = Hasher::new();
let mut key_h = Hasher::new();
for (p, h) in raw {
key_h.update(p.as_os_str().as_bytes());
if let Some(hash) = h.as_ref() {
all_h.update(hash);
}
}
// We're done!
Self {
key: key_h.finalize(),
hash: all_h.finalize(),
status: CheckedSame::Noop,
}
}
}
impl CheckSame {
/// # New Instance.
///
/// This generates a new instance from a set of paths and flags. This is
/// the only public method for the struct; after running, make use of its
/// `Display` implementation to print the results.
///
/// If [`FLAG_RESET`] is passed, all existing cache references will be
/// cleared.
///
/// If [`FLAG_CACHE`] is passed, the resulting hash will be cached to a
/// temporary file, and `Display` will print the status (compared to any
/// previous cache) rather than the hash itself.
///
/// ## Errors
///
/// This will return an error if the path list is empty or any reset/cache
/// operations fail for any reason.
pub(crate) fn new(paths: Vec<PathBuf>, flags: u8) -> Result<Self, CheckSameError> {
// If there are no paths, there's (probably) nothing for us to do.
if paths.is_empty() {
// We need to reset any other random caches before leaving.
// Assuming the reset goes all right, this is a no-op rather than
// a shameful error.
if 0 != flags & FLAG_RESET {
reset(&tmp_dir()?)?;
return Err(CheckSameError::Noop);
}
// Otherwise shame!
return Err(CheckSameError::NoFiles);
}
// Consume and build.
let mut out = Self::from(paths);
// We need to do something with the cache directory.
if 0 < flags {
let cache_dir = tmp_dir()?;
// Reset the cache?
if 0 != flags & FLAG_RESET {
reset(&cache_dir)?;
}
// Check the cache?
if 0 != flags & FLAG_CACHE {
out.check_same(cache_dir)?;
}
}
Ok(out)
}
/// # Check Sameness.
///
/// This checks the temporary file cache to see if there is a previous
/// result for the path set, and if that value was different than the new
/// hash.
///
/// If there is a change, the cache is updated accordingly.
///
/// ## Errors
///
/// This method returns an error if the cache file cannot be written to.
fn check_same(&mut self, mut path: PathBuf) -> Result<(), CheckSameError> {
use std::io::Write;
// Generate a file path for the cache.
let key: &str = &self.key.to_hex();
path.push(key);
// Get the hash as bytes.
let bytes: &[u8] = self.hash.as_bytes();
// This is already cached.
if path.is_file() {
// If it is unchanged, we're done!
if std::fs::read(&path).unwrap_or_default() == bytes {
self.status = CheckedSame::Same;
return Ok(());
}
self.status = CheckedSame::Changed;
}
// This is something new.
else {
self.status = CheckedSame::New;
}
// Save it for next time.
File::create(&path)
.and_then(|mut out| out.write_all(bytes).and_then(|_| out.flush()))
.map_err(|_| CheckSameError::Write)
}
}
/// # Hash File.
///
/// Hash the contents of a file path if possible, returning the hash bytes on
/// success.
fn hash_file(path: &Path) -> Option<[u8; 32]> {
let mut file = File::open(path).ok()?;
let mut hasher = Hasher::new();
std::io::copy(&mut file, &mut hasher).ok()?;
Some(*(hasher.finalize().as_bytes()))
}
/// # Reset Cache.
///
/// This will attempt to remove all `CheckSame` caches, which are just stored
/// as files in a temporary directory generated by the program.
///
/// Note: this does not delete the directory itself; that is preserved for
/// future use.
///
/// ## Errors
///
/// This method returns an error in cases where the temporary directory cannot
/// be read, or any files within it cannot be deleted.
fn reset(cache_dir: &Path) -> Result<(), CheckSameError> {
let entries = std::fs::read_dir(cache_dir).map_err(|_| CheckSameError::Reset)?;
entries.filter_map(Result::ok).try_for_each(|path| {
let path = path.path();
if path.is_file() {
std::fs::remove_file(path).map_err(|_| CheckSameError::Reset)?;
}
Ok(())
})
}
/// # Get/Make Temporary Directory.
///
/// This retrieves/creates a temporary directory to store `CheckSame` cache
/// files in.
///
/// ## Errors
///
/// This will return an error if the directory path is blocked or cannot be
/// created.
fn tmp_dir() -> Result<PathBuf, CheckSameError> {
let mut dir = std::env::temp_dir();
dir.push("checksame");
// The directory has to exist.
if ! dir.is_dir() && (dir.exists() || std::fs::create_dir(&dir).is_err()) {
Err(CheckSameError::Tmp)
}
else { Ok(dir) }
}
| CheckSame |
registry_test.go | package commandregistry_test
import (
"strings"
"github.com/cloudfoundry/cli/cf/commandregistry"
. "github.com/cloudfoundry/cli/cf/commandregistry/fakecommand"
. "github.com/cloudfoundry/cli/testhelpers/matchers"
. "github.com/cloudfoundry/cli/cf/i18n"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("CommandRegistry", func() {
BeforeEach(func() {
commandregistry.Commands = commandregistry.NewRegistry() // because other tests load all the commands into the registry
})
Context("i18n", func() {
It("initialize i18n T() func", func() {
Expect(T).ToNot(BeNil())
})
})
| Describe("Register()", func() {
AfterEach(func() {
commandregistry.Commands.RemoveCommand("fake-command2")
})
It("registers a command and its alias into the Command Registry map", func() {
Expect(commandregistry.Commands.CommandExists("fake-command2")).To(BeFalse())
Expect(commandregistry.Commands.CommandExists("fc2")).To(BeFalse())
commandregistry.Register(FakeCommand2{})
Expect(commandregistry.Commands.CommandExists("fake-command2")).To(BeTrue())
Expect(commandregistry.Commands.CommandExists("fc2")).To(BeTrue())
})
})
Describe("CommandExists()", func() {
Context("when the command has been registered", func() {
BeforeEach(func() {
commandregistry.Register(FakeCommand1{})
})
AfterEach(func() {
commandregistry.Commands.RemoveCommand("fake-command")
})
It("returns true the command exists in the list", func() {
Expect(commandregistry.Commands.CommandExists("fake-command")).To(BeTrue())
})
It("returns true if the alias exists", func() {
Expect(commandregistry.Commands.CommandExists("fc1")).To(BeTrue())
})
})
It("returns false when the command has not been registered", func() {
Expect(commandregistry.Commands.CommandExists("non-exist-cmd")).To(BeFalse())
})
It("returns false if the command name is an empty string", func() {
Expect(commandregistry.Commands.CommandExists("")).To(BeFalse())
})
})
Describe("FindCommand()", func() {
Context("when the command has been registered", func() {
BeforeEach(func() {
commandregistry.Register(FakeCommand1{})
})
AfterEach(func() {
commandregistry.Commands.RemoveCommand("fake-command")
})
It("returns the command when the command's name is given", func() {
cmd := commandregistry.Commands.FindCommand("fake-command")
Expect(cmd.MetaData().Usage[0]).To(ContainSubstring("Usage of fake-command"))
Expect(cmd.MetaData().Description).To(Equal("Description for fake-command"))
})
It("returns the command when the command's alias is given", func() {
cmd := commandregistry.Commands.FindCommand("fc1")
Expect(cmd.MetaData().Usage[0]).To(ContainSubstring("Usage of fake-command"))
Expect(cmd.MetaData().Description).To(Equal("Description for fake-command"))
})
})
It("returns nil when the command has not been registered", func() {
cmd := commandregistry.Commands.FindCommand("fake-command")
Expect(cmd).To(BeNil())
})
})
Describe("ShowAllCommands()", func() {
BeforeEach(func() {
commandregistry.Register(FakeCommand1{})
commandregistry.Register(FakeCommand2{})
commandregistry.Register(FakeCommand3{})
})
AfterEach(func() {
commandregistry.Commands.RemoveCommand("fake-command")
commandregistry.Commands.RemoveCommand("fake-command2")
commandregistry.Commands.RemoveCommand("this-is-a-really-long-command-name-123123123123123123123") // fake-command3
})
It("show all the commands in registry", func() {
cmds := commandregistry.Commands.ListCommands()
Expect(cmds).To(ContainElement("fake-command2"))
Expect(cmds).To(ContainElement("this-is-a-really-long-command-name-123123123123123123123"))
Expect(cmds).To(ContainElement("fake-command"))
})
})
Describe("SetCommand()", func() {
It("replaces the command in registry with command provided", func() {
updatedCmd := FakeCommand1{Data: "This is new data"}
oldCmd := commandregistry.Commands.FindCommand("fake-command")
Expect(oldCmd).ToNot(Equal(updatedCmd))
commandregistry.Commands.SetCommand(updatedCmd)
oldCmd = commandregistry.Commands.FindCommand("fake-command")
Expect(oldCmd).To(Equal(updatedCmd))
})
})
Describe("TotalCommands()", func() {
Context("when there are commands registered", func() {
BeforeEach(func() {
commandregistry.Register(FakeCommand1{})
commandregistry.Register(FakeCommand2{})
commandregistry.Register(FakeCommand3{})
})
AfterEach(func() {
commandregistry.Commands.RemoveCommand("fake-command")
commandregistry.Commands.RemoveCommand("fake-command2")
commandregistry.Commands.RemoveCommand("this-is-a-really-long-command-name-123123123123123123123") // fake-command3
})
It("returns the total number of registered commands", func() {
Expect(commandregistry.Commands.TotalCommands()).To(Equal(3))
})
})
It("returns 0 when there are no commands registered", func() {
Expect(commandregistry.Commands.TotalCommands()).To(Equal(0))
})
})
Describe("Metadatas()", func() {
BeforeEach(func() {
commandregistry.Register(FakeCommand1{})
commandregistry.Register(FakeCommand2{})
commandregistry.Register(FakeCommand3{})
})
AfterEach(func() {
commandregistry.Commands.RemoveCommand("fake-command")
commandregistry.Commands.RemoveCommand("fake-command2")
commandregistry.Commands.RemoveCommand("this-is-a-really-long-command-name-123123123123123123123") // fake-command3
})
It("returns all the metadata for all registered commands", func() {
Expect(len(commandregistry.Commands.Metadatas())).To(Equal(3))
})
})
Describe("RemoveCommand()", func() {
BeforeEach(func() {
commandregistry.Register(FakeCommand1{})
})
It("removes the command in registry with command name provided", func() {
commandregistry.Commands.RemoveCommand("fake-command")
Expect(commandregistry.Commands.CommandExists("fake-command")).To(BeFalse())
})
})
Describe("MaxCommandNameLength()", func() {
BeforeEach(func() {
commandregistry.Register(FakeCommand1{})
commandregistry.Register(FakeCommand2{})
commandregistry.Register(FakeCommand3{})
})
AfterEach(func() {
commandregistry.Commands.RemoveCommand("fake-command")
commandregistry.Commands.RemoveCommand("fake-command2")
commandregistry.Commands.RemoveCommand("this-is-a-really-long-command-name-123123123123123123123") // fake-command3
})
It("returns the length of the longest command name", func() {
maxLen := commandregistry.Commands.MaxCommandNameLength()
Expect(maxLen).To(Equal(len("this-is-a-really-long-command-name-123123123123123123123")))
})
})
Describe("CommandUsage()", func() {
BeforeEach(func() {
commandregistry.Register(FakeCommand1{})
})
AfterEach(func() {
commandregistry.Commands.RemoveCommand("fake-command")
})
It("prints the name, description and usage of a command", func() {
o := commandregistry.Commands.CommandUsage("fake-command")
outputs := strings.Split(o, "\n")
Expect(outputs).To(BeInDisplayOrder(
[]string{"NAME:"},
[]string{" fake-command", "Description"},
[]string{"USAGE:"},
))
})
Context("i18n translations", func() {
var originalT func(string, ...interface{}) string
BeforeEach(func() {
originalT = T
})
AfterEach(func() {
T = originalT
})
It("includes ':' in caption translation strings for language like French to be translated correctly", func() {
nameCaption := "NAME:"
aliasCaption := "ALIAS:"
usageCaption := "USAGE:"
optionsCaption := "OPTIONS:"
captionCheckCount := 0
T = func(translationID string, args ...interface{}) string {
if strings.HasPrefix(translationID, "NAME") {
Expect(translationID).To(Equal(nameCaption))
captionCheckCount += 1
} else if strings.HasPrefix(translationID, "ALIAS") {
Expect(translationID).To(Equal(aliasCaption))
captionCheckCount += 1
} else if strings.HasPrefix(translationID, "USAGE") {
Expect(translationID).To(Equal(usageCaption))
captionCheckCount += 1
} else if strings.HasPrefix(translationID, "OPTIONS") {
Expect(translationID).To(Equal(optionsCaption))
captionCheckCount += 1
}
return translationID
}
commandregistry.Commands.CommandUsage("fake-command")
})
})
It("prints the flag options", func() {
o := commandregistry.Commands.CommandUsage("fake-command")
outputs := strings.Split(o, "\n")
Expect(outputs).To(BeInDisplayOrder(
[]string{"NAME:"},
[]string{"USAGE:"},
[]string{"OPTIONS:"},
[]string{"intFlag", "Usage for"},
))
})
It("replaces 'CF_NAME' with executable name from os.Arg[0]", func() {
o := commandregistry.Commands.CommandUsage("fake-command")
outputs := strings.Split(o, "\n")
Expect(outputs).To(BeInDisplayOrder(
[]string{"USAGE:"},
[]string{"cf", "Usage of"},
))
Consistently(outputs).ShouldNot(ContainSubstrings([]string{"CF_NAME"}))
})
})
}) | |
update-user.dto.ts | import { Role } from '../enums/roles.enum';
export interface UpdateUserDTO {
name?: string;
surname?: string;
email?: string;
birthDate?: string;
address?: UserAddress;
role?: Role;
}
export interface UserAddress { | city?: string;
street?: string;
street_address?: string;
apt_address?: string;
} | country?: string; |
keccak.go | // Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package keccak
import (
"fmt"
"gitlab.com/nitya-sattva/go-x11/hash"
)
// HashSize holds the size of a hash in bytes.
const HashSize = int(64)
// BlockSize holds the size of a block in bytes.
const BlockSize = uintptr(72)
////////////////
type digest struct {
ptr uintptr
cnt uintptr
h [25]uint64
b [144]byte
}
// New returns a new digest compute a KECCAK512 hash.
func New() hash.Digest |
////////////////
// Reset resets the digest to its initial state.
func (ref *digest) Reset() {
ref.ptr = 0
ref.cnt = 200 - (512 >> 2)
h := ref.h[:]
h[0] = uint64(0x0)
h[1] = uint64(0xFFFFFFFFFFFFFFFF)
h[2] = uint64(0xFFFFFFFFFFFFFFFF)
h[3] = uint64(0x0)
h[4] = uint64(0x0)
h[5] = uint64(0x0)
h[6] = uint64(0x0)
h[7] = uint64(0x0)
h[8] = uint64(0xFFFFFFFFFFFFFFFF)
h[9] = uint64(0x0)
h[10] = uint64(0x0)
h[11] = uint64(0x0)
h[12] = uint64(0xFFFFFFFFFFFFFFFF)
h[13] = uint64(0x0)
h[14] = uint64(0x0)
h[15] = uint64(0x0)
h[16] = uint64(0x0)
h[17] = uint64(0xFFFFFFFFFFFFFFFF)
h[18] = uint64(0x0)
h[19] = uint64(0x0)
h[20] = uint64(0xFFFFFFFFFFFFFFFF)
h[21] = uint64(0x0)
h[22] = uint64(0x0)
h[23] = uint64(0x0)
h[24] = uint64(0x0)
}
// Sum appends the current hash to dst and returns the result
// as a slice. It does not change the underlying hash state.
func (ref *digest) Sum(dst []byte) []byte {
dgt := *ref
hsh := [64]byte{}
dgt.Close(hsh[:], 0, 0)
return append(dst, hsh[:]...)
}
// Write more data to the running hash, never returns an error.
func (ref *digest) Write(src []byte) (int, error) {
sln := uintptr(len(src))
fln := len(src)
ptr := ref.ptr
buf := ref.b[:]
sta := ref.h[:]
if sln < (BlockSize - ptr) {
copy(ref.b[ptr:], src)
ref.ptr += sln
return int(sln), nil
}
for sln > 0 {
cln := BlockSize - ptr
if cln > sln {
cln = sln
}
sln -= cln
copy(ref.b[ptr:], src[:cln])
src = src[cln:]
ptr += cln
if ptr == BlockSize {
sta[0] ^= decUInt64le(buf[0:])
sta[1] ^= decUInt64le(buf[8:])
sta[2] ^= decUInt64le(buf[16:])
sta[3] ^= decUInt64le(buf[24:])
sta[4] ^= decUInt64le(buf[32:])
sta[5] ^= decUInt64le(buf[40:])
sta[6] ^= decUInt64le(buf[48:])
sta[7] ^= decUInt64le(buf[56:])
sta[8] ^= decUInt64le(buf[64:])
for j := uintptr(0); j < 24; j++ {
var t0, t1, t2, t3, t4, tp uint64
{
var tt0, tt1, tt2, tt3 uint64
tt0 = sta[1] ^ sta[6]
tt1 = sta[11] ^ sta[16]
tt0 = tt0 ^ sta[21]
tt0 = tt0 ^ tt1
tt0 = (tt0 << 1) | (tt0 >> (64 - 1))
tt2 = sta[4] ^ sta[9]
tt3 = sta[14] ^ sta[19]
tt0 = tt0 ^ sta[24]
tt2 = tt2 ^ tt3
t0 = tt0 ^ tt2
tt0 = sta[2] ^ sta[7]
tt1 = sta[12] ^ sta[17]
tt0 = tt0 ^ sta[22]
tt0 = tt0 ^ tt1
tt0 = (tt0 << 1) | (tt0 >> (64 - 1))
tt2 = sta[0] ^ sta[5]
tt3 = sta[10] ^ sta[15]
tt0 = tt0 ^ sta[20]
tt2 = tt2 ^ tt3
t1 = tt0 ^ tt2
tt0 = sta[3] ^ sta[8]
tt1 = sta[13] ^ sta[18]
tt0 = tt0 ^ sta[23]
tt0 = tt0 ^ tt1
tt0 = (tt0 << 1) | (tt0 >> (64 - 1))
tt2 = sta[1] ^ sta[6]
tt3 = sta[11] ^ sta[16]
tt0 = tt0 ^ sta[21]
tt2 = tt2 ^ tt3
t2 = tt0 ^ tt2
tt0 = sta[4] ^ sta[9]
tt1 = sta[14] ^ sta[19]
tt0 = tt0 ^ sta[24]
tt0 = tt0 ^ tt1
tt0 = (tt0 << 1) | (tt0 >> (64 - 1))
tt2 = sta[2] ^ sta[7]
tt3 = sta[12] ^ sta[17]
tt0 = tt0 ^ sta[22]
tt2 = tt2 ^ tt3
t3 = tt0 ^ tt2
tt0 = sta[0] ^ sta[5]
tt1 = sta[10] ^ sta[15]
tt0 = tt0 ^ sta[20]
tt0 = tt0 ^ tt1
tt0 = (tt0 << 1) | (tt0 >> (64 - 1))
tt2 = sta[3] ^ sta[8]
tt3 = sta[13] ^ sta[18]
tt0 = tt0 ^ sta[23]
tt2 = tt2 ^ tt3
t4 = tt0 ^ tt2
}
sta[0] = sta[0] ^ t0
sta[1] = sta[1] ^ t1
sta[2] = sta[2] ^ t2
sta[3] = sta[3] ^ t3
sta[4] = sta[4] ^ t4
sta[5] = sta[5] ^ t0
sta[6] = sta[6] ^ t1
sta[7] = sta[7] ^ t2
sta[8] = sta[8] ^ t3
sta[9] = sta[9] ^ t4
sta[10] = sta[10] ^ t0
sta[11] = sta[11] ^ t1
sta[12] = sta[12] ^ t2
sta[13] = sta[13] ^ t3
sta[14] = sta[14] ^ t4
sta[15] = sta[15] ^ t0
sta[16] = sta[16] ^ t1
sta[17] = sta[17] ^ t2
sta[18] = sta[18] ^ t3
sta[23] = sta[23] ^ t3
sta[19] = sta[19] ^ t4
sta[20] = sta[20] ^ t0
sta[22] = sta[22] ^ t2
sta[21] = sta[21] ^ t1
sta[24] = sta[24] ^ t4
sta[1] = (sta[1] << 1) | (sta[1] >> (64 - 1))
sta[2] = (sta[2] << 62) | (sta[2] >> (64 - 62))
sta[3] = (sta[3] << 28) | (sta[3] >> (64 - 28))
sta[4] = (sta[4] << 27) | (sta[4] >> (64 - 27))
sta[5] = (sta[5] << 36) | (sta[5] >> (64 - 36))
sta[6] = (sta[6] << 44) | (sta[6] >> (64 - 44))
sta[7] = (sta[7] << 6) | (sta[7] >> (64 - 6))
sta[8] = (sta[8] << 55) | (sta[8] >> (64 - 55))
sta[9] = (sta[9] << 20) | (sta[9] >> (64 - 20))
sta[10] = (sta[10] << 3) | (sta[10] >> (64 - 3))
sta[11] = (sta[11] << 10) | (sta[11] >> (64 - 10))
sta[12] = (sta[12] << 43) | (sta[12] >> (64 - 43))
sta[13] = (sta[13] << 25) | (sta[13] >> (64 - 25))
sta[14] = (sta[14] << 39) | (sta[14] >> (64 - 39))
sta[15] = (sta[15] << 41) | (sta[15] >> (64 - 41))
sta[16] = (sta[16] << 45) | (sta[16] >> (64 - 45))
sta[17] = (sta[17] << 15) | (sta[17] >> (64 - 15))
sta[18] = (sta[18] << 21) | (sta[18] >> (64 - 21))
sta[19] = (sta[19] << 8) | (sta[19] >> (64 - 8))
sta[20] = (sta[20] << 18) | (sta[20] >> (64 - 18))
sta[21] = (sta[21] << 2) | (sta[21] >> (64 - 2))
sta[22] = (sta[22] << 61) | (sta[22] >> (64 - 61))
sta[23] = (sta[23] << 56) | (sta[23] >> (64 - 56))
sta[24] = (sta[24] << 14) | (sta[24] >> (64 - 14))
tp = ^sta[12]
t0 = sta[6] | sta[12]
t0 = sta[0] ^ t0
t1 = tp | sta[18]
t1 = sta[6] ^ t1
t2 = sta[18] & sta[24]
t2 = sta[12] ^ t2
t3 = sta[24] | sta[0]
t3 = sta[18] ^ t3
t4 = sta[0] & sta[6]
t4 = sta[24] ^ t4
sta[0] = t0
sta[6] = t1
sta[12] = t2
sta[18] = t3
sta[24] = t4
tp = ^sta[22]
t0 = sta[9] | sta[10]
t0 = sta[3] ^ t0
t1 = sta[10] & sta[16]
t1 = sta[9] ^ t1
t2 = sta[16] | tp
t2 = sta[10] ^ t2
t3 = sta[22] | sta[3]
t3 = sta[16] ^ t3
t4 = sta[3] & sta[9]
t4 = sta[22] ^ t4
sta[3] = t0
sta[9] = t1
sta[10] = t2
sta[16] = t3
sta[22] = t4
tp = ^sta[19]
t0 = sta[7] | sta[13]
t0 = sta[1] ^ t0
t1 = sta[13] & sta[19]
t1 = sta[7] ^ t1
t2 = tp & sta[20]
t2 = sta[13] ^ t2
t3 = sta[20] | sta[1]
t3 = tp ^ t3
t4 = sta[1] & sta[7]
t4 = sta[20] ^ t4
sta[1] = t0
sta[7] = t1
sta[13] = t2
sta[19] = t3
sta[20] = t4
tp = ^sta[17]
t0 = sta[5] & sta[11]
t0 = sta[4] ^ t0
t1 = sta[11] | sta[17]
t1 = sta[5] ^ t1
t2 = tp | sta[23]
t2 = sta[11] ^ t2
t3 = sta[23] & sta[4]
t3 = tp ^ t3
t4 = sta[4] | sta[5]
t4 = sta[23] ^ t4
sta[4] = t0
sta[5] = t1
sta[11] = t2
sta[17] = t3
sta[23] = t4
tp = ^sta[8]
t0 = tp & sta[14]
t0 = sta[2] ^ t0
t1 = sta[14] | sta[15]
t1 = tp ^ t1
t2 = sta[15] & sta[21]
t2 = sta[14] ^ t2
t3 = sta[21] | sta[2]
t3 = sta[15] ^ t3
t4 = sta[2] & sta[8]
t4 = sta[21] ^ t4
sta[2] = t0
sta[8] = t1
sta[14] = t2
sta[15] = t3
sta[21] = t4
sta[0] = sta[0] ^ kSpec[j+0]
t0 = sta[5]
sta[5] = sta[3]
sta[3] = sta[18]
sta[18] = sta[17]
sta[17] = sta[11]
sta[11] = sta[7]
sta[7] = sta[10]
sta[10] = sta[1]
sta[1] = sta[6]
sta[6] = sta[9]
sta[9] = sta[22]
sta[22] = sta[14]
sta[14] = sta[20]
sta[20] = sta[2]
sta[2] = sta[12]
sta[12] = sta[13]
sta[13] = sta[19]
sta[19] = sta[23]
sta[23] = sta[15]
sta[15] = sta[4]
sta[4] = sta[24]
sta[24] = sta[21]
sta[21] = sta[8]
sta[8] = sta[16]
sta[16] = t0
}
ptr = 0
}
}
ref.ptr = ptr
return fln, nil
}
// Close the digest by writing the last bits and storing the hash
// in dst. This prepares the digest for reuse by calling reset. A call
// to Close with a dst that is smaller then HashSize will return an error.
func (ref *digest) Close(dst []byte, bits uint8, bcnt uint8) error {
if ln := len(dst); HashSize > ln {
return fmt.Errorf("Keccak Close: dst min length: %d, got %d", HashSize, ln)
}
var tln uintptr
var tmp [73]uint8
off := uint8((uint16(0x100) | uint16(bits&0xFF)) >> (8 - bcnt))
if ref.ptr == (72 - 1) {
if bcnt == 7 {
tmp[0] = off
tmp[72] = 0x80
tln = 1 + 72
} else {
tmp[0] = uint8(off | 0x80)
tln = 1
}
} else {
tln = 72 - ref.ptr
tmp[0] = off
tmp[tln-1] = 0x80
}
ref.Write(tmp[:tln])
ref.h[1] = ^ref.h[1]
ref.h[2] = ^ref.h[2]
ref.h[8] = ^ref.h[8]
ref.h[12] = ^ref.h[12]
ref.h[17] = ^ref.h[17]
ref.h[20] = ^ref.h[20]
for u := uintptr(0); u < 64; u += 8 {
encUInt64le(dst[u:], ref.h[(u>>3)])
}
ref.Reset()
return nil
}
// Size returns the number of bytes required to store the hash.
func (*digest) Size() int {
return HashSize
}
// BlockSize returns the block size of the hash.
func (*digest) BlockSize() int {
return int(BlockSize)
}
////////////////
func decUInt64le(src []byte) uint64 {
return (uint64(src[0]) |
uint64(src[1])<<8 |
uint64(src[2])<<16 |
uint64(src[3])<<24 |
uint64(src[4])<<32 |
uint64(src[5])<<40 |
uint64(src[6])<<48 |
uint64(src[7])<<56)
}
func encUInt64le(dst []byte, src uint64) {
dst[0] = uint8(src)
dst[1] = uint8(src >> 8)
dst[2] = uint8(src >> 16)
dst[3] = uint8(src >> 24)
dst[4] = uint8(src >> 32)
dst[5] = uint8(src >> 40)
dst[6] = uint8(src >> 48)
dst[7] = uint8(src >> 56)
}
////////////////
var kSpec = []uint64{
uint64(0x0000000000000001), uint64(0x0000000000008082),
uint64(0x800000000000808A), uint64(0x8000000080008000),
uint64(0x000000000000808B), uint64(0x0000000080000001),
uint64(0x8000000080008081), uint64(0x8000000000008009),
uint64(0x000000000000008A), uint64(0x0000000000000088),
uint64(0x0000000080008009), uint64(0x000000008000000A),
uint64(0x000000008000808B), uint64(0x800000000000008B),
uint64(0x8000000000008089), uint64(0x8000000000008003),
uint64(0x8000000000008002), uint64(0x8000000000000080),
uint64(0x000000000000800A), uint64(0x800000008000000A),
uint64(0x8000000080008081), uint64(0x8000000000008080),
uint64(0x0000000080000001), uint64(0x8000000080008008),
}
| {
ref := &digest{}
ref.Reset()
return ref
} |
file_test.go | package object
import (
"io"
"gopkg.in/src-d/go-git.v4/fixtures"
"gopkg.in/src-d/go-git.v4/plumbing"
"gopkg.in/src-d/go-git.v4/plumbing/storer"
"gopkg.in/src-d/go-git.v4/storage/filesystem"
. "gopkg.in/check.v1"
)
type FileSuite struct {
BaseObjectsSuite
}
var _ = Suite(&FileSuite{})
type fileIterExpectedEntry struct {
Name string
Hash string
}
var fileIterTests = []struct {
repo string // the repo name as in localRepos
commit string // the commit to search for the file
files []fileIterExpectedEntry
}{
{"https://github.com/git-fixtures/basic.git", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5", []fileIterExpectedEntry{
{".gitignore", "32858aad3c383ed1ff0a0f9bdf231d54a00c9e88"},
{"CHANGELOG", "d3ff53e0564a9f87d8e84b6e28e5060e517008aa"},
{"LICENSE", "c192bd6a24ea1ab01d78686e417c8bdc7c3d197f"},
{"binary.jpg", "d5c0f4ab811897cadf03aec358ae60d21f91c50d"},
{"go/example.go", "880cd14280f4b9b6ed3986d6671f907d7cc2a198"},
{"json/long.json", "49c6bb89b17060d7b4deacb7b338fcc6ea2352a9"},
{"json/short.json", "c8f1d8c61f9da76f4cb49fd86322b6e685dba956"},
{"php/crappy.php", "9a48f23120e880dfbe41f7c9b7b708e9ee62a492"},
{"vendor/foo.go", "9dea2395f5403188298c1dabe8bdafe562c491e3"},
}},
}
func (s *FileSuite) TestIter(c *C) {
for i, t := range fileIterTests {
f := fixtures.ByURL(t.repo).One()
sto, err := filesystem.NewStorage(f.DotGit())
c.Assert(err, IsNil)
h := plumbing.NewHash(t.commit)
commit, err := GetCommit(sto, h)
c.Assert(err, IsNil, Commentf("subtest %d: %v (%s)", i, err, t.commit))
tree, err := commit.Tree()
c.Assert(err, IsNil)
iter := NewFileIter(sto, tree)
for k := 0; k < len(t.files); k++ {
exp := t.files[k]
file, err := iter.Next()
c.Assert(err, IsNil, Commentf("subtest %d, iter %d, err=%v", i, k, err))
c.Assert(file.Mode.String(), Equals, "-rw-r--r--")
c.Assert(file.Hash.IsZero(), Equals, false)
c.Assert(file.Hash, Equals, file.ID())
c.Assert(file.Name, Equals, exp.Name, Commentf("subtest %d, iter %d, name=%s, expected=%s", i, k, file.Name, exp.Hash))
c.Assert(file.Hash.String(), Equals, exp.Hash, Commentf("subtest %d, iter %d, hash=%v, expected=%s", i, k, file.Hash.String(), exp.Hash))
}
_, err = iter.Next()
c.Assert(err, Equals, io.EOF)
}
}
var contentsTests = []struct {
repo string // the repo name as in localRepos
commit string // the commit to search for the file
path string // the path of the file to find
contents string // expected contents of the file
}{
{
"https://github.com/git-fixtures/basic.git",
"b029517f6300c2da0f4b651b8642506cd6aaf45d",
".gitignore",
`*.class
# Mobile Tools for Java (J2ME)
.mtj.tmp/
# Package Files #
*.jar
*.war
*.ear
# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
hs_err_pid*
`,
},
{
"https://github.com/git-fixtures/basic.git",
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"CHANGELOG",
`Initial changelog
`,
},
}
func (s *FileSuite) TestContents(c *C) {
for i, t := range contentsTests {
f := fixtures.ByURL(t.repo).One()
sto, err := filesystem.NewStorage(f.DotGit())
c.Assert(err, IsNil)
h := plumbing.NewHash(t.commit)
commit, err := GetCommit(sto, h)
c.Assert(err, IsNil, Commentf("subtest %d: %v (%s)", i, err, t.commit))
file, err := commit.File(t.path)
c.Assert(err, IsNil)
content, err := file.Contents()
c.Assert(err, IsNil)
c.Assert(content, Equals, t.contents, Commentf(
"subtest %d: commit=%s, path=%s", i, t.commit, t.path))
}
}
var linesTests = []struct {
repo string // the repo name as in localRepos
commit string // the commit to search for the file
path string // the path of the file to find
lines []string // expected lines in the file
}{
{
"https://github.com/git-fixtures/basic.git",
"b029517f6300c2da0f4b651b8642506cd6aaf45d",
".gitignore",
[]string{
"*.class",
"",
"# Mobile Tools for Java (J2ME)",
".mtj.tmp/",
"",
"# Package Files #",
"*.jar",
"*.war",
"*.ear",
"",
"# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml",
"hs_err_pid*",
},
},
{
"https://github.com/git-fixtures/basic.git",
"6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
"CHANGELOG",
[]string{
"Initial changelog",
},
},
}
func (s *FileSuite) TestLines(c *C) {
for i, t := range linesTests {
f := fixtures.ByURL(t.repo).One()
sto, err := filesystem.NewStorage(f.DotGit())
c.Assert(err, IsNil)
h := plumbing.NewHash(t.commit)
commit, err := GetCommit(sto, h)
c.Assert(err, IsNil, Commentf("subtest %d: %v (%s)", i, err, t.commit))
file, err := commit.File(t.path)
c.Assert(err, IsNil)
lines, err := file.Lines()
c.Assert(err, IsNil)
c.Assert(lines, DeepEquals, t.lines, Commentf(
"subtest %d: commit=%s, path=%s", i, t.commit, t.path))
}
}
var ignoreEmptyDirEntriesTests = []struct {
repo string // the repo name as in localRepos
commit string // the commit to search for the file
}{
{
"https://github.com/cpcs499/Final_Pres_P.git",
"70bade703ce556c2c7391a8065c45c943e8b6bc3",
// the Final dir in this commit is empty
},
}
// It is difficult to assert that we are ignoring an (empty) dir as even
// if we don't, no files will be found in it.
//
// At least this test has a high chance of panicking if
// we don't ignore empty dirs.
func (s *FileSuite) TestIgnoreEmptyDirEntries(c *C) {
for i, t := range ignoreEmptyDirEntriesTests {
f := fixtures.ByURL(t.repo).One()
sto, err := filesystem.NewStorage(f.DotGit())
c.Assert(err, IsNil)
h := plumbing.NewHash(t.commit)
commit, err := GetCommit(sto, h)
c.Assert(err, IsNil, Commentf("subtest %d: %v (%s)", i, err, t.commit))
tree, err := commit.Tree()
c.Assert(err, IsNil)
iter := tree.Files()
defer iter.Close()
for file, err := iter.Next(); err == nil; file, err = iter.Next() {
_, _ = file.Contents()
// this would probably panic if we are not ignoring empty dirs
}
} | hash := plumbing.NewHash("1669dce138d9b841a518c64b10914d88f5e488ea")
commit, err := GetCommit(s.Storer, hash)
c.Assert(err, IsNil)
tree, err := commit.Tree()
c.Assert(err, IsNil)
expected := []string{
".gitignore",
"CHANGELOG",
"LICENSE",
"binary.jpg",
}
var count int
i := tree.Files()
i.ForEach(func(f *File) error {
c.Assert(f.Name, Equals, expected[count])
count++
return nil
})
c.Assert(count, Equals, 4)
count = 0
i = tree.Files()
i.ForEach(func(f *File) error {
count++
return storer.ErrStop
})
c.Assert(count, Equals, 1)
} | }
func (s *FileSuite) TestFileIter(c *C) { |
test_events.py | #!/usr/bin/env python
# -- Content-Encoding: UTF-8 --
"""
Tests the framework events.
:author: Thomas Calmant
"""
# Standard library
try:
import unittest2 as unittest
except ImportError:
import unittest
# Pelix
from pelix.framework import FrameworkFactory, Bundle, BundleException, \
BundleContext, BundleEvent, ServiceEvent
from pelix.services import SERVICE_EVENT_LISTENER_HOOK
# Tests
from tests import log_on, log_off
from tests.interfaces import IEchoService
# ------------------------------------------------------------------------------
__version_info__ = (1, 0, 1)
__version__ = ".".join(str(x) for x in __version_info__)
SERVICE_BUNDLE = "tests.framework.service_bundle"
SIMPLE_BUNDLE = "tests.framework.simple_bundle"
# ------------------------------------------------------------------------------
class BundleEventTest(unittest.TestCase):
"""
Pelix bundle event tests
"""
def setUp(self):
"""
Called before each test. Initiates a framework.
"""
self.framework = FrameworkFactory.get_framework()
self.framework.start()
self.test_bundle_name = SIMPLE_BUNDLE
self.bundle = None
self.received = []
def tearDown(self):
"""
Called after each test
"""
self.framework.stop()
FrameworkFactory.delete_framework()
def reset_state(self):
"""
Resets the flags
"""
del self.received[:]
def bundle_changed(self, event):
"""
Called by the framework when a bundle event is triggered
@param event: The BundleEvent
"""
assert isinstance(event, BundleEvent)
bundle = event.get_bundle()
kind = event.get_kind()
if self.bundle is not None \
and kind == BundleEvent.INSTALLED:
# Bundle is not yet locally known...
self.assertIs(self.bundle, bundle,
"Received an event for an other bundle.")
self.assertNotIn(kind, self.received, "Event received twice")
self.received.append(kind)
def testBundleEvents(self):
"""
Tests if the signals are correctly received
"""
context = self.framework.get_bundle_context()
assert isinstance(context, BundleContext)
# Register to events
self.assertTrue(context.add_bundle_listener(self),
"Can't register the bundle listener")
# Install the bundle
self.bundle = bundle = context.install_bundle(self.test_bundle_name)
assert isinstance(bundle, Bundle)
# Assert the Install events has been received
self.assertEqual([BundleEvent.INSTALLED],
self.received, "Received {0}".format(self.received))
self.reset_state()
# Start the bundle
bundle.start()
# Assert the events have been received
self.assertEqual([BundleEvent.STARTING, BundleEvent.STARTED],
self.received, "Received {0}".format(self.received))
self.reset_state()
# Stop the bundle
bundle.stop()
# Assert the events have been received
self.assertEqual([BundleEvent.STOPPING, BundleEvent.STOPPING_PRECLEAN,
BundleEvent.STOPPED], self.received,
"Received {0}".format(self.received))
self.reset_state()
# Uninstall the bundle
bundle.uninstall()
# Assert the events have been received
self.assertEqual([BundleEvent.UNINSTALLED],
self.received, "Received {0}".format(self.received))
self.reset_state()
# Unregister from events
context.remove_bundle_listener(self)
# ------------------------------------------------------------------------------
class ServiceEventTest(unittest.TestCase):
"""
Pelix service event tests
"""
def setUp(self):
"""
Called before each test. Initiates a framework.
"""
self.framework = FrameworkFactory.get_framework()
self.framework.start()
self.test_bundle_name = SERVICE_BUNDLE
self.bundle = None
self.received = []
def tearDown(self):
"""
Called after each test
"""
self.framework.stop()
FrameworkFactory.delete_framework()
def reset_state(self):
"""
Resets the flags
"""
del self.received[:]
def service_changed(self, event):
"""
Called by the framework when a service event is triggered
@param event: The ServiceEvent
"""
assert isinstance(event, ServiceEvent)
ref = event.get_service_reference()
self.assertIsNotNone(ref, "Invalid service reference in the event")
kind = event.get_kind()
if kind == ServiceEvent.MODIFIED \
or kind == ServiceEvent.MODIFIED_ENDMATCH:
# Properties have been modified
self.assertNotEqual(ref.get_properties(),
event.get_previous_properties(),
"Modified event for unchanged properties")
self.assertNotIn(kind, self.received, "Event received twice")
self.received.append(kind)
def testDoubleListener(self):
"""
Tests double registration / unregistration
"""
context = self.framework.get_bundle_context()
assert isinstance(context, BundleContext)
# Double registration
self.assertTrue(context.add_service_listener(self),
"Can't register the service listener")
log_off()
self.assertFalse(context.add_service_listener(self),
"Service listener registered twice")
log_on()
# Double unregistration
self.assertTrue(context.remove_service_listener(self),
"Can't unregister the service listener")
log_off()
self.assertFalse(context.remove_service_listener(self),
"Service listener unregistered twice")
log_on()
def testInvalidFilterListener(self):
"""
Tests invalid filter listener registration
"""
context = self.framework.get_bundle_context()
assert isinstance(context, BundleContext)
log_off()
self.assertRaises(BundleException, context.add_service_listener, self,
"Invalid")
log_on()
self.assertFalse(context.remove_service_listener(self),
"Invalid filter was registered anyway")
def testServiceEventsNormal(self):
|
def testServiceEventsNoStop(self):
"""
Tests if the signals are correctly received, even if the service is not
correctly removed
"""
context = self.framework.get_bundle_context()
assert isinstance(context, BundleContext)
# Register to events
self.assertTrue(context.add_service_listener(self),
"Can't register the service listener")
# Install the bundle
self.bundle = bundle = context.install_bundle(self.test_bundle_name)
assert isinstance(bundle, Bundle)
# Assert the Install events has been received
self.assertEqual(
[], self.received, "Received {0}".format(self.received))
self.reset_state()
# Start the bundle
bundle.start()
# Assert the events have been received
self.assertEqual([ServiceEvent.REGISTERED],
self.received, "Received {0}".format(self.received))
self.reset_state()
# Uninstall the bundle, without unregistering the service
module_ = bundle.get_module()
module_.unregister = False
bundle.uninstall()
# Assert the events have been received
self.assertEqual([ServiceEvent.UNREGISTERING],
self.received, "Received {0}".format(self.received))
self.reset_state()
# Unregister from events
context.remove_service_listener(self)
def testServiceModified(self):
"""
Tests the service modified event
"""
context = self.framework.get_bundle_context()
assert isinstance(context, BundleContext)
# Register to events
self.assertTrue(context.add_service_listener(self, "(test=True)"),
"Can't register the service listener")
# Install the bundle
self.bundle = bundle = context.install_bundle(self.test_bundle_name)
assert isinstance(bundle, Bundle)
# Start the bundle
bundle.start()
# Assert the events have been received
self.assertEqual([ServiceEvent.REGISTERED],
self.received, "Received {0}".format(self.received))
self.reset_state()
# Get the service
ref = context.get_service_reference(IEchoService)
self.assertIsNotNone(ref, "ServiceReference not found")
svc = context.get_service(ref)
self.assertIsNotNone(ref, "Invalid service instance")
# Modify the service => Simple modification
svc.modify({"answer": 42})
self.assertEqual([ServiceEvent.MODIFIED],
self.received, "Received {0}".format(self.received))
self.reset_state()
# Set the same value => No event should be sent
svc.modify({"answer": 42})
self.assertEqual([], self.received,
"Received {0}".format(self.received))
self.reset_state()
# Modify the service => Ends the filter match
svc.modify({"test": False})
# Assert the events have been received
self.assertEqual([ServiceEvent.MODIFIED_ENDMATCH],
self.received, "Received {0}".format(self.received))
self.reset_state()
# Modify the service => the filter matches again
svc.modify({"test": True})
# Assert the events have been received
self.assertEqual([ServiceEvent.MODIFIED],
self.received, "Received {0}".format(self.received))
self.reset_state()
# Stop the bundle
bundle.stop()
# Assert the events have been received
self.assertEqual([ServiceEvent.UNREGISTERING],
self.received, "Received {0}".format(self.received))
self.reset_state()
# Uninstall the bundle
bundle.uninstall()
# Unregister from events
context.remove_service_listener(self)
# ------------------------------------------------------------------------------
class EventListenerHookTest(unittest.TestCase):
"""
Event Listener Hook tests
"""
def setUp(self):
"""
Called before each test. Initiates a framework.
"""
self.framework = FrameworkFactory.get_framework()
self.framework.start()
self.test_bundle_name = SERVICE_BUNDLE
self.bundle = None
self.received = []
def tearDown(self):
"""
Called after each test
"""
self.framework.stop()
self.framework.delete()
def test_normal_behaviour(self):
"""
Checks if event listener hooks are registered correctly
"""
# Test implementation
events = []
class Hook(object):
@staticmethod
def event(svc_event, listeners_dict):
events.append((svc_event, listeners_dict))
# Register the hook
ctx = self.framework.get_bundle_context()
reg = ctx.register_service(SERVICE_EVENT_LISTENER_HOOK, Hook(), {})
# Hooks shouldn't be aware of themselves
self.assertFalse(events)
# Register a dummy service
dummy_reg = ctx.register_service("dummy", object(), {})
# Pop information
event, listeners = events.pop(0)
# Check event
assert isinstance(event, ServiceEvent)
self.assertEqual(event.get_kind(), ServiceEvent.REGISTERED)
self.assertIs(event.get_service_reference(), dummy_reg.get_reference())
# No listeners are registered
self.assertFalse(listeners)
# Update the service
dummy_reg.set_properties({"hello": "world"})
# Pop information
event, listeners = events.pop(0)
# Check event
assert isinstance(event, ServiceEvent)
self.assertEqual(event.get_kind(), ServiceEvent.MODIFIED)
self.assertIs(event.get_service_reference(), dummy_reg.get_reference())
# Unregister the service
dummy_reg.unregister()
# Pop information
event, listeners = events.pop(0)
# Check event
assert isinstance(event, ServiceEvent)
self.assertEqual(event.get_kind(), ServiceEvent.UNREGISTERING)
self.assertIs(event.get_service_reference(), dummy_reg.get_reference())
# Unregister the hook
reg.unregister()
# Register a new service
ctx.register_service("dummy", object(), {})
# Hook must not be notified
self.assertFalse(events)
def test_hook(self):
"""
Tests the hook filtering behaviour
"""
# Add a bundle to have two contexts in the test
fw_ctx = self.framework.get_bundle_context()
bnd = fw_ctx.install_bundle("tests.dummy_1")
bnd.start()
bnd_ctx = bnd.get_bundle_context()
# Setup a hook
class Hook(object):
@staticmethod
def event(svc_event, listeners_dict):
to_remove = svc_event.get_service_reference() \
.get_property("to.remove")
info_to_remove = []
for listener_bc, listeners_info in listeners_dict.items():
# Check the dictionary content
for listener_info in listeners_info:
self.assertIs(listener_bc, listener_info.bundle_context)
self.assertIs(
listener_bc, listener_info.listener.context)
self.assertIs(
listener_bc, listener_info.get_bundle_context())
if listener_info.listener in to_remove:
info_to_remove.append(listener_info)
# Remove the requested listeners
for listener_info in info_to_remove:
listeners_dict[listener_info.bundle_context] \
.remove(listener_info)
fw_ctx.register_service(SERVICE_EVENT_LISTENER_HOOK, Hook(), {})
# Register multiple listeners
class Listener(object):
def __init__(self, bc):
self.context = bc
self.storage = []
bc.add_service_listener(self)
def service_changed(self, event):
self.storage.append(event)
listener_referee = Listener(fw_ctx)
listener_1 = Listener(fw_ctx)
listener_2 = Listener(bnd_ctx)
# Register a service that only the referee will get
reg = fw_ctx.register_service(
"dummy", object(), {"to.remove": [listener_1, listener_2]})
evt = listener_referee.storage.pop(0)
self.assertIs(evt.get_service_reference(), reg.get_reference())
self.assertEqual(evt.get_kind(), ServiceEvent.REGISTERED)
self.assertFalse(listener_1.storage)
self.assertFalse(listener_2.storage)
# Modify it so that listener_1 gets it
reg.set_properties({"to.remove": [listener_2]})
self.assertFalse(listener_2.storage)
evt = listener_referee.storage.pop(0)
self.assertIs(evt.get_service_reference(), reg.get_reference())
self.assertEqual(evt.get_kind(), ServiceEvent.MODIFIED)
evt1 = listener_1.storage.pop(0)
self.assertIs(evt1, evt)
# Modify it so that listener_2, but not listener_1 gets it
reg.set_properties({"to.remove": [listener_1]})
self.assertFalse(listener_1.storage)
evt = listener_referee.storage.pop(0)
self.assertIs(evt.get_service_reference(), reg.get_reference())
self.assertEqual(evt.get_kind(), ServiceEvent.MODIFIED)
evt2 = listener_2.storage.pop(0)
self.assertIs(evt2, evt)
# ------------------------------------------------------------------------------
if __name__ == "__main__":
# Set logging level
import logging
logging.basicConfig(level=logging.DEBUG)
unittest.main()
| """
Tests if the signals are correctly received
"""
context = self.framework.get_bundle_context()
assert isinstance(context, BundleContext)
# Register to events
self.assertTrue(context.add_service_listener(self),
"Can't register the service listener")
# Install the bundle
self.bundle = bundle = context.install_bundle(self.test_bundle_name)
assert isinstance(bundle, Bundle)
# Assert the Install events has been received
self.assertEqual(
[], self.received, "Received {0}".format(self.received))
self.reset_state()
# Start the bundle
bundle.start()
# Assert the events have been received
self.assertEqual([ServiceEvent.REGISTERED],
self.received, "Received {0}".format(self.received))
self.reset_state()
# Stop the bundle
bundle.stop()
# Assert the events have been received
self.assertEqual([ServiceEvent.UNREGISTERING],
self.received, "Received {0}".format(self.received))
self.reset_state()
# Uninstall the bundle
bundle.uninstall()
# Assert the events have been received
self.assertEqual(
[], self.received, "Received {0}".format(self.received))
self.reset_state()
# Unregister from events
context.remove_service_listener(self) |
script.js | ;(function()
{
if (window.BXMainMailConfirm)
return;
var options = {};
var mailboxes = [];
var listParams = {};
var action;
var BXMainMailConfirm = {
init: function(params)
{
mailboxes = params.mailboxes;
action = params.action;
delete params.mailboxes;
options = params;
},
getMailboxes: function()
{
return mailboxes;
},
showList: function(id, bind, params)
{
if (!BX.type.isNotEmptyString(params.placeholder)) | }
if (!(params.settings && params.settings.length))
{
params.settings = [];
}
if (!BX.type.isFunction(params.callback))
{
params.callback = function() {};
}
if((typeof params.popupSettings) != "object")
{
params.popupSettings = {};
}
params.popupSettings.className = 'main-mail-confirm-menu-content';
params.popupSettings.offsetLeft = 40;
params.popupSettings.angle = true;
params.popupSettings.closeByEsc = true;
listParams[id] = params;
var items = [];
var handler = function(event, item)
{
var action = 'apply';
if (event && event.target)
{
var deleteIconClass = 'main-mail-confirm-menu-delete-icon';
if (BX.hasClass(event.target, deleteIconClass) || BX.findParent(event.target, { class: deleteIconClass }, item.layout.item))
{
action = 'delete';
}
if (BX.hasClass(event.target, "sender-hint") || BX.findParent(event.target, { class: "sender-hint" }, item.layout.item))
{
action = 'edit';
}
}
if ('delete' == action)
{
BXMainMailConfirm.deleteSender(
item.id, function()
{
mailboxes = mailboxes.filter(function(value, index)
{
return item.id !== value.id
});
item.menuWindow.removeMenuItem(item.id);
if (listParams[id].selected == item.title)
{
listParams[id].callback('', listParams[id].placeholder);
}
}
);
}
else if ('edit' === action)
{
BXMainMailConfirm.showEditForm(item.id);
}
else
{
listParams[id].callback(item.title, item.text);
item.menuWindow.close();
}
};
if (!params.required)
{
items.push({
text: BX.util.htmlspecialchars(params.placeholder),
title: '',
onclick: handler
});
items.push({ delimiter: true });
}
if (mailboxes && mailboxes.length > 0)
{
var itemText, itemClass;
for (var i in mailboxes)
{
itemClass = 'menu-popup-no-icon';
itemText = BX.util.htmlspecialchars(mailboxes[i].formated);
if (mailboxes[i]['can_delete'] && mailboxes[i].id > 0)
{
itemText += '<span class="main-mail-confirm-menu-delete-icon popup-window-close-icon popup-window-titlebar-close-icon"\
title="' + BX.util.htmlspecialchars(BX.message('MAIN_MAIL_CONFIRM_DELETE')) + '"></span>';
itemClass = 'menu-popup-no-icon menu-popup-right-icon';
itemText += '<span data-role="sender-hint" class="sender-hint main-mail-edit-icon"\
title="' + BX.util.htmlspecialchars(BX.message('MAIN_MAIL_CONFIRM_EDIT')) + '"></span>';
itemClass = 'menu-popup-no-icon menu-popup-right-icon';
}
items.push({
html: itemText,
title: mailboxes[i].formated,
mailbox: mailboxes[i],
onclick: handler,
className: itemClass,
id: mailboxes[i].id
});
}
items.push({ delimiter: true });
}
items.push({
text: BX.util.htmlspecialchars(BX.message('MAIN_MAIL_CONFIRM_MENU')),
onclick: function(event, item)
{
item.menuWindow.close();
BXMainMailConfirm.showForm(function(mailbox, formated)
{
mailboxes.push({
email: mailbox.email,
name: mailbox.name,
id: mailbox.id,
formated: formated,
can_delete: true
});
listParams[id].callback(formated, BX.util.htmlspecialchars(formated));
BX.PopupMenu.destroy(id + '-menu');
});
}
});
//additional settings
if (params.settings.length > 0)
{
items = items.concat(params.settings);
}
BX.PopupMenu.show(
id + '-menu',
bind,
items,
params.popupSettings
);
},
showForm: function(callback, params)
{
window.step = 'email';
var senderId;
window.mode = params && params.mode ? params.mode : 'add';
var dlg = new BX.PopupWindow('add_from_email', null, {
titleBar: BX.message('MAIN_MAIL_CONFIRM_TITLE'),
draggable: true,
closeIcon: true,
lightShadow: true,
contentColor: 'white',
contentNoPaddings: true,
cacheable: false,
content: BX('new_from_email_dialog_content').innerHTML,
buttons: this.prepareDialogButtons(null, 'add', params, callback)
});
this.prepareDialog(dlg);
},
prepareDialog: function(dlg)
{
dlg.formFieldHint = function(field, type, text)
{
if (!field)
{
return;
}
var container = BX.findParent(field, { 'class': 'new-from-email-dialog-cell' });
var hint = BX.findChildByClassName(container, 'new-from-email-dialog-field-hint', true);
BX.removeClass(container, 'new-from-email-dialog-field-error');
BX.removeClass(container, 'new-from-email-dialog-field-warning');
switch (type)
{
case 'error':
BX.addClass(container, 'new-from-email-dialog-field-error');
break;
case 'warning':
BX.addClass(container, 'new-from-email-dialog-field-warning');
break;
}
if (typeof text != 'undefined' && text.length > 0)
{
BX.adjust(hint, { 'html': text });
BX.show(hint, 'block');
}
else
{
BX.hide(hint, 'block');
}
};
dlg.hideNotify = function()
{
var error = BX.findChild(dlg.contentContainer, { class: 'new-from-email-dialog-error' }, true);
if (error)
{
BX.hide(error, 'block');
}
};
dlg.showNotify = function(text)
{
var error = BX.findChild(dlg.contentContainer, { class: 'new-from-email-dialog-error' }, true);
if (error)
{
error.innerHTML = text;
BX.show(error, 'block');
}
};
dlg.switchBlock = function(block, immediately)
{
var emailBlock = BX.findChildByClassName(dlg.contentContainer, 'new-from-email-dialog-email-block', true);
var codeBlock = BX.findChildByClassName(dlg.contentContainer, 'new-from-email-dialog-code-block', true);
var hideBlock, showBlock;
if ('code' != step && 'code' == block)
{
hideBlock = emailBlock;
showBlock = codeBlock;
dlg.buttons[0].setName(BX.message('MAIN_MAIL_CONFIRM_SAVE'));
dlg.buttons[1].setName(BX.message('MAIN_MAIL_CONFIRM_BACK'));
}
else if ('code' == step && 'code' != block)
{
hideBlock = codeBlock;
showBlock = emailBlock;
dlg.buttons[0].setName(BX.message(
'smtp' == block && options.canCheckSmtp
? 'MAIN_MAIL_CONFIRM_SAVE'
: 'MAIN_MAIL_CONFIRM_GET_CODE'
));
dlg.buttons[1].setName(BX.message('MAIN_MAIL_CONFIRM_CANCEL'));
}
step = block;
if (hideBlock && showBlock)
{
if (immediately)
{
showBlock.style.position = '';
showBlock.style.height = '';
showBlock.style.display = '';
hideBlock.style.display = 'none';
}
else
{
hideBlock.style.height = hideBlock.offsetHeight + 'px';
hideBlock.offsetHeight;
hideBlock.style.height = '0px';
showBlock.style.position = 'absolute';
showBlock.style.height = '';
showBlock.style.display = '';
var showBlockHeight = showBlock.offsetHeight;
showBlock.style.height = '0px';
showBlock.style.position = '';
showBlock.offsetHeight;
showBlock.style.height = showBlockHeight + 'px';
}
}
};
var smtpLink = BX.findChildByClassName(dlg.contentContainer, 'new-from-email-dialog-smtp-link', true);
var smtpBlock = BX.findChildByClassName(dlg.contentContainer, 'new-from-email-dialog-smtp-block', true);
var useLimitCheckbox = BX.findChildByClassName(dlg.contentContainer, 'new-from-email-smtp-use-limit', true);
if (useLimitCheckbox)
{
BX.bind(
useLimitCheckbox,
'click',
function()
{
var useLimitCheckbox = BX.findChildByClassName(dlg.contentContainer, 'new-from-email-smtp-use-limit', true);
var emailBlock = BX.findChildByClassName(dlg.contentContainer, 'new-from-email-dialog-email-block', true);
var smtpLimitField = BX.findChild(emailBlock, { attr: { 'data-name': 'smtp-limit' } }, true);
smtpLimitField.disabled = !useLimitCheckbox.checked;
}
)
}
if (smtpLink && smtpBlock)
{
BX.bind(
smtpLink,
'click',
function(event)
{
var emailBlock = BX.findChildByClassName(dlg.contentContainer, 'new-from-email-dialog-email-block', true);
emailBlock.style.height = '';
if ('smtp' == step)
{
step = 'email';
BX.hide(smtpBlock, 'table-row-group');
dlg.buttons[0].setName(BX.message('MAIN_MAIL_CONFIRM_GET_CODE'));
}
else
{
step = 'smtp';
BX.show(smtpBlock, 'table-row-group');
dlg.buttons[0].setName(BX.message(
options.canCheckSmtp ? 'MAIN_MAIL_CONFIRM_SAVE' : 'MAIN_MAIL_CONFIRM_GET_CODE'
));
}
event.preventDefault();
}
);
}
if ('confirm' == window.mode)
{
dlg.switchBlock('code', true);
dlg.setOverlay(true);
}
dlg.show();
var emailBlock = BX.findChildByClassName(dlg.contentContainer, 'new-from-email-dialog-email-block', true);
var nameField = BX.findChild(emailBlock, { attr: { 'data-name': 'name' } }, true);
var emailField = BX.findChild(emailBlock, { attr: { 'data-name': 'email' } }, true);
if (nameField.value.length > 0)
{
emailField.focus();
}
else
{
nameField.focus();
}
},
showEditForm: function(senderId)
{
window.step = 'email';
window.mode = 'edit';
var dlg = new BX.PopupWindow('edit_from_email', null, {
titleBar: BX.message('MAIN_MAIL_CONFIRM_EDIT_TITLE'),
draggable: true,
closeIcon: true,
lightShadow: true,
contentColor: 'white',
contentNoPaddings: true,
cacheable: false,
content: BX('new_from_email_dialog_content').innerHTML,
events: {
onPopupShow: function () {
BX.ajax({
'url': BX.util.add_url_param(action, {
'act': 'info',
senderId: senderId,
}),
'method': 'GET',
'dataType': 'json',
onsuccess: function (data)
{
var emailBlock = BX.findChildByClassName(dlg.contentContainer, 'new-from-email-dialog-email-block', true);
var smtpLink = BX.findChildByClassName(dlg.contentContainer, 'new-from-email-dialog-smtp-link', true);
var useLimitCheckbox = BX.findChildByClassName(dlg.contentContainer, 'new-from-email-smtp-use-limit', true);
var nameField = BX.findChild(emailBlock, { attr: { 'data-name': 'name' } }, true);
var emailField = BX.findChild(emailBlock, { attr: { 'data-name': 'email' } }, true);
var smtpServerField = BX.findChild(emailBlock, { attr: { 'data-name': 'smtp-server' } }, true);
var smtpPortField = BX.findChild(emailBlock, { attr: { 'data-name': 'smtp-port' } }, true);
var smtpSslField = BX.findChild(emailBlock, { attr: { 'data-name': 'smtp-ssl' } }, true);
var smtpLoginField = BX.findChild(emailBlock, { attr: { 'data-name': 'smtp-login' } }, true);
var smtpLimitField = BX.findChild(emailBlock, { attr: { 'data-name': 'smtp-limit' } }, true);
nameField.value = data.name || '';
emailField.value = BX.util.htmlspecialchars(data.email);
smtpServerField.value = BX.util.htmlspecialchars(data.server || '');
smtpPortField.value = BX.util.htmlspecialchars(data.port || '');
smtpLoginField.value = BX.util.htmlspecialchars(data.login || '');
var hasNoLimit = typeof data.limit === 'undefined' || data.limit === null;
smtpLimitField.value = hasNoLimit ? smtpLimitField.value : data.limit;
if (!hasNoLimit)
{
useLimitCheckbox.checked = true;
smtpLimitField.disabled = false;
}
if (data.protocol === 'smtps')
{
smtpSslField.checked = true;
}
if (data.server)
{
BX.fireEvent(smtpLink, 'click');
}
},
onfailure: function (data)
{
},
})
}
},
buttons: this.prepareDialogButtons(senderId, 'edit')
});
this.prepareDialog(dlg);
},
prepareDialogButtons: function(senderId, act, params, callback)
{
return [
new BX.PopupWindowButton({
text: BX.message('MAIN_MAIL_CONFIRM_GET_CODE'),
className: 'popup-window-button-create',
events: {
click: function(event, popup)
{
var btn = this;
var dlg = btn.popupWindow;
if (BX.hasClass(btn.buttonNode, 'popup-window-button-wait'))
return;
var emailBlock = BX.findChildByClassName(dlg.contentContainer, 'new-from-email-dialog-email-block', true);
var codeBlock = BX.findChildByClassName(dlg.contentContainer, 'new-from-email-dialog-code-block', true);
var nameField = BX.findChild(emailBlock, { attr: { 'data-name': 'name' } }, true);
var emailField = BX.findChild(emailBlock, { attr: { 'data-name': 'email' } }, true);
var codeField = BX.findChild(codeBlock, { attr: { 'data-name': 'code' } }, true);
var publicField = BX.findChild(dlg.contentContainer, { attr: { 'data-name': 'public' } }, true);
var smtpServerField = BX.findChild(emailBlock, { attr: { 'data-name': 'smtp-server' } }, true);
var smtpPortField = BX.findChild(emailBlock, { attr: { 'data-name': 'smtp-port' } }, true);
var smtpSslField = BX.findChild(emailBlock, { attr: { 'data-name': 'smtp-ssl' } }, true);
var smtpLoginField = BX.findChild(emailBlock, { attr: { 'data-name': 'smtp-login' } }, true);
var smtpPassField = BX.findChild(emailBlock, { attr: { 'data-name': 'smtp-password' } }, true);
var smtpLimit = BX.findChild(emailBlock, { attr: { 'data-name': 'smtp-limit' } }, true);
dlg.formFieldHint(smtpPassField);
if ('email' == window.step || 'smtp' == window.step)
{
codeField.value = '';
var atom = "[=a-z0-9_+~'!$&*^`|#%/?{}-]";
var pattern = new RegExp('^' + atom + '+(\\.' + atom + '+)*@([a-z0-9-]+\\.)+[a-z0-9-]{2,20}$', 'i');
if (!emailField.value.match(pattern))
{
dlg.showNotify(BX.message(emailField.value.length > 0
? 'MAIN_MAIL_CONFIRM_INVALID_EMAIL'
: 'MAIN_MAIL_CONFIRM_EMPTY_EMAIL'
));
return;
}
}
if ('smtp' == window.step)
{
if (!smtpServerField.value.match(/^([a-z0-9-]+\.)+[a-z0-9-]{2,20}$/))
{
dlg.showNotify(BX.message(smtpServerField.value.length > 0
? 'MAIN_MAIL_CONFIRM_INVALID_SMTP_SERVER'
: 'MAIN_MAIL_CONFIRM_EMPTY_SMTP_SERVER'
));
return;
}
if (!smtpPortField.value.match(/^[0-9]+$/) || smtpPortField.value < 1 || smtpPortField.value > 65535)
{
dlg.showNotify(BX.message(smtpPortField.value.length > 0
? 'MAIN_MAIL_CONFIRM_INVALID_SMTP_PORT'
: 'MAIN_MAIL_CONFIRM_EMPTY_SMTP_PORT'
));
return;
}
if (!(smtpLoginField.value.length > 0))
{
dlg.showNotify(BX.message('MAIN_MAIL_CONFIRM_EMPTY_SMTP_LOGIN'));
return;
}
if (!senderId && smtpPassField.value.length > 0)
{
if (smtpPassField.value.match(/^\^/))
{
dlg.showNotify(BX.message('MAIN_MAIL_CONFIRM_INVALID_SMTP_PASSWORD_CARET'));
return;
}
else if (smtpPassField.value.match(/\x00/))
{
dlg.showNotify(BX.message('MAIN_MAIL_CONFIRM_INVALID_SMTP_PASSWORD_NULL'));
return;
}
else if (smtpPassField.value.match(/^\s|\s$/))
{
dlg.formFieldHint(smtpPassField, 'warning', BX.message('MAIN_MAIL_CONFIRM_SPACE_SMTP_PASSWORD'));
}
}
else if (!senderId)
{
dlg.showNotify(BX.message('MAIN_MAIL_CONFIRM_EMPTY_SMTP_PASSWORD'));
return;
}
}
if ('code' == window.step)
{
if (codeField.value.length == 0)
{
dlg.showNotify(BX.message('MAIN_MAIL_CONFIRM_EMPTY_CODE'));
return;
}
}
dlg.hideNotify();
BX.addClass(btn.buttonNode, 'popup-window-button-wait');
var data = {
id: senderId,
name: nameField.value,
email: emailField.value,
smtp: {},
code: '',
public: publicField.checked ? publicField.value : ''
};
if ('smtp' == window.step)
{
data.smtp = {
server: smtpServerField.value,
port: smtpPortField.value,
ssl: smtpSslField.checked ? smtpSslField.value : '',
login: smtpLoginField.value,
password: smtpPassField.value,
limit: smtpLimit.disabled ? null : smtpLimit.value
};
}
if ('code' == window.step)
{
data.code = codeField.value;
}
if (params && params.data)
{
for (var i in params.data)
{
if (params.data.hasOwnProperty(i))
{
data[i] = params.data[i];
}
}
}
BX.ajax({
'url': BX.util.add_url_param(action, {
'act': act
}),
'method': 'POST',
'dataType': 'json',
'data': data,
onsuccess: function(data)
{
BX.removeClass(btn.buttonNode, 'popup-window-button-wait');
if (data.senderId)
{
senderId = data.senderId;
}
if (data.result == 'error')
{
dlg.showNotify(data.error);
}
else if (('email' == window.step || 'smtp' == window.step) && !data.confirmed)
{
dlg.formFieldHint(smtpPassField);
dlg.switchBlock('code');
}
else
{
btn.popupWindow.close();
if (callback && BX.type.isFunction(callback))
{
var mailboxName = nameField.value.length > 0
? nameField.value
: BX.message('MAIN_MAIL_CONFIRM_USER_FULL_NAME');
callback(
{
name: mailboxName,
email: emailField.value,
id: senderId
},
mailboxName.length > 0 ? mailboxName + ' <' + emailField.value + '>' : emailField.value
);
}
}
},
onfailure: function()
{
BX.removeClass(btn.buttonNode, 'popup-window-button-wait');
dlg.showNotify(BX.message('MAIN_MAIL_CONFIRM_AJAX_ERROR'));
}
});
}
}
}),
new BX.PopupWindowButton({
text: BX.message('MAIN_MAIL_CONFIRM_CANCEL'),
className: 'popup-window-button-link',
events: {
click: function()
{
var dlg = this.popupWindow;
if ('code' == window.step && 'confirm' != window.mode)
{
var smtpBlock = BX.findChildByClassName(dlg.contentContainer, 'new-from-email-dialog-smtp-block', true);
dlg.switchBlock(smtpBlock && smtpBlock.offsetHeight > 0 ? 'smtp' : 'email');
}
else
{
this.popupWindow.close();
}
}
}
})
]
},
updateListCanDel: function(id)
{
BX.ajax({
'url':BX.util.add_url_param(action, {
'act': 'sendersListCanDel',
}),
'method': 'POST',
'dataType': 'json',
'data': {},
onsuccess: function(data)
{
if (data.result == 'error')
{
BX.UI.Notification.Center.notify({
content: BX.message('MAIN_MAIL_DELETE_SENDER_ERROR')
});
}
else
{
mailboxes = mailboxes.filter(function(value, index)
{
if (!value.can_delete)
{
return true;
}
for (var i in data.mailboxes)
{
if (data.mailboxes[i].id == value.id)
{
return true;
}
}
return false;
});
BX.PopupMenu.destroy(id + '-menu');
}
},
onfailure: function(data)
{
BX.UI.Notification.Center.notify({
content: BX.message('MAIN_MAIL_DELETE_SENDER_ERROR')
});
}
});
},
deleteSender: function(senderId, callback)
{
BX.UI.Dialogs.MessageBox.show({
message: BX.message('MAIN_MAIL_CONFIRM_DELETE_SENDER_CONFIRM'),
modal: true,
buttons: BX.UI.Dialogs.MessageBoxButtons.OK_CANCEL,
onOk: function(messageBox)
{
return new Promise(
function(resolve,reject)
{
BX.ajax({
'url': BX.util.add_url_param(action, {
'act': 'delete',
}),
'method': 'POST',
'dataType': 'json',
'data': {
senderId: senderId
},
onsuccess: function(data)
{
if (data.result == 'error')
{
BX.UI.Notification.Center.notify({
content: BX.message('MAIN_MAIL_DELETE_SENDER_ERROR')
});
reject(data);
}
else
{
if (BX.type.isFunction(callback))
{
callback();
}
resolve(data);
}
},
onfailure: function(data)
{
BX.UI.Notification.Center.notify({
content: BX.message('MAIN_MAIL_DELETE_SENDER_ERROR')
});
reject(data);
}
});
}
);
},
onCancel: function(messageBox)
{
messageBox.close();
}
});
}
};
window.BXMainMailConfirm = BXMainMailConfirm;
})(); | {
params.placeholder = BX.message(params.required ? 'MAIN_MAIL_CONFIRM_MENU_UNKNOWN' : 'MAIN_MAIL_CONFIRM_MENU_PLACEHOLDER'); |
serialize_b2_rope_joint.rs | use serde::{ser::SerializeStruct, Deserialize, Serialize, Serializer};
use serde::de::DeserializeSeed;
use std::fmt;
use std::cell::RefCell;
use std::rc::Rc;
use crate::b2_body::*;
use crate::b2_settings::*;
use crate::joints::b2_rope_joint::*;
use crate::serialize_b2_joint::*;
use strum::VariantNames;
use strum_macros::EnumVariantNames;
pub(crate) trait B2ropeJoinToDef<D: UserDataType> {
fn get_def(&self) -> B2ropeJointDef<D>;
}
impl<D: UserDataType> B2ropeJoinToDef<D> for B2ropeJoint<D> {
fn get_def(&self) -> B2ropeJointDef<D> {
return B2ropeJointDef {
base: self.base.get_def(),
local_anchor_a: self.m_local_anchor_a,
local_anchor_b: self.m_local_anchor_b,
max_length: self.m_max_length,
};
}
}
impl<D: UserDataType> Serialize for B2ropeJointDef<D> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut state = serializer.serialize_struct("B2ropeJointDef", 4)?;
state.serialize_field("base", &self.base)?;
state.serialize_field("local_anchor_a", &self.local_anchor_a)?;
state.serialize_field("local_anchor_b", &self.local_anchor_b)?;
state.serialize_field("max_length", &self.max_length)?;
state.end()
}
}
#[derive(Clone)]
pub(crate) struct B2ropeJointDefContext<D: UserDataType> {
pub(crate) m_body_array: Rc<RefCell<Vec<BodyPtr<D>>>>,
}
impl<'de, U: UserDataType> DeserializeSeed<'de> for B2ropeJointDefContext<U> {
type Value = B2ropeJointDef<U>;
fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
where
D: Deserializer<'de>,
{
#[derive(Deserialize)]
#[serde(field_identifier, rename_all = "lowercase")]
#[derive(EnumVariantNames)]
#[allow(non_camel_case_types)]
enum Field {
base,
local_anchor_a,
local_anchor_b,
max_length,
}
struct B2ropeJointDefVisitor<D: UserDataType>(B2ropeJointDefContext<D>);
impl<'de, U: UserDataType> Visitor<'de> for B2ropeJointDefVisitor<U> {
type Value = B2ropeJointDef<U>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("struct B2ropeJointDef")
}
fn visit_seq<V>(self, mut seq: V) -> Result<Self::Value, V::Error>
where
V: SeqAccess<'de>,
{
let joint_def = B2ropeJointDef {
base: seq
.next_element_seed(B2jointDefVisitorContext {
m_body_array: self.0.m_body_array.clone(),
})?
.ok_or_else(|| de::Error::invalid_length(0, &self))?,
local_anchor_a: seq
.next_element()?
.ok_or_else(|| de::Error::invalid_length(0, &self))?,
local_anchor_b: seq
.next_element()?
.ok_or_else(|| de::Error::invalid_length(0, &self))?,
max_length: seq
.next_element()?
.ok_or_else(|| de::Error::invalid_length(0, &self))?,
};
Ok(joint_def)
}
fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>
where
V: MapAccess<'de>,
{
let mut joint_def = B2ropeJointDef::default();
while let Some(key) = map.next_key()? {
match key {
Field::base => {
joint_def.base = map.next_value_seed(B2jointDefVisitorContext {
m_body_array: self.0.m_body_array.clone(),
})?;
}
Field::local_anchor_a => {
joint_def.local_anchor_a = map.next_value()?;
}
Field::local_anchor_b => {
joint_def.local_anchor_b = map.next_value()?;
}
Field::max_length => {
joint_def.max_length = map.next_value()?;
}
}
}
Ok(joint_def)
}
}
deserializer.deserialize_struct(
"B2ropeJointDef",
Field::VARIANTS,
B2ropeJointDefVisitor(self),
)
}
} | use serde::de::{self, Deserializer, MapAccess, SeqAccess, Visitor}; |
|
hook_runner.rs | //! Runs a service lifecycle hook on a separate thread, and wraps the
//! whole execution in a future.
//!
//! Ideally, we'd want to use something like
//! [tokio_process](https://github.com/alexcrichton/tokio-process),
//! but we're not able to use that based on how our Windows hooks get
//! executed. If that were to be re-cast in terms of Rust's
//! `std::process::Command`, we could consider it. In the meantime,
//! this seems to do the trick.
use super::{hook_timer,
Pkg};
use habitat_common::templating::hooks::Hook;
use habitat_core::service::ServiceGroup;
use std::{clone::Clone,
sync::Arc,
time::{Duration,
Instant}};
use tokio::{task,
task::JoinError};
pub struct HookRunner<H: Hook + Sync> {
hook: Arc<H>,
service_group: ServiceGroup,
pkg: Pkg,
passwd: Option<String>,
}
// We cannot use `#[derive(Clone)]` here because it unnecessarily requires `H` to be
// `Clone`. See https://github.com/rust-lang/rust/issues/44151.
impl<H: Hook + Sync> Clone for HookRunner<H> {
fn clone(&self) -> Self {
Self { hook: self.hook.clone(),
service_group: self.service_group.clone(),
pkg: self.pkg.clone(),
passwd: self.passwd.clone(), }
}
}
impl<H> HookRunner<H> where H: Hook + Sync + 'static
{
pub fn new(hook: Arc<H>,
service_group: ServiceGroup,
pkg: Pkg,
passwd: Option<String>)
-> HookRunner<H> {
HookRunner { hook,
service_group, | pub async fn retryable_future(self) {
loop {
match self.clone().into_future().await {
Ok((maybe_exit_value, _duration)) => {
// If we did not get an exit value always retry
if maybe_exit_value.as_ref().map_or(true, H::should_retry) {
debug!("Retrying the '{}' hook", H::file_name());
} else {
break;
}
}
Err(e) => error!("Error running the '{}' hook: {:?}", H::file_name(), e),
}
}
}
pub async fn into_future(self) -> Result<(Option<H::ExitValue>, Duration), JoinError> {
// TODO (CM): May want to consider adding a configurable
// timeout to how long this hook is allowed to run.
task::spawn_blocking(move || {
// _timer is for Prometheus metrics, but we also want
// the runtime for other purposes. Unfortunately,
// we're not able to use the same timer for both :(
let _timer = hook_timer(H::file_name());
let start = Instant::now();
let exit_value = self.hook
.run(&self.service_group, &self.pkg, self.passwd.as_ref())
.ok();
let run_time = start.elapsed();
(exit_value, run_time)
}).await
}
} | pkg,
passwd }
}
|
rule.go | // Copyright 2019 TiKV Project Authors.
//
// 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,
// See the License for the specific language governing permissions and
// limitations under the License.
package placement
import (
"encoding/hex"
"encoding/json"
"sort"
)
// PeerRoleType is the expected peer type of the placement rule.
type PeerRoleType string
const (
// Voter can either match a leader peer or follower peer
Voter PeerRoleType = "voter"
// Leader matches a leader.
Leader PeerRoleType = "leader"
// Follower matches a follower.
Follower PeerRoleType = "follower"
// Learner matches a learner.
Learner PeerRoleType = "learner"
)
func validateRole(s PeerRoleType) bool {
return s == Voter || s == Leader || s == Follower || s == Learner
}
// Rule is the placement rule that can be checked against a region. When
// applying rules (apply means schedule regions to match selected rules), the
// apply order is defined by the tuple [GroupID, Index, ID].
type Rule struct {
GroupID string `json:"group_id"` // mark the source that add the rule
ID string `json:"id"` // unique ID within a group
Index int `json:"index,omitempty"` // rule apply order in a group, rule with less ID is applied first when indexes are equal
Override bool `json:"override,omitempty"` // when it is true, all rules with less indexes are disabled
StartKey []byte `json:"-"` // range start key
StartKeyHex string `json:"start_key"` // hex format start key, for marshal/unmarshal
EndKey []byte `json:"-"` // range end key
EndKeyHex string `json:"end_key"` // hex format end key, for marshal/unmarshal
Role PeerRoleType `json:"role"` // expected role of the peers
Count int `json:"count"` // expected count of the peers
LabelConstraints []LabelConstraint `json:"label_constraints,omitempty"` // used to select stores to place peers
LocationLabels []string `json:"location_labels,omitempty"` // used to make peers isolated physically
}
func (r Rule) String() string {
b, _ := json.Marshal(r)
return string(b)
}
// Key returns (groupID, ID) as the global unique key of a rule.
func (r Rule) Key() [2]string {
return [2]string{r.GroupID, r.ID}
}
// StoreKey returns the rule's key for persistent store.
func (r Rule) StoreKey() string {
return hex.EncodeToString([]byte(r.GroupID)) + "-" + hex.EncodeToString([]byte(r.ID))
}
// Rules are ordered by (GroupID, Index, ID).
func compareRule(a, b *Rule) int {
switch {
case a.GroupID < b.GroupID:
return -1
case a.GroupID > b.GroupID:
return 1
case a.Index < b.Index:
return -1
case a.Index > b.Index:
return 1
case a.ID < b.ID:
return -1
case a.ID > b.ID:
return 1
default:
return 0
}
}
func sortRules(rules []*Rule) {
sort.Slice(rules, func(i, j int) bool { return compareRule(rules[i], rules[j]) < 0 })
}
// Sort Rules, trim concealed rules.
func | (rules []*Rule) []*Rule {
var res []*Rule
var i, j int
for i = 1; i < len(rules); i++ {
if rules[j].GroupID != rules[i].GroupID {
res = append(res, rules[j:i]...)
j = i
}
if rules[i].Override {
j = i
}
}
return append(res, rules[j:]...)
}
| prepareRulesForApply |
main.rs | use ethereum::{BlockIngestor as EthereumBlockIngestor, EthereumAdapterTrait, EthereumNetworks};
use git_testament::{git_testament, render_testament};
use graph::blockchain::firehose_block_ingestor::FirehoseBlockIngestor;
use graph::blockchain::{Block as BlockchainBlock, Blockchain, BlockchainKind, BlockchainMap};
use graph::components::store::BlockStore;
use graph::data::graphql::effort::LoadManager;
use graph::firehose::{FirehoseEndpoints, FirehoseNetworks};
use graph::log::logger;
use graph::prelude::{IndexNodeServer as _, JsonRpcServer as _, *};
use graph::prometheus::Registry;
use graph::url::Url;
use graph_chain_ethereum as ethereum;
use graph_chain_near::{self as near, HeaderOnlyBlock as NearFirehoseHeaderOnlyBlock};
use graph_chain_tendermint::{self as tendermint, EventList as TendermintFirehoseEventList};
use graph_core::{
LinkResolver, MetricsRegistry, SubgraphAssignmentProvider as IpfsSubgraphAssignmentProvider,
SubgraphInstanceManager, SubgraphRegistrar as IpfsSubgraphRegistrar,
};
use graph_graphql::prelude::GraphQlRunner;
use graph_node::chain::{
connect_ethereum_networks, connect_firehose_networks, create_ethereum_networks,
create_firehose_networks, create_ipfs_clients, REORG_THRESHOLD,
};
use graph_node::config::Config;
use graph_node::opt;
use graph_node::store_builder::StoreBuilder;
use graph_server_http::GraphQLServer as GraphQLQueryServer;
use graph_server_index_node::IndexNodeServer;
use graph_server_json_rpc::JsonRpcServer;
use graph_server_metrics::PrometheusMetricsServer;
use graph_server_websocket::SubscriptionServer as GraphQLSubscriptionServer;
use graph_store_postgres::{register_jobs as register_store_jobs, ChainHeadUpdateListener, Store};
use std::collections::BTreeMap;
use std::io::{BufRead, BufReader};
use std::path::Path;
use std::sync::atomic;
use std::time::Duration;
use std::{collections::HashMap, env};
use structopt::StructOpt;
use tokio::sync::mpsc;
git_testament!(TESTAMENT);
fn read_expensive_queries() -> Result<Vec<Arc<q::Document>>, std::io::Error> {
// A file with a list of expensive queries, one query per line
// Attempts to run these queries will return a
// QueryExecutionError::TooExpensive to clients
const EXPENSIVE_QUERIES: &str = "/etc/graph-node/expensive-queries.txt";
let path = Path::new(EXPENSIVE_QUERIES);
let mut queries = Vec::new();
if path.exists() {
let file = std::fs::File::open(path)?;
let reader = BufReader::new(file);
for line in reader.lines() {
let line = line?;
let query = graphql_parser::parse_query(&line)
.map_err(|e| {
let msg = format!(
"invalid GraphQL query in {}: {}\n{}",
EXPENSIVE_QUERIES,
e.to_string(),
line
);
std::io::Error::new(std::io::ErrorKind::InvalidData, msg)
})?
.into_static();
queries.push(Arc::new(query));
}
}
Ok(queries)
}
#[tokio::main]
async fn main() {
env_logger::init();
// Allow configuring fail points on debug builds. Used for integration tests.
#[cfg(debug_assertions)]
std::mem::forget(fail::FailScenario::setup());
let opt = opt::Opt::from_args();
// Set up logger
let logger = logger(opt.debug);
// Log version information
info!(
logger,
"Graph Node version: {}",
render_testament!(TESTAMENT)
);
if opt.unsafe_config {
warn!(logger, "allowing unsafe configurations");
graph::env::UNSAFE_CONFIG.store(true, atomic::Ordering::SeqCst);
}
if !graph_server_index_node::POI_PROTECTION.is_active() {
warn!(
logger,
"GRAPH_POI_ACCESS_TOKEN not set; might leak POIs to the public via GraphQL"
);
}
let config = match Config::load(&logger, &opt.clone().into()) {
Err(e) => {
eprintln!("configuration error: {}", e);
std::process::exit(1);
}
Ok(config) => config,
};
if opt.check_config {
match config.to_json() {
Ok(txt) => println!("{}", txt),
Err(e) => eprintln!("error serializing config: {}", e),
}
eprintln!("Successfully validated configuration");
std::process::exit(0);
}
let node_id =
NodeId::new(opt.node_id.clone()).expect("Node ID must contain only a-z, A-Z, 0-9, and '_'");
let query_only = config.query_only(&node_id);
// Obtain subgraph related command-line arguments
let subgraph = opt.subgraph.clone();
// Obtain ports to use for the GraphQL server(s)
let http_port = opt.http_port;
let ws_port = opt.ws_port;
// Obtain JSON-RPC server port
let json_rpc_port = opt.admin_port;
// Obtain index node server port
let index_node_port = opt.index_node_port;
// Obtain metrics server port
let metrics_port = opt.metrics_port;
// Obtain the fork base URL
let fork_base = match &opt.fork_base {
Some(url) => {
// Make sure the endpoint ends with a terminating slash.
let url = if !url.ends_with("/") {
let mut url = url.clone();
url.push('/');
Url::parse(&url)
} else {
Url::parse(url)
};
Some(url.expect("Failed to parse the fork base URL"))
}
None => {
warn!(
logger,
"No fork base URL specified, subgraph forking is disabled"
);
None
}
};
info!(logger, "Starting up");
// Optionally, identify the Elasticsearch logging configuration
let elastic_config = opt
.elasticsearch_url
.clone()
.map(|endpoint| ElasticLoggingConfig {
endpoint: endpoint.clone(),
username: opt.elasticsearch_user.clone(),
password: opt.elasticsearch_password.clone(),
});
// Create a component and subgraph logger factory
let logger_factory = LoggerFactory::new(logger.clone(), elastic_config);
// Try to create IPFS clients for each URL specified in `--ipfs`
let ipfs_clients: Vec<_> = create_ipfs_clients(&logger, &opt.ipfs);
// Convert the clients into a link resolver. Since we want to get past
// possible temporary DNS failures, make the resolver retry
let link_resolver = Arc::new(LinkResolver::from(ipfs_clients));
// Set up Prometheus registry
let prometheus_registry = Arc::new(Registry::new());
let metrics_registry = Arc::new(MetricsRegistry::new(
logger.clone(),
prometheus_registry.clone(),
));
let mut metrics_server =
PrometheusMetricsServer::new(&logger_factory, prometheus_registry.clone());
// Ethereum clients; query nodes ignore all ethereum clients and never
// connect to them directly
let eth_networks = if query_only {
EthereumNetworks::new()
} else {
create_ethereum_networks(logger.clone(), metrics_registry.clone(), &config)
.await
.expect("Failed to parse Ethereum networks")
};
let mut firehose_networks_by_kind = if query_only {
BTreeMap::new()
} else {
create_firehose_networks(logger.clone(), metrics_registry.clone(), &config)
.await
.expect("Failed to parse Firehose networks")
};
let graphql_metrics_registry = metrics_registry.clone();
let contention_logger = logger.clone();
let expensive_queries = read_expensive_queries().unwrap();
let store_builder = StoreBuilder::new(
&logger,
&node_id,
&config,
fork_base,
metrics_registry.cheap_clone(),
)
.await;
let launch_services = |logger: Logger| async move {
let subscription_manager = store_builder.subscription_manager();
let chain_head_update_listener = store_builder.chain_head_update_listener();
let primary_pool = store_builder.primary_pool();
// To support the ethereum block ingestor, ethereum networks are referenced both by the
// `blockchain_map` and `ethereum_chains`. Future chains should be referred to only in
// `blockchain_map`.
let mut blockchain_map = BlockchainMap::new();
let (eth_networks, ethereum_idents) =
connect_ethereum_networks(&logger, eth_networks).await;
let (near_networks, near_idents) =
connect_firehose_networks::<NearFirehoseHeaderOnlyBlock>(
&logger,
firehose_networks_by_kind
.remove(&BlockchainKind::Near)
.unwrap_or_else(|| FirehoseNetworks::new()),
)
.await;
let (tendermint_networks, tendermint_idents) =
connect_firehose_networks::<TendermintFirehoseEventList>(
&logger,
firehose_networks_by_kind
.remove(&BlockchainKind::Tendermint)
.unwrap_or_else(|| FirehoseNetworks::new()),
)
.await;
let network_identifiers = ethereum_idents
.into_iter()
.chain(near_idents)
.chain(tendermint_idents)
.collect();
let network_store = store_builder.network_store(network_identifiers);
let ethereum_chains = ethereum_networks_as_chains(
&mut blockchain_map,
&logger,
node_id.clone(),
metrics_registry.clone(),
firehose_networks_by_kind.get(&BlockchainKind::Ethereum),
ð_networks,
network_store.as_ref(),
chain_head_update_listener,
&logger_factory,
);
let near_chains = near_networks_as_chains(
&mut blockchain_map,
&logger,
&near_networks,
network_store.as_ref(),
&logger_factory,
);
let tendermint_chains = tendermint_networks_as_chains(
&mut blockchain_map,
&logger,
&tendermint_networks,
network_store.as_ref(),
&logger_factory,
);
let blockchain_map = Arc::new(blockchain_map);
let load_manager = Arc::new(LoadManager::new(
&logger,
expensive_queries,
metrics_registry.clone(),
));
let graphql_runner = Arc::new(GraphQlRunner::new(
&logger,
network_store.clone(),
subscription_manager.clone(),
load_manager,
metrics_registry.clone(),
));
let mut graphql_server = GraphQLQueryServer::new(
&logger_factory,
graphql_metrics_registry,
graphql_runner.clone(),
node_id.clone(),
);
let subscription_server =
GraphQLSubscriptionServer::new(&logger, graphql_runner.clone(), network_store.clone());
let mut index_node_server = IndexNodeServer::new(
&logger_factory,
graphql_runner.clone(),
network_store.clone(), | );
if !opt.disable_block_ingestor {
if ethereum_chains.len() > 0 {
let block_polling_interval = Duration::from_millis(opt.ethereum_polling_interval);
start_block_ingestor(
&logger,
&logger_factory,
block_polling_interval,
ethereum_chains,
);
}
start_firehose_block_ingestor::<_, NearFirehoseHeaderOnlyBlock>(
&logger,
&network_store,
near_chains,
);
start_firehose_block_ingestor::<_, TendermintFirehoseEventList>(
&logger,
&network_store,
tendermint_chains,
);
// Start a task runner
let mut job_runner = graph::util::jobs::Runner::new(&logger);
register_store_jobs(
&mut job_runner,
network_store.clone(),
primary_pool,
metrics_registry.clone(),
);
graph::spawn_blocking(job_runner.start());
}
let static_filters = env::var_os("EXPERIMENTAL_STATIC_FILTERS").is_some();
let subgraph_instance_manager = SubgraphInstanceManager::new(
&logger_factory,
network_store.subgraph_store(),
blockchain_map.cheap_clone(),
metrics_registry.clone(),
link_resolver.cheap_clone(),
static_filters,
);
// Create IPFS-based subgraph provider
let subgraph_provider = IpfsSubgraphAssignmentProvider::new(
&logger_factory,
link_resolver.cheap_clone(),
subgraph_instance_manager,
);
// Check version switching mode environment variable
let version_switching_mode = SubgraphVersionSwitchingMode::parse(
env::var_os("EXPERIMENTAL_SUBGRAPH_VERSION_SWITCHING_MODE")
.unwrap_or_else(|| "instant".into())
.to_str()
.expect("invalid version switching mode"),
);
// Create named subgraph provider for resolving subgraph name->ID mappings
let subgraph_registrar = Arc::new(IpfsSubgraphRegistrar::new(
&logger_factory,
link_resolver.cheap_clone(),
Arc::new(subgraph_provider),
network_store.subgraph_store(),
subscription_manager,
blockchain_map,
node_id.clone(),
version_switching_mode,
));
graph::spawn(
subgraph_registrar
.start()
.map_err(|e| panic!("failed to initialize subgraph provider {}", e))
.compat(),
);
// Start admin JSON-RPC server.
let json_rpc_server = JsonRpcServer::serve(
json_rpc_port,
http_port,
ws_port,
subgraph_registrar.clone(),
node_id.clone(),
logger.clone(),
)
.expect("failed to start JSON-RPC admin server");
// Let the server run forever.
std::mem::forget(json_rpc_server);
// Add the CLI subgraph with a REST request to the admin server.
if let Some(subgraph) = subgraph {
let (name, hash) = if subgraph.contains(':') {
let mut split = subgraph.split(':');
(split.next().unwrap(), split.next().unwrap().to_owned())
} else {
("cli", subgraph)
};
let name = SubgraphName::new(name)
.expect("Subgraph name must contain only a-z, A-Z, 0-9, '-' and '_'");
let subgraph_id =
DeploymentHash::new(hash).expect("Subgraph hash must be a valid IPFS hash");
let debug_fork = opt
.debug_fork
.map(DeploymentHash::new)
.map(|h| h.expect("Debug fork hash must be a valid IPFS hash"));
let start_block = opt
.start_block
.map(|block| {
let mut split = block.split(":");
(
// BlockHash
split.next().unwrap().to_owned(),
// BlockNumber
split.next().unwrap().parse::<i64>().unwrap(),
)
})
.map(|(hash, number)| BlockPtr::try_from((hash.as_str(), number)))
.map(Result::unwrap);
graph::spawn(
async move {
subgraph_registrar.create_subgraph(name.clone()).await?;
subgraph_registrar
.create_subgraph_version(
name,
subgraph_id,
node_id,
debug_fork,
start_block,
)
.await
}
.map_err(|e| panic!("Failed to deploy subgraph from `--subgraph` flag: {}", e)),
);
}
// Serve GraphQL queries over HTTP
graph::spawn(
graphql_server
.serve(http_port, ws_port)
.expect("Failed to start GraphQL query server")
.compat(),
);
// Serve GraphQL subscriptions over WebSockets
graph::spawn(subscription_server.serve(ws_port));
// Run the index node server
graph::spawn(
index_node_server
.serve(index_node_port)
.expect("Failed to start index node server")
.compat(),
);
graph::spawn(
metrics_server
.serve(metrics_port)
.expect("Failed to start metrics server")
.compat(),
);
};
graph::spawn(launch_services(logger.clone()));
// Periodically check for contention in the tokio threadpool. First spawn a
// task that simply responds to "ping" requests. Then spawn a separate
// thread to periodically ping it and check responsiveness.
let (ping_send, mut ping_receive) = mpsc::channel::<crossbeam_channel::Sender<()>>(1);
graph::spawn(async move {
while let Some(pong_send) = ping_receive.recv().await {
let _ = pong_send.clone().send(());
}
panic!("ping sender dropped");
});
std::thread::spawn(move || loop {
std::thread::sleep(Duration::from_secs(1));
let (pong_send, pong_receive) = crossbeam_channel::bounded(1);
if futures::executor::block_on(ping_send.clone().send(pong_send)).is_err() {
debug!(contention_logger, "Shutting down contention checker thread");
break;
}
let mut timeout = Duration::from_millis(10);
while pong_receive.recv_timeout(timeout)
== Err(crossbeam_channel::RecvTimeoutError::Timeout)
{
debug!(contention_logger, "Possible contention in tokio threadpool";
"timeout_ms" => timeout.as_millis(),
"code" => LogCode::TokioContention);
if timeout < Duration::from_secs(10) {
timeout *= 10;
} else if std::env::var_os("GRAPH_KILL_IF_UNRESPONSIVE").is_some() {
// The node is unresponsive, kill it in hopes it will be restarted.
crit!(contention_logger, "Node is unresponsive, killing process");
std::process::abort()
}
}
});
futures::future::pending::<()>().await;
}
/// Return the hashmap of ethereum chains and also add them to `blockchain_map`.
fn ethereum_networks_as_chains(
blockchain_map: &mut BlockchainMap,
logger: &Logger,
node_id: NodeId,
registry: Arc<MetricsRegistry>,
firehose_networks: Option<&FirehoseNetworks>,
eth_networks: &EthereumNetworks,
store: &Store,
chain_head_update_listener: Arc<ChainHeadUpdateListener>,
logger_factory: &LoggerFactory,
) -> HashMap<String, Arc<ethereum::Chain>> {
let chains: Vec<_> = eth_networks
.networks
.iter()
.filter_map(|(network_name, eth_adapters)| {
store
.block_store()
.chain_store(network_name)
.map(|chain_store| {
let is_ingestible = chain_store.is_ingestible();
(network_name, eth_adapters, chain_store, is_ingestible)
})
.or_else(|| {
error!(
logger,
"No store configured for Ethereum chain {}; ignoring this chain",
network_name
);
None
})
})
.map(|(network_name, eth_adapters, chain_store, is_ingestible)| {
let firehose_endpoints = firehose_networks.and_then(|v| v.networks.get(network_name));
let chain = ethereum::Chain::new(
logger_factory.clone(),
network_name.clone(),
node_id.clone(),
registry.clone(),
chain_store.cheap_clone(),
chain_store,
firehose_endpoints.map_or_else(|| FirehoseEndpoints::new(), |v| v.clone()),
eth_adapters.clone(),
chain_head_update_listener.clone(),
*REORG_THRESHOLD,
is_ingestible,
);
(network_name.clone(), Arc::new(chain))
})
.collect();
for (network_name, chain) in chains.iter().cloned() {
blockchain_map.insert::<graph_chain_ethereum::Chain>(network_name, chain)
}
HashMap::from_iter(chains)
}
fn tendermint_networks_as_chains(
blockchain_map: &mut BlockchainMap,
logger: &Logger,
firehose_networks: &FirehoseNetworks,
store: &Store,
logger_factory: &LoggerFactory,
) -> HashMap<String, FirehoseChain<tendermint::Chain>> {
let chains: Vec<_> = firehose_networks
.networks
.iter()
.filter_map(|(network_name, firehose_endpoints)| {
store
.block_store()
.chain_store(network_name)
.map(|chain_store| (network_name, chain_store, firehose_endpoints))
.or_else(|| {
error!(
logger,
"No store configured for Tendermint chain {}; ignoring this chain",
network_name
);
None
})
})
.map(|(network_name, chain_store, firehose_endpoints)| {
(
network_name.clone(),
FirehoseChain {
chain: Arc::new(tendermint::Chain::new(
logger_factory.clone(),
network_name.clone(),
chain_store,
firehose_endpoints.clone(),
)),
firehose_endpoints: firehose_endpoints.clone(),
},
)
})
.collect();
for (network_name, firehose_chain) in chains.iter() {
blockchain_map
.insert::<tendermint::Chain>(network_name.clone(), firehose_chain.chain.clone())
}
HashMap::from_iter(chains)
}
/// Return the hashmap of NEAR chains and also add them to `blockchain_map`.
fn near_networks_as_chains(
blockchain_map: &mut BlockchainMap,
logger: &Logger,
firehose_networks: &FirehoseNetworks,
store: &Store,
logger_factory: &LoggerFactory,
) -> HashMap<String, FirehoseChain<near::Chain>> {
let chains: Vec<_> = firehose_networks
.networks
.iter()
.filter_map(|(chain_id, endpoints)| {
store
.block_store()
.chain_store(chain_id)
.map(|chain_store| (chain_id, chain_store, endpoints))
.or_else(|| {
error!(
logger,
"No store configured for NEAR chain {}; ignoring this chain", chain_id
);
None
})
})
.map(|(chain_id, chain_store, endpoints)| {
(
chain_id.clone(),
FirehoseChain {
chain: Arc::new(near::Chain::new(
logger_factory.clone(),
chain_id.clone(),
chain_store,
endpoints.clone(),
)),
firehose_endpoints: endpoints.clone(),
},
)
})
.collect();
for (chain_id, firehose_chain) in chains.iter() {
blockchain_map
.insert::<graph_chain_near::Chain>(chain_id.clone(), firehose_chain.chain.clone())
}
HashMap::from_iter(chains)
}
fn start_block_ingestor(
logger: &Logger,
logger_factory: &LoggerFactory,
block_polling_interval: Duration,
chains: HashMap<String, Arc<ethereum::Chain>>,
) {
info!(
logger,
"Starting block ingestors with {} chains [{}]",
chains.len(),
chains
.keys()
.map(|v| v.clone())
.collect::<Vec<String>>()
.join(", ")
);
// Create Ethereum block ingestors and spawn a thread to run each
chains
.iter()
.filter(|(network_name, chain)| {
if !chain.is_ingestible {
error!(logger, "Not starting block ingestor (chain is defective)"; "network_name" => &network_name);
}
chain.is_ingestible
})
.for_each(|(network_name, chain)| {
info!(
logger,
"Starting block ingestor for network";
"network_name" => &network_name
);
let eth_adapter = chain.cheapest_adapter();
let logger = logger_factory
.component_logger(
"BlockIngestor",
Some(ComponentLoggerConfig {
elastic: Some(ElasticComponentLoggerConfig {
index: String::from("block-ingestor-logs"),
}),
}),
)
.new(o!("provider" => eth_adapter.provider().to_string()));
// The block ingestor must be configured to keep at least REORG_THRESHOLD ancestors,
// because the json-rpc BlockStream expects blocks after the reorg threshold to be
// present in the DB.
let block_ingestor = EthereumBlockIngestor::new(
logger,
*REORG_THRESHOLD,
eth_adapter,
chain.chain_store(),
block_polling_interval,
)
.expect("failed to create Ethereum block ingestor");
// Run the Ethereum block ingestor in the background
graph::spawn(block_ingestor.into_polling_stream());
});
}
#[derive(Clone)]
struct FirehoseChain<C: Blockchain> {
chain: Arc<C>,
firehose_endpoints: FirehoseEndpoints,
}
fn start_firehose_block_ingestor<C, M>(
logger: &Logger,
store: &Store,
chains: HashMap<String, FirehoseChain<C>>,
) where
C: Blockchain,
M: prost::Message + BlockchainBlock + Default + 'static,
{
info!(
logger,
"Starting firehose block ingestors with {} chains [{}]",
chains.len(),
chains
.keys()
.map(|v| v.clone())
.collect::<Vec<String>>()
.join(", ")
);
// Create Firehose block ingestors and spawn a thread to run each
chains
.iter()
.for_each(|(network_name, chain)| {
info!(
logger,
"Starting firehose block ingestor for network";
"network_name" => &network_name
);
let endpoint = chain
.firehose_endpoints
.random()
.expect("One Firehose endpoint should exist at that execution point");
match store.block_store().chain_store(network_name.as_ref()) {
Some(s) => {
let block_ingestor = FirehoseBlockIngestor::<M>::new(
s,
endpoint.clone(),
logger.new(o!("component" => "FirehoseBlockIngestor", "provider" => endpoint.provider.clone())),
);
// Run the Firehose block ingestor in the background
graph::spawn(block_ingestor.run());
},
None => {
error!(logger, "Not starting firehose block ingestor (no chain store available)"; "network_name" => &network_name);
}
}
});
} | link_resolver.clone(), |
render_app.py | import numpy as np
from prnet.utils.render import vis_of_vertices, render_texture
from scipy import ndimage
def get_visibility(vertices, triangles, h, w):
triangles = triangles.T
vertices_vis = vis_of_vertices(vertices.T, triangles, h, w)
vertices_vis = vertices_vis.astype(bool)
for k in range(2):
tri_vis = vertices_vis[triangles[0,:]] | vertices_vis[triangles[1,:]] | vertices_vis[triangles[2,:]]
ind = triangles[:, tri_vis]
vertices_vis[ind] = True
# for k in range(2):
# tri_vis = vertices_vis[triangles[0,:]] & vertices_vis[triangles[1,:]] & vertices_vis[triangles[2,:]]
# ind = triangles[:, tri_vis]
# vertices_vis[ind] = True
vertices_vis = vertices_vis.astype(np.float32) #1 for visible and 0 for non-visible
return vertices_vis
def | (vertices_vis, triangles, uv_coords, h, w, resolution):
triangles = triangles.T
vertices_vis = vertices_vis.astype(np.float32)
uv_mask = render_texture(uv_coords.T, vertices_vis[np.newaxis, :], triangles, resolution, resolution, 1)
uv_mask = np.squeeze(uv_mask > 0)
uv_mask = ndimage.binary_closing(uv_mask)
uv_mask = ndimage.binary_erosion(uv_mask, structure = np.ones((4,4)))
uv_mask = ndimage.binary_closing(uv_mask)
uv_mask = ndimage.binary_erosion(uv_mask, structure = np.ones((4,4)))
uv_mask = ndimage.binary_erosion(uv_mask, structure = np.ones((4,4)))
uv_mask = ndimage.binary_erosion(uv_mask, structure = np.ones((4,4)))
uv_mask = uv_mask.astype(np.float32)
return np.squeeze(uv_mask)
def get_depth_image(vertices, triangles, h, w, isShow = False):
z = vertices[:, 2:]
if isShow:
z = z/max(z)
depth_image = render_texture(vertices.T, z.T, triangles.T, h, w, 1)
return np.squeeze(depth_image) | get_uv_mask |
read_auxiliary.py | """This module provides auxiliary functions for the import process of the init file."""
import numpy as np
def create_attr_dict_est(init_dict, semipar=False, include_constant=False):
"""This function processes the imported initialization file so that it fulfills the
requirements for the subsequent estimation process.
"""
init_dict["AUX"] = {"init_values"}
init_values = []
if semipar is True:
if include_constant is True:
init_dict = add_constant(init_dict, semipar)
else:
pass
init_dict = read_keys_semipar(init_dict, init_values)
# semipar is False
else:
if include_constant is True:
init_dict = add_constant(init_dict, semipar)
else:
pass
init_dict = read_keys_par(init_dict, init_values)
init_dict = provide_auxiliary_information(init_dict, init_values)
return init_dict
def create_attr_dict_sim(init_dict):
"""This function processes the imported initialization file so that it fulfills the
requirements for the following simulation and estimation process.
"""
init_dict["AUX"] = {"init_values"}
init_values = []
init_dict = read_keys_par(init_dict, init_values)
init_dict = provide_auxiliary_information(init_dict, init_values)
return init_dict
def add_constant(init_dict, semipar=False):
"""The function checks if the user has provided a constant
for the relevant subsections:
["TREATED", "UNTREATED", "CHOICE"] for the parametric, and
["CHOICE"] for the semiparamteric estimation, respectively.
"""
if semipar is True:
if "const" not in init_dict["CHOICE"]["order"]:
init_dict["CHOICE"]["order"].insert(0, "const")
init_dict["CHOICE"]["params"] = np.array([1.0])
else:
pass
# semipar is False
else:
for key in ["TREATED", "UNTREATED", "CHOICE"]:
if "const" not in init_dict[key]["order"]:
init_dict[key]["order"].insert(0, "const")
init_dict[key]["params"] = np.array([1.0])
else:
pass
return init_dict
def read_keys_par(init_dict, init_values):
"""This function reads the information provided by the
["TREATED", "UNTREATED", "CHOICE", "DIST"] keys for
the simulation and parametric estimation.
"""
for key in ["TREATED", "UNTREATED", "CHOICE", "DIST"]:
if "params" in init_dict[key].keys():
init_dict[key]["params"] = np.array(init_dict[key]["params"])
init_values += list(init_dict[key]["params"])
else:
init_values += [0.0] * len(init_dict[key]["order"])
if np.all(init_dict["DIST"]["params"] == 0):
init_dict["DETERMINISTIC"] = True
else:
init_dict["DETERMINISTIC"] = False
return init_dict
def read_keys_semipar(init_dict, init_values):
"""This function reads the information provided by the
["TREATED", "UNTREATED", "CHOICE"] keys for
semiparametric estimation.
"""
for key in ["TREATED", "UNTREATED", "CHOICE"]:
if "params" in init_dict[key].keys():
init_dict[key]["params"] = np.array(init_dict[key]["params"])
init_values += list(init_dict[key]["params"])
else:
init_values += [0.0] * len(init_dict[key]["order"])
return init_dict
def provide_auxiliary_information(init_dict, init_values):
| """This function generates auxiliary information
given the parameters in the initialization dictionary
"""
num_covars = len(
set(
init_dict["TREATED"]["order"]
+ init_dict["UNTREATED"]["order"]
+ init_dict["CHOICE"]["order"]
)
)
covar_label = []
for section in ["TREATED", "UNTREATED", "CHOICE"]:
covar_label += [i for i in init_dict[section]["order"] if i not in covar_label]
# Generate the AUX section that include some additional auxiliary information
init_dict["AUX"] = {
"init_values": np.array(init_values),
"num_covars_choice": len(init_dict["CHOICE"]["order"]),
"num_covars_treated": len(init_dict["TREATED"]["order"]),
"num_covars_untreated": len(init_dict["UNTREATED"]["order"]),
"num_paras": len(init_values) + 1,
"num_covars": num_covars,
"labels": covar_label,
}
return init_dict |
|
router_test.go | package main
import (
"fmt"
"net/http"
"net/http/httptest"
"os"
"strconv"
"testing"
"github.com/astaxie/beego"
beegocontext "github.com/astaxie/beego/context"
"github.com/gin-gonic/gin"
"github.com/ihornet/gorouter"
"github.com/julienschmidt/httprouter"
"github.com/labstack/echo"
)
type (
Route struct {
Method string
Path string
}
)
var (
num = 0
static = []*Route{
{"GET", "/"},
{"GET", "/cmd.html"},
{"GET", "/code.html"},
{"GET", "/contrib.html"},
{"GET", "/contribute.html"},
{"GET", "/debugging_with_gdb.html"},
{"GET", "/docs.html"},
{"GET", "/effective_go.html"},
{"GET", "/files.log"},
{"GET", "/gccgo_contribute.html"},
{"GET", "/gccgo_install.html"},
{"GET", "/go-logo-black.png"},
{"GET", "/go-logo-blue.png"},
{"GET", "/go-logo-white.png"},
{"GET", "/go1.1.html"},
{"GET", "/go1.2.html"},
{"GET", "/go1.html"},
{"GET", "/go1compat.html"},
{"GET", "/go_faq.html"},
{"GET", "/go_mem.html"},
{"GET", "/go_spec.html"},
{"GET", "/help.html"},
{"GET", "/ie.css"},
{"GET", "/install-source.html"},
{"GET", "/install.html"},
{"GET", "/logo-153x55.png"},
{"GET", "/Makefile"},
{"GET", "/root.html"},
{"GET", "/share.png"},
{"GET", "/sieve.gif"},
{"GET", "/tos.html"},
{"GET", "/articles/"},
{"GET", "/articles/go_command.html"},
{"GET", "/articles/index.html"},
{"GET", "/articles/wiki/"},
{"GET", "/articles/wiki/edit.html"},
{"GET", "/articles/wiki/final-noclosure.go"},
{"GET", "/articles/wiki/final-noerror.go"},
{"GET", "/articles/wiki/final-parsetemplate.go"},
{"GET", "/articles/wiki/final-template.go"},
{"GET", "/articles/wiki/final.go"},
{"GET", "/articles/wiki/get.go"},
{"GET", "/articles/wiki/http-sample.go"},
{"GET", "/articles/wiki/index.html"},
{"GET", "/articles/wiki/Makefile"},
{"GET", "/articles/wiki/notemplate.go"},
{"GET", "/articles/wiki/part1-noerror.go"},
{"GET", "/articles/wiki/part1.go"},
{"GET", "/articles/wiki/part2.go"},
{"GET", "/articles/wiki/part3-errorhandling.go"},
{"GET", "/articles/wiki/part3.go"},
{"GET", "/articles/wiki/test.bash"},
{"GET", "/articles/wiki/test_edit.good"},
{"GET", "/articles/wiki/test_Test.txt.good"},
{"GET", "/articles/wiki/test_view.good"},
{"GET", "/articles/wiki/view.html"},
{"GET", "/codewalk/"},
{"GET", "/codewalk/codewalk.css"},
{"GET", "/codewalk/codewalk.js"},
{"GET", "/codewalk/codewalk.xml"},
{"GET", "/codewalk/functions.xml"},
{"GET", "/codewalk/markov.go"},
{"GET", "/codewalk/markov.xml"},
{"GET", "/codewalk/pig.go"},
{"GET", "/codewalk/popout.png"},
{"GET", "/codewalk/run"},
{"GET", "/codewalk/sharemem.xml"},
{"GET", "/codewalk/urlpoll.go"},
{"GET", "/devel/"},
{"GET", "/devel/release.html"},
{"GET", "/devel/weekly.html"},
{"GET", "/gopher/"},
{"GET", "/gopher/appenginegopher.jpg"},
{"GET", "/gopher/appenginegophercolor.jpg"},
{"GET", "/gopher/appenginelogo.gif"},
{"GET", "/gopher/bumper.png"},
{"GET", "/gopher/bumper192x108.png"},
{"GET", "/gopher/bumper320x180.png"},
{"GET", "/gopher/bumper480x270.png"},
{"GET", "/gopher/bumper640x360.png"},
{"GET", "/gopher/doc.png"},
{"GET", "/gopher/frontpage.png"},
{"GET", "/gopher/gopherbw.png"},
{"GET", "/gopher/gophercolor.png"},
{"GET", "/gopher/gophercolor16x16.png"},
{"GET", "/gopher/help.png"},
{"GET", "/gopher/pkg.png"},
{"GET", "/gopher/project.png"},
{"GET", "/gopher/ref.png"},
{"GET", "/gopher/run.png"},
{"GET", "/gopher/talks.png"},
{"GET", "/gopher/pencil/"},
{"GET", "/gopher/pencil/gopherhat.jpg"},
{"GET", "/gopher/pencil/gopherhelmet.jpg"},
{"GET", "/gopher/pencil/gophermega.jpg"},
{"GET", "/gopher/pencil/gopherrunning.jpg"},
{"GET", "/gopher/pencil/gopherswim.jpg"},
{"GET", "/gopher/pencil/gopherswrench.jpg"},
{"GET", "/play/"},
{"GET", "/play/fib.go"},
{"GET", "/play/hello.go"},
{"GET", "/play/life.go"},
{"GET", "/play/peano.go"},
{"GET", "/play/pi.go"},
{"GET", "/play/sieve.go"},
{"GET", "/play/solitaire.go"},
{"GET", "/play/tree.go"},
{"GET", "/progs/"},
{"GET", "/progs/cgo1.go"},
{"GET", "/progs/cgo2.go"},
{"GET", "/progs/cgo3.go"},
{"GET", "/progs/cgo4.go"},
{"GET", "/progs/defer.go"},
{"GET", "/progs/defer.out"},
{"GET", "/progs/defer2.go"},
{"GET", "/progs/defer2.out"},
{"GET", "/progs/eff_bytesize.go"},
{"GET", "/progs/eff_bytesize.out"},
{"GET", "/progs/eff_qr.go"},
{"GET", "/progs/eff_sequence.go"},
{"GET", "/progs/eff_sequence.out"},
{"GET", "/progs/eff_unused1.go"},
{"GET", "/progs/eff_unused2.go"},
{"GET", "/progs/error.go"},
{"GET", "/progs/error2.go"},
{"GET", "/progs/error3.go"},
{"GET", "/progs/error4.go"},
{"GET", "/progs/go1.go"},
{"GET", "/progs/gobs1.go"},
{"GET", "/progs/gobs2.go"},
{"GET", "/progs/image_draw.go"},
{"GET", "/progs/image_package1.go"},
{"GET", "/progs/image_package1.out"},
{"GET", "/progs/image_package2.go"},
{"GET", "/progs/image_package2.out"},
{"GET", "/progs/image_package3.go"},
{"GET", "/progs/image_package3.out"},
{"GET", "/progs/image_package4.go"},
{"GET", "/progs/image_package4.out"},
{"GET", "/progs/image_package5.go"},
{"GET", "/progs/image_package5.out"},
{"GET", "/progs/image_package6.go"},
{"GET", "/progs/image_package6.out"},
{"GET", "/progs/interface.go"},
{"GET", "/progs/interface2.go"},
{"GET", "/progs/interface2.out"},
{"GET", "/progs/json1.go"},
{"GET", "/progs/json2.go"},
{"GET", "/progs/json2.out"},
{"GET", "/progs/json3.go"},
{"GET", "/progs/json4.go"},
{"GET", "/progs/json5.go"},
{"GET", "/progs/run"},
{"GET", "/progs/slices.go"},
{"GET", "/progs/timeout1.go"},
{"GET", "/progs/timeout2.go"},
{"GET", "/progs/update.bash"},
}
githubAPI = []*Route{
// OAuth Authorizations
{"GET", "/authorizations"},
{"GET", "/authorizations/:id"},
{"POST", "/authorizations"},
//{"PUT", "/authorizations/clients/:client_id"},
//{"PATCH", "/authorizations/:id"},
{"DELETE", "/authorizations/:id"},
{"GET", "/applications/:client_id/tokens/:access_token"},
{"DELETE", "/applications/:client_id/tokens"},
{"DELETE", "/applications/:client_id/tokens/:access_token"},
// Activity
{"GET", "/events"},
{"GET", "/repos/:owner/:repo/events"},
{"GET", "/networks/:owner/:repo/events"},
{"GET", "/orgs/:org/events"},
{"GET", "/users/:user/received_events"},
{"GET", "/users/:user/received_events/public"},
{"GET", "/users/:user/events"},
{"GET", "/users/:user/events/public"},
{"GET", "/users/:user/events/orgs/:org"},
{"GET", "/feeds"},
{"GET", "/notifications"},
{"GET", "/repos/:owner/:repo/notifications"},
{"PUT", "/notifications"},
{"PUT", "/repos/:owner/:repo/notifications"},
{"GET", "/notifications/threads/:id"},
//{"PATCH", "/notifications/threads/:id"},
{"GET", "/notifications/threads/:id/subscription"},
{"PUT", "/notifications/threads/:id/subscription"},
{"DELETE", "/notifications/threads/:id/subscription"},
{"GET", "/repos/:owner/:repo/stargazers"},
{"GET", "/users/:user/starred"},
{"GET", "/user/starred"},
{"GET", "/user/starred/:owner/:repo"},
{"PUT", "/user/starred/:owner/:repo"},
{"DELETE", "/user/starred/:owner/:repo"},
{"GET", "/repos/:owner/:repo/subscribers"},
{"GET", "/users/:user/subscriptions"},
{"GET", "/user/subscriptions"},
{"GET", "/repos/:owner/:repo/subscription"},
{"PUT", "/repos/:owner/:repo/subscription"},
{"DELETE", "/repos/:owner/:repo/subscription"},
{"GET", "/user/subscriptions/:owner/:repo"},
{"PUT", "/user/subscriptions/:owner/:repo"},
{"DELETE", "/user/subscriptions/:owner/:repo"},
// Gists
{"GET", "/users/:user/gists"},
{"GET", "/gists"},
//{"GET", "/gists/public"},
//{"GET", "/gists/starred"},
{"GET", "/gists/:id"},
{"POST", "/gists"},
//{"PATCH", "/gists/:id"},
{"PUT", "/gists/:id/star"},
{"DELETE", "/gists/:id/star"},
{"GET", "/gists/:id/star"},
{"POST", "/gists/:id/forks"},
{"DELETE", "/gists/:id"},
// Git Data
{"GET", "/repos/:owner/:repo/git/blobs/:sha"},
{"POST", "/repos/:owner/:repo/git/blobs"},
{"GET", "/repos/:owner/:repo/git/commits/:sha"},
{"POST", "/repos/:owner/:repo/git/commits"},
//{"GET", "/repos/:owner/:repo/git/refs/*ref"},
{"GET", "/repos/:owner/:repo/git/refs"},
{"POST", "/repos/:owner/:repo/git/refs"},
//{"PATCH", "/repos/:owner/:repo/git/refs/*ref"},
//{"DELETE", "/repos/:owner/:repo/git/refs/*ref"},
{"GET", "/repos/:owner/:repo/git/tags/:sha"},
{"POST", "/repos/:owner/:repo/git/tags"},
{"GET", "/repos/:owner/:repo/git/trees/:sha"},
{"POST", "/repos/:owner/:repo/git/trees"},
// Issues
{"GET", "/issues"},
{"GET", "/user/issues"},
{"GET", "/orgs/:org/issues"},
{"GET", "/repos/:owner/:repo/issues"},
{"GET", "/repos/:owner/:repo/issues/:number"},
{"POST", "/repos/:owner/:repo/issues"},
//{"PATCH", "/repos/:owner/:repo/issues/:number"},
{"GET", "/repos/:owner/:repo/assignees"},
{"GET", "/repos/:owner/:repo/assignees/:assignee"},
{"GET", "/repos/:owner/:repo/issues/:number/comments"},
//{"GET", "/repos/:owner/:repo/issues/comments"},
//{"GET", "/repos/:owner/:repo/issues/comments/:id"},
{"POST", "/repos/:owner/:repo/issues/:number/comments"},
//{"PATCH", "/repos/:owner/:repo/issues/comments/:id"},
//{"DELETE", "/repos/:owner/:repo/issues/comments/:id"},
{"GET", "/repos/:owner/:repo/issues/:number/events"},
//{"GET", "/repos/:owner/:repo/issues/events"},
//{"GET", "/repos/:owner/:repo/issues/events/:id"},
{"GET", "/repos/:owner/:repo/labels"},
{"GET", "/repos/:owner/:repo/labels/:name"},
{"POST", "/repos/:owner/:repo/labels"},
//{"PATCH", "/repos/:owner/:repo/labels/:name"},
{"DELETE", "/repos/:owner/:repo/labels/:name"},
{"GET", "/repos/:owner/:repo/issues/:number/labels"},
{"POST", "/repos/:owner/:repo/issues/:number/labels"},
{"DELETE", "/repos/:owner/:repo/issues/:number/labels/:name"},
{"PUT", "/repos/:owner/:repo/issues/:number/labels"},
{"DELETE", "/repos/:owner/:repo/issues/:number/labels"},
{"GET", "/repos/:owner/:repo/milestones/:number/labels"},
{"GET", "/repos/:owner/:repo/milestones"},
{"GET", "/repos/:owner/:repo/milestones/:number"},
{"POST", "/repos/:owner/:repo/milestones"},
//{"PATCH", "/repos/:owner/:repo/milestones/:number"},
{"DELETE", "/repos/:owner/:repo/milestones/:number"},
// Miscellaneous
{"GET", "/emojis"},
{"GET", "/gitignore/templates"},
{"GET", "/gitignore/templates/:name"},
{"POST", "/markdown"},
{"POST", "/markdown/raw"},
{"GET", "/meta"},
{"GET", "/rate_limit"},
// Organizations
{"GET", "/users/:user/orgs"},
{"GET", "/user/orgs"},
{"GET", "/orgs/:org"},
//{"PATCH", "/orgs/:org"},
{"GET", "/orgs/:org/members"},
{"GET", "/orgs/:org/members/:user"},
{"DELETE", "/orgs/:org/members/:user"},
{"GET", "/orgs/:org/public_members"},
{"GET", "/orgs/:org/public_members/:user"},
{"PUT", "/orgs/:org/public_members/:user"},
{"DELETE", "/orgs/:org/public_members/:user"},
{"GET", "/orgs/:org/teams"},
{"GET", "/teams/:id"},
{"POST", "/orgs/:org/teams"},
//{"PATCH", "/teams/:id"},
{"DELETE", "/teams/:id"},
{"GET", "/teams/:id/members"},
{"GET", "/teams/:id/members/:user"},
{"PUT", "/teams/:id/members/:user"},
{"DELETE", "/teams/:id/members/:user"},
{"GET", "/teams/:id/repos"},
{"GET", "/teams/:id/repos/:owner/:repo"},
{"PUT", "/teams/:id/repos/:owner/:repo"},
{"DELETE", "/teams/:id/repos/:owner/:repo"},
{"GET", "/user/teams"},
// Pull Requests
{"GET", "/repos/:owner/:repo/pulls"},
{"GET", "/repos/:owner/:repo/pulls/:number"},
{"POST", "/repos/:owner/:repo/pulls"},
//{"PATCH", "/repos/:owner/:repo/pulls/:number"},
{"GET", "/repos/:owner/:repo/pulls/:number/commits"},
{"GET", "/repos/:owner/:repo/pulls/:number/files"},
{"GET", "/repos/:owner/:repo/pulls/:number/merge"},
{"PUT", "/repos/:owner/:repo/pulls/:number/merge"},
{"GET", "/repos/:owner/:repo/pulls/:number/comments"},
//{"GET", "/repos/:owner/:repo/pulls/comments"},
//{"GET", "/repos/:owner/:repo/pulls/comments/:number"},
{"PUT", "/repos/:owner/:repo/pulls/:number/comments"},
//{"PATCH", "/repos/:owner/:repo/pulls/comments/:number"},
//{"DELETE", "/repos/:owner/:repo/pulls/comments/:number"},
// Repositories
{"GET", "/user/repos"},
{"GET", "/users/:user/repos"},
{"GET", "/orgs/:org/repos"},
{"GET", "/repositories"},
{"POST", "/user/repos"},
{"POST", "/orgs/:org/repos"},
{"GET", "/repos/:owner/:repo"},
//{"PATCH", "/repos/:owner/:repo"},
{"GET", "/repos/:owner/:repo/contributors"},
{"GET", "/repos/:owner/:repo/languages"},
{"GET", "/repos/:owner/:repo/teams"},
{"GET", "/repos/:owner/:repo/tags"},
{"GET", "/repos/:owner/:repo/branches"},
{"GET", "/repos/:owner/:repo/branches/:branch"},
{"DELETE", "/repos/:owner/:repo"},
{"GET", "/repos/:owner/:repo/collaborators"},
{"GET", "/repos/:owner/:repo/collaborators/:user"},
{"PUT", "/repos/:owner/:repo/collaborators/:user"},
{"DELETE", "/repos/:owner/:repo/collaborators/:user"},
{"GET", "/repos/:owner/:repo/comments"}, | {"POST", "/repos/:owner/:repo/commits/:sha/comments"},
{"GET", "/repos/:owner/:repo/comments/:id"},
//{"PATCH", "/repos/:owner/:repo/comments/:id"},
{"DELETE", "/repos/:owner/:repo/comments/:id"},
{"GET", "/repos/:owner/:repo/commits"},
{"GET", "/repos/:owner/:repo/commits/:sha"},
{"GET", "/repos/:owner/:repo/readme"},
//{"GET", "/repos/:owner/:repo/contents/*path"},
//{"PUT", "/repos/:owner/:repo/contents/*path"},
//{"DELETE", "/repos/:owner/:repo/contents/*path"},
//{"GET", "/repos/:owner/:repo/:archive_format/:ref"},
{"GET", "/repos/:owner/:repo/keys"},
{"GET", "/repos/:owner/:repo/keys/:id"},
{"POST", "/repos/:owner/:repo/keys"},
//{"PATCH", "/repos/:owner/:repo/keys/:id"},
{"DELETE", "/repos/:owner/:repo/keys/:id"},
{"GET", "/repos/:owner/:repo/downloads"},
{"GET", "/repos/:owner/:repo/downloads/:id"},
{"DELETE", "/repos/:owner/:repo/downloads/:id"},
{"GET", "/repos/:owner/:repo/forks"},
{"POST", "/repos/:owner/:repo/forks"},
{"GET", "/repos/:owner/:repo/hooks"},
{"GET", "/repos/:owner/:repo/hooks/:id"},
{"POST", "/repos/:owner/:repo/hooks"},
//{"PATCH", "/repos/:owner/:repo/hooks/:id"},
{"POST", "/repos/:owner/:repo/hooks/:id/tests"},
{"DELETE", "/repos/:owner/:repo/hooks/:id"},
{"POST", "/repos/:owner/:repo/merges"},
{"GET", "/repos/:owner/:repo/releases"},
{"GET", "/repos/:owner/:repo/releases/:id"},
{"POST", "/repos/:owner/:repo/releases"},
//{"PATCH", "/repos/:owner/:repo/releases/:id"},
{"DELETE", "/repos/:owner/:repo/releases/:id"},
{"GET", "/repos/:owner/:repo/releases/:id/assets"},
{"GET", "/repos/:owner/:repo/stats/contributors"},
{"GET", "/repos/:owner/:repo/stats/commit_activity"},
{"GET", "/repos/:owner/:repo/stats/code_frequency"},
{"GET", "/repos/:owner/:repo/stats/participation"},
{"GET", "/repos/:owner/:repo/stats/punch_card"},
{"GET", "/repos/:owner/:repo/statuses/:ref"},
{"POST", "/repos/:owner/:repo/statuses/:ref"},
// Search
{"GET", "/search/repositories"},
{"GET", "/search/code"},
{"GET", "/search/issues"},
{"GET", "/search/users"},
{"GET", "/legacy/issues/search/:owner/:repository/:state/:keyword"},
{"GET", "/legacy/repos/search/:keyword"},
{"GET", "/legacy/user/search/:keyword"},
{"GET", "/legacy/user/email/:email"},
// Users
{"GET", "/users/:user"},
{"GET", "/user"},
//{"PATCH", "/user"},
{"GET", "/users"},
{"GET", "/user/emails"},
{"POST", "/user/emails"},
{"DELETE", "/user/emails"},
{"GET", "/users/:user/followers"},
{"GET", "/user/followers"},
{"GET", "/users/:user/following"},
{"GET", "/user/following"},
{"GET", "/user/following/:user"},
{"GET", "/users/:user/following/:target_user"},
{"PUT", "/user/following/:user"},
{"DELETE", "/user/following/:user"},
{"GET", "/users/:user/keys"},
{"GET", "/user/keys"},
{"GET", "/user/keys/:id"},
{"POST", "/user/keys"},
//{"PATCH", "/user/keys/:id"},
{"DELETE", "/user/keys/:id"},
}
gplusAPI = []*Route{
// People
{"GET", "/people/:userId"},
{"GET", "/people"},
{"GET", "/activities/:activityId/people/:collection"},
{"GET", "/people/:userId/people/:collection"},
{"GET", "/people/:userId/openIdConnect"},
// Activities
{"GET", "/people/:userId/activities/:collection"},
{"GET", "/activities/:activityId"},
{"GET", "/activities"},
// Comments
{"GET", "/activities/:activityId/comments"},
{"GET", "/comments/:commentId"},
// Moments
{"POST", "/people/:userId/moments/:collection"},
{"GET", "/people/:userId/moments/:collection"},
{"DELETE", "/moments/:id"},
}
parseAPI = []*Route{
// Objects
{"POST", "/1/classes/:className"},
{"GET", "/1/classes/:className/:objectId"},
{"PUT", "/1/classes/:className/:objectId"},
{"GET", "/1/classes/:className"},
{"DELETE", "/1/classes/:className/:objectId"},
// Users
{"POST", "/1/users"},
{"GET", "/1/login"},
{"GET", "/1/users/:objectId"},
{"PUT", "/1/users/:objectId"},
{"GET", "/1/users"},
{"DELETE", "/1/users/:objectId"},
{"POST", "/1/requestPasswordReset"},
// Roles
{"POST", "/1/roles"},
{"GET", "/1/roles/:objectId"},
{"PUT", "/1/roles/:objectId"},
{"GET", "/1/roles"},
{"DELETE", "/1/roles/:objectId"},
// Files
{"POST", "/1/files/:fileName"},
// Analytics
{"POST", "/1/events/:eventName"},
// Push Notifications
{"POST", "/1/push"},
// Installations
{"POST", "/1/installations"},
{"GET", "/1/installations/:objectId"},
{"PUT", "/1/installations/:objectId"},
{"GET", "/1/installations"},
{"DELETE", "/1/installations/:objectId"},
// Cloud Functions
{"POST", "/1/functions"},
}
apis = [][]*Route{githubAPI, gplusAPI, parseAPI}
)
func init() {
str := os.Getenv("NUM")
if len(str) > 0 {
n, err := strconv.Atoi(str)
if err == nil {
num = n
}
}
}
func benchmarkRoutes(b *testing.B, router http.Handler, routes []*Route) {
b.ReportAllocs()
r := httptest.NewRequest("GET", "/", nil)
u := r.URL
w := httptest.NewRecorder()
for i := 0; i < b.N; i++ {
for _, route := range routes {
r.Method = route.Method
u.Path = route.Path
r.URL.Path = route.Path
router.ServeHTTP(w, r)
}
}
}
// echo
func loadEchoRoutes(e *echo.Echo, routes []*Route) {
for i := 0; i < num; i++ {
e.Use(func(h echo.HandlerFunc) echo.HandlerFunc {
return func(ctx echo.Context) error {
return h(ctx)
}
})
}
for _, r := range routes {
switch r.Method {
case "GET":
e.GET(r.Path, echoHandler(r.Method, r.Path))
case "POST":
e.POST(r.Path, echoHandler(r.Method, r.Path))
case "PATCH":
e.PATCH(r.Path, echoHandler(r.Method, r.Path))
case "PUT":
e.PUT(r.Path, echoHandler(r.Method, r.Path))
case "DELETE":
e.DELETE(r.Path, echoHandler(r.Method, r.Path))
}
}
}
func echoHandler(method, path string) echo.HandlerFunc {
return func(c echo.Context) error {
return c.String(http.StatusOK, "OK")
}
}
func Benchmark_Echo_Static(b *testing.B) {
e := echo.New()
loadEchoRoutes(e, static)
benchmarkRoutes(b, e, static)
}
func Benchmark_Echo_GitHubAPI(b *testing.B) {
e := echo.New()
loadEchoRoutes(e, githubAPI)
benchmarkRoutes(b, e, githubAPI)
}
func Benchmark_Echo_GplusAPI(b *testing.B) {
e := echo.New()
loadEchoRoutes(e, gplusAPI)
benchmarkRoutes(b, e, gplusAPI)
}
func Benchmark_Echo_ParseAPI(b *testing.B) {
e := echo.New()
loadEchoRoutes(e, parseAPI)
benchmarkRoutes(b, e, parseAPI)
}
// gorouter
func loadGorouterRoutes(e *gorouter.Router, routes []*Route) {
for _, r := range routes {
switch r.Method {
case "GET":
e.GET(r.Path, goHandler(r.Method, r.Path))
case "POST":
e.POST(r.Path, goHandler(r.Method, r.Path))
case "PUT":
e.PUT(r.Path, goHandler(r.Method, r.Path))
case "DELETE":
e.DELETE(r.Path, goHandler(r.Method, r.Path))
}
}
}
func goHandler(method, path string) gorouter.Handle {
return func(w http.ResponseWriter, req *http.Request, p *gorouter.Param) {
w.WriteHeader(http.StatusOK)
w.Write([]byte("OK"))
}
}
func Benchmark_Gorouter_Static(b *testing.B) {
e := gorouter.New()
loadGorouterRoutes(e, static)
benchmarkRoutes(b, e, static)
}
func Benchmark_Gorouter_GitHubAPI(b *testing.B) {
e := gorouter.New()
loadGorouterRoutes(e, githubAPI)
benchmarkRoutes(b, e, githubAPI)
}
func Benchmark_Gorouter_GplusAPI(b *testing.B) {
e := gorouter.New()
loadGorouterRoutes(e, gplusAPI)
benchmarkRoutes(b, e, gplusAPI)
}
func Benchmark_Gorouter_ParseAPI(b *testing.B) {
e := gorouter.New()
loadGorouterRoutes(e, parseAPI)
benchmarkRoutes(b, e, parseAPI)
}
// gin
func loadGinRoutes(g *gin.Engine, routes []*Route) {
for i := 0; i < num; i++ {
g.Use(func(*gin.Context) {})
}
if os.Getenv("SP") != "" {
g.Use(func(ctx *gin.Context) {
fmt.Println("gin path", ctx.FullPath())
})
}
for _, r := range routes {
switch r.Method {
case "GET":
g.GET(r.Path, ginHandler(r.Method, r.Path))
case "POST":
g.POST(r.Path, ginHandler(r.Method, r.Path))
case "PATCH":
g.PATCH(r.Path, ginHandler(r.Method, r.Path))
case "PUT":
g.PUT(r.Path, ginHandler(r.Method, r.Path))
case "DELETE":
g.DELETE(r.Path, ginHandler(r.Method, r.Path))
}
}
}
func ginHandler(method, path string) gin.HandlerFunc {
return func(c *gin.Context) {
c.String(http.StatusOK, "OK")
}
}
func Benchmark_Gin_Static(b *testing.B) {
gin.SetMode(gin.ReleaseMode)
g := gin.New()
loadGinRoutes(g, static)
benchmarkRoutes(b, g, static)
}
func Benchmark_Gin_GitHubAPI(b *testing.B) {
gin.SetMode(gin.ReleaseMode)
g := gin.New()
loadGinRoutes(g, githubAPI)
benchmarkRoutes(b, g, githubAPI)
}
func Benchmark_Gin_GplusAPI(b *testing.B) {
gin.SetMode(gin.ReleaseMode)
g := gin.New()
loadGinRoutes(g, gplusAPI)
benchmarkRoutes(b, g, gplusAPI)
}
func Benchmark_Gin_ParseAPI(b *testing.B) {
gin.SetMode(gin.ReleaseMode)
g := gin.New()
loadGinRoutes(g, parseAPI)
benchmarkRoutes(b, g, parseAPI)
}
// beego
func loadBeegoRoutes(app *beego.App, routes []*Route) {
for _, r := range routes {
switch r.Method {
case "GET":
app.Handlers.Get(r.Path, beegoHandler(r.Method, r.Path))
case "POST":
app.Handlers.Post(r.Path, beegoHandler(r.Method, r.Path))
case "PATCH":
app.Handlers.Patch(r.Path, beegoHandler(r.Method, r.Path))
case "PUT":
app.Handlers.Put(r.Path, beegoHandler(r.Method, r.Path))
case "DELETE":
app.Handlers.Delete(r.Path, beegoHandler(r.Method, r.Path))
}
}
}
func beegoHandler(method, path string) beego.FilterFunc {
return func(ctx *beegocontext.Context) {
ctx.Output.Body([]byte("OK"))
}
}
func Benchmark_Beego_Static(b *testing.B) {
if num > 0 {
return
}
beego.SetLevel(beego.LevelEmergency)
app := beego.NewApp()
loadBeegoRoutes(app, static)
benchmarkRoutes(b, app.Handlers, static)
}
func Benchmark_Beego_GitHubAPI(b *testing.B) {
if num > 0 {
return
}
app := beego.NewApp()
loadBeegoRoutes(app, githubAPI)
benchmarkRoutes(b, app.Handlers, githubAPI)
}
func Benchmark_Beego_GplusAPI(b *testing.B) {
if num > 0 {
return
}
app := beego.NewApp()
loadBeegoRoutes(app, gplusAPI)
benchmarkRoutes(b, app.Handlers, gplusAPI)
}
func Benchmark_Beego_ParseAPI(b *testing.B) {
if num > 0 {
return
}
app := beego.NewApp()
loadBeegoRoutes(app, parseAPI)
benchmarkRoutes(b, app.Handlers, parseAPI)
}
// httprouter
func loadHttprouterRoutes(g *httprouter.Router, routes []*Route) {
for _, r := range routes {
switch r.Method {
case "GET":
g.GET(r.Path, httprouterHandler(r.Method, r.Path))
case "POST":
g.POST(r.Path, httprouterHandler(r.Method, r.Path))
case "PATCH":
g.PATCH(r.Path, httprouterHandler(r.Method, r.Path))
case "PUT":
g.PUT(r.Path, httprouterHandler(r.Method, r.Path))
case "DELETE":
g.DELETE(r.Path, httprouterHandler(r.Method, r.Path))
}
}
}
func httprouterHandler(method, path string) httprouter.Handle {
return func(w http.ResponseWriter, req *http.Request, p httprouter.Params) {
w.WriteHeader(http.StatusOK)
w.Write([]byte("OK"))
}
}
func Benchmark_Httprouter_Static(b *testing.B) {
if num > 0 {
return
}
router := httprouter.New()
loadHttprouterRoutes(router, static)
benchmarkRoutes(b, router, static)
}
func Benchmark_Httprouter_GitHubAPI(b *testing.B) {
if num > 0 {
return
}
router := httprouter.New()
loadHttprouterRoutes(router, githubAPI)
benchmarkRoutes(b, router, githubAPI)
}
func Benchmark_Httprouter_GplusAPI(b *testing.B) {
if num > 0 {
return
}
router := httprouter.New()
loadHttprouterRoutes(router, gplusAPI)
benchmarkRoutes(b, router, gplusAPI)
}
func Benchmark_Httprouter_ParseAPI(b *testing.B) {
if num > 0 {
return
}
router := httprouter.New()
loadHttprouterRoutes(router, parseAPI)
benchmarkRoutes(b, router, parseAPI)
} | {"GET", "/repos/:owner/:repo/commits/:sha/comments"}, |
walletTransaction.routes.js | // 1. import module Router
import { Router } from 'express'; |
const router = Router();
router.get('/', indexCtrl.walletTransaction.readWalletTransaction);
router.post('/insertWalletTransaction',indexCtrl.walletTransaction.addWalletTransaction);
router.put('/updateWalletTransaction/:watr_id',indexCtrl.walletTransaction.editWalletTransaction);
router.delete('/deleteWalletTransaction/:watr_id',indexCtrl.walletTransaction.deleteWalletTransaction);
export default router; | import indexCtrl from '../controllers/IndexController' |
json.rs | //! A JSON emitter for errors.
//!
//! This works by converting errors to a simplified structural format (see the
//! structs at the start of the file) and then serializing them. These should
//! contain as much information about the error as possible.
//!
//! The format of the JSON output should be considered *unstable*. For now the
//! structs at the end of this file (Diagnostic*) specify the error format.
// FIXME: spec the JSON output properly.
use rustc_span::source_map::{FilePathMapping, SourceMap};
use crate::emitter::{Emitter, HumanReadableErrorType};
use crate::registry::Registry;
use crate::DiagnosticId;
use crate::ToolMetadata;
use crate::{CodeSuggestion, FluentBundle, MultiSpan, SpanLabel, SubDiagnostic};
use rustc_lint_defs::Applicability;
use rustc_data_structures::sync::Lrc;
use rustc_error_messages::FluentArgs;
use rustc_span::hygiene::ExpnData;
use rustc_span::Span;
use std::io::{self, Write};
use std::path::Path;
use std::sync::{Arc, Mutex};
use std::vec;
use rustc_serialize::json::{as_json, as_pretty_json};
use rustc_serialize::{Encodable, Encoder};
#[cfg(test)]
mod tests;
pub struct JsonEmitter {
dst: Box<dyn Write + Send>,
registry: Option<Registry>,
sm: Lrc<SourceMap>,
fluent_bundle: Option<Lrc<FluentBundle>>,
fallback_bundle: Lrc<FluentBundle>,
pretty: bool,
ui_testing: bool,
json_rendered: HumanReadableErrorType,
terminal_width: Option<usize>,
macro_backtrace: bool,
}
impl JsonEmitter {
pub fn stderr(
registry: Option<Registry>,
source_map: Lrc<SourceMap>,
fluent_bundle: Option<Lrc<FluentBundle>>,
fallback_bundle: Lrc<FluentBundle>,
pretty: bool,
json_rendered: HumanReadableErrorType,
terminal_width: Option<usize>,
macro_backtrace: bool,
) -> JsonEmitter {
JsonEmitter {
dst: Box::new(io::BufWriter::new(io::stderr())),
registry,
sm: source_map,
fluent_bundle,
fallback_bundle,
pretty,
ui_testing: false,
json_rendered,
terminal_width,
macro_backtrace,
}
}
pub fn basic(
pretty: bool,
json_rendered: HumanReadableErrorType,
fluent_bundle: Option<Lrc<FluentBundle>>,
fallback_bundle: Lrc<FluentBundle>,
terminal_width: Option<usize>,
macro_backtrace: bool,
) -> JsonEmitter {
let file_path_mapping = FilePathMapping::empty();
JsonEmitter::stderr(
None,
Lrc::new(SourceMap::new(file_path_mapping)),
fluent_bundle,
fallback_bundle,
pretty,
json_rendered,
terminal_width,
macro_backtrace,
)
}
pub fn new(
dst: Box<dyn Write + Send>,
registry: Option<Registry>,
source_map: Lrc<SourceMap>,
fluent_bundle: Option<Lrc<FluentBundle>>,
fallback_bundle: Lrc<FluentBundle>,
pretty: bool,
json_rendered: HumanReadableErrorType,
terminal_width: Option<usize>,
macro_backtrace: bool,
) -> JsonEmitter {
JsonEmitter {
dst,
registry,
sm: source_map,
fluent_bundle,
fallback_bundle,
pretty,
ui_testing: false,
json_rendered,
terminal_width,
macro_backtrace,
}
}
pub fn ui_testing(self, ui_testing: bool) -> Self {
Self { ui_testing, ..self }
}
}
impl Emitter for JsonEmitter {
fn emit_diagnostic(&mut self, diag: &crate::Diagnostic) {
let data = Diagnostic::from_errors_diagnostic(diag, self);
let result = if self.pretty {
writeln!(&mut self.dst, "{}", as_pretty_json(&data))
} else {
writeln!(&mut self.dst, "{}", as_json(&data))
}
.and_then(|_| self.dst.flush());
if let Err(e) = result {
panic!("failed to print diagnostics: {:?}", e);
}
}
fn emit_artifact_notification(&mut self, path: &Path, artifact_type: &str) {
let data = ArtifactNotification { artifact: path, emit: artifact_type };
let result = if self.pretty {
writeln!(&mut self.dst, "{}", as_pretty_json(&data))
} else {
writeln!(&mut self.dst, "{}", as_json(&data))
}
.and_then(|_| self.dst.flush());
if let Err(e) = result {
panic!("failed to print notification: {:?}", e);
}
}
fn emit_future_breakage_report(&mut self, diags: Vec<crate::Diagnostic>) {
let data: Vec<FutureBreakageItem> = diags
.into_iter()
.map(|mut diag| {
if diag.level == crate::Level::Allow {
diag.level = crate::Level::Warning;
}
FutureBreakageItem { diagnostic: Diagnostic::from_errors_diagnostic(&diag, self) }
})
.collect();
let report = FutureIncompatReport { future_incompat_report: data };
let result = if self.pretty {
writeln!(&mut self.dst, "{}", as_pretty_json(&report))
} else {
writeln!(&mut self.dst, "{}", as_json(&report))
}
.and_then(|_| self.dst.flush());
if let Err(e) = result {
panic!("failed to print future breakage report: {:?}", e);
}
}
fn emit_unused_externs(&mut self, lint_level: &str, unused_externs: &[&str]) {
let data = UnusedExterns { lint_level, unused_extern_names: unused_externs };
let result = if self.pretty {
writeln!(&mut self.dst, "{}", as_pretty_json(&data))
} else {
writeln!(&mut self.dst, "{}", as_json(&data))
}
.and_then(|_| self.dst.flush());
if let Err(e) = result {
panic!("failed to print unused externs: {:?}", e);
}
}
fn source_map(&self) -> Option<&Lrc<SourceMap>> {
Some(&self.sm)
}
fn fluent_bundle(&self) -> Option<&Lrc<FluentBundle>> {
self.fluent_bundle.as_ref()
}
fn fallback_fluent_bundle(&self) -> &Lrc<FluentBundle> {
&self.fallback_bundle
}
fn should_show_explain(&self) -> bool {
!matches!(self.json_rendered, HumanReadableErrorType::Short(_))
}
}
// The following data types are provided just for serialisation.
// NOTE: this has a manual implementation of Encodable which needs to be updated in
// parallel.
struct Diagnostic {
/// The primary error message.
message: String,
code: Option<DiagnosticCode>,
/// "error: internal compiler error", "error", "warning", "note", "help".
level: &'static str,
spans: Vec<DiagnosticSpan>,
/// Associated diagnostic messages.
children: Vec<Diagnostic>,
/// The message as rustc would render it.
rendered: Option<String>,
/// Extra tool metadata
tool_metadata: ToolMetadata,
}
macro_rules! encode_fields {
(
$enc:expr, // encoder
$idx:expr, // starting field index
$struct:expr, // struct we're serializing
$struct_name:ident, // struct name
[ $($name:ident),+$(,)? ], // fields to encode
[ $($ignore:ident),+$(,)? ] // fields we're skipping
) => {
{
// Pattern match to make sure all fields are accounted for
let $struct_name { $($name,)+ $($ignore: _,)+ } = $struct;
let mut idx = $idx;
$(
$enc.emit_struct_field(
stringify!($name),
idx == 0,
|enc| $name.encode(enc),
)?;
idx += 1;
)+
idx
}
};
}
// Special-case encoder to skip tool_metadata if not set
impl<E: Encoder> Encodable<E> for Diagnostic {
fn encode(&self, s: &mut E) -> Result<(), E::Error> {
s.emit_struct(false, |s| {
let mut idx = 0;
idx = encode_fields!(
s,
idx,
self,
Self,
[message, code, level, spans, children, rendered],
[tool_metadata]
);
if self.tool_metadata.is_set() {
idx = encode_fields!(
s,
idx,
self,
Self,
[tool_metadata],
[message, code, level, spans, children, rendered]
);
}
let _ = idx;
Ok(())
})
}
}
#[derive(Encodable)]
struct DiagnosticSpan {
file_name: String,
byte_start: u32,
byte_end: u32,
/// 1-based.
line_start: usize,
line_end: usize,
/// 1-based, character offset.
column_start: usize,
column_end: usize,
/// Is this a "primary" span -- meaning the point, or one of the points,
/// where the error occurred?
is_primary: bool,
/// Source text from the start of line_start to the end of line_end.
text: Vec<DiagnosticSpanLine>,
/// Label that should be placed at this location (if any)
label: Option<String>,
/// If we are suggesting a replacement, this will contain text
/// that should be sliced in atop this span.
suggested_replacement: Option<String>,
/// If the suggestion is approximate
suggestion_applicability: Option<Applicability>,
/// Macro invocations that created the code at this span, if any.
expansion: Option<Box<DiagnosticSpanMacroExpansion>>,
}
#[derive(Encodable)]
struct DiagnosticSpanLine {
text: String,
/// 1-based, character offset in self.text.
highlight_start: usize,
highlight_end: usize,
}
#[derive(Encodable)]
struct DiagnosticSpanMacroExpansion {
/// span where macro was applied to generate this code; note that
/// this may itself derive from a macro (if
/// `span.expansion.is_some()`)
span: DiagnosticSpan,
/// name of macro that was applied (e.g., "foo!" or "#[derive(Eq)]")
macro_decl_name: String,
/// span where macro was defined (if known)
def_site_span: DiagnosticSpan,
}
#[derive(Encodable)]
struct DiagnosticCode {
/// The code itself.
code: String,
/// An explanation for the code.
explanation: Option<&'static str>,
}
#[derive(Encodable)]
struct ArtifactNotification<'a> {
/// The path of the artifact.
artifact: &'a Path,
/// What kind of artifact we're emitting.
emit: &'a str,
}
#[derive(Encodable)]
struct FutureBreakageItem {
diagnostic: Diagnostic,
}
#[derive(Encodable)]
struct FutureIncompatReport {
future_incompat_report: Vec<FutureBreakageItem>,
}
// NOTE: Keep this in sync with the equivalent structs in rustdoc's
// doctest component (as well as cargo).
// We could unify this struct the one in rustdoc but they have different
// ownership semantics, so doing so would create wasteful allocations.
#[derive(Encodable)]
struct | <'a, 'b, 'c> {
/// The severity level of the unused dependencies lint
lint_level: &'a str,
/// List of unused externs by their names.
unused_extern_names: &'b [&'c str],
}
impl Diagnostic {
fn from_errors_diagnostic(diag: &crate::Diagnostic, je: &JsonEmitter) -> Diagnostic {
let args = je.to_fluent_args(diag.args());
let sugg = diag.suggestions.iter().flatten().map(|sugg| {
let translated_message = je.translate_message(&sugg.msg, &args);
Diagnostic {
message: translated_message.to_string(),
code: None,
level: "help",
spans: DiagnosticSpan::from_suggestion(sugg, &args, je),
children: vec![],
rendered: None,
tool_metadata: sugg.tool_metadata.clone(),
}
});
// generate regular command line output and store it in the json
// A threadsafe buffer for writing.
#[derive(Default, Clone)]
struct BufWriter(Arc<Mutex<Vec<u8>>>);
impl Write for BufWriter {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
self.0.lock().unwrap().write(buf)
}
fn flush(&mut self) -> io::Result<()> {
self.0.lock().unwrap().flush()
}
}
let buf = BufWriter::default();
let output = buf.clone();
je.json_rendered
.new_emitter(
Box::new(buf),
Some(je.sm.clone()),
je.fluent_bundle.clone(),
je.fallback_bundle.clone(),
false,
je.terminal_width,
je.macro_backtrace,
)
.ui_testing(je.ui_testing)
.emit_diagnostic(diag);
let output = Arc::try_unwrap(output.0).unwrap().into_inner().unwrap();
let output = String::from_utf8(output).unwrap();
let translated_message = je.translate_messages(&diag.message, &args);
Diagnostic {
message: translated_message.to_string(),
code: DiagnosticCode::map_opt_string(diag.code.clone(), je),
level: diag.level.to_str(),
spans: DiagnosticSpan::from_multispan(&diag.span, &args, je),
children: diag
.children
.iter()
.map(|c| Diagnostic::from_sub_diagnostic(c, &args, je))
.chain(sugg)
.collect(),
rendered: Some(output),
tool_metadata: ToolMetadata::default(),
}
}
fn from_sub_diagnostic(
diag: &SubDiagnostic,
args: &FluentArgs<'_>,
je: &JsonEmitter,
) -> Diagnostic {
let translated_message = je.translate_messages(&diag.message, args);
Diagnostic {
message: translated_message.to_string(),
code: None,
level: diag.level.to_str(),
spans: diag
.render_span
.as_ref()
.map(|sp| DiagnosticSpan::from_multispan(sp, args, je))
.unwrap_or_else(|| DiagnosticSpan::from_multispan(&diag.span, args, je)),
children: vec![],
rendered: None,
tool_metadata: ToolMetadata::default(),
}
}
}
impl DiagnosticSpan {
fn from_span_label(
span: SpanLabel,
suggestion: Option<(&String, Applicability)>,
args: &FluentArgs<'_>,
je: &JsonEmitter,
) -> DiagnosticSpan {
Self::from_span_etc(
span.span,
span.is_primary,
span.label.as_ref().map(|m| je.translate_message(m, args)).map(|m| m.to_string()),
suggestion,
je,
)
}
fn from_span_etc(
span: Span,
is_primary: bool,
label: Option<String>,
suggestion: Option<(&String, Applicability)>,
je: &JsonEmitter,
) -> DiagnosticSpan {
// obtain the full backtrace from the `macro_backtrace`
// helper; in some ways, it'd be better to expand the
// backtrace ourselves, but the `macro_backtrace` helper makes
// some decision, such as dropping some frames, and I don't
// want to duplicate that logic here.
let backtrace = span.macro_backtrace();
DiagnosticSpan::from_span_full(span, is_primary, label, suggestion, backtrace, je)
}
fn from_span_full(
span: Span,
is_primary: bool,
label: Option<String>,
suggestion: Option<(&String, Applicability)>,
mut backtrace: impl Iterator<Item = ExpnData>,
je: &JsonEmitter,
) -> DiagnosticSpan {
let start = je.sm.lookup_char_pos(span.lo());
let end = je.sm.lookup_char_pos(span.hi());
let backtrace_step = backtrace.next().map(|bt| {
let call_site = Self::from_span_full(bt.call_site, false, None, None, backtrace, je);
let def_site_span = Self::from_span_full(
je.sm.guess_head_span(bt.def_site),
false,
None,
None,
[].into_iter(),
je,
);
Box::new(DiagnosticSpanMacroExpansion {
span: call_site,
macro_decl_name: bt.kind.descr(),
def_site_span,
})
});
DiagnosticSpan {
file_name: je.sm.filename_for_diagnostics(&start.file.name).to_string(),
byte_start: start.file.original_relative_byte_pos(span.lo()).0,
byte_end: start.file.original_relative_byte_pos(span.hi()).0,
line_start: start.line,
line_end: end.line,
column_start: start.col.0 + 1,
column_end: end.col.0 + 1,
is_primary,
text: DiagnosticSpanLine::from_span(span, je),
suggested_replacement: suggestion.map(|x| x.0.clone()),
suggestion_applicability: suggestion.map(|x| x.1),
expansion: backtrace_step,
label,
}
}
fn from_multispan(
msp: &MultiSpan,
args: &FluentArgs<'_>,
je: &JsonEmitter,
) -> Vec<DiagnosticSpan> {
msp.span_labels()
.into_iter()
.map(|span_str| Self::from_span_label(span_str, None, args, je))
.collect()
}
fn from_suggestion(
suggestion: &CodeSuggestion,
args: &FluentArgs<'_>,
je: &JsonEmitter,
) -> Vec<DiagnosticSpan> {
suggestion
.substitutions
.iter()
.flat_map(|substitution| {
substitution.parts.iter().map(move |suggestion_inner| {
let span_label =
SpanLabel { span: suggestion_inner.span, is_primary: true, label: None };
DiagnosticSpan::from_span_label(
span_label,
Some((&suggestion_inner.snippet, suggestion.applicability)),
args,
je,
)
})
})
.collect()
}
}
impl DiagnosticSpanLine {
fn line_from_source_file(
sf: &rustc_span::SourceFile,
index: usize,
h_start: usize,
h_end: usize,
) -> DiagnosticSpanLine {
DiagnosticSpanLine {
text: sf.get_line(index).map_or_else(String::new, |l| l.into_owned()),
highlight_start: h_start,
highlight_end: h_end,
}
}
/// Creates a list of DiagnosticSpanLines from span - each line with any part
/// of `span` gets a DiagnosticSpanLine, with the highlight indicating the
/// `span` within the line.
fn from_span(span: Span, je: &JsonEmitter) -> Vec<DiagnosticSpanLine> {
je.sm
.span_to_lines(span)
.map(|lines| {
// We can't get any lines if the source is unavailable.
if !je.sm.ensure_source_file_source_present(lines.file.clone()) {
return vec![];
}
let sf = &*lines.file;
lines
.lines
.iter()
.map(|line| {
DiagnosticSpanLine::line_from_source_file(
sf,
line.line_index,
line.start_col.0 + 1,
line.end_col.0 + 1,
)
})
.collect()
})
.unwrap_or_else(|_| vec![])
}
}
impl DiagnosticCode {
fn map_opt_string(s: Option<DiagnosticId>, je: &JsonEmitter) -> Option<DiagnosticCode> {
s.map(|s| {
let s = match s {
DiagnosticId::Error(s) => s,
DiagnosticId::Lint { name, .. } => name,
};
let je_result =
je.registry.as_ref().map(|registry| registry.try_find_description(&s)).unwrap();
DiagnosticCode { code: s, explanation: je_result.unwrap_or(None) }
})
}
}
| UnusedExterns |
model.go | package agent
// RespGetAgent 查询应用响应
type RespGetAgent struct {
RespCommon
AgentID int64 `json:"agentid"`
Name string `json:"name"`
SquareLogoURL string `json:"square_logo_url"`
Description string `json:"description"`
AllowUserinfos struct {
User []struct {
Userid string `json:"userid"`
} `json:"user"`
} `json:"allow_userinfos"`
AllowPartys struct {
Partyid []int `json:"partyid"`
} `json:"allow_partys"`
AllowTags struct {
Tagid []int `json:"tagid"`
} `json:"allow_tags"`
Close int `json:"close"`
RedirectDomain string `json:"redirect_domain"`
ReportLocationFlag int `json:"report_location_flag"`
Isreportenter int `json:"isreportenter"`
HomeURL string `json:"home_url"`
}
// ReqSetAgent 设置应用请求
type ReqSetAgent struct {
AgentID int64 `json:"agentid"`
ReportLocationFlag int `json:"report_location_flag,omitempty"`
LogoMediaID string `json:"logo_mediaid,omitempty"`
Name string `json:"name,omitempty"`
Description string `json:"description,omitempty"`
RedirectDomain string `json:"redirect_domain,omitempty"`
IsReportEnter int `json:"isreportenter,omitempty"`
HomeURL string `json:"home_url,omitempty"`
}
type RespListAgents struct {
*RespCommon
AgentList []AgentItem `json:"agentlist"`
}
type AgentItem struct { | Agentid int `json:"agentid"`
Name string `json:"name"`
SquareLogoURL string `json:"square_logo_url"`
}
// RespCommon Comman Response Struct
type RespCommon struct {
ErrCode int `json:"errcode"`
ErrMsg string `json:"errmsg"`
} | |
truffle.js | var HDWalletProvider = require("truffle-hdwallet-provider");
// Be sure to match this mnemonic with that in Ganache!
var mnemonic = "candy maple cake sugar pudding cream honey rich smooth crumble sweet treat";
module.exports = {
networks: {
development: {
provider: function() {
return new HDWalletProvider(mnemonic, "http://127.0.0.1:8545/", 0, 10);
},
network_id: '*',
gas: 9999999
}
},
compilers: {
solc: {
version: "0.4.24", // Fetch exact version from solc-bin (default: truffle's version)
// docker: true, // Use "0.5.1" you've installed locally with docker (default: false)
// settings: { // See the solidity docs for advice about optimization and evmVersion
// optimizer: {
// enabled: false,
// runs: 200 | }
}; | // },
// evmVersion: "byzantium"
// }
} |
admin.guard.ts | import { Injectable } from '@angular/core';
import {
CanActivate,
ActivatedRouteSnapshot,
RouterStateSnapshot,
Router
} from '@angular/router';
import { Observable } from 'rxjs';
import { AuthService } from '../services/auth.service';
@Injectable({
providedIn: 'root'
})
export class | implements CanActivate {
constructor(private authService: AuthService, private router: Router) { }
canActivate(
next: ActivatedRouteSnapshot,
state: RouterStateSnapshot): Observable<boolean> | Promise<boolean> | boolean {
if (this.authService.isAdmin()) {
return true;
}
this.router.navigate(['/home']);
return false;
}
}
| AdminGuard |
slack.rs | use crate::{alerts::Alert, probes::Notification};
use anyhow::Result;
use async_trait::async_trait;
use lazy_static::lazy_static;
use prometheus::{register_counter_vec, CounterVec};
use serde::Serialize;
use serde_derive::Deserialize;
#[derive(Debug, Clone, Default, Deserialize)]
pub struct Slack {
namepass: Option<Vec<String>>,
webhook_url: String,
}
lazy_static! {
static ref RUNS_TOTAL: CounterVec = register_counter_vec!(
"alert_slack_runs_total",
"run counter for slack alert plugin",
&["plugin", "webhook_url"]
)
.unwrap();
}
#[async_trait]
impl Alert for Slack {
fn new(namepass: Vec<&str>) -> Self {
Slack {
namepass: Some(namepass.into_iter().map(String::from).collect()),
..Default::default()
}
}
fn namepass(&self) -> Option<Vec<String>> {
self.namepass.clone()
}
| if !self.should_fire(¬if.name) {
log::info!("should not fire slack alert for {}", ¬if.name);
return Ok(());
}
RUNS_TOTAL
.with_label_values(&["alert.slack", "https://hooks.slack.com/services/[redacted]"])
.inc();
log::info!("sending slack alert to webhook url {}", self.webhook_url);
log::debug!("NOTIFICATION: {:?}", notif);
let pretext = format!("*TRIGGERED `{}`:* {}", notif.from, notif.title);
let mut payload = Payload {
username: "Otto".to_string(),
icon_emoji: ":robot_face:".to_string(),
text: pretext.clone(),
attachments: vec![],
};
match notif.message_entries.as_ref() {
Some(message_entries) => {
let entries_length = message_entries.len();
for (i, entry) in message_entries.iter() {
payload.attachments.push(Attachment {
title: format!("[{} of {}] {}", i + 1, entries_length, entry.title),
text: entry.description.replace("**", "*"),
color: "#ede542".to_string(),
})
}
}
None => payload.attachments.push(Attachment {
title: notif.check.clone(),
text: notif.message.replace("**", "*"),
color: "#ede542".to_string(),
}),
}
let client = reqwest::Client::new();
let result = client.post(&self.webhook_url).json(&payload).send().await;
match result {
Ok(_) => Ok(()),
Err(err) => anyhow::bail!(
"failed to post message to slack webhook url {}: {}",
self.webhook_url,
err
),
}
}
}
// slack webhook payload structs
#[derive(Debug, Serialize)]
struct Payload {
username: String,
icon_emoji: String,
text: String,
attachments: Vec<Attachment>,
}
#[derive(Debug, Serialize)]
struct Attachment {
title: String,
text: String,
color: String,
} | async fn notify(&self, notif: &Notification) -> Result<()> { |
struct_error_msg_params_in_describe_data_import_pre_check_result.go | package drds
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License. | //
//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.
//
// Code generated by Alibaba Cloud SDK Code Generator.
// Changes may cause incorrect behavior and will be lost if the code is regenerated.
// ErrorMsgParamsInDescribeDataImportPreCheckResult is a nested struct in drds response
type ErrorMsgParamsInDescribeDataImportPreCheckResult struct {
ErrorMsgParams []string `json:"ErrorMsgParams" xml:"ErrorMsgParams"`
} | //You may obtain a copy of the License at
//
//http://www.apache.org/licenses/LICENSE-2.0 |
networkInterface.go | // *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
// nolint: lll
package network
import (
"reflect"
"github.com/pkg/errors"
"github.com/pulumi/pulumi/sdk/go/pulumi"
)
// Manages a Network Interface located in a Virtual Network, usually attached to a Virtual Machine.
//
// > This content is derived from https://github.com/terraform-providers/terraform-provider-azurerm/blob/master/website/docs/r/network_interface.html.markdown.
type NetworkInterface struct {
pulumi.CustomResourceState
// If the VM that uses this NIC is part of an Availability Set, then this list will have the union of all DNS servers from all NICs that are part of the Availability Set
AppliedDnsServers pulumi.StringArrayOutput `pulumi:"appliedDnsServers"`
// List of DNS servers IP addresses to use for this NIC, overrides the VNet-level server list
DnsServers pulumi.StringArrayOutput `pulumi:"dnsServers"`
// Enables Azure Accelerated Networking using SR-IOV. Only certain VM instance sizes are supported. Refer to [Create a Virtual Machine with Accelerated Networking](https://docs.microsoft.com/en-us/azure/virtual-network/create-vm-accelerated-networking-cli). Defaults to `false`.
EnableAcceleratedNetworking pulumi.BoolPtrOutput `pulumi:"enableAcceleratedNetworking"`
// Enables IP Forwarding on the NIC. Defaults to `false`.
EnableIpForwarding pulumi.BoolPtrOutput `pulumi:"enableIpForwarding"`
// Relative DNS name for this NIC used for internal communications between VMs in the same VNet
InternalDnsNameLabel pulumi.StringOutput `pulumi:"internalDnsNameLabel"`
InternalFqdn pulumi.StringOutput `pulumi:"internalFqdn"`
// One or more `ipConfiguration` associated with this NIC as documented below.
IpConfigurations NetworkInterfaceIpConfigurationArrayOutput `pulumi:"ipConfigurations"`
// The location/region where the network interface is created. Changing this forces a new resource to be created.
Location pulumi.StringOutput `pulumi:"location"`
// The media access control (MAC) address of the network interface.
MacAddress pulumi.StringOutput `pulumi:"macAddress"`
// The name of the network interface. Changing this forces a new resource to be created.
Name pulumi.StringOutput `pulumi:"name"`
// The ID of the Network Security Group to associate with the network interface.
NetworkSecurityGroupId pulumi.StringPtrOutput `pulumi:"networkSecurityGroupId"`
// The first private IP address of the network interface.
PrivateIpAddress pulumi.StringOutput `pulumi:"privateIpAddress"`
// The private IP addresses of the network interface.
PrivateIpAddresses pulumi.StringArrayOutput `pulumi:"privateIpAddresses"`
// The name of the resource group in which to create the network interface. Changing this forces a new resource to be created.
ResourceGroupName pulumi.StringOutput `pulumi:"resourceGroupName"`
// A mapping of tags to assign to the resource.
Tags pulumi.StringMapOutput `pulumi:"tags"`
// Reference to a VM with which this NIC has been associated.
VirtualMachineId pulumi.StringOutput `pulumi:"virtualMachineId"`
}
// NewNetworkInterface registers a new resource with the given unique name, arguments, and options.
func NewNetworkInterface(ctx *pulumi.Context,
name string, args *NetworkInterfaceArgs, opts ...pulumi.ResourceOption) (*NetworkInterface, error) {
if args == nil || args.IpConfigurations == nil {
return nil, errors.New("missing required argument 'IpConfigurations'")
}
if args == nil || args.ResourceGroupName == nil {
return nil, errors.New("missing required argument 'ResourceGroupName'")
}
if args == nil {
args = &NetworkInterfaceArgs{}
}
var resource NetworkInterface
err := ctx.RegisterResource("azure:network/networkInterface:NetworkInterface", name, args, &resource, opts...)
if err != nil {
return nil, err
}
return &resource, nil
}
// GetNetworkInterface gets an existing NetworkInterface resource's state with the given name, ID, and optional
// state properties that are used to uniquely qualify the lookup (nil if not required).
func GetNetworkInterface(ctx *pulumi.Context,
name string, id pulumi.IDInput, state *NetworkInterfaceState, opts ...pulumi.ResourceOption) (*NetworkInterface, error) {
var resource NetworkInterface
err := ctx.ReadResource("azure:network/networkInterface:NetworkInterface", name, id, state, &resource, opts...)
if err != nil {
return nil, err
}
return &resource, nil
}
// Input properties used for looking up and filtering NetworkInterface resources.
type networkInterfaceState struct {
// If the VM that uses this NIC is part of an Availability Set, then this list will have the union of all DNS servers from all NICs that are part of the Availability Set
AppliedDnsServers []string `pulumi:"appliedDnsServers"`
// List of DNS servers IP addresses to use for this NIC, overrides the VNet-level server list
DnsServers []string `pulumi:"dnsServers"`
// Enables Azure Accelerated Networking using SR-IOV. Only certain VM instance sizes are supported. Refer to [Create a Virtual Machine with Accelerated Networking](https://docs.microsoft.com/en-us/azure/virtual-network/create-vm-accelerated-networking-cli). Defaults to `false`.
EnableAcceleratedNetworking *bool `pulumi:"enableAcceleratedNetworking"`
// Enables IP Forwarding on the NIC. Defaults to `false`.
EnableIpForwarding *bool `pulumi:"enableIpForwarding"`
// Relative DNS name for this NIC used for internal communications between VMs in the same VNet
InternalDnsNameLabel *string `pulumi:"internalDnsNameLabel"`
InternalFqdn *string `pulumi:"internalFqdn"`
// One or more `ipConfiguration` associated with this NIC as documented below.
IpConfigurations []NetworkInterfaceIpConfiguration `pulumi:"ipConfigurations"`
// The location/region where the network interface is created. Changing this forces a new resource to be created.
Location *string `pulumi:"location"`
// The media access control (MAC) address of the network interface.
MacAddress *string `pulumi:"macAddress"`
// The name of the network interface. Changing this forces a new resource to be created.
Name *string `pulumi:"name"`
// The ID of the Network Security Group to associate with the network interface.
NetworkSecurityGroupId *string `pulumi:"networkSecurityGroupId"`
// The first private IP address of the network interface.
PrivateIpAddress *string `pulumi:"privateIpAddress"`
// The private IP addresses of the network interface.
PrivateIpAddresses []string `pulumi:"privateIpAddresses"`
// The name of the resource group in which to create the network interface. Changing this forces a new resource to be created.
ResourceGroupName *string `pulumi:"resourceGroupName"`
// A mapping of tags to assign to the resource.
Tags map[string]string `pulumi:"tags"`
// Reference to a VM with which this NIC has been associated.
VirtualMachineId *string `pulumi:"virtualMachineId"`
}
type NetworkInterfaceState struct {
// If the VM that uses this NIC is part of an Availability Set, then this list will have the union of all DNS servers from all NICs that are part of the Availability Set
AppliedDnsServers pulumi.StringArrayInput
// List of DNS servers IP addresses to use for this NIC, overrides the VNet-level server list
DnsServers pulumi.StringArrayInput
// Enables Azure Accelerated Networking using SR-IOV. Only certain VM instance sizes are supported. Refer to [Create a Virtual Machine with Accelerated Networking](https://docs.microsoft.com/en-us/azure/virtual-network/create-vm-accelerated-networking-cli). Defaults to `false`.
EnableAcceleratedNetworking pulumi.BoolPtrInput
// Enables IP Forwarding on the NIC. Defaults to `false`.
EnableIpForwarding pulumi.BoolPtrInput
// Relative DNS name for this NIC used for internal communications between VMs in the same VNet
InternalDnsNameLabel pulumi.StringPtrInput
InternalFqdn pulumi.StringPtrInput
// One or more `ipConfiguration` associated with this NIC as documented below.
IpConfigurations NetworkInterfaceIpConfigurationArrayInput
// The location/region where the network interface is created. Changing this forces a new resource to be created.
Location pulumi.StringPtrInput
// The media access control (MAC) address of the network interface.
MacAddress pulumi.StringPtrInput
// The name of the network interface. Changing this forces a new resource to be created.
Name pulumi.StringPtrInput
// The ID of the Network Security Group to associate with the network interface.
NetworkSecurityGroupId pulumi.StringPtrInput
// The first private IP address of the network interface.
PrivateIpAddress pulumi.StringPtrInput
// The private IP addresses of the network interface.
PrivateIpAddresses pulumi.StringArrayInput
// The name of the resource group in which to create the network interface. Changing this forces a new resource to be created.
ResourceGroupName pulumi.StringPtrInput
// A mapping of tags to assign to the resource.
Tags pulumi.StringMapInput
// Reference to a VM with which this NIC has been associated.
VirtualMachineId pulumi.StringPtrInput
}
func (NetworkInterfaceState) ElementType() reflect.Type {
return reflect.TypeOf((*networkInterfaceState)(nil)).Elem()
}
type networkInterfaceArgs struct {
// If the VM that uses this NIC is part of an Availability Set, then this list will have the union of all DNS servers from all NICs that are part of the Availability Set
AppliedDnsServers []string `pulumi:"appliedDnsServers"`
// List of DNS servers IP addresses to use for this NIC, overrides the VNet-level server list
DnsServers []string `pulumi:"dnsServers"`
// Enables Azure Accelerated Networking using SR-IOV. Only certain VM instance sizes are supported. Refer to [Create a Virtual Machine with Accelerated Networking](https://docs.microsoft.com/en-us/azure/virtual-network/create-vm-accelerated-networking-cli). Defaults to `false`.
EnableAcceleratedNetworking *bool `pulumi:"enableAcceleratedNetworking"`
// Enables IP Forwarding on the NIC. Defaults to `false`.
EnableIpForwarding *bool `pulumi:"enableIpForwarding"`
// Relative DNS name for this NIC used for internal communications between VMs in the same VNet
InternalDnsNameLabel *string `pulumi:"internalDnsNameLabel"`
InternalFqdn *string `pulumi:"internalFqdn"`
// One or more `ipConfiguration` associated with this NIC as documented below.
IpConfigurations []NetworkInterfaceIpConfiguration `pulumi:"ipConfigurations"`
// The location/region where the network interface is created. Changing this forces a new resource to be created.
Location *string `pulumi:"location"`
// The media access control (MAC) address of the network interface.
MacAddress *string `pulumi:"macAddress"`
// The name of the network interface. Changing this forces a new resource to be created.
Name *string `pulumi:"name"`
// The ID of the Network Security Group to associate with the network interface.
NetworkSecurityGroupId *string `pulumi:"networkSecurityGroupId"`
// The name of the resource group in which to create the network interface. Changing this forces a new resource to be created. | // Reference to a VM with which this NIC has been associated.
VirtualMachineId *string `pulumi:"virtualMachineId"`
}
// The set of arguments for constructing a NetworkInterface resource.
type NetworkInterfaceArgs struct {
// If the VM that uses this NIC is part of an Availability Set, then this list will have the union of all DNS servers from all NICs that are part of the Availability Set
AppliedDnsServers pulumi.StringArrayInput
// List of DNS servers IP addresses to use for this NIC, overrides the VNet-level server list
DnsServers pulumi.StringArrayInput
// Enables Azure Accelerated Networking using SR-IOV. Only certain VM instance sizes are supported. Refer to [Create a Virtual Machine with Accelerated Networking](https://docs.microsoft.com/en-us/azure/virtual-network/create-vm-accelerated-networking-cli). Defaults to `false`.
EnableAcceleratedNetworking pulumi.BoolPtrInput
// Enables IP Forwarding on the NIC. Defaults to `false`.
EnableIpForwarding pulumi.BoolPtrInput
// Relative DNS name for this NIC used for internal communications between VMs in the same VNet
InternalDnsNameLabel pulumi.StringPtrInput
InternalFqdn pulumi.StringPtrInput
// One or more `ipConfiguration` associated with this NIC as documented below.
IpConfigurations NetworkInterfaceIpConfigurationArrayInput
// The location/region where the network interface is created. Changing this forces a new resource to be created.
Location pulumi.StringPtrInput
// The media access control (MAC) address of the network interface.
MacAddress pulumi.StringPtrInput
// The name of the network interface. Changing this forces a new resource to be created.
Name pulumi.StringPtrInput
// The ID of the Network Security Group to associate with the network interface.
NetworkSecurityGroupId pulumi.StringPtrInput
// The name of the resource group in which to create the network interface. Changing this forces a new resource to be created.
ResourceGroupName pulumi.StringInput
// A mapping of tags to assign to the resource.
Tags pulumi.StringMapInput
// Reference to a VM with which this NIC has been associated.
VirtualMachineId pulumi.StringPtrInput
}
func (NetworkInterfaceArgs) ElementType() reflect.Type {
return reflect.TypeOf((*networkInterfaceArgs)(nil)).Elem()
} | ResourceGroupName string `pulumi:"resourceGroupName"`
// A mapping of tags to assign to the resource.
Tags map[string]string `pulumi:"tags"` |
event_transport_test.py | '''
Copyright (c) 2011-2017, Agora Games, LLC All rights reserved.
https://github.com/agoragames/haigha/blob/master/LICENSE.txt
'''
from chai import Chai
from haigha.transports import event_transport
from haigha.transports.event_transport import *
class EventTransportTest(Chai):
def setUp(self):
super(EventTransportTest, self).setUp()
self.connection = mock()
self.transport = EventTransport(self.connection)
self.transport._host = 'server'
def test_sock_close_cb(self):
expect(self.connection.transport_closed).args(
msg='socket to server closed unexpectedly')
self.transport._sock_close_cb('sock')
def test_sock_error_cb(self):
expect(self.connection.transport_closed).args(
msg='error on connection to server: amsg')
self.transport._sock_error_cb('sock', 'amsg')
def test_sock_read_cb(self):
expect(self.connection.read_frames)
self.transport._sock_read_cb('sock')
def test_connect(self):
sock = mock()
mock(event_transport, 'EventSocket')
self.connection._connect_timeout = 4.12
self.connection._sock_opts = {
('family', 'tcp'): 34,
('range', 'ipv6'): 'hex'
}
expect(event_transport.EventSocket).args(
read_cb=self.transport._sock_read_cb,
close_cb=self.transport._sock_close_cb,
error_cb=self.transport._sock_error_cb,
debug=self.connection.debug,
logger=self.connection.logger,
).returns(sock)
expect(sock.setsockopt).args('family', 'tcp', 34).any_order()
expect(sock.setsockopt).args('range', 'ipv6', 'hex').any_order()
expect(sock.setblocking).args(False)
expect(sock.connect).args(('host', 5309), timeout=4.12)
self.transport.connect(('host', 5309))
def test_read(self):
self.transport._heartbeat_timeout = None
self.transport._sock = mock()
expect(self.transport._sock.read).returns('buffereddata')
assert_equals('buffereddata', self.transport.read())
def test_read_with_timeout_and_no_current_one(self):
self.transport._heartbeat_timeout = None
self.transport._sock = mock()
mock(event_transport, 'event')
expect(event_transport.event.timeout).args(
'timeout', self.transport._sock_read_cb, self.transport._sock).returns(
'timer')
expect(self.transport._sock.read).returns('buffereddata')
assert_equals('buffereddata', self.transport.read('timeout'))
assert_equals('timer', self.transport._heartbeat_timeout)
def test_read_with_timeout_and_current_one(self):
self.transport._heartbeat_timeout = mock()
self.transport._sock = mock()
mock(event_transport, 'event')
expect(self.transport._heartbeat_timeout.delete)
expect(event_transport.event.timeout).args(
'timeout', self.transport._sock_read_cb, self.transport._sock).returns(
'timer')
expect(self.transport._sock.read).returns('buffereddata')
assert_equals('buffereddata', self.transport.read('timeout'))
assert_equals('timer', self.transport._heartbeat_timeout)
def test_read_without_timeout_but_current_one(self):
self.transport._heartbeat_timeout = mock()
self.transport._sock = mock()
mock(event_transport, 'event')
expect(self.transport._heartbeat_timeout.delete)
expect(self.transport._sock.read).returns('buffereddata')
assert_equals('buffereddata', self.transport.read())
assert_equals(None, self.transport._heartbeat_timeout)
def test_read_when_no_sock(self):
self.transport.read()
def test_buffer(self):
self.transport._sock = mock()
expect(self.transport._sock.buffer).args('somedata')
self.transport.buffer('somedata')
def test_buffer_when_no_sock(self):
self.transport.buffer('somedata')
def test_write(self):
self.transport._sock = mock()
expect(self.transport._sock.write).args('somedata')
self.transport.write('somedata')
def test_write_when_no_sock(self):
self.transport.write('somedata')
def test_disconnect(self):
self.transport._sock = mock()
self.transport._sock.close_cb = 'cb'
expect(self.transport._sock.close)
self.transport.disconnect()
assert_equals(None, self.transport._sock.close_cb)
def | (self):
self.transport.disconnect()
| test_disconnect_when_no_sock |
debugging.py | """Module containing helper functions."""
from __future__ import annotations
import collections
import logging
import sys
import traceback
from prettyqt import qt, widgets
from prettyqt.qt import QtCore
logger = logging.getLogger(__name__)
LOG_MAP = {
QtCore.QtMsgType.QtInfoMsg: 20,
QtCore.QtMsgType.QtWarningMsg: 30,
QtCore.QtMsgType.QtCriticalMsg: 40,
QtCore.QtMsgType.QtFatalMsg: 50,
}
def qt_message_handler(mode: QtCore.QtMsgType, context, message: str):
level = LOG_MAP.get(mode, 20)
logger.log(level, f"{message} ({context.file}:{context.line}, {context.file})")
def install_exceptionhook(debug: bool = False):
def handleException(exc_type, exc_value, exc_traceback):
"""Causes the application to quit in case of an unhandled exception.
Shows an error dialog before quitting when not in debugging mode.
"""
logger.critical(
f"Bug: uncaught {exc_type.__name__}",
exc_info=(exc_type, exc_value, exc_traceback),
)
if debug:
sys.exit(1)
else:
from prettyqt import widgets
# Constructing a QApplication in case this hasn't been done yet.
_ = widgets.app()
lst = traceback.format_exception(exc_type, exc_value, exc_traceback)
msg_box = widgets.MessageBox(
icon="warning",
text=f"Bug: uncaught {exc_type.__name__}",
informative_text=str(exc_value),
details="".join(lst),
)
msg_box.main_loop()
sys.exit(1)
sys.excepthook = handleException
def count_objects():
win = widgets.Application.get_mainwindow()
objects = win.findChildren(QtCore.QObject)
counter = collections.Counter([type(o) for o in objects])
logger.info(counter)
def is_deleted(obj) -> bool:
if qt.API == "pyside2":
import shiboken2
return not shiboken2.isValid(obj)
elif qt.API == "pyside6":
import shiboken6
return not shiboken6.isValid(obj)
elif qt.API == "pyqt5": | return sip.isdeleted(obj)
else:
try:
from PyQt6 import sip
except ImportError:
import sip # type: ignore[import, no-redef]
return sip.isdeleted(obj) | try:
from PyQt5 import sip
except ImportError:
import sip # type: ignore[import, no-redef] |
mod.rs | pub mod block_entity;
pub mod player;
use crate::ecs::{Manager, SystemExecStage};
use crate::entity::slime::SlimeModel;
use crate::entity::zombie::ZombieModel;
use crate::render::Texture;
use bevy_ecs::component::Component;
use bevy_ecs::prelude::*;
use cgmath::Vector3;
use collision::Aabb3;
use std::sync::Arc;
pub mod player_like;
pub mod slime;
mod systems;
pub mod versions;
pub mod zombie;
// TODO: There may be wrong entries in this!
// 1.0, 1.0, 0.0 | 0.0, 0.0, 0.0
static TEXTURE_MATRIX: [[[f32; 3]; 6]; 2] = [
[
[0.0, 1.0, 0.0], // OR (although the current one seems correct) 1 0 1 [1.0, 0.0, 1.0], // OR 1 0 1
[0.0, 0.0, 1.0],
[0.0, 0.0, 1.0],
[0.0, 1.0, 1.0], // south(back) - 0, 1, 1 | 1, 0, 1 - 0, 0, 1 displays the left half of the back (body) and the left side of the head
[1.0, 0.0, 1.0], // left(west)
[0.0, 0.0, 0.0], // right(east)
],
[
[0.0, 0.0, 0.0], | [0.0, 0.0, 0.0],
[0.0, 0.0, 1.0],
[0.0, 0.0, 1.0],
[0.0, 0.0, 1.0],
[0.0, 0.0, 1.0],
],
];
/*
resolve_textures(&tex, 8.0, 12.0, 4.0, 16.0, 16.0) // width, height, depth...
srel!(28.0, 16.0, 8.0, 4.0), // Down | 1 0 1 | 0 0 0 OR 0 1 0 | 0 0 0
srel!(20.0, 16.0, 8.0, 4.0), // Up | 0 0 1 | 0 0 0
srel!(20.0, 20.0, 8.0, 12.0), // North | 0 0 1 | 0 0 1
srel!(32.0, 20.0, 8.0, 12.0), // South | 0 1 1 | 0 0 1
srel!(16.0, 20.0, 4.0, 12.0), // West | 0 0 0 | 0 0 1
srel!(28.0, 20.0, 4.0, 12.0), // East | 0 1 0 | 0 0 1 OR 1 0 1 | 0 0 1
[1.0, 0.0, 0.0, 0.0],
[1.0, 0.0, 0.0, 0.0],
[1.0, 0.0, 0.0, 1.0],
[2.0, 0.0, 0.0, 1.0],
[2.0, 0.0, 0.0, 1.0],
[0.0, 0.0, 0.0, 1.0],
*/
pub fn add_systems(
m: &mut Manager,
parallel: &mut SystemStage,
sync: &mut SystemStage,
entity_sched: &mut SystemStage,
) {
entity_sched.add_system(
systems::update_last_position
.system()
.label(SystemExecStage::Normal),
);
player::add_systems(m, parallel, sync, entity_sched);
entity_sched
.add_system(
systems::apply_velocity
.system()
.label(SystemExecStage::Normal),
)
.add_system(
systems::apply_gravity
.system()
.label(SystemExecStage::Normal),
);
sync.add_system(
systems::lerp_position
.system()
.label(SystemExecStage::Render)
.after(SystemExecStage::Normal),
)
.add_system(
systems::lerp_rotation
.system()
.label(SystemExecStage::Render)
.after(SystemExecStage::Normal),
)
.add_system(
systems::light_entity
.system()
.label(SystemExecStage::Render)
.after(SystemExecStage::Normal),
);
block_entity::add_systems(m, parallel, sync);
crate::particle::block_break_effect::add_systems(m, parallel, sync, entity_sched);
}
/// Location of an entity in the world.
#[derive(Component, Debug)]
pub struct Position {
pub position: Vector3<f64>,
pub last_position: Vector3<f64>,
pub moved: bool,
}
impl Position {
pub fn new(x: f64, y: f64, z: f64) -> Position {
Position {
position: Vector3::new(x, y, z),
last_position: Vector3::new(x, y, z),
moved: false,
}
}
pub fn zero() -> Position {
Position::new(0.0, 0.0, 0.0)
}
}
#[derive(Component, Debug)]
pub struct TargetPosition {
pub position: Vector3<f64>,
pub lerp_amount: f64,
}
impl TargetPosition {
pub fn new(x: f64, y: f64, z: f64) -> TargetPosition {
TargetPosition {
position: Vector3::new(x, y, z),
lerp_amount: 0.2,
}
}
pub fn zero() -> TargetPosition {
TargetPosition::new(0.0, 0.0, 0.0)
}
}
/// Velocity of an entity in the world.
#[derive(Component, Debug)]
pub struct Velocity {
pub velocity: Vector3<f64>,
}
impl Velocity {
pub fn new(x: f64, y: f64, z: f64) -> Velocity {
Velocity {
velocity: Vector3::new(x, y, z),
}
}
pub fn zero() -> Velocity {
Velocity::new(0.0, 0.0, 0.0)
}
}
/// Rotation of an entity in the world
#[derive(Component, Debug)]
pub struct Rotation {
pub yaw: f64,
pub pitch: f64,
}
impl Rotation {
pub fn new(yaw: f64, pitch: f64) -> Rotation {
Rotation { yaw, pitch }
}
pub fn zero() -> Rotation {
Rotation::new(0.0, 0.0)
}
}
#[derive(Component, Debug)]
pub struct TargetRotation {
pub yaw: f64,
pub pitch: f64,
}
impl TargetRotation {
pub fn new(yaw: f64, pitch: f64) -> TargetRotation {
TargetRotation { yaw, pitch }
}
pub fn zero() -> TargetRotation {
TargetRotation::new(0.0, 0.0)
}
}
#[derive(Component, Default)]
pub struct Gravity {
pub on_ground: bool,
}
impl Gravity {
pub fn new() -> Gravity {
Default::default()
}
}
#[derive(Component)]
pub struct Bounds {
pub bounds: Aabb3<f64>,
}
impl Bounds {
pub fn new(bounds: Aabb3<f64>) -> Bounds {
Bounds { bounds }
}
}
#[derive(Default)]
pub struct GameInfo {
pub delta: f64,
}
impl GameInfo {
pub fn new() -> GameInfo {
Default::default()
}
}
#[derive(Component, Default)]
pub struct Light {
pub block_light: f32,
pub sky_light: f32,
}
impl Light {
pub fn new() -> Light {
Default::default()
}
}
#[derive(Component, Copy, Clone, Eq, PartialEq, Hash, Debug)]
pub enum EntityType {
DroppedItem,
ExperienceOrb,
LeashHitch,
Painting,
Arrow,
Snowball,
Fireball,
SmallFireball,
EnderPearl,
EnderSignal,
ThrownExpBottle,
ItemFrame,
WitherSkull,
PrimedTnt,
FallingBlock,
Firework,
TippedArrow,
SpectralArrow,
ShulkerBullet,
DragonFireball,
ArmorStand,
MinecartCommand,
Boat,
Minecart,
MinecartChest,
MinecartFurnace,
MinecartTnt,
MinecartHopper,
MinecartMobSpawner,
Creeper,
Skeleton,
Spider,
Giant,
Zombie,
Slime,
Ghast,
PigZombie,
Enderman,
CaveSpider,
Silverfish,
Blaze,
MagmaCube,
EnderDragon,
Wither,
Bat,
Witch,
Endermite,
Guardian,
Shulker,
Pig,
Sheep,
Cow,
Chicken,
Squid,
Wolf,
MushroomCow,
Snowman,
Ocelot,
IronGolem,
Horse,
Rabbit,
PolarBear,
Villager,
EnderCrystal,
SplashPotion,
LingeringPotion,
AreaEffectCloud,
Egg,
FishingHook,
Lightning,
Weather,
Player,
ComplexPart,
Unknown,
ElderGuardian,
WitherSkeleton,
Stray,
Husk,
ZombieVillager,
SkeletonHorse,
ZombieHorse,
Donkey,
Mule,
EvokerFangs,
Evoker,
Vex,
Vindicator,
Llama,
LlamaSpit,
Illusioner,
Parrot,
Turtle,
Phantom,
Trident,
Cod,
Salmon,
Pufferfish,
TropicalFish,
Drowned,
Dolphin,
Cat,
Panda,
Pillager,
Ravager,
TraderLlama,
WanderingTrader,
Fox,
Bee,
ZombifiedPiglin,
Hoglin,
Piglin,
Strider,
Zoglin,
PiglinBrute,
}
impl EntityType {
pub fn create_entity(
&self,
m: &mut Manager,
x: f64,
y: f64,
z: f64,
yaw: f64,
pitch: f64,
) -> Option<Entity> {
if self.supported() {
let ret = self.create_entity_internally(m, x, y, z, yaw, pitch);
self.create_model(m, ret);
return Some(ret);
}
None
}
pub fn create_entity_custom_model(
&self,
m: &mut Manager,
x: f64,
y: f64,
z: f64,
yaw: f64,
pitch: f64,
) -> Option<Entity> {
if self.supported() {
return Some(self.create_entity_internally(m, x, y, z, yaw, pitch));
}
None
}
fn create_entity_internally(
&self,
m: &mut Manager,
x: f64,
y: f64,
z: f64,
yaw: f64,
pitch: f64,
) -> Entity {
let mut entity = m.world.spawn();
entity
.insert(Position::new(x, y, z))
.insert(Rotation::new(yaw, pitch))
.insert(Velocity::new(0.0, 0.0, 0.0))
.insert(TargetPosition::new(x, y, z))
.insert(TargetRotation::new(yaw, pitch))
.insert(Light::new())
.insert(*self);
entity.id()
}
fn create_model(&self, m: &mut Manager, entity: Entity) {
match self {
EntityType::Zombie => {
m.world
.entity_mut(entity)
.insert(ZombieModel::new(Some(String::from("test"))));
}
EntityType::Slime => {
m.world.entity_mut(entity).insert(SlimeModel::new("test"));
}
_ => {}
};
}
fn supported(&self) -> bool {
matches!(self, EntityType::Zombie)
}
}
pub fn resolve_textures(
texture: &Texture,
width: f32,
height: f32,
depth: f32,
offset_x: f32,
offset_y: f32,
) -> [Option<Texture>; 6] {
[
Some(texture.relative(
(offset_x
+ width * TEXTURE_MATRIX[0][0][0]
+ height * TEXTURE_MATRIX[0][0][1]
+ depth * TEXTURE_MATRIX[0][0][2])
/ (texture.get_width() as f32),
(offset_y + depth * TEXTURE_MATRIX[1][0][2]) / (texture.get_height() as f32),
width / (texture.get_width() as f32),
height / (texture.get_height() as f32),
)),
Some(texture.relative(
(offset_x
+ width * TEXTURE_MATRIX[0][1][0]
+ height * TEXTURE_MATRIX[0][1][1]
+ depth * TEXTURE_MATRIX[0][1][2])
/ (texture.get_width() as f32),
(offset_y + depth * TEXTURE_MATRIX[1][1][2]) / (texture.get_height() as f32),
width / (texture.get_width() as f32),
height / (texture.get_height() as f32),
)),
Some(texture.relative(
(offset_x
+ width * TEXTURE_MATRIX[0][2][0]
+ height * TEXTURE_MATRIX[0][2][1]
+ depth * TEXTURE_MATRIX[0][2][2])
/ (texture.get_width() as f32),
(offset_y + depth * TEXTURE_MATRIX[1][2][2]) / (texture.get_height() as f32),
width / (texture.get_width() as f32),
height / (texture.get_height() as f32),
)),
Some(texture.relative(
(offset_x
+ width * TEXTURE_MATRIX[0][3][0]
+ height * TEXTURE_MATRIX[0][3][1]
+ depth * TEXTURE_MATRIX[0][3][2])
/ (texture.get_width() as f32),
(offset_y + depth * TEXTURE_MATRIX[1][3][2]) / (texture.get_height() as f32),
width / (texture.get_width() as f32),
height / (texture.get_height() as f32),
)),
Some(texture.relative(
(offset_x
+ width * TEXTURE_MATRIX[0][4][0]
+ height * TEXTURE_MATRIX[0][4][1]
+ depth * TEXTURE_MATRIX[0][4][2])
/ (texture.get_width() as f32),
(offset_y + depth * TEXTURE_MATRIX[1][4][2]) / (texture.get_height() as f32),
width / (texture.get_width() as f32),
height / (texture.get_height() as f32),
)),
Some(texture.relative(
(offset_x
+ width * TEXTURE_MATRIX[0][5][0]
+ height * TEXTURE_MATRIX[0][5][1]
+ depth * TEXTURE_MATRIX[0][5][2])
/ (texture.get_width() as f32),
(offset_y + depth * TEXTURE_MATRIX[1][5][2]) / (texture.get_height() as f32),
width / (texture.get_width() as f32),
height / (texture.get_height() as f32),
)),
]
} | |
traits1.rs | // traits1.rs
// Time to implement some traits!
//
// Your task is to implement the trait
// `AppendBar' for the type `String'.
//
// The trait AppendBar has only one function,
// which appends "Bar" to any object
// implementing this trait.
trait AppendBar {
fn append_bar(self) -> Self;
}
impl AppendBar for String {
//Add your code here
fn append_bar(self) -> Self {
return self.to_string() + &"Bar".to_string();
}
}
fn main() |
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn is_FooBar() {
assert_eq!(String::from("Foo").append_bar(), String::from("FooBar"));
}
#[test]
fn is_BarBar() {
assert_eq!(
String::from("").append_bar().append_bar(),
String::from("BarBar")
);
}
}
| {
let s = String::from("Foo");
let s = s.append_bar();
println!("s: {}", s);
} |
product-of-array-except-self.py | # Time: O(n)
# Space: O(1)
class Solution(object):
# @param {integer[]} nums
# @return {integer[]}
def productExceptSelf(self, nums):
if not nums:
return []
left_product = [1 for _ in xrange(len(nums))]
for i in xrange(1, len(nums)):
left_product[i] = left_product[i - 1] * nums[i - 1]
right_product = 1 | left_product[i] = left_product[i] * right_product
return left_product | for i in xrange(len(nums) - 2, -1, -1):
right_product *= nums[i + 1] |
util.py | ##############################################################################
#
# Copyright (c) 2002 Zope Foundation and Contributors.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
from datetime import datetime
from DateTime.DateTime import DateTime
import six
MAX32 = int(2 ** 31 - 1)
def safe_callable(ob):
# Works with ExtensionClasses and Acquisition.
try:
ob.__class__
try:
return bool(ob.__call__)
except AttributeError:
return isinstance(ob, six.class_types)
except AttributeError:
return callable(ob)
def datetime_to_minutes(value, precision=1,
max_value=MAX32, min_value=-MAX32):
if value is None:
return value
if isinstance(value, (str, datetime)):
value = DateTime(value)
if isinstance(value, DateTime):
|
# flatten to precision
if precision > 1:
value = value - (value % precision)
value = int(value)
if value > max_value or value < min_value:
# value must be integer fitting in the range (default 32bit)
raise OverflowError(
'{0} is not within the range of dates allowed.'.format(value))
return value
| value = value.millis() / 1000 / 60 # flatten to minutes |
model.go | package model
import "time"
// HTTPProxyPool [...]
type HTTPProxyPool struct {
ID int `gorm:"primary_key;column:id;type:int(11);not null" json:"-"` | Source string `gorm:"unique_index:idx_ip;column:source;type:varchar(6);not null" json:"source"`
IP string `gorm:"unique_index:idx_ip;column:ip;type:varchar(16);not null" json:"ip"`
Port string `gorm:"unique_index:idx_ip;column:port;type:varchar(6);not null" json:"port"`
City string `gorm:"column:city;type:varchar(24);not null" json:"city"`
Isp string `gorm:"column:isp;type:varchar(12);not null" json:"isp"`
ExpireTime time.Time `gorm:"index:idx_expire;column:expire_time;type:datetime;not null" json:"expire_time"`
Outip string `gorm:"column:outip;type:varchar(16);not null" json:"outip"`
} | CreatedAt time.Time `gorm:"column:created_at;type:datetime;not null" json:"created_at"`
UpdatedAt time.Time `gorm:"column:updated_at;type:datetime;not null" json:"updated_at"` |
http.py | # Copyright 2012 OpenStack Foundation
# 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 copy
import logging
import socket
from oslo_utils import importutils
from oslo_utils import netutils
import requests
try:
from requests.packages.urllib3.exceptions import ProtocolError
except ImportError:
ProtocolError = requests.exceptions.ConnectionError
import six
from six.moves.urllib import parse
try:
import json
except ImportError:
import simplejson as json
# Python 2.5 compat fix
if not hasattr(parse, 'parse_qsl'):
import cgi
parse.parse_qsl = cgi.parse_qsl
from oslo_utils import encodeutils
from glanceclient.common import https
from glanceclient.common.utils import safe_header
from glanceclient import exc
osprofiler_web = importutils.try_import("osprofiler.web")
LOG = logging.getLogger(__name__)
USER_AGENT = 'python-glanceclient'
CHUNKSIZE = 1024 * 64 # 64kB
class HTTPClient(object):
def __init__(self, endpoint, **kwargs):
self.endpoint = endpoint
self.identity_headers = kwargs.get('identity_headers')
self.auth_token = kwargs.get('token')
if self.identity_headers:
if self.identity_headers.get('X-Auth-Token'):
self.auth_token = self.identity_headers.get('X-Auth-Token')
del self.identity_headers['X-Auth-Token']
self.session = requests.Session()
self.session.headers["User-Agent"] = USER_AGENT
if self.auth_token:
self.session.headers["X-Auth-Token"] = self.auth_token
self.timeout = float(kwargs.get('timeout', 600))
if self.endpoint.startswith("https"):
compression = kwargs.get('ssl_compression', True)
if not compression:
self.session.mount("glance+https://", https.HTTPSAdapter())
self.endpoint = 'glance+' + self.endpoint
self.session.verify = (
kwargs.get('cacert', requests.certs.where()),
kwargs.get('insecure', False))
else:
if kwargs.get('insecure', False) is True:
self.session.verify = False
else:
if kwargs.get('cacert', None) is not '':
self.session.verify = kwargs.get('cacert', True)
self.session.cert = (kwargs.get('cert_file'),
kwargs.get('key_file'))
@staticmethod
def parse_endpoint(endpoint):
return netutils.urlsplit(endpoint)
def log_curl_request(self, method, url, headers, data, kwargs):
curl = ['curl -g -i -X %s' % method]
headers = copy.deepcopy(headers)
headers.update(self.session.headers)
for (key, value) in six.iteritems(headers):
header = '-H \'%s: %s\'' % safe_header(key, value)
curl.append(header)
if not self.session.verify:
curl.append('-k')
else:
if isinstance(self.session.verify, six.string_types):
curl.append(' --cacert %s' % self.session.verify)
if self.session.cert:
curl.append(' --cert %s --key %s' % self.session.cert)
if data and isinstance(data, six.string_types):
curl.append('-d \'%s\'' % data)
curl.append(url)
msg = ' '.join([encodeutils.safe_decode(item, errors='ignore')
for item in curl])
LOG.debug(msg)
@staticmethod
def log_http_response(resp, body=None):
status = (resp.raw.version / 10.0, resp.status_code, resp.reason)
dump = ['\nHTTP/%.1f %s %s' % status]
headers = resp.headers.items()
dump.extend(['%s: %s' % safe_header(k, v) for k, v in headers])
dump.append('')
if body:
body = encodeutils.safe_decode(body)
dump.extend([body, ''])
LOG.debug('\n'.join([encodeutils.safe_decode(x, errors='ignore')
for x in dump]))
@staticmethod
def encode_headers(headers):
"""Encodes headers.
Note: This should be used right before
sending anything out.
:param headers: Headers to encode
:returns: Dictionary with encoded headers'
names and values
"""
return dict((encodeutils.safe_encode(h), encodeutils.safe_encode(v))
for h, v in six.iteritems(headers) if v is not None)
def _request(self, method, url, **kwargs):
"""Send an http request with the specified characteristics.
Wrapper around httplib.HTTP(S)Connection.request to handle tasks such
as setting headers and error handling.
"""
# Copy the kwargs so we can reuse the original in case of redirects
headers = kwargs.pop("headers", {})
headers = headers and copy.deepcopy(headers) or {}
if self.identity_headers:
for k, v in six.iteritems(self.identity_headers):
headers.setdefault(k, v)
# Default Content-Type is octet-stream
content_type = headers.get('Content-Type', 'application/octet-stream')
def | (body):
chunk = body
while chunk:
chunk = body.read(CHUNKSIZE)
if chunk == '':
break
yield chunk
data = kwargs.pop("data", None)
if data is not None and not isinstance(data, six.string_types):
try:
data = json.dumps(data)
content_type = 'application/json'
except TypeError:
# Here we assume it's
# a file-like object
# and we'll chunk it
data = chunk_body(data)
headers['Content-Type'] = content_type
stream = True if content_type == 'application/octet-stream' else False
if osprofiler_web:
headers.update(osprofiler_web.get_trace_id_headers())
# Note(flaper87): Before letting headers / url fly,
# they should be encoded otherwise httplib will
# complain.
headers = self.encode_headers(headers)
try:
if self.endpoint.endswith("/") or url.startswith("/"):
conn_url = "%s%s" % (self.endpoint, url)
else:
conn_url = "%s/%s" % (self.endpoint, url)
self.log_curl_request(method, conn_url, headers, data, kwargs)
resp = self.session.request(method,
conn_url,
data=data,
stream=stream,
headers=headers,
**kwargs)
except requests.exceptions.Timeout as e:
message = ("Error communicating with %(endpoint)s %(e)s" %
dict(url=conn_url, e=e))
raise exc.InvalidEndpoint(message=message)
except (requests.exceptions.ConnectionError, ProtocolError) as e:
message = ("Error finding address for %(url)s: %(e)s" %
dict(url=conn_url, e=e))
raise exc.CommunicationError(message=message)
except socket.gaierror as e:
message = "Error finding address for %s: %s" % (
self.endpoint_hostname, e)
raise exc.InvalidEndpoint(message=message)
except (socket.error, socket.timeout) as e:
endpoint = self.endpoint
message = ("Error communicating with %(endpoint)s %(e)s" %
{'endpoint': endpoint, 'e': e})
raise exc.CommunicationError(message=message)
if not resp.ok:
LOG.debug("Request returned failure status %s." % resp.status_code)
raise exc.from_response(resp, resp.text)
elif resp.status_code == requests.codes.MULTIPLE_CHOICES:
raise exc.from_response(resp)
content_type = resp.headers.get('Content-Type')
# Read body into string if it isn't obviously image data
if content_type == 'application/octet-stream':
# Do not read all response in memory when
# downloading an image.
body_iter = _close_after_stream(resp, CHUNKSIZE)
self.log_http_response(resp)
else:
content = resp.text
self.log_http_response(resp, content)
if content_type and content_type.startswith('application/json'):
# Let's use requests json method,
# it should take care of response
# encoding
body_iter = resp.json()
else:
body_iter = six.StringIO(content)
try:
body_iter = json.loads(''.join([c for c in body_iter]))
except ValueError:
body_iter = None
return resp, body_iter
def head(self, url, **kwargs):
return self._request('HEAD', url, **kwargs)
def get(self, url, **kwargs):
return self._request('GET', url, **kwargs)
def post(self, url, **kwargs):
return self._request('POST', url, **kwargs)
def put(self, url, **kwargs):
return self._request('PUT', url, **kwargs)
def patch(self, url, **kwargs):
return self._request('PATCH', url, **kwargs)
def delete(self, url, **kwargs):
return self._request('DELETE', url, **kwargs)
def _close_after_stream(response, chunk_size):
"""Iterate over the content and ensure the response is closed after."""
# Yield each chunk in the response body
for chunk in response.iter_content(chunk_size=chunk_size):
yield chunk
# Once we're done streaming the body, ensure everything is closed.
# This will return the connection to the HTTPConnectionPool in urllib3
# and ideally reduce the number of HTTPConnectionPool full warnings.
response.close()
| chunk_body |
test_timestamp.py | """ test the scalar Timestamp """
import calendar
from datetime import (
datetime,
timedelta,
)
import locale
import pickle
import unicodedata
from dateutil.tz import tzutc
import numpy as np
import pytest
import pytz
from pytz import (
timezone,
utc,
)
from pandas._libs.tslibs.timezones import (
dateutil_gettz as gettz,
get_timezone,
)
import pandas.util._test_decorators as td
from pandas import (
NaT,
Timedelta,
Timestamp,
)
import pandas._testing as tm
from pandas.tseries import offsets
class TestTimestampProperties:
def test_freq_deprecation(self):
# GH#41586
msg = "The 'freq' argument in Timestamp is deprecated"
with tm.assert_produces_warning(FutureWarning, match=msg):
# warning issued at construction
ts = Timestamp("2021-06-01", freq="D")
ts2 = Timestamp("2021-06-01", freq="B")
msg = "Timestamp.freq is deprecated"
with tm.assert_produces_warning(FutureWarning, match=msg):
# warning issued at attribute lookup
ts.freq
for per in ["month", "quarter", "year"]:
for side in ["start", "end"]:
attr = f"is_{per}_{side}"
with tm.assert_produces_warning(FutureWarning, match=msg):
getattr(ts2, attr)
# is_(month|quarter|year)_(start|end) does _not_ issue a warning
# with freq="D" bc the result will be unaffected by the deprecation
with tm.assert_produces_warning(None):
getattr(ts, attr)
@pytest.mark.filterwarnings("ignore:The 'freq' argument:FutureWarning")
@pytest.mark.filterwarnings("ignore:Timestamp.freq is deprecated:FutureWarning")
def test_properties_business(self):
ts = Timestamp("2017-10-01", freq="B")
control = Timestamp("2017-10-01")
assert ts.dayofweek == 6
assert ts.day_of_week == 6
assert not ts.is_month_start # not a weekday
assert not ts.freq.is_month_start(ts)
assert ts.freq.is_month_start(ts + Timedelta(days=1))
assert not ts.is_quarter_start # not a weekday
assert not ts.freq.is_quarter_start(ts)
assert ts.freq.is_quarter_start(ts + Timedelta(days=1))
# Control case: non-business is month/qtr start
assert control.is_month_start
assert control.is_quarter_start
ts = Timestamp("2017-09-30", freq="B")
control = Timestamp("2017-09-30")
assert ts.dayofweek == 5
assert ts.day_of_week == 5
assert not ts.is_month_end # not a weekday
assert not ts.freq.is_month_end(ts)
assert ts.freq.is_month_end(ts - Timedelta(days=1))
assert not ts.is_quarter_end # not a weekday
assert not ts.freq.is_quarter_end(ts)
assert ts.freq.is_quarter_end(ts - Timedelta(days=1))
# Control case: non-business is month/qtr start
assert control.is_month_end
assert control.is_quarter_end
@pytest.mark.parametrize(
"attr, expected",
[
["year", 2014],
["month", 12],
["day", 31],
["hour", 23],
["minute", 59],
["second", 0],
["microsecond", 0],
["nanosecond", 0],
["dayofweek", 2],
["day_of_week", 2],
["quarter", 4],
["dayofyear", 365],
["day_of_year", 365],
["week", 1],
["daysinmonth", 31],
],
)
@pytest.mark.parametrize("tz", [None, "US/Eastern"])
def test_fields(self, attr, expected, tz):
# GH 10050
# GH 13303
ts = Timestamp("2014-12-31 23:59:00", tz=tz)
result = getattr(ts, attr)
# that we are int like
assert isinstance(result, int)
assert result == expected
@pytest.mark.parametrize("tz", [None, "US/Eastern"])
def test_millisecond_raises(self, tz):
ts = Timestamp("2014-12-31 23:59:00", tz=tz)
msg = "'Timestamp' object has no attribute 'millisecond'"
with pytest.raises(AttributeError, match=msg):
ts.millisecond
@pytest.mark.parametrize(
"start", ["is_month_start", "is_quarter_start", "is_year_start"]
)
@pytest.mark.parametrize("tz", [None, "US/Eastern"])
def test_is_start(self, start, tz):
ts = Timestamp("2014-01-01 00:00:00", tz=tz)
assert getattr(ts, start)
@pytest.mark.parametrize("end", ["is_month_end", "is_year_end", "is_quarter_end"])
@pytest.mark.parametrize("tz", [None, "US/Eastern"])
def test_is_end(self, end, tz):
|
# GH 12806
@pytest.mark.parametrize(
"data",
[Timestamp("2017-08-28 23:00:00"), Timestamp("2017-08-28 23:00:00", tz="EST")],
)
# error: Unsupported operand types for + ("List[None]" and "List[str]")
@pytest.mark.parametrize(
"time_locale", [None] + (tm.get_locales() or []) # type: ignore[operator]
)
def test_names(self, data, time_locale):
# GH 17354
# Test .day_name(), .month_name
if time_locale is None:
expected_day = "Monday"
expected_month = "August"
else:
with tm.set_locale(time_locale, locale.LC_TIME):
expected_day = calendar.day_name[0].capitalize()
expected_month = calendar.month_name[8].capitalize()
result_day = data.day_name(time_locale)
result_month = data.month_name(time_locale)
# Work around https://github.com/pandas-dev/pandas/issues/22342
# different normalizations
expected_day = unicodedata.normalize("NFD", expected_day)
expected_month = unicodedata.normalize("NFD", expected_month)
result_day = unicodedata.normalize("NFD", result_day)
result_month = unicodedata.normalize("NFD", result_month)
assert result_day == expected_day
assert result_month == expected_month
# Test NaT
nan_ts = Timestamp(NaT)
assert np.isnan(nan_ts.day_name(time_locale))
assert np.isnan(nan_ts.month_name(time_locale))
def test_is_leap_year(self, tz_naive_fixture):
tz = tz_naive_fixture
# GH 13727
dt = Timestamp("2000-01-01 00:00:00", tz=tz)
assert dt.is_leap_year
assert isinstance(dt.is_leap_year, bool)
dt = Timestamp("1999-01-01 00:00:00", tz=tz)
assert not dt.is_leap_year
dt = Timestamp("2004-01-01 00:00:00", tz=tz)
assert dt.is_leap_year
dt = Timestamp("2100-01-01 00:00:00", tz=tz)
assert not dt.is_leap_year
def test_woy_boundary(self):
# make sure weeks at year boundaries are correct
d = datetime(2013, 12, 31)
result = Timestamp(d).week
expected = 1 # ISO standard
assert result == expected
d = datetime(2008, 12, 28)
result = Timestamp(d).week
expected = 52 # ISO standard
assert result == expected
d = datetime(2009, 12, 31)
result = Timestamp(d).week
expected = 53 # ISO standard
assert result == expected
d = datetime(2010, 1, 1)
result = Timestamp(d).week
expected = 53 # ISO standard
assert result == expected
d = datetime(2010, 1, 3)
result = Timestamp(d).week
expected = 53 # ISO standard
assert result == expected
result = np.array(
[
Timestamp(datetime(*args)).week
for args in [(2000, 1, 1), (2000, 1, 2), (2005, 1, 1), (2005, 1, 2)]
]
)
assert (result == [52, 52, 53, 53]).all()
def test_resolution(self):
# GH#21336, GH#21365
dt = Timestamp("2100-01-01 00:00:00")
assert dt.resolution == Timedelta(nanoseconds=1)
# Check that the attribute is available on the class, mirroring
# the stdlib datetime behavior
assert Timestamp.resolution == Timedelta(nanoseconds=1)
class TestTimestamp:
def test_tz(self):
tstr = "2014-02-01 09:00"
ts = Timestamp(tstr)
local = ts.tz_localize("Asia/Tokyo")
assert local.hour == 9
assert local == Timestamp(tstr, tz="Asia/Tokyo")
conv = local.tz_convert("US/Eastern")
assert conv == Timestamp("2014-01-31 19:00", tz="US/Eastern")
assert conv.hour == 19
# preserves nanosecond
ts = Timestamp(tstr) + offsets.Nano(5)
local = ts.tz_localize("Asia/Tokyo")
assert local.hour == 9
assert local.nanosecond == 5
conv = local.tz_convert("US/Eastern")
assert conv.nanosecond == 5
assert conv.hour == 19
def test_utc_z_designator(self):
assert get_timezone(Timestamp("2014-11-02 01:00Z").tzinfo) is utc
def test_asm8(self):
np.random.seed(7_960_929)
ns = [Timestamp.min.value, Timestamp.max.value, 1000]
for n in ns:
assert (
Timestamp(n).asm8.view("i8") == np.datetime64(n, "ns").view("i8") == n
)
assert Timestamp("nat").asm8.view("i8") == np.datetime64("nat", "ns").view("i8")
def test_class_ops_pytz(self):
def compare(x, y):
assert int((Timestamp(x).value - Timestamp(y).value) / 1e9) == 0
compare(Timestamp.now(), datetime.now())
compare(Timestamp.now("UTC"), datetime.now(timezone("UTC")))
compare(Timestamp.utcnow(), datetime.utcnow())
compare(Timestamp.today(), datetime.today())
current_time = calendar.timegm(datetime.now().utctimetuple())
msg = "timezone-aware Timestamp with UTC"
with tm.assert_produces_warning(FutureWarning, match=msg):
# GH#22451
ts_utc = Timestamp.utcfromtimestamp(current_time)
compare(
ts_utc,
datetime.utcfromtimestamp(current_time),
)
compare(
Timestamp.fromtimestamp(current_time), datetime.fromtimestamp(current_time)
)
compare(
# Support tz kwarg in Timestamp.fromtimestamp
Timestamp.fromtimestamp(current_time, "UTC"),
datetime.fromtimestamp(current_time, utc),
)
compare(
# Support tz kwarg in Timestamp.fromtimestamp
Timestamp.fromtimestamp(current_time, tz="UTC"),
datetime.fromtimestamp(current_time, utc),
)
date_component = datetime.utcnow()
time_component = (date_component + timedelta(minutes=10)).time()
compare(
Timestamp.combine(date_component, time_component),
datetime.combine(date_component, time_component),
)
def test_class_ops_dateutil(self):
def compare(x, y):
assert (
int(
np.round(Timestamp(x).value / 1e9)
- np.round(Timestamp(y).value / 1e9)
)
== 0
)
compare(Timestamp.now(), datetime.now())
compare(Timestamp.now("UTC"), datetime.now(tzutc()))
compare(Timestamp.utcnow(), datetime.utcnow())
compare(Timestamp.today(), datetime.today())
current_time = calendar.timegm(datetime.now().utctimetuple())
msg = "timezone-aware Timestamp with UTC"
with tm.assert_produces_warning(FutureWarning, match=msg):
# GH#22451
ts_utc = Timestamp.utcfromtimestamp(current_time)
compare(
ts_utc,
datetime.utcfromtimestamp(current_time),
)
compare(
Timestamp.fromtimestamp(current_time), datetime.fromtimestamp(current_time)
)
date_component = datetime.utcnow()
time_component = (date_component + timedelta(minutes=10)).time()
compare(
Timestamp.combine(date_component, time_component),
datetime.combine(date_component, time_component),
)
def test_basics_nanos(self):
val = np.int64(946_684_800_000_000_000).view("M8[ns]")
stamp = Timestamp(val.view("i8") + 500)
assert stamp.year == 2000
assert stamp.month == 1
assert stamp.microsecond == 0
assert stamp.nanosecond == 500
# GH 14415
val = np.iinfo(np.int64).min + 80_000_000_000_000
stamp = Timestamp(val)
assert stamp.year == 1677
assert stamp.month == 9
assert stamp.day == 21
assert stamp.microsecond == 145224
assert stamp.nanosecond == 192
@pytest.mark.parametrize(
"value, check_kwargs",
[
[946688461000000000, {}],
[946688461000000000 / 1000, {"unit": "us"}],
[946688461000000000 / 1_000_000, {"unit": "ms"}],
[946688461000000000 / 1_000_000_000, {"unit": "s"}],
[10957, {"unit": "D", "h": 0}],
[
(946688461000000000 + 500000) / 1000000000,
{"unit": "s", "us": 499, "ns": 964},
],
[
(946688461000000000 + 500000000) / 1000000000,
{"unit": "s", "us": 500000},
],
[(946688461000000000 + 500000) / 1000000, {"unit": "ms", "us": 500}],
[(946688461000000000 + 500000) / 1000, {"unit": "us", "us": 500}],
[(946688461000000000 + 500000000) / 1000000, {"unit": "ms", "us": 500000}],
[946688461000000000 / 1000.0 + 5, {"unit": "us", "us": 5}],
[946688461000000000 / 1000.0 + 5000, {"unit": "us", "us": 5000}],
[946688461000000000 / 1000000.0 + 0.5, {"unit": "ms", "us": 500}],
[946688461000000000 / 1000000.0 + 0.005, {"unit": "ms", "us": 5, "ns": 5}],
[946688461000000000 / 1000000000.0 + 0.5, {"unit": "s", "us": 500000}],
[10957 + 0.5, {"unit": "D", "h": 12}],
],
)
def test_unit(self, value, check_kwargs):
def check(value, unit=None, h=1, s=1, us=0, ns=0):
stamp = Timestamp(value, unit=unit)
assert stamp.year == 2000
assert stamp.month == 1
assert stamp.day == 1
assert stamp.hour == h
if unit != "D":
assert stamp.minute == 1
assert stamp.second == s
assert stamp.microsecond == us
else:
assert stamp.minute == 0
assert stamp.second == 0
assert stamp.microsecond == 0
assert stamp.nanosecond == ns
check(value, **check_kwargs)
def test_roundtrip(self):
# test value to string and back conversions
# further test accessors
base = Timestamp("20140101 00:00:00")
result = Timestamp(base.value + Timedelta("5ms").value)
assert result == Timestamp(f"{base}.005000")
assert result.microsecond == 5000
result = Timestamp(base.value + Timedelta("5us").value)
assert result == Timestamp(f"{base}.000005")
assert result.microsecond == 5
result = Timestamp(base.value + Timedelta("5ns").value)
assert result == Timestamp(f"{base}.000000005")
assert result.nanosecond == 5
assert result.microsecond == 0
result = Timestamp(base.value + Timedelta("6ms 5us").value)
assert result == Timestamp(f"{base}.006005")
assert result.microsecond == 5 + 6 * 1000
result = Timestamp(base.value + Timedelta("200ms 5us").value)
assert result == Timestamp(f"{base}.200005")
assert result.microsecond == 5 + 200 * 1000
def test_hash_equivalent(self):
d = {datetime(2011, 1, 1): 5}
stamp = Timestamp(datetime(2011, 1, 1))
assert d[stamp] == 5
@pytest.mark.parametrize(
"timezone, year, month, day, hour",
[["America/Chicago", 2013, 11, 3, 1], ["America/Santiago", 2021, 4, 3, 23]],
)
def test_hash_timestamp_with_fold(self, timezone, year, month, day, hour):
# see gh-33931
test_timezone = gettz(timezone)
transition_1 = Timestamp(
year=year,
month=month,
day=day,
hour=hour,
minute=0,
fold=0,
tzinfo=test_timezone,
)
transition_2 = Timestamp(
year=year,
month=month,
day=day,
hour=hour,
minute=0,
fold=1,
tzinfo=test_timezone,
)
assert hash(transition_1) == hash(transition_2)
def test_tz_conversion_freq(self, tz_naive_fixture):
# GH25241
with tm.assert_produces_warning(FutureWarning, match="freq"):
t1 = Timestamp("2019-01-01 10:00", freq="H")
assert t1.tz_localize(tz=tz_naive_fixture).freq == t1.freq
with tm.assert_produces_warning(FutureWarning, match="freq"):
t2 = Timestamp("2019-01-02 12:00", tz="UTC", freq="T")
assert t2.tz_convert(tz="UTC").freq == t2.freq
def test_pickle_freq_no_warning(self):
# GH#41949 we don't want a warning on unpickling
with tm.assert_produces_warning(FutureWarning, match="freq"):
ts = Timestamp("2019-01-01 10:00", freq="H")
out = pickle.dumps(ts)
with tm.assert_produces_warning(None):
res = pickle.loads(out)
assert res._freq == ts._freq
class TestTimestampNsOperations:
def test_nanosecond_string_parsing(self):
ts = Timestamp("2013-05-01 07:15:45.123456789")
# GH 7878
expected_repr = "2013-05-01 07:15:45.123456789"
expected_value = 1_367_392_545_123_456_789
assert ts.value == expected_value
assert expected_repr in repr(ts)
ts = Timestamp("2013-05-01 07:15:45.123456789+09:00", tz="Asia/Tokyo")
assert ts.value == expected_value - 9 * 3600 * 1_000_000_000
assert expected_repr in repr(ts)
ts = Timestamp("2013-05-01 07:15:45.123456789", tz="UTC")
assert ts.value == expected_value
assert expected_repr in repr(ts)
ts = Timestamp("2013-05-01 07:15:45.123456789", tz="US/Eastern")
assert ts.value == expected_value + 4 * 3600 * 1_000_000_000
assert expected_repr in repr(ts)
# GH 10041
ts = Timestamp("20130501T071545.123456789")
assert ts.value == expected_value
assert expected_repr in repr(ts)
def test_nanosecond_timestamp(self):
# GH 7610
expected = 1_293_840_000_000_000_005
t = Timestamp("2011-01-01") + offsets.Nano(5)
assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000005')"
assert t.value == expected
assert t.nanosecond == 5
t = Timestamp(t)
assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000005')"
assert t.value == expected
assert t.nanosecond == 5
t = Timestamp("2011-01-01 00:00:00.000000005")
assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000005')"
assert t.value == expected
assert t.nanosecond == 5
expected = 1_293_840_000_000_000_010
t = t + offsets.Nano(5)
assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000010')"
assert t.value == expected
assert t.nanosecond == 10
t = Timestamp(t)
assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000010')"
assert t.value == expected
assert t.nanosecond == 10
t = Timestamp("2011-01-01 00:00:00.000000010")
assert repr(t) == "Timestamp('2011-01-01 00:00:00.000000010')"
assert t.value == expected
assert t.nanosecond == 10
class TestTimestampToJulianDate:
def test_compare_1700(self):
r = Timestamp("1700-06-23").to_julian_date()
assert r == 2_342_145.5
def test_compare_2000(self):
r = Timestamp("2000-04-12").to_julian_date()
assert r == 2_451_646.5
def test_compare_2100(self):
r = Timestamp("2100-08-12").to_julian_date()
assert r == 2_488_292.5
def test_compare_hour01(self):
r = Timestamp("2000-08-12T01:00:00").to_julian_date()
assert r == 2_451_768.5416666666666666
def test_compare_hour13(self):
r = Timestamp("2000-08-12T13:00:00").to_julian_date()
assert r == 2_451_769.0416666666666666
class TestTimestampConversion:
def test_conversion(self):
# GH#9255
ts = Timestamp("2000-01-01")
result = ts.to_pydatetime()
expected = datetime(2000, 1, 1)
assert result == expected
assert type(result) == type(expected)
result = ts.to_datetime64()
expected = np.datetime64(ts.value, "ns")
assert result == expected
assert type(result) == type(expected)
assert result.dtype == expected.dtype
def test_to_pydatetime_nonzero_nano(self):
ts = Timestamp("2011-01-01 9:00:00.123456789")
# Warn the user of data loss (nanoseconds).
with tm.assert_produces_warning(UserWarning):
expected = datetime(2011, 1, 1, 9, 0, 0, 123456)
result = ts.to_pydatetime()
assert result == expected
def test_timestamp_to_datetime(self):
stamp = Timestamp("20090415", tz="US/Eastern")
dtval = stamp.to_pydatetime()
assert stamp == dtval
assert stamp.tzinfo == dtval.tzinfo
def test_timestamp_to_datetime_dateutil(self):
stamp = Timestamp("20090415", tz="dateutil/US/Eastern")
dtval = stamp.to_pydatetime()
assert stamp == dtval
assert stamp.tzinfo == dtval.tzinfo
def test_timestamp_to_datetime_explicit_pytz(self):
stamp = Timestamp("20090415", tz=pytz.timezone("US/Eastern"))
dtval = stamp.to_pydatetime()
assert stamp == dtval
assert stamp.tzinfo == dtval.tzinfo
@td.skip_if_windows
def test_timestamp_to_datetime_explicit_dateutil(self):
stamp = Timestamp("20090415", tz=gettz("US/Eastern"))
dtval = stamp.to_pydatetime()
assert stamp == dtval
assert stamp.tzinfo == dtval.tzinfo
def test_to_datetime_bijective(self):
# Ensure that converting to datetime and back only loses precision
# by going from nanoseconds to microseconds.
exp_warning = None if Timestamp.max.nanosecond == 0 else UserWarning
with tm.assert_produces_warning(exp_warning):
pydt_max = Timestamp.max.to_pydatetime()
assert Timestamp(pydt_max).value / 1000 == Timestamp.max.value / 1000
exp_warning = None if Timestamp.min.nanosecond == 0 else UserWarning
with tm.assert_produces_warning(exp_warning):
pydt_min = Timestamp.min.to_pydatetime()
# The next assertion can be enabled once GH#39221 is merged
# assert pydt_min < Timestamp.min # this is bc nanos are dropped
tdus = timedelta(microseconds=1)
assert pydt_min + tdus > Timestamp.min
assert Timestamp(pydt_min + tdus).value / 1000 == Timestamp.min.value / 1000
def test_to_period_tz_warning(self):
# GH#21333 make sure a warning is issued when timezone
# info is lost
ts = Timestamp("2009-04-15 16:17:18", tz="US/Eastern")
with tm.assert_produces_warning(UserWarning):
# warning that timezone info will be lost
ts.to_period("D")
def test_to_numpy_alias(self):
# GH 24653: alias .to_numpy() for scalars
ts = Timestamp(datetime.now())
assert ts.to_datetime64() == ts.to_numpy()
# GH#44460
msg = "dtype and copy arguments are ignored"
with pytest.raises(ValueError, match=msg):
ts.to_numpy("M8[s]")
with pytest.raises(ValueError, match=msg):
ts.to_numpy(copy=True)
class SubDatetime(datetime):
pass
@pytest.mark.parametrize(
"lh,rh",
[
(SubDatetime(2000, 1, 1), Timedelta(hours=1)),
(Timedelta(hours=1), SubDatetime(2000, 1, 1)),
],
)
def test_dt_subclass_add_timedelta(lh, rh):
# GH#25851
# ensure that subclassed datetime works for
# Timedelta operations
result = lh + rh
expected = SubDatetime(2000, 1, 1, 1)
assert result == expected
| ts = Timestamp("2014-12-31 23:59:59", tz=tz)
assert getattr(ts, end) |
rights_reducer.rs | // Copyright (c) SimpleStaking, Viable Systems and Tezedge Contributors
// SPDX-License-Identifier: MIT
use std::collections::hash_map::Entry;
use crate::{Action, State};
use redux_rs::ActionWithMeta;
use super::{
cycle_delegates::{CycleDelegatesQuery, CycleDelegatesQueryState},
rights_actions::*,
RightsRequest, Validators,
};
pub fn rights_reducer(state: &mut State, action: &ActionWithMeta<Action>) | {
let requests = &mut state.rights.requests;
match &action.action {
// RPC actions
Action::RightsRpcGet(RightsRpcGetAction { key, rpc_id }) => {
state
.rights
.rpc_requests
.entry(key.clone())
.or_default()
.push(*rpc_id);
}
Action::RightsPruneRpcRequest(RightsRpcPruneAction { key }) => {
state.rights.rpc_requests.remove(key);
}
// Auxiliary actions
Action::RightsInit(RightsInitAction { key }) if !requests.contains_key(key) => {
requests.insert(key.clone(), RightsRequest::Init { start: action.id });
}
Action::RightsGetBlockHeader(RightsGetBlockHeaderAction { key }) => {
if let Some(request) = requests.get_mut(key) {
if let RightsRequest::Init { start } = request {
*request = RightsRequest::PendingBlockHeader { start: *start };
}
}
}
Action::RightsBlockHeaderReady(RightsBlockHeaderReadyAction { key, block_header }) => {
if let Some(request) = requests.get_mut(key) {
if let RightsRequest::PendingBlockHeader { start } = request {
*request = RightsRequest::BlockHeaderReady {
start: *start,
block_header: block_header.clone(),
};
}
}
}
Action::RightsGetProtocolHash(RightsGetProtocolHashAction { key }) => {
if let Some(request) = requests.get_mut(key) {
if let RightsRequest::BlockHeaderReady {
start,
block_header,
} = request
{
*request = RightsRequest::PendingProtocolHash {
start: *start,
block_header: block_header.clone(),
};
}
}
}
Action::RightsProtocolHashReady(RightsProtocolHashReadyAction {
key,
proto_hash,
protocol,
}) => {
if let Some(request) = requests.get_mut(key) {
if let RightsRequest::PendingProtocolHash {
start,
block_header,
} = request
{
*request = RightsRequest::ProtocolHashReady {
start: *start,
block_header: block_header.clone(),
proto_hash: proto_hash.clone(),
protocol: protocol.clone(),
};
}
}
}
Action::RightsGetProtocolConstants(RightsGetProtocolConstantsAction { key }) => {
if let Some(request) = requests.get_mut(key) {
if let RightsRequest::ProtocolHashReady {
start,
block_header,
proto_hash,
protocol,
} = request
{
*request = RightsRequest::PendingProtocolConstants {
start: *start,
block_header: block_header.clone(),
proto_hash: proto_hash.clone(),
protocol: protocol.clone(),
};
}
}
}
Action::RightsProtocolConstantsReady(RightsProtocolConstantsReadyAction {
key,
constants,
}) => {
if let Some(request) = requests.get_mut(key) {
if let RightsRequest::PendingProtocolConstants {
start,
block_header,
proto_hash,
protocol,
} = request
{
*request = RightsRequest::ProtocolConstantsReady {
start: *start,
block_header: block_header.clone(),
proto_hash: proto_hash.clone(),
protocol: protocol.clone(),
protocol_constants: constants.clone(),
};
}
}
}
Action::RightsGetCycleEras(RightsGetCycleErasAction { key }) => {
if let Some(request) = requests.get_mut(key) {
if let RightsRequest::ProtocolConstantsReady {
start,
block_header,
proto_hash,
protocol,
protocol_constants,
} = request
{
*request =
if let Some(cycle_eras) = state.rights.cycle_eras.get_result(proto_hash) {
RightsRequest::CycleErasReady {
start: *start,
block_header: block_header.clone(),
protocol: protocol.clone(),
protocol_constants: protocol_constants.clone(),
cycle_eras: cycle_eras.clone(),
}
} else {
RightsRequest::PendingCycleEras {
start: *start,
block_header: block_header.clone(),
proto_hash: proto_hash.clone(),
protocol: protocol.clone(),
protocol_constants: protocol_constants.clone(),
}
};
}
}
}
Action::RightsCycleErasReady(RightsCycleErasReadyAction { key, cycle_eras }) => {
if let Some(request) = requests.get_mut(key) {
if let RightsRequest::PendingCycleEras {
start,
block_header,
proto_hash: _,
protocol,
protocol_constants,
} = request
{
*request = RightsRequest::CycleErasReady {
start: *start,
block_header: block_header.clone(),
protocol: protocol.clone(),
protocol_constants: protocol_constants.clone(),
cycle_eras: cycle_eras.clone(),
};
}
}
}
Action::RightsGetCycle(RightsGetCycleAction { key }) => {
if let Some(request) = requests.get_mut(key) {
if let RightsRequest::CycleErasReady {
start,
block_header,
protocol,
protocol_constants,
cycle_eras,
} = request
{
*request = RightsRequest::PendingCycle {
start: *start,
block_header: block_header.clone(),
protocol: protocol.clone(),
protocol_constants: protocol_constants.clone(),
cycle_eras: cycle_eras.clone(),
};
}
}
}
Action::RightsCycleReady(RightsCycleReadyAction {
key,
cycle,
position,
}) => {
if let Some(request) = requests.get_mut(key) {
if let RightsRequest::PendingCycle {
start,
block_header,
protocol,
protocol_constants,
cycle_eras: _,
} = request
{
*request = RightsRequest::CycleReady {
start: *start,
block_header: block_header.clone(),
protocol: protocol.clone(),
protocol_constants: protocol_constants.clone(),
level: key.level().unwrap_or_else(|| block_header.level()),
cycle: *cycle,
position: *position,
};
}
}
}
Action::RightsGetCycleData(RightsGetCycleDataAction { key }) => {
if let Some(request) = requests.get_mut(key) {
if let RightsRequest::CycleReady {
start,
block_header: _,
protocol,
protocol_constants,
level,
cycle,
position,
} = request
{
*request = RightsRequest::PendingCycleData {
start: *start,
protocol: protocol.clone(),
protocol_constants: protocol_constants.clone(),
level: *level,
cycle: *cycle,
position: *position,
};
}
}
}
Action::RightsCycleDataReady(RightsCycleDataReadyAction { key, cycle_data }) => {
if let Some(request) = requests.get_mut(key) {
if let RightsRequest::PendingCycleData {
start,
protocol,
protocol_constants,
level,
cycle: _,
position,
} = request
{
*request = RightsRequest::CycleDataReady {
start: *start,
protocol: protocol.clone(),
protocol_constants: protocol_constants.clone(),
level: *level,
position: *position,
cycle_data: cycle_data.clone(),
};
}
}
}
Action::RightsCalculateEndorsingRights(RightsCalculateAction { key }) => {
if let Some(request) = requests.get_mut(key) {
if let RightsRequest::CycleDataReady {
start,
protocol,
protocol_constants,
level,
cycle_data,
position,
} = request
{
*request = RightsRequest::PendingRightsCalculation {
start: *start,
protocol: protocol.clone(),
protocol_constants: protocol_constants.clone(),
level: *level,
cycle_data: cycle_data.clone(),
position: *position,
};
}
}
}
Action::RightsGetCycleDelegates(RightsGetCycleDelegatesAction { key }) => {
if let Some(request) = requests.get_mut(key) {
if let RightsRequest::CycleReady {
start,
block_header,
level,
cycle,
..
} = request
{
let req = state.rights.cycle_delegates.get(cycle);
*request = if let Some(CycleDelegatesQuery {
state: CycleDelegatesQueryState::Success(delegates),
}) = req
{
RightsRequest::CycleDelegatesReady {
start: *start,
block_header: block_header.clone(),
level: *level,
delegates: delegates.clone(),
}
} else {
RightsRequest::PendingCycleDelegates {
start: *start,
block_header: block_header.clone(),
level: *level,
cycle: *cycle,
}
};
}
}
}
Action::RightsCycleDelegatesReady(RightsCycleDelegatesReadyAction { key, delegates }) => {
if let Some(request) = requests.get_mut(key) {
if let RightsRequest::PendingCycleDelegates {
start,
block_header,
level,
cycle: _,
} = request
{
*request = RightsRequest::CycleDelegatesReady {
start: *start,
block_header: block_header.clone(),
level: *level,
delegates: delegates.clone(),
};
}
}
}
Action::RightsCalculateIthaca(RightsCalculateIthacaAction { key }) => {
if let Some(request) = requests.get_mut(key) {
if let RightsRequest::CycleDelegatesReady {
start,
block_header,
level,
delegates,
} = request
{
*request = RightsRequest::PendingRightsCalculationIthaca {
start: *start,
block_header: block_header.clone(),
level: *level,
delegates: delegates.clone(),
};
}
}
}
Action::RightsContextRequested(RightsContextRequestedAction { key, token }) => {
if let Some(request) = requests.get_mut(key) {
if let RightsRequest::PendingRightsCalculationIthaca {
start,
block_header: _,
level,
delegates,
} = request
{
*request = RightsRequest::PendingRightsFromContextIthaca {
start: *start,
level: *level,
delegates: delegates.clone(),
token: *token,
};
}
}
}
Action::RightsIthacaContextValidatorsSuccess(
RightsIthacaContextValidatorsSuccessAction {
key,
validators: context_validators,
},
) => {
if let Some(request) = requests.get_mut(key) {
if let RightsRequest::PendingRightsFromContextIthaca {
start: _,
level,
delegates,
..
} = request
{
let validators = context_validators
.validators
.iter()
.filter_map(|pkh| delegates.get(pkh).cloned())
.collect();
let slots = context_validators
.slots
.iter()
.filter_map(|(pkh, rights)| {
delegates.get(pkh).cloned().map(|pk| (pk, rights.clone()))
})
.collect();
*request = RightsRequest::ValidatorsReady(Validators {
level: *level,
validators,
slots,
});
}
}
}
Action::RightsBakingOldReady(RightsBakingOldReadyAction { key, baking_rights }) => {
if let Some(RightsRequest::PendingRightsCalculation { .. }) = requests.remove(key) {
let cache = &mut state.rights.cache.baking;
let duration = state.rights.cache.time;
cache.retain(|_, (timestamp, _)| action.id.duration_since(*timestamp) < duration);
slog::trace!(&state.log, "cached endorsing rights"; "level" => baking_rights.level);
cache.insert(baking_rights.level, (action.id, baking_rights.clone()));
}
}
Action::RightsEndorsingOldReady(RightsEndorsingOldReadyAction {
key,
endorsing_rights,
}) => {
if let Entry::Occupied(entry) = requests.entry(key.clone()) {
if let RightsRequest::PendingRightsCalculation { .. } = entry.get() {
entry.remove();
}
let cache = &mut state.rights.cache.endorsing_old;
let duration = state.rights.cache.time;
cache.retain(|_, (timestamp, _)| action.id.duration_since(*timestamp) < duration);
slog::trace!(&state.log, "cached endorsing rights"; "level" => endorsing_rights.level);
cache.insert(
endorsing_rights.level,
(action.id, endorsing_rights.clone()),
);
}
}
Action::RightsValidatorsReady(RightsValidatorsReadyAction { key }) => {
if let Entry::Occupied(entry) = requests.entry(key.clone()) {
if let RightsRequest::ValidatorsReady(validators) = entry.get() {
let validators = validators.clone();
entry.remove();
let cache = &mut state.rights.cache.validators;
let duration = state.rights.cache.time;
cache.retain(|_, (timestamp, _)| {
action.id.duration_since(*timestamp) < duration
});
slog::trace!(&state.log, "cached endorsing rights"; "level" => validators.level);
cache.insert(validators.level, (action.id, validators));
}
}
}
Action::RightsError(RightsErrorAction { key, error }) => {
if let Some(request) = requests.remove(key) {
state
.rights
.errors
.push((key.clone().into(), request, error.clone()));
}
}
_ => (),
}
} |
|
views.py | from django.utils.translation import ugettext as _
from rest_framework.generics import GenericAPIView
from rest_framework.response import Response
from .serializers import PaymentInputSerializer, PaymentPatchSerializer, PaymentResponseSerializer
from .services import PaymentService
class PaymentView(GenericAPIView):
serializer_class = PaymentInputSerializer
def | (self, **kwargs):
super().__init__(**kwargs)
self.service = PaymentService()
def post(self, request):
"""
Record a new payment.
"""
params = request.data.copy()
data = self.service.insert(params)
serializer = PaymentResponseSerializer(data)
result = {'detail': _('Payment recorded successfully!'), 'data': serializer.data}
return Response(result)
class PaymentViewId(GenericAPIView):
serializer_class = PaymentPatchSerializer
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.service = PaymentService()
def patch(self, request, payment_id):
"""
Update payment value. If payment value reach zero, the flag is_paid will be set to true.
It will raise an error if:
- Payment is already paid;
- Expiration date has already passed;
- Value is higher than amount available for payment;
- Branch has no balance.
"""
params = dict(
value=request.data.get('value'), id=payment_id
)
data = self.service.pay(params)
serializer = PaymentResponseSerializer(data)
result = {'detail': _('Payment changed successfully!'), 'data': serializer.data}
return Response(result)
| __init__ |
SearchStudio.js | import { SearchFilterFirstLetter, SearchFilterSortBy } from "components/search-filter";
import useEntitySearch from "hooks/useEntitySearch";
import { SearchEntity } from "components/search";
import { navigate } from "gatsby";
import { SummaryCard } from "components/card";
const sortByFields = new Map([
[ "A ➜ Z", "name" ],
[ "Z ➜ A", "-name" ],
[ "Last Added", "-created_at" ]
]);
const sortByOptions = [ ...sortByFields.keys() ];
export function Sear | earchQuery, locationState }) {
const filterFirstLetter = locationState?.filterFirstLetter || null;
const sortBy = locationState?.sortBy || sortByOptions[0];
const updateState = (field) => (newValue) => {
navigate("", {
state: {
...locationState,
[field]: newValue
},
replace: true
});
};
const entitySearch = useEntitySearch("studio", searchQuery, {
filters: {
"name][like": filterFirstLetter ? `${filterFirstLetter}%` : null,
},
sortBy: searchQuery ? null : sortByFields.get(sortBy)
});
return (
<SearchEntity
searchQuery={searchQuery}
filters={
<>
<SearchFilterFirstLetter value={filterFirstLetter} setValue={updateState("filterFirstLetter")}/>
<SearchFilterSortBy
options={searchQuery ? [ "Relevance" ] : sortByOptions}
value={searchQuery ? "Relevance" : sortBy}
setValue={updateState("sortBy")}
/>
</>
}
renderSummaryCard={(studio) => <SummaryCard key={studio.slug} title={studio.name} description="Studio" to={`/studio/${studio.slug}`} />}
{...entitySearch}
/>
);
}
| chStudio({ s |
di.spec.ts | import { Resolver, Factory, fallbackInvoker, transient, singleton } from './../../src/di';
import { spy } from 'sinon';
import { DI, Container, PLATFORM, IContainer, IDefaultableInterfaceSymbol, ResolverStrategy, inject, invokeWithDynamicDependencies, classInvokers, Registration } from "../../src";
import { expect } from "chai";
import { _ } from "./util";
import * as sinon from 'sinon';
function assertIsMutableArray(arr: any[], length: number): void {
expect(Array.isArray(arr)).to.be.true;
expect(arr instanceof Array).to.be.true;
expect(arr).not.to.equal(PLATFORM.emptyArray);
expect(arr.length).to.equal(length);
arr.push(null);
expect(arr.length).to.equal(length + 1);
arr.pop();
expect(arr.length).to.equal(length);
}
function decorator(): ClassDecorator { return (target: any) => target; }
describe(`The DI object`, () => {
describe(`createContainer()`, () => {
it(`returns an instance of Container`, () => {
const actual = DI.createContainer();
expect(actual).to.be.instanceof(Container);
});
it(`returns a new container every time`, () => {
expect(DI.createContainer()).not.to.equal(DI.createContainer());
});
});
describe(`getDesignParamTypes()`, () => {
it(`returns PLATFORM.emptyArray if the class has no constructor or decorators`, () => {
class Foo {}
const actual = DI.getDesignParamTypes(Foo);
expect(actual).to.equal(PLATFORM.emptyArray);
});
it(`returns PLATFORM.emptyArray if the class has a decorator but no constructor`, () => {
@decorator()
class Foo {}
const actual = DI.getDesignParamTypes(Foo);
expect(actual).to.equal(PLATFORM.emptyArray);
});
it(`returns PLATFORM.emptyArray if the class has no constructor args or decorators`, () => {
class Foo { constructor() {} }
const actual = DI.getDesignParamTypes(Foo);
expect(actual).to.equal(PLATFORM.emptyArray);
});
it(`returns PLATFORM.emptyArray if the class has constructor args but no decorators`, () => {
class Bar {}
class Foo { constructor(public bar: Bar) {} }
const actual = DI.getDesignParamTypes(Foo);
expect(actual).to.equal(PLATFORM.emptyArray);
});
it(`returns PLATFORM.emptyArray if the class has constructor args and the decorator is applied via a function call`, () => {
class Bar {}
class Foo { constructor(public bar: Bar) {} }
decorator()(Foo)
const actual = DI.getDesignParamTypes(Foo);
expect(actual).to.equal(PLATFORM.emptyArray);
});
it(`returns PLATFORM.emptyArray if the class is declared as an anonymous variable, even if it has ctor args and decorator is applied properly`, () => {
class Bar {}
@decorator()
const FooInline = class{ constructor(public bar: Bar) {} }
const actual = DI.getDesignParamTypes(FooInline);
expect(actual).to.equal(PLATFORM.emptyArray);
});
it(`returns PLATFORM.emptyArray if the class is declared as a named variable, even if it has ctor args and decorator is applied properly`, () => {
class Bar {}
@decorator()
const FooInline = class Foo{ constructor(public bar: Bar) {} }
const actual = DI.getDesignParamTypes(FooInline);
expect(actual).to.equal(PLATFORM.emptyArray);
});
describe(`returns an empty array if the class has a decorator but no constructor args`, () => {
@decorator()
class Foo { constructor() {} }
it(_`${Foo}`, () => {
const actual = DI.getDesignParamTypes(Foo);
assertIsMutableArray(actual, 0);
});
it(_`${class{}}`, () => {
let cls;
function anonDecorator(): ClassDecorator { return (target: any) => cls = target; }
@anonDecorator()
class{ constructor() {} };
const actual = DI.getDesignParamTypes(cls);
assertIsMutableArray(actual, 0);
});
});
describe(`falls back to Object for declarations that cannot be statically analyzed`, () => {
interface argCtor{}
for (const argCtor of <any[]>[
class Bar{},
function(){},
()=>{},
class{},
{},
Error,
Array,
(class Bar{}).prototype,
(class Bar{}).prototype.constructor
]) {
@decorator()
class FooDecoratorInvocation{ constructor(public arg: argCtor){} }
it(_`${FooDecoratorInvocation} { constructor(${argCtor}) }`, () => {
const actual = DI.getDesignParamTypes(FooDecoratorInvocation);
assertIsMutableArray(actual, 1);
expect(actual[0]).to.equal(Object);
});
@(<any>decorator)
class FooDecoratorNonInvocation{ constructor(public arg: argCtor){} }
it(_`${FooDecoratorNonInvocation} { constructor(${argCtor}) }`, () => {
const actual = DI.getDesignParamTypes(FooDecoratorInvocation);
assertIsMutableArray(actual, 1);
expect(actual[0]).to.equal(Object);
});
}
});
describe(`falls back to Object for mismatched declarations`, () => {
// Technically we're testing TypeScript here, but it's still useful to have an in-place fixture to validate our assumptions
// And also to have an alert mechanism for when the functionality in TypeScript changes, without having to read the changelogs
// What we're verifying here is under which circumstances a function object will or won't be properly resolved as a
// designParamType, and it seems like the presence of a same-name interface actually breaks this in some situations
// Note: the order of declaration (interface first or other thing first) doesn't seem to matter here
// But whether or not there is a direct type cast, does seem to matter in the case of AnonClass (note the negative assertion)
// It's unclear whether the difference between AnonClass (which works) and AnonClassInterface (which doesn't work) is a bug in TS or not,
// but it has ramifications we need to keep in mind.
interface Bar {}
class Bar{}
interface AnonClass {}
const AnonClass = class{};
interface AnonClassInterface {}
const AnonClassInterface: AnonClassInterface = class{};
interface VarFunc {}
const VarFunc = function(){};
interface VarFuncInterface {}
const VarFuncInterface: VarFuncInterface = function(){};
interface Func {}
function Func(){}
interface Arrow {}
const Arrow = () => {};
interface ArrowInterface {}
const ArrowInterface: ArrowInterface = () => {};
describe(`decorator invocation`, () => {
@decorator()
class FooBar{ constructor(public arg: Bar){} }
// Note: this is a negative assertion meant to make it easier to compare this describe with the one below
it(_`NOT ${FooBar} { constructor(public ${Bar}) }`, () => {
const actual = DI.getDesignParamTypes(FooBar);
assertIsMutableArray(actual, 1);
expect(actual[0]).to.equal(Bar);
});
@decorator()
class FooAnonClass{ constructor(public arg: AnonClass){} }
// Note: this is a negative assertion meant to make it easier to compare this describe with the one below
it(_`NOT ${FooAnonClass} { constructor(public ${AnonClass}) }`, () => {
const actual = DI.getDesignParamTypes(FooAnonClass);
assertIsMutableArray(actual, 1);
expect(actual[0]).to.equal(AnonClass);
});
@decorator()
class FooAnonClassInterface{ constructor(public arg: AnonClassInterface){} }
// this one is particularly interesting..
it(_`${FooAnonClassInterface} { constructor(public ${AnonClassInterface}) }`, () => {
const actual = DI.getDesignParamTypes(FooAnonClassInterface);
assertIsMutableArray(actual, 1);
expect(actual[0]).to.equal(Object);
});
@decorator()
class FooVarFunc{ constructor(public arg: VarFunc){} }
it(_`${FooVarFunc} { constructor(public ${VarFunc}) }`, () => {
const actual = DI.getDesignParamTypes(FooVarFunc);
assertIsMutableArray(actual, 1);
expect(actual[0]).to.equal(Object);
});
@decorator()
class FooVarFuncInterface{ constructor(public arg: VarFuncInterface){} }
it(_`${FooVarFuncInterface} { constructor(public ${VarFuncInterface}) }`, () => {
const actual = DI.getDesignParamTypes(FooVarFuncInterface);
assertIsMutableArray(actual, 1);
expect(actual[0]).to.equal(Object);
});
@decorator()
class FooFunc{ constructor(public arg: Func){} }
it(_`${FooFunc} { constructor(public ${Func}) }`, () => {
const actual = DI.getDesignParamTypes(FooFunc);
assertIsMutableArray(actual, 1);
expect(actual[0]).to.equal(Object);
});
@decorator()
class FooArrow{ constructor(public arg: Arrow){} }
it(_`${FooArrow} { constructor(public ${Arrow}) }`, () => {
const actual = DI.getDesignParamTypes(FooArrow);
assertIsMutableArray(actual, 1);
expect(actual[0]).to.equal(Object);
});
@decorator()
class FooArrowInterface{ constructor(public arg: ArrowInterface){} }
it(_`${FooArrowInterface} { constructor(public ${ArrowInterface}) }`, () => {
const actual = DI.getDesignParamTypes(FooArrowInterface);
assertIsMutableArray(actual, 1);
expect(actual[0]).to.equal(Object);
});
});
});
describe(`returns the correct types for valid declarations`, () => {
class Bar{}
const AnonClass = class{};
const VarFunc = function(){};
function Func(){}
const Arrow = () => {};
describe(`decorator invocation`, () => {
@decorator()
class FooBar{ constructor(public arg: Bar){} }
it(_`${FooBar} { constructor(public ${Bar}) }`, () => {
const actual = DI.getDesignParamTypes(FooBar);
assertIsMutableArray(actual, 1);
expect(actual[0]).to.equal(Bar);
});
@decorator()
class FooAnonClass{ constructor(public arg: AnonClass){} }
it(_`${FooAnonClass} { constructor(public ${AnonClass}) }`, () => {
const actual = DI.getDesignParamTypes(FooAnonClass);
assertIsMutableArray(actual, 1);
expect(actual[0]).to.equal(AnonClass);
});
@decorator()
class FooVarFunc{ constructor(public arg: VarFunc){} }
it(_`${FooVarFunc} { constructor(public ${VarFunc}) }`, () => {
const actual = DI.getDesignParamTypes(FooVarFunc);
assertIsMutableArray(actual, 1);
expect(actual[0]).to.equal(VarFunc);
});
@decorator()
class FooFunc{ constructor(public arg: Func){} }
it(_`${FooFunc} { constructor(public ${Func}) }`, () => {
const actual = DI.getDesignParamTypes(FooFunc);
assertIsMutableArray(actual, 1);
expect(actual[0]).to.equal(Func);
});
@decorator()
class FooArrow{ constructor(public arg: Arrow){} }
it(_`${FooArrow} { constructor(public ${Arrow}) }`, () => {
const actual = DI.getDesignParamTypes(FooArrow);
assertIsMutableArray(actual, 1);
expect(actual[0]).to.equal(Arrow);
});
});
});
});
describe(`getDependencies()`, () => {
let getDesignParamTypes: ReturnType<typeof spy>;
beforeEach(() => {
getDesignParamTypes = spy(DI, 'getDesignParamTypes');
});
afterEach(() => {
getDesignParamTypes.restore();
});
it(`uses getDesignParamTypes() if the static inject property does not exist`, () => {
class Bar {}
@decorator()
class Foo{ constructor(bar: Bar){} }
const actual = DI.getDependencies(Foo);
expect(getDesignParamTypes).to.have.been.calledWith(Foo);
expect(actual).to.deep.equal([Bar]);
});
it(`uses getDesignParamTypes() if the static inject property is undefined`, () => {
class Bar {}
@decorator()
class Foo{ static inject = undefined; constructor(bar: Bar){} }
const actual = DI.getDependencies(Foo);
expect(getDesignParamTypes).to.have.been.calledWith(Foo);
expect(actual).to.deep.equal([Bar]);
});
it(`throws when inject is not an array`, () => {
class Bar {}
class Foo{ static inject = Bar; }
expect(() => DI.getDependencies(Foo)).to.throw();
expect(getDesignParamTypes).not.to.have.been.called;
});
for (const deps of [
[class Bar{}],
[class Bar{}, class Bar{}],
[undefined],
[null],
[42]
]) {
it(_`returns a copy of the inject array ${deps}`, () => {
class Foo{ static inject = deps.slice(); }
const actual = DI.getDependencies(Foo);
expect(getDesignParamTypes).not.to.have.been.called;
expect(actual).to.deep.equal(deps);
expect(actual).not.to.equal(Foo.inject);
});
}
for (const deps of [
[class Bar{}],
[class Bar{}, class Bar{}],
[undefined],
[null],
[42]
]) {
it(_`traverses the 2-layer prototype chain for inject array ${deps}`, () => {
class Foo{ static inject = deps.slice(); }
class Bar extends Foo{ static inject = deps.slice(); }
const actual = DI.getDependencies(Bar);
expect(getDesignParamTypes).not.to.have.been.called;
expect(actual).to.deep.equal([...deps, ...deps]);
expect(actual).not.to.equal(Foo.inject);
expect(actual).not.to.equal(Bar.inject);
});
it(_`traverses the 3-layer prototype chain for inject array ${deps}`, () => {
class Foo{ static inject = deps.slice(); }
class Bar extends Foo{ static inject = deps.slice(); }
class Baz extends Bar{ static inject = deps.slice(); }
const actual = DI.getDependencies(Baz);
expect(getDesignParamTypes).not.to.have.been.called;
expect(actual).to.deep.equal([...deps, ...deps, ...deps]);
expect(actual).not.to.equal(Foo.inject);
expect(actual).not.to.equal(Bar.inject);
expect(actual).not.to.equal(Baz.inject);
});
it(_`traverses the 1-layer + 2-layer prototype chain (with gap) for inject array ${deps}`, () => {
class Foo{ static inject = deps.slice(); }
class Bar extends Foo{ }
class Baz extends Bar{ static inject = deps.slice(); }
class Qux extends Baz{ static inject = deps.slice(); }
const actual = DI.getDependencies(Qux);
expect(getDesignParamTypes).not.to.have.been.called;
expect(actual).to.deep.equal([...deps, ...deps, ...deps]);
expect(actual).not.to.equal(Foo.inject);
expect(actual).not.to.equal(Baz.inject);
expect(actual).not.to.equal(Qux.inject);
});
}
});
describe(`createInterface()`, () => {
it(`returns a function that has withDefault and noDefault functions`, () => {
const sut = DI.createInterface();
expect(typeof sut).to.equal('function');
expect(typeof sut.withDefault).to.equal('function');
expect(typeof sut.noDefault).to.equal('function');
});
it(`noDefault returns self`, () => {
const sut = DI.createInterface();
expect(sut.noDefault()).to.equal(sut);
});
it(`withDefault returns self with modified withDefault that throws`, () => {
const sut = DI.createInterface();
const sut2 = sut.withDefault(<any>null);
expect(sut).to.equal(sut2);
expect(() => sut.withDefault(<any>null)).to.throw;
});
describe(`withDefault returns self with register function that registers the appropriate resolver`, () => {
let sut: IDefaultableInterfaceSymbol<any>;
let container: IContainer;
let registerResolver: ReturnType<typeof spy>;
beforeEach(() => {
sut = DI.createInterface();
container = new Container();
registerResolver = spy(container, 'registerResolver');
});
afterEach(() => {
registerResolver.restore();
});
function matchResolver(key: any, strategy: any, state: any): sinon.SinonMatcher {
return sinon.match(val => val.key === key && val.strategy === strategy && val.state === state);
}
it(`instance without key`, () => {
const value = {};
sut.withDefault(builder => builder.instance(value));
(<any>sut).register(container);
expect(registerResolver).to.have.been.calledWith(sut, matchResolver(sut, ResolverStrategy.instance, value));
});
it(`instance with key`, () => {
const value = {};
sut.withDefault(builder => builder.instance(value));
(<any>sut).register(container, 'key');
expect(registerResolver).to.have.been.calledWith('key', matchResolver('key', ResolverStrategy.instance, value));
});
it(`singleton without key`, () => {
class Foo {}
sut.withDefault(builder => builder.singleton(Foo));
(<any>sut).register(container);
expect(registerResolver).to.have.been.calledWith(sut, matchResolver(sut, ResolverStrategy.singleton, Foo));
});
it(`singleton with key`, () => {
class Foo {}
sut.withDefault(builder => builder.singleton(Foo));
(<any>sut).register(container, 'key');
expect(registerResolver).to.have.been.calledWith('key', matchResolver('key', ResolverStrategy.singleton, Foo));
});
it(`transient without key`, () => {
class Foo {}
sut.withDefault(builder => builder.transient(Foo));
(<any>sut).register(container);
expect(registerResolver).to.have.been.calledWith(sut, matchResolver(sut, ResolverStrategy.transient, Foo));
});
it(`transient with key`, () => {
class Foo {}
sut.withDefault(builder => builder.transient(Foo));
(<any>sut).register(container, 'key');
expect(registerResolver).to.have.been.calledWith('key', matchResolver('key', ResolverStrategy.transient, Foo));
});
it(`callback without key`, () => {
const callback = () => {};
sut.withDefault(builder => builder.callback(callback));
(<any>sut).register(container);
expect(registerResolver).to.have.been.calledWith(sut, matchResolver(sut, ResolverStrategy.callback, callback));
});
it(`callback with key`, () => {
const callback = () => {};
sut.withDefault(builder => builder.callback(callback));
(<any>sut).register(container, 'key');
expect(registerResolver).to.have.been.calledWith('key', matchResolver('key', ResolverStrategy.callback, callback));
});
it(`aliasTo without key`, () => {
sut.withDefault(builder => builder.aliasTo('key2'));
(<any>sut).register(container);
expect(registerResolver).to.have.been.calledWith(sut, matchResolver(sut, ResolverStrategy.alias, 'key2'));
});
it(`aliasTo with key`, () => {
sut.withDefault(builder => builder.aliasTo('key2'));
(<any>sut).register(container, 'key1');
expect(registerResolver).to.have.been.calledWith('key1', matchResolver('key1', ResolverStrategy.alias, 'key2'));
});
});
});
});
describe(`The inject decorator`, () => {
class Dep1{}
class Dep2{}
class Dep3{}
it(`can decorate classes with explicit dependencies`, () => {
@inject(Dep1, Dep2, Dep3)
class Foo {}
expect(Foo['inject']).to.deep.equal([Dep1, Dep2, Dep3]);
});
it(`can decorate classes with implicit dependencies`, () => {
@inject()
class Foo { constructor(dep1: Dep1, dep2: Dep2, dep3: Dep3){} }
expect(Foo['inject']).to.deep.equal([Dep1, Dep2, Dep3]);
});
it(`can decorate constructor parameters explicitly`, () => {
class Foo { constructor(@inject(Dep1)dep1, @inject(Dep2)dep2, @inject(Dep3)dep3){} }
expect(Foo['inject']).to.deep.equal([Dep1, Dep2, Dep3]);
});
it(`can decorate constructor parameters implicitly`, () => {
class | { constructor(@inject() dep1: Dep1, @inject() dep2: Dep2, @inject() dep3: Dep3){} }
expect(Foo['inject']).to.deep.equal([Dep1, Dep2, Dep3]);
});
it(`can decorate properties explicitly`, () => {
class Foo { @inject(Dep1)dep1; @inject(Dep2)dep2; @inject(Dep3)dep3; }
expect(Foo['inject'].dep1).to.equal(Dep1);
expect(Foo['inject'].dep2).to.equal(Dep2);
expect(Foo['inject'].dep3).to.equal(Dep3);
});
it(`cannot decorate properties implicitly`, () => {
class Foo { @inject()dep1: Dep1; @inject()dep2: Dep2; @inject()dep3: Dep3; }
expect(Foo['inject'].dep1).to.be.undefined;
expect(Foo['inject'].dep2).to.be.undefined;
expect(Foo['inject'].dep3).to.be.undefined;
});
});
describe(`The transient decorator`, () => {
it(`works as a plain decorator`, () => {
@transient
class Foo {}
expect(Foo['register']).to.be.a('function');
const container = DI.createContainer();
const foo1 = container.get(Foo);
const foo2 = container.get(Foo);
expect(foo1).not.to.equal(foo2);
});
it(`works as an invocation`, () => {
@transient()
class Foo {}
expect(Foo['register']).to.be.a('function');
const container = DI.createContainer();
const foo1 = container.get(Foo);
const foo2 = container.get(Foo);
expect(foo1).not.to.equal(foo2);
});
});
describe(`The singleton decorator`, () => {
it(`works as a plain decorator`, () => {
@singleton
class Foo {}
expect(Foo['register']).to.be.a('function');
const container = DI.createContainer();
const foo1 = container.get(Foo);
const foo2 = container.get(Foo);
expect(foo1).to.equal(foo2);
});
it(`works as an invocation`, () => {
@singleton()
class Foo {}
expect(Foo['register']).to.be.a('function');
const container = DI.createContainer();
const foo1 = container.get(Foo);
const foo2 = container.get(Foo);
expect(foo1).to.equal(foo2);
});
});
describe(`The Resolver class`, () => {
let container: IContainer;
let registerResolver: ReturnType<typeof spy>;
beforeEach(() => {
container = new Container();
registerResolver = spy(container, 'registerResolver');
});
afterEach(() => {
registerResolver.restore();
});
describe(`register()`, () => {
it(`registers the resolver to the container with the provided key`, () => {
const sut = new Resolver('foo', 0, null);
sut.register(container, 'bar');
expect(registerResolver).to.have.been.calledWith('bar', sut);
})
it(`registers the resolver to the container with its own`, () => {
const sut = new Resolver('foo', 0, null);
sut.register(container);
expect(registerResolver).to.have.been.calledWith('foo', sut);
})
});
describe(`resolve()`, () => {
it(`instance - returns state`, () => {
const state = {};
const sut = new Resolver('foo', ResolverStrategy.instance, state);
const actual = sut.resolve(container, container);
expect(actual).to.equal(state);
});
it(`singleton - returns an instance of the type and sets strategy to instance`, () => {
class Foo {}
const sut = new Resolver('foo', ResolverStrategy.singleton, Foo);
const actual = sut.resolve(container, container);
expect(actual).to.be.instanceof(Foo);
const actual2 = sut.resolve(container, container);
expect(actual2).to.equal(actual);
});
it(`transient - always returns a new instance of the type`, () => {
class Foo {}
const sut = new Resolver('foo', ResolverStrategy.transient, Foo);
const actual1 = sut.resolve(container, container);
expect(actual1).to.be.instanceof(Foo);
const actual2 = sut.resolve(container, container);
expect(actual2).to.be.instanceof(Foo);
expect(actual2).not.to.equal(actual1);
});
it(`array - calls resolve() on the first item in the state array`, () => {
const resolver = { resolve: spy() };
const sut = new Resolver('foo', ResolverStrategy.array, [resolver]);
sut.resolve(container, container);
expect(resolver.resolve).to.have.been.calledWith(container, container);
});
it(`throws for unknown strategy`, () => {
const sut = new Resolver('foo', -1, null);
expect(() => sut.resolve(container, container)).to.throw(/6/);
});
});
describe(`getFactory()`, () => {
it(`returns a new singleton Factory if it does not exist`, () => {
class Foo{}
const sut = new Resolver(Foo, ResolverStrategy.singleton, Foo);
const actual = sut.getFactory(container);
expect(actual).to.be.instanceof(Factory);
expect(actual.Type).to.equal(Foo);;
});
it(`returns a new transient Factory if it does not exist`, () => {
class Foo{}
const sut = new Resolver(Foo, ResolverStrategy.transient, Foo);
const actual = sut.getFactory(container);
expect(actual).to.be.instanceof(Factory);
expect(actual.Type).to.equal(Foo);
});
it(`returns a null for instance strategy`, () => {
class Foo{}
const sut = new Resolver(Foo, ResolverStrategy.instance, Foo);
const actual = sut.getFactory(container);
expect(actual).to.be.null;
});
it(`returns a null for array strategy`, () => {
class Foo{}
const sut = new Resolver(Foo, ResolverStrategy.array, Foo);
const actual = sut.getFactory(container);
expect(actual).to.be.null;
});
it(`returns a null for alias strategy`, () => {
class Foo{}
const sut = new Resolver(Foo, ResolverStrategy.alias, Foo);
const actual = sut.getFactory(container);
expect(actual).to.be.null;
});
it(`returns a null for callback strategy`, () => {
class Foo{}
const sut = new Resolver(Foo, ResolverStrategy.callback, Foo);
const actual = sut.getFactory(container);
expect(actual).to.be.null;
});
});
});
describe(`The Factory class`, () => {
describe(`create()`, () => {
for (const count of [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) {
it(`returns a new Factory with ${count} deps`, () => {
class Bar{}
class Foo{static inject=Array(count).map(c => Bar)}
const actual = Factory.create(Foo);
expect(actual).to.be.instanceof(Factory);
expect(actual.Type).to.equal(Foo);
if (count < 6) {
expect(actual['invoker']).to.equal(classInvokers[count]);
} else {
expect(actual['invoker']).to.equal(fallbackInvoker);
}
expect(actual['dependencies']).not.to.equal(Foo.inject);
expect(actual['dependencies']).to.deep.equal(Foo.inject);
});
}
});
describe(`construct()`, () => {
for (const staticCount of [0, 1, 2, 3, 4, 5, 6, 7]) {
for (const dynamicCount of [0, 1, 2]) {
const container = new Container();
it(`instantiates a type with ${staticCount} static deps and ${dynamicCount} dynamic deps`, () => {
class Bar{}
class Foo{args:any[];constructor(...args:any[]){this.args=args}static inject=Array(staticCount).fill(Bar)}
const sut = Factory.create(Foo);
const dynamicDeps = dynamicCount ? Array(dynamicCount).fill({}) : undefined;
const actual = sut.construct(container, dynamicDeps);
for (let i = 0, ii = Foo.inject.length; i < ii; ++i) {
expect(actual.args[i]).to.be.instanceof(Foo.inject[i]);
}
for (let i = 0, ii = dynamicDeps ? dynamicDeps.length : 0; i < ii; ++i) {
expect(actual.args[Foo.inject.length+i]).to.equal(dynamicDeps[i]);
}
});
}
}
});
describe(`registerTransformer()`, () => {
it(`registers the transformer`, () => {
const container = new Container();
class Foo{bar;baz}
const sut = Factory.create(Foo);
sut.registerTransformer(foo => Object.assign(foo, { bar: 1 }));
sut.registerTransformer(foo => Object.assign(foo, { baz: 2 }));
const foo = sut.construct(container);
expect(foo.bar).to.equal(1);
expect(foo.baz).to.equal(2);
expect(foo).to.be.instanceof(Foo);
});
});
});
describe(`The Container class`, () => {
let sut: IContainer;
beforeEach(() => {
sut = new Container();
});
describe(`register()`, () => {
let register: ReturnType<typeof spy>;
beforeEach(() => {
register = spy();
});
it(_`calls register() on {register}`, () => {
sut.register({register});
expect(register).to.have.been.calledWith(sut);
})
it(_`calls register() on {register},{register}`, () => {
sut.register({register},{register});
expect(register).to.have.been.calledWith(sut);
expect(register.getCalls().length).to.equal(2);
})
it(_`calls register() on [{register},{register}]`, () => {
sut.register(<any>[{register},{register}]);
expect(register).to.have.been.calledWith(sut);
expect(register.getCalls().length).to.equal(2);
})
it(_`calls register() on {foo:{register}}`, () => {
sut.register({foo:{register}});
expect(register).to.have.been.calledWith(sut);
})
it(_`calls register() on {foo:{register}},{foo:{register}}`, () => {
sut.register({foo:{register}},{foo:{register}});
expect(register).to.have.been.calledWith(sut);
expect(register.getCalls().length).to.equal(2);
})
it(_`calls register() on [{foo:{register}},{foo:{register}}]`, () => {
sut.register(<any>[{foo:{register}},{foo:{register}}]);
expect(register).to.have.been.calledWith(sut);
expect(register.getCalls().length).to.equal(2);
})
it(_`calls register() on {register},{foo:{register}}`, () => {
sut.register({register},{foo:{register}});
expect(register).to.have.been.calledWith(sut);
expect(register.getCalls().length).to.equal(2);
})
it(_`calls register() on [{register},{foo:{register}}]`, () => {
sut.register(<any>[{register},{foo:{register}}]);
expect(register).to.have.been.calledWith(sut);
expect(register.getCalls().length).to.equal(2);
})
it(_`calls register() on [{register},{}]`, () => {
sut.register(<any>[{register},{}]);
expect(register).to.have.been.calledWith(sut);
})
it(_`calls register() on [{},{register}]`, () => {
sut.register(<any>[{},{register}]);
expect(register).to.have.been.calledWith(sut);
})
it(_`calls register() on [{foo:{register}},{foo:{}}]`, () => {
sut.register(<any>[{foo:{register}},{foo:{}}]);
expect(register).to.have.been.calledWith(sut);
})
it(_`calls register() on [{foo:{}},{foo:{register}}]`, () => {
sut.register(<any>[{foo:{}},{foo:{register}}]);
expect(register).to.have.been.calledWith(sut);
})
});
describe(`registerResolver()`, () => {
for (const key of [null, undefined, Object]) {
it(_`throws on invalid key ${key}`, () => {
expect(() => sut.registerResolver(key, <any>null)).to.throw(/5/);
});
}
it(`registers the resolver if it does not exist yet`, () => {
const key = {};
const resolver = new Resolver(key, ResolverStrategy.instance, {});
sut.registerResolver(key, resolver);
const actual = sut.getResolver(key);
expect(actual).to.equal(resolver);
});
it(`changes to array resolver if the key already exists`, () => {
const key = {};
const resolver1 = new Resolver(key, ResolverStrategy.instance, {});
const resolver2 = new Resolver(key, ResolverStrategy.instance, {});
sut.registerResolver(key, resolver1);
const actual1 = sut.getResolver(key);
expect(actual1).to.equal(resolver1);
sut.registerResolver(key, resolver2);
const actual2 = sut.getResolver(key);
expect(actual2).not.to.equal(actual1);
expect(actual2).not.to.equal(resolver1);
expect(actual2).not.to.equal(resolver2);
expect(actual2['strategy']).to.equal(ResolverStrategy.array);
expect(actual2['state'][0]).to.equal(resolver1);
expect(actual2['state'][1]).to.equal(resolver2);
});
it(`appends to the array resolver if the key already exists more than once`, () => {
const key = {};
const resolver1 = new Resolver(key, ResolverStrategy.instance, {});
const resolver2 = new Resolver(key, ResolverStrategy.instance, {});
const resolver3 = new Resolver(key, ResolverStrategy.instance, {});
sut.registerResolver(key, resolver1);
sut.registerResolver(key, resolver2);
sut.registerResolver(key, resolver3);
const actual1 = sut.getResolver(key);
expect(actual1['strategy']).to.equal(ResolverStrategy.array);
expect(actual1['state'][0]).to.equal(resolver1);
expect(actual1['state'][1]).to.equal(resolver2);
expect(actual1['state'][2]).to.equal(resolver3);
});
});
describe(`registerTransformer()`, () => {
for (const key of [null, undefined, Object]) {
it(_`throws on invalid key ${key}`, () => {
expect(() => sut.registerTransformer(key, <any>null)).to.throw(/5/);
});
}
it(`registers the transformer if it does not exist yet`, () => {
});
it(`reuses the existing transformer if it exists`, () => {
});
});
describe(`getResolver()`, () => {
for (const key of [null, undefined, Object]) {
it(_`throws on invalid key ${key}`, () => {
expect(() => sut.getResolver(key, <any>null)).to.throw(/5/);
});
}
});
describe(`has()`, () => {
for (const key of [null, undefined, Object]) {
it(_`returns false for non-existing key ${key}`, () => {
expect(sut.has(<any>key, false)).to.be.false;
});
}
it(`returns true for existing key`, () => {
const key = {};
sut.registerResolver(key, new Resolver(key, ResolverStrategy.instance, {}));
expect(sut.has(<any>key, false)).to.be.true;
});
});
describe(`get()`, () => {
for (const key of [null, undefined, Object]) {
it(_`throws on invalid key ${key}`, () => {
expect(() => sut.get(key)).to.throw(/5/);
});
}
});
describe(`getAll()`, () => {
for (const key of [null, undefined, Object]) {
it(_`throws on invalid key ${key}`, () => {
expect(() => sut.getAll(key)).to.throw(/5/);
});
}
});
describe(`getFactory()`, () => {
for (const count of [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) {
sut = new Container(); // ensure the state is reset (beforeEach doesn't know about loops)
it(`returns a new Factory with ${count} deps if it does not exist`, () => {
class Bar{}
class Foo{static inject=Array(count).map(c => Bar)}
const actual = sut.getFactory(Foo);
expect(actual).to.be.instanceof(Factory);
expect(actual.Type).to.equal(Foo);
if (count < 6) {
expect(actual['invoker']).to.equal(classInvokers[count]);
} else {
expect(actual['invoker']).to.equal(fallbackInvoker);
}
expect(actual['dependencies']).not.to.equal(Foo.inject);
expect(actual['dependencies']).to.deep.equal(Foo.inject);
});
}
it(`reuses the existing factory if it already exists`, () => {
const create = spy(Factory, 'create');
class Foo{}
const actual = sut.getFactory(Foo);
expect(actual).to.be.instanceof(Factory);
const actual2 = sut.getFactory(Foo);
expect(actual).to.equal(actual2);
expect(create).to.have.been.calledOnce;
create.restore();
});
});
describe(`createChild()`, () => {
it(`creates a child with same config and sut as parent`, () => {
const actual = sut.createChild();
expect(actual['configuration']).to.equal(sut['configuration']);
expect(actual['parent']).to.equal(sut);
expect(sut['parent']).to.be.null
});
});
describe(`jitRegister()`, () => {
});
});
describe(`The Registration object`, () => {
it(`instance() returns the correct resolver`, () => {
const value = {};
const actual = Registration.instance('key', value);
expect(actual['key']).to.equal('key');
expect(actual['strategy']).to.equal(ResolverStrategy.instance);
expect(actual['state']).to.equal(value);
});
it(`singleton() returns the correct resolver`, () => {
class Foo {}
const actual = Registration.singleton('key', Foo);
expect(actual['key']).to.equal('key');
expect(actual['strategy']).to.equal(ResolverStrategy.singleton);
expect(actual['state']).to.equal(Foo);
});
it(`transient() returns the correct resolver`, () => {
class Foo {}
const actual = Registration.transient('key', Foo);
expect(actual['key']).to.equal('key');
expect(actual['strategy']).to.equal(ResolverStrategy.transient);
expect(actual['state']).to.equal(Foo);
});
it(`callback() returns the correct resolver`, () => {
const callback = () => {};
const actual = Registration.callback('key', callback);
expect(actual['key']).to.equal('key');
expect(actual['strategy']).to.equal(ResolverStrategy.callback);
expect(actual['state']).to.equal(callback);
});
it(`alias() returns the correct resolver`, () => {
const actual = Registration.alias('key', 'key2');
expect(actual['key']).to.equal('key2');
expect(actual['strategy']).to.equal(ResolverStrategy.alias);
expect(actual['state']).to.equal('key');
});
});
describe(`The classInvokers object`, () => {
const container = <IContainer><any>{ get(t){ return new t(); } }
class Foo { args: any[]; constructor(...args: any[]){ this.args = args; } }
class Dep1{}
class Dep2{}
class Dep3{}
class Dep4{}
class Dep5{}
class Dep6{}
it(`invoke() handles 0 deps`, () => {
const actual = classInvokers[0].invoke(container, Foo, []);
expect(actual.args.length).to.equal(0);
});
it(`invoke() handles 1 dep`, () => {
const actual = classInvokers[1].invoke(container, Foo, [Dep1]);
expect(actual.args.length).to.equal(1);
expect(actual.args[0]).to.be.instanceof(Dep1);
});
it(`invoke() handles 2 deps`, () => {
const actual = classInvokers[2].invoke(container, Foo, [Dep1, Dep2]);
expect(actual.args.length).to.equal(2);
expect(actual.args[0]).to.be.instanceof(Dep1);
expect(actual.args[1]).to.be.instanceof(Dep2);
});
it(`invoke() handles 3 deps`, () => {
const actual = classInvokers[3].invoke(container, Foo, [Dep1, Dep2, Dep3]);
expect(actual.args.length).to.equal(3);
expect(actual.args[0]).to.be.instanceof(Dep1);
expect(actual.args[1]).to.be.instanceof(Dep2);
expect(actual.args[2]).to.be.instanceof(Dep3);
});
it(`invoke() handles 4 deps`, () => {
const actual = classInvokers[4].invoke(container, Foo, [Dep1, Dep2, Dep3, Dep4]);
expect(actual.args.length).to.equal(4);
expect(actual.args[0]).to.be.instanceof(Dep1);
expect(actual.args[1]).to.be.instanceof(Dep2);
expect(actual.args[2]).to.be.instanceof(Dep3);
expect(actual.args[3]).to.be.instanceof(Dep4);
});
it(`invoke() handles 5 deps`, () => {
const actual = classInvokers[5].invoke(container, Foo, [Dep1, Dep2, Dep3, Dep4, Dep5]);
expect(actual.args.length).to.equal(5);
expect(actual.args[0]).to.be.instanceof(Dep1);
expect(actual.args[1]).to.be.instanceof(Dep2);
expect(actual.args[2]).to.be.instanceof(Dep3);
expect(actual.args[3]).to.be.instanceof(Dep4);
expect(actual.args[4]).to.be.instanceof(Dep5);
});
it(`invoke() does not handle 6 deps`, () => {
expect(() => classInvokers[6].invoke(container, Foo, [Dep1, Dep2, Dep3, Dep4, Dep5, Dep6])).to.throw(/undefined/);
});
});
describe(`The invokeWithDynamicDependencies function`, () => {
const container = <IContainer><any>{ get(t){ return 'static'+t; } }
class Foo { args: any[]; constructor(...args: any[]){ this.args = args; } }
const deps = [class Dep1{}, class Dep2{}, class Dep3{}];
it(_`throws when staticDeps is null`, () => {
expect(() => invokeWithDynamicDependencies(container, Foo, null, [])).to.throw();
});
it(_`throws when any of the staticDeps is null`, () => {
expect(() => invokeWithDynamicDependencies(container, Foo, [null], [])).to.throw(/7/);
});
it(_`throws when any of the staticDeps is undefined`, () => {
expect(() => invokeWithDynamicDependencies(container, Foo, [undefined], [])).to.throw(/7/);
});
it(_`throws when staticDeps is undefined`, () => {
expect(() => invokeWithDynamicDependencies(container, Foo, undefined, [])).to.throw();
});
it(_`handles staticDeps is ${deps}`, () => {
const actual = <Foo>invokeWithDynamicDependencies(container, Foo, deps, []);
expect(actual.args).to.deep.equal(deps.map(d => 'static'+d));
});
it(`handles dynamicDeps is null`, () => {
const actual = <Foo>invokeWithDynamicDependencies(container, Foo, [], null);
expect(actual.args.length).to.equal(1);
expect(actual.args[0]).to.be.null;
});
it(`handles dynamicDeps is undefined`, () => {
const actual = <Foo>invokeWithDynamicDependencies(container, Foo, [], undefined);
expect(actual.args.length).to.equal(0);
});
it(_`handles dynamicDeps is ${deps}`, () => {
const actual = <Foo>invokeWithDynamicDependencies(container, Foo, [], deps);
expect(actual.args).to.deep.equal(deps);
});
it(_`handles staticDeps is ${deps} and dynamicDeps is ${deps}`, () => {
const actual = <Foo>invokeWithDynamicDependencies(container, Foo, deps, deps);
expect(actual.args[0]).to.equal('static'+deps[0]);
expect(actual.args[1]).to.equal('static'+deps[1]);
expect(actual.args[2]).to.equal('static'+deps[2]);
expect(actual.args[3]).to.equal(deps[0]);
expect(actual.args[4]).to.equal(deps[1]);
expect(actual.args[5]).to.equal(deps[2]);
});
});
| Foo |
gatsby-node.js | const path = require('path');
const slash = require('slash');
exports.createPages = ({ graphql, actions }) => {
const { createPage } = actions;
return new Promise((resolve, reject) => {
resolve(
graphql(`
{
allProjectsJson {
edges {
node {
name
description
headline
stack | weight
route
team {
name
twitter
}
content {
title
description
screenshots {
screen
}
}
}
}
}
}
`).then(result => {
if (result.errors) {
reject(result.errors);
}
// Create pages for each project detail
const projectDetailsTemplate = path.resolve(`src/templates/ProjectLandingPage/index.js`);
result.data.allProjectsJson.edges.forEach(({ node }) => {
createPage({
path: `/${node.route.toLowerCase()}`,
component: slash(projectDetailsTemplate),
context: {
project: { ...node },
},
});
});
return;
})
);
});
}; | tags
repo
image
featured |
VisCostCallback.py | from bokeh.plotting import output_notebook, figure, ColumnDataSource, show
from bokeh.io import push_notebook
from timeit import default_timer
import math
from collections import deque
class CostVisCallback(object):
"""
Callback providing a live updating console based progress bar.
"""
def __init__(self, epoch_freq=1, y_range=(0, 4.5), fig=None, handle=None,
update_thresh_s=0.65, w=400, h=300, nepochs=1.0, total_batches=10.0,
train_source=None, val_source=None, history=10):
self.update_thresh_s = update_thresh_s
self.w = w
self.h = h
self.nepochs = nepochs
self.total = total_batches
self.last_update = 0
self.epoch = -1
self.history = history
self.cost_history = deque(maxlen=history)
if handle is None:
output_notebook()
self.handle = None
else:
self.handle = handle
if fig is None:
self.fig = figure(name="cost", y_axis_label="Cost", x_range=(0, self.nepochs), y_range=y_range,
x_axis_label="Epoch", plot_width=self.w, plot_height=self.h)
else:
self.fig = fig
if train_source is None:
self.train_source = ColumnDataSource(data=dict(x=[], y=[]))
else:
self.train_source = train_source
self.train_source.data = dict(x=[], y=[])
self.train_cost = self.fig.line('x', 'y', source=self.train_source)
if val_source is None:
self.val_source = ColumnDataSource(data=dict(x=[], y=[]))
else:
self.val_source = val_source
self.val_source.data = dict(x=[], y=[])
self.val_cost = self.fig.line('x', 'y', source=self.val_source, color='red')
def get_average_cost(self, cost):
self.cost_history.append(cost)
return sum(list(self.cost_history))/ float(len(self.cost_history))
def train_callback(self, param):
self._process_batch(param, 'train')
def eval_callback(self, param):
self._process_batch(param, 'eval')
def _process_batch(self, param, name):
if self.handle is None:
self.handle = show(self.fig, notebook_handle=True)
now = default_timer()
# print "{}_{}".format(param.nbatch, param.epoch)
if param.nbatch == 0:
self.epoch = self.epoch + 1
time = float(param.nbatch) / self.total + param.epoch
if param.eval_metric is not None:
name_value = param.eval_metric.get_name_value()
param.eval_metric.reset()
cost = name_value[0][1]
if name == 'train':
cost = self.get_average_cost(cost)
if math.isnan(cost) or cost > 4000: | self.train_source.data['y'].append(cost)
elif name == 'eval':
self.val_source.data['x'].append(param.epoch+1)
self.val_source.data['y'].append(cost)
if (now - self.last_update > self.update_thresh_s):
self.last_update = now
if self.handle is not None:
push_notebook(handle=self.handle)
else:
push_notebook()
def get_callbacks(self):
return {'train_cost': self.train_callback,
'eval_cost': self.eval_callback} | cost = 4000
if name == 'train':
self.train_source.data['x'].append(time) |
__init__.py | try:
from .pfdo_med2image import pfdo_med2image
except: | from pfdo_med2image import pfdo_med2image |
|
gameClassifier.js | 'use strict';
describe('Service: gameClassifier', function () {
beforeEach(module('twistedHangmanApp'));
var playerMD5 = 'anmd5!';
var mockPlayerService = {
currentPlayer: function () {
return {md5: playerMD5};
}
};
var twGameDetails = {
playerActionRequired: jasmine.createSpy('action')
};
beforeEach(module(function ($provide) {
$provide.factory('jtbPlayerService', [function () {
return mockPlayerService;
}]);
$provide.factory('twGameDetails', [function () {
return twGameDetails;
}]);
}));
var service;
beforeEach(inject(function ($injector) {
twGameDetails.playerActionRequired.calls.reset();
service = $injector.get('jtbGameClassifier');
}));
var expectedYourTurnClassification = 'Your move.';
var expectedTheirTurnClassification = 'Their move.';
var expectedOlderGameClassification = 'Older games.';
var expectedIconMap = {};
expectedIconMap[expectedYourTurnClassification] = 'play';
expectedIconMap[expectedTheirTurnClassification] = 'pause';
expectedIconMap[expectedOlderGameClassification] = 'stop';
it('get classifications', function () {
expect(service.getClassifications()).toEqual([expectedYourTurnClassification, expectedTheirTurnClassification, expectedOlderGameClassification]);
});
it('get icon map', function () {
expect(service.getIcons()).toEqual(expectedIconMap);
});
| it('classification for no player action needed, non-roundover phase', function () {
var game = {gamePhase: 'TBD'};
twGameDetails.playerActionRequired.and.returnValue(false);
expect(service.getClassification(game)).toEqual(expectedTheirTurnClassification);
expect(twGameDetails.playerActionRequired).toHaveBeenCalledWith(game, playerMD5);
});
it('classification for player action needed, non-roundover phase', function () {
var game = {gamePhase: 'TBD'};
twGameDetails.playerActionRequired.and.returnValue(true);
expect(service.getClassification(game)).toEqual(expectedYourTurnClassification);
expect(twGameDetails.playerActionRequired).toHaveBeenCalledWith(game, playerMD5);
});
it('classification for phase RoundOver', function () {
var game = {gamePhase: 'RoundOver'};
twGameDetails.playerActionRequired.and.returnValue(false);
expect(service.getClassification(game)).toEqual(expectedYourTurnClassification);
expect(twGameDetails.playerActionRequired).toHaveBeenCalledWith(game, playerMD5);
});
angular.forEach(['Declined', 'Quit', 'NextRoundStarted'], function (phase) {
it('classification for phase ' + phase, function () {
var game = {gamePhase: phase};
twGameDetails.playerActionRequired.and.returnValue(false);
expect(service.getClassification(game)).toEqual(expectedOlderGameClassification);
});
});
}); | |
cis-bed.d.ts | export declare const cisBed: string[]; |
||
file.py | # Open3D: www.open3d.org
# The MIT License (MIT)
# See license file or visit www.open3d.org for details
# examples/Python/Utility/file.py
from os import listdir, makedirs
from os.path import exists, isfile, join, splitext
import shutil
import re
def sorted_alphanum(file_list_ordered):
convert = lambda text: int(text) if text.isdigit() else text
alphanum_key = lambda key: [convert(c) for c in re.split('([0-9]+)', key)]
return sorted(file_list_ordered, key=alphanum_key)
def get_file_list(path, extension=None):
if extension is None:
file_list = [path + f for f in listdir(path) if isfile(join(path, f))]
else:
file_list = [path + f for f in listdir(path)
if isfile(join(path, f)) and splitext(f)[1] == extension]
file_list = sorted_alphanum(file_list)
return file_list
def | (path_dataset, folder_names):
for folder_name in folder_names:
if exists(join(path_dataset, folder_name)):
path = join(path_dataset, folder_name)
return path
def get_rgbd_folders(path_dataset):
path_color = add_if_exists(path_dataset, ["image/", "rgb/", "color/"])
path_depth = join(path_dataset, "depth/")
return path_color, path_depth
def get_rgbd_file_lists(path_dataset):
path_color, path_depth = get_rgbd_folders(path_dataset)
color_files = get_file_list(path_color, ".jpg") + \
get_file_list(path_color, ".png")
depth_files = get_file_list(path_depth, ".png")
return color_files, depth_files
def make_clean_folder(path_folder):
if not exists(path_folder):
makedirs(path_folder)
else:
shutil.rmtree(path_folder)
makedirs(path_folder)
def check_folder_structure(path_dataset):
path_color, path_depth = get_rgbd_folders(path_dataset)
assert exists(path_depth), \
"Path %s is not exist!" % path_depth
assert exists(path_color), \
"Path %s is not exist!" % path_color
| add_if_exists |
basic.py | """
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
WARNING
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
This directory is for the internal of Theano.
You are strongly advised not to use it, except if you know
what you are doing!
If you want to use a scalar variable in a Theano graph,
you probably want to use theano.tensor.[c,z,f,d,b,w,i,l,]scalar!
"""
import math
import warnings
from copy import copy
from itertools import imap
from textwrap import dedent
import numpy
import theano
from theano.compat import PY3
from theano import gof
from theano.gof import (Op, utils, Variable, Constant, Type, Apply,
FunctionGraph)
from theano.gof.python25 import partial, all, any
from theano.configparser import config
from theano.gradient import DisconnectedType
from theano.gradient import grad_undefined
builtin_complex = complex
builtin_int = int
builtin_float = float
class ComplexError(Exception):
"""Raised if complex numbers are used in an unsupported operation."""
pass
class IntegerDivisionError(Exception):
"""Raised if someone tries to divide integers with '/' instead of '//'."""
pass
def upcast(dtype, *dtypes):
# Should we try to keep float32 instead of float64? This is used so that
# for instance mixing int64 with float32 yields float32 instead of float64.
# Note that we store this boolean as a one-element list so that it can be
# modified within `make_array`.
keep_float32 = [(config.cast_policy == 'numpy+floatX' and
config.floatX == 'float32')]
def make_array(dt):
if dt == 'float64':
# There is an explicit float64 dtype: we cannot keep float32.
keep_float32[0] = False
return numpy.zeros((), dtype=dt)
z = make_array(dtype)
for dt in dtypes:
z = z + make_array(dt=dt)
rval = str(z.dtype)
if rval == 'float64' and keep_float32[0]:
return 'float32'
else:
return rval
def as_scalar(x, name=None):
if isinstance(x, gof.Apply):
if len(x.outputs) != 1:
raise ValueError("It is ambiguous which output of a multi-output"
" Op has to be fetched.", x)
else:
x = x.outputs[0]
if isinstance(x, Variable):
if not isinstance(x.type, Scalar):
raise TypeError("Variable type field must be a Scalar.", x, x.type)
return x
try:
return constant(x)
except TypeError:
raise TypeError("Cannot convert %s to Scalar" % x, type(x))
def constant(x):
# pass through numpy scalars, since they are already typed on
# purpose typically.
if hasattr(x, 'dtype'):
assert x.ndim == 0
return ScalarConstant(Scalar(str(x.dtype)), x)
if isinstance(x, builtin_float):
for dtype in ['float32', 'float64']:
x_ = theano._asarray(x, dtype=dtype)
if numpy.all(x == x_):
break
x_ = None
assert x_ is not None
return ScalarConstant(Scalar(str(x_.dtype)), x)
if isinstance(x, builtin_int):
for dtype in ['int8', 'int16', 'int32', 'int64']:
x_ = theano._asarray(x, dtype=dtype)
if numpy.all(x == x_):
break
x_ = None
assert x_ is not None
return ScalarConstant(Scalar(str(x_.dtype)), x)
if isinstance(x, builtin_complex):
#TODO: We have added the complex type, so this should be tested
raise NotImplementedError()
raise TypeError(x)
#return ScalarConstant(float64, float(x))
class Scalar(Type):
"""
Internal class, should not be used by clients
Primarily used by tensor.elemwise and tensor.reduce
Analogous to TensorType, but for zero-dimensional objects
Maps directly to C primitives
TODO: refactor to be named ScalarType for consistency with TensorType
"""
ndim = 0
def __init__(self, dtype):
if dtype == 'floatX':
dtype = config.floatX
self.dtype = dtype
self.dtype_specs() # error checking
def filter(self, data, strict=False, allow_downcast=None):
py_type = self.dtype_specs()[0]
if strict and not isinstance(data, py_type):
raise TypeError("%s expected a %s, got %s of type %s" % (
self, py_type, data, type(data)), data)
try:
converted_data = py_type(data)
if (allow_downcast or
(allow_downcast is None and
type(data) is float and
self.dtype == theano.config.floatX) or
data == converted_data):
return py_type(data)
else:
raise TypeError('Value cannot accurately be converted to dtype'
' (%s) and allow_downcast is not True' % self.dtype)
except Exception, e:
raise TypeError("Could not convert %s (value=%s) to %s" % (
type(data), data, self.dtype), e)
def values_eq_approx(self, a, b, tolerance=1e-4):
return abs(a - b) <= ((abs(a) + abs(b)) * tolerance)
def c_headers(self):
l = ['<math.h>']
l.append('<numpy/arrayscalars.h>')
if config.lib.amdlibm:
l += ['<amdlibm.h>']
return l
def c_libraries(self):
l = []
if config.lib.amdlibm:
l += ['amdlibm']
return l
def c_compile_args(self):
if config.lib.amdlibm:
return ['-DREPLACE_WITH_AMDLIBM']
else:
return []
def __eq__(self, other):
return type(self) == type(other) and other.dtype == self.dtype
def __hash__(self):
return hash('theano.scalar.Scalar') ^ hash(self.dtype)
def dtype_specs(self):
try:
return { # dtype: (py_type, c_type, cls_name)
'float32': (numpy.float32, 'npy_float32', 'Float32'),
'float64': (numpy.float64, 'npy_float64', 'Float64'),
'complex128': (numpy.complex128, 'theano_complex128',
'Complex128'),
'complex64': (numpy.complex64, 'theano_complex64',
'Complex64'),
'uint8': (numpy.uint8, 'npy_uint8', 'UInt8'),
'int8': (numpy.int8, 'npy_int8', 'Int8'),
'uint16': (numpy.uint16, 'npy_uint16', 'UInt16'),
'int16': (numpy.int16, 'npy_int16', 'Int16'),
'uint32': (numpy.uint32, 'npy_uint32', 'UInt32'),
'int32': (numpy.int32, 'npy_int32', 'Int32'),
'uint64': (numpy.uint64, 'npy_uint64', 'UInt64'),
'int64': (numpy.int64, 'npy_int64', 'Int64')
}[self.dtype]
except KeyError:
raise TypeError("Unsupported dtype for %s: %s" % (
self.__class__.__name__, self.dtype))
def upcast(self, *others):
return upcast(*[x.dtype for x in [self] + list(others)])
def make_variable(self, name=None):
return ScalarVariable(self, name=name)
def __str__(self):
return str(self.dtype)
def __repr__(self):
return "Scalar(%s)" % self.dtype
def c_literal(self, data):
if 'complex' in self.dtype:
raise NotImplementedError("No literal for complex values.")
return str(data)
def c_declare(self, name, sub):
return """
%(dtype)s %(name)s;
typedef %(dtype)s %(name)s_dtype;
""" % dict(name=name, dtype=self.dtype_specs()[1])
def c_init(self, name, sub):
return """
%(name)s = 0;
""" % locals()
def c_extract(self, name, sub):
specs = self.dtype_specs()
return """
if (!PyObject_TypeCheck(py_%(name)s, &%(pyarr_type)s))
{
PyErr_Format(PyExc_ValueError,
"Scalar check failed (%(dtype)s)");
%(fail)s
}
PyArray_ScalarAsCtype(py_%(name)s, &%(name)s);
""" % dict(sub,
name=name,
dtype=specs[1],
pyarr_type='Py%sArrType_Type' % specs[2])
def c_sync(self, name, sub):
specs = self.dtype_specs()
return """
Py_XDECREF(py_%(name)s);
py_%(name)s = PyArrayScalar_New(%(cls)s);
if (!py_%(name)s)
{
Py_XINCREF(Py_None);
py_%(name)s = Py_None;
PyErr_Format(PyExc_MemoryError,
"Instantiation of new Python scalar failed (%(dtype)s)");
%(fail)s
}
PyArrayScalar_ASSIGN(py_%(name)s, %(cls)s, %(name)s);
""" % dict(sub,
name=name,
dtype=specs[1],
cls=specs[2])
def c_cleanup(self, name, sub):
return ""
def c_support_code(self):
if self.dtype.startswith('complex'):
cplx_types = ['theano_complex64', 'theano_complex128']
real_types = ['npy_int8', 'npy_int16', 'npy_int32', 'npy_int64',
'npy_float32', 'npy_float64']
# If the 'int' C type is not exactly the same as an existing
# 'npy_intX', some C code may not compile, e.g. when assigning
# the value 0 (cast to 'int' in C) to a theano_complex64.
if (numpy.dtype('intc').num not in
[numpy.dtype(d[4:]).num for d in real_types]):
# In that case we add the 'int' type to the real types.
real_types.append('int')
template = """
struct theano_complex%(nbits)s : public npy_complex%(nbits)s
{
typedef theano_complex%(nbits)s complex_type;
typedef npy_float%(half_nbits)s scalar_type;
complex_type operator +(const complex_type &y) const {
complex_type ret;
ret.real = this->real + y.real;
ret.imag = this->imag + y.imag;
return ret;
}
complex_type operator -() const {
complex_type ret;
ret.real = -this->real;
ret.imag = -this->imag;
return ret;
}
bool operator ==(const complex_type &y) const {
return (this->real == y.real) && (this->imag == y.imag);
}
bool operator ==(const npy_float%(nbits)s &y) const {
return (this->real == y) && (this->imag == 0);
}
complex_type operator -(const complex_type &y) const {
complex_type ret;
ret.real = this->real - y.real;
ret.imag = this->imag - y.imag;
return ret;
}
complex_type operator *(const complex_type &y) const {
complex_type ret;
ret.real = this->real * y.real - this->imag * y.imag;
ret.imag = this->real * y.imag + this->imag * y.real;
return ret;
}
complex_type operator /(const complex_type &y) const {
complex_type ret;
scalar_type y_norm_square = y.real * y.real + y.imag * y.imag;
ret.real = (this->real * y.real + this->imag * y.imag) / y_norm_square;
ret.imag = (this->imag * y.real - this->real * y.imag) / y_norm_square;
return ret;
}
template <typename T>
complex_type& operator =(const T& y);
theano_complex%(nbits)s() {}
template <typename T>
theano_complex%(nbits)s(const T& y) { *this = y; }
template <typename TR, typename TI>
theano_complex%(nbits)s(const TR& r, const TI& i) { this->real=r; this->imag=i; }
};
"""
def operator_eq_real(mytype, othertype):
return '''
template <> %(mytype)s & %(mytype)s::operator=<%(othertype)s>(const %(othertype)s & y)
{ this->real=y; this->imag=0; return *this; }
''' % dict(mytype=mytype, othertype=othertype)
def operator_eq_cplx(mytype, othertype):
return '''
template <> %(mytype)s & %(mytype)s::operator=<%(othertype)s>(const %(othertype)s & y)
{ this->real=y.real; this->imag=y.imag; return *this; }
''' % dict(mytype=mytype, othertype=othertype)
operator_eq = ''.join(operator_eq_real(ctype, rtype)
for ctype in cplx_types
for rtype in real_types) \
+ ''.join(operator_eq_cplx(ctype1, ctype2)
for ctype1 in cplx_types
for ctype2 in cplx_types)
# We are not using C++ generic templating here, because this would
# generate two different functions for adding a complex64 and a
# complex128, one returning a complex64, the other a complex128,
# and the compiler complains it is ambiguous.
# Instead, we generate code for known and safe types only.
def operator_plus_real(mytype, othertype):
return '''
const %(mytype)s operator+(const %(mytype)s &x, const %(othertype)s &y)
{ return %(mytype)s(x.real+y, x.imag); }
const %(mytype)s operator+(const %(othertype)s &y, const %(mytype)s &x)
{ return %(mytype)s(x.real+y, x.imag); }
''' % dict(mytype=mytype, othertype=othertype)
operator_plus = ''.join(operator_plus_real(ctype, rtype)
for ctype in cplx_types
for rtype in real_types)
def operator_minus_real(mytype, othertype):
return '''
const %(mytype)s operator-(const %(mytype)s &x, const %(othertype)s &y)
{ return %(mytype)s(x.real-y, x.imag); }
const %(mytype)s operator-(const %(othertype)s &y, const %(mytype)s &x)
{ return %(mytype)s(y-x.real, -x.imag); }
''' % dict(mytype=mytype, othertype=othertype)
operator_minus = ''.join(operator_minus_real(ctype, rtype)
for ctype in cplx_types
for rtype in real_types)
def operator_mul_real(mytype, othertype):
return '''
const %(mytype)s operator*(const %(mytype)s &x, const %(othertype)s &y)
{ return %(mytype)s(x.real*y, x.imag*y); }
const %(mytype)s operator*(const %(othertype)s &y, const %(mytype)s &x)
{ return %(mytype)s(x.real*y, x.imag*y); }
''' % dict(mytype=mytype, othertype=othertype)
operator_mul = ''.join(operator_mul_real(ctype, rtype)
for ctype in cplx_types
for rtype in real_types)
return template % dict(nbits=64, half_nbits=32) \
+ template % dict(nbits=128, half_nbits=64) \
+ operator_eq \
+ operator_plus \
+ operator_minus \
+ operator_mul
else:
return ""
def c_code_cache_version(self):
# Use the correct type checking and conversion functions
return (10, numpy.__version__)
# Make operators work with 64 and 128 arguments at the same time
return (9, numpy.__version__)
# put const around operators and added unary '-' operator
return (8, numpy.__version__)
# no need to put lib.amdlibm here as c_compile_args() are put
# in the key.
return (7,) # make complex c code optional
return (6,) # added implemeentations of operators that work
# with scalar arguments
return (5,) # added constructors to theano_complex class
return (4,) # explicit T given in specialization of operator=
# lines. This makes it compile with open64
def get_shape_info(self, obj):
|
def get_size(self, shape_info):
return shape_info
# Register C code for ViewOp on Scalars.
theano.compile.register_view_op_c_code(
Scalar,
"""
%(oname)s = %(iname)s;
""",
1)
int8 = Scalar('int8')
int16 = Scalar('int16')
int32 = Scalar('int32')
int64 = Scalar('int64')
uint8 = Scalar('uint8')
uint16 = Scalar('uint16')
uint32 = Scalar('uint32')
uint64 = Scalar('uint64')
float32 = Scalar('float32')
float64 = Scalar('float64')
complex64 = Scalar('complex64')
complex128 = Scalar('complex128')
int_types = int8, int16, int32, int64
uint_types = uint8, uint16, uint32, uint64
float_types = float32, float64
complex_types = complex64, complex128
discrete_types = int_types + uint_types
continuous_types = float_types + complex_types
all_types = discrete_types + continuous_types
class _scalar_py_operators:
# So that we can simplify checking code when we have a mixture of Scalar
# variables and Tensor variables
ndim = 0
dtype = property(lambda self: self.type.dtype)
""" The dtype of this scalar. """
#UNARY
def __abs__(self):
return abs_(self)
def __neg__(self):
return neg(self)
#CASTS
#def __int__(self): return AsInt(self).out
#def __float__(self): return AsDouble(self).out
#def __complex__(self): return AsComplex(self).out
#BITWISE
def __invert__(self):
return invert(self)
def __and__(self, other):
return and_(self, other)
def __or__(self, other):
return or_(self, other)
def __xor__(self, other):
return xor(self, other)
def __rand__(self, other):
return and_(other, self)
def __ror__(self, other):
return or_(other, self)
def __rxor__(self, other):
return xor(other, self)
#COMPARISONS
def __lt__(self, other):
return lt(self, other)
def __le__(self, other):
return le(self, other)
def __gt__(self, other):
return gt(self, other)
def __ge__(self, other):
return ge(self, other)
#ARITHMETIC - NORMAL
def __add__(self, other):
return add(self, other)
def __sub__(self, other):
return sub(self, other)
def __mul__(self, other):
return mul(self, other)
if PY3:
def __truediv__(self, other):
return div_proxy(self, other)
else:
def __div__(self, other):
return div_proxy(self, other)
def __floordiv__(self, other):
return int_div(self, other)
def __mod__(self, other):
return mod_check(self, other)
def __pow__(self, other):
return pow(self, other)
#ARITHMETIC - RIGHT-OPERAND
def __radd__(self, other):
return add(other, self)
def __rsub__(self, other):
return sub(other, self)
def __rmul__(self, other):
return mul(other, self)
def __rdiv__(self, other):
return div_proxy(other, self)
def __rmod__(self, other):
return mod(other, self)
def __rpow__(self, other):
return pow(other, self)
def zeros_like(self):
# The second is needed for Elemwise ops to work right
return second(self, ScalarConstant(Scalar(str(self.type.dtype)), 0))
def astype(self, dtype):
return cast(self, dtype)
class ScalarVariable(_scalar_py_operators, Variable):
pass
class ScalarConstant(_scalar_py_operators, Constant):
pass
# Register ScalarConstant as the type of Constant corresponding to Scalar
Scalar.Constant = ScalarConstant
# Easy constructors
def _multi(*fns):
def f2(f, names):
if len(names) == 1:
return f(names)
else:
return [f(name) for name in names]
if len(fns) == 1:
return partial(f2, fns[0])
else:
return [partial(f2, f) for f in fns]
ints = _multi(int64)
floats = _multi(float64)
complexs = _multi(complex128)
complexs64 = _multi(complex64)
complexs128 = _multi(complex128)
# Using a class instead of a function makes it possible to deep-copy it in
# Python 2.4.
# Note that currently only a few functions use this mechanism, because it is
# enough to make the test-suite pass with Python 2.4. However, it may prove
# necessary to use this same mechanism in other places as well in the future.
class upcast_out(object):
def __new__(self, *types):
return Scalar(dtype=Scalar.upcast(*types)),
class upgrade_to_float(object):
def __new__(self, *types):
"""
Upgrade any int types to float32 or float64 to avoid losing precision.
"""
conv = {int8: float32,
int16: float32,
int32: float64,
int64: float64,
uint8: float32,
uint16: float32,
uint32: float64,
uint64: float64}
return Scalar(Scalar.upcast(*[conv.get(type, type)
for type in types])),
class same_out(object):
def __new__(self, type):
return type,
def upcast_out_no_complex(*types):
if any([type in complex_types for type in types]):
raise TypeError('complex type are not supported')
return Scalar(dtype=Scalar.upcast(*types)),
def same_out_float_only(type):
if type not in float_types:
raise TypeError('only float type are supported')
return type,
class transfer_type(gof.utils.object2):
def __init__(self, *transfer):
assert all(type(x) == int for x in transfer)
self.transfer = transfer
def __str__(self):
return 'transfer_type{%s}' % self.transfer
def __call__(self, *types):
upcast = upcast_out(*types)
retval = []
for i in self.transfer:
if i is None:
retval += [upcast]
else:
retval += [types[i]]
return retval
#return [upcast if i is None else types[i] for i in self.transfer]
def __eq__(self, other):
return type(self) == type(other) and self.transfer == other.transfer
def __hash__(self):
return hash(self.transfer)
class specific_out(gof.utils.object2):
def __init__(self, *spec):
self.spec = spec
def __call__(self, *types):
return self.spec
def __eq__(self, other):
return type(self) == type(other) and self.spec == other.spec
def __hash__(self):
return hash(self.spec)
def int_out(*types):
return int64,
def float_out(*types):
return float64,
def upgrade_to_float_no_complex(*types):
"""
don't accept complex, otherwise call upgrade_to_float().
"""
for type in types:
if type in complex_types:
raise TypeError('complex argument not supported')
return upgrade_to_float(*types)
def same_out_nocomplex(type):
if type in complex_types:
raise TypeError('complex argument not supported')
return type,
def int_out_nocomplex(*types):
for type in types:
if type in complex_types:
raise TypeError('complex argument not supported')
return int64,
def float_out_nocomplex(*types):
for type in types:
if type in complex_types:
raise TypeError('complex argument not supported')
return float64,
class unary_out_lookup(gof.utils.object2):
"""
get a output_types_preference object by passing a dictionary:
unary_out_lookup({int8:int32, float32:complex128})
The result is an op that maps in8 to int32 and float32 to
complex128 and other input types lead to a TypeError.
"""
def __init__(self, type_table):
self.tbl = type_table
def __call__(self, *types):
if len(types) == 1:
types = types[0]
try:
rval = self.tbl[types]
except Exception:
raise TypeError(types)
if isinstance(types, (list, tuple)):
return rval
else:
return [rval]
def __eq__(self, other):
return type(self) == type(other) and self.tbl == other.tbl
def __hash__(self):
return hash(type(self)) # ignore hash of table
def real_out(type):
if type == complex64:
return float32,
if type == complex128:
return float64,
return type,
class ScalarOp(Op):
nin = -1
nout = 1
def __init__(self, output_types_preference=None, name=None):
self.name = name
if output_types_preference is not None:
if not callable(output_types_preference):
raise TypeError(
"Expected a callable for the 'output_types_preference' argument to %s. (got: %s)" % (self.__class__, output_types_preference))
self.output_types_preference = output_types_preference
def make_node(self, *inputs):
if self.nin >= 0:
if len(inputs) != self.nin:
raise TypeError("Wrong number of inputs for %s.make_node (got %i(%s), expected %i)" \
% (self, len(inputs), str(inputs), self.nin))
inputs = [as_scalar(input) for input in inputs]
outputs = [t() for t in self.output_types([input.
type for input in inputs])]
if len(outputs) != self.nout:
raise TypeError("Not the right number of outputs produced for %s(%s). Expected %s, got %s."
% (self, ", ".join(str(input) for input in inputs), self.nout, len(outputs)))
return Apply(self, inputs, outputs)
def output_types(self, types):
if hasattr(self, 'output_types_preference'):
variables = self.output_types_preference(*types)
if not isinstance(variables, (list, tuple)) or any(not isinstance(x, Type) for x in variables):
raise TypeError(
"output_types_preference should return a list or a tuple of types", self.output_types_preference, variables)
if len(variables) != self.nout:
raise TypeError("Not the right number of outputs types produced for %s(%s) by %s. Expected %s, got %s."
% (self, ", ".join(str(type) for type in variables),
self.output_types_preference, self.nout, len(variables)))
return variables
else:
raise NotImplementedError(
"Cannot calculate the output types for %s" % self)
def perform(self, node, inputs, output_storage):
if self.nout == 1:
output_storage[0][0] = self.impl(*inputs)
else:
variables = utils.from_return_values(self.impl(*inputs))
assert len(variables) == len(output_storage)
for storage, variable in zip(output_storage, variables):
storage[0] = variable
def impl(self, *inputs):
raise utils.MethodNotDefined("impl", type(self),
self.__class__.__name__)
def grad(self, inputs, output_gradients):
raise utils.MethodNotDefined("grad", type(self),
self.__class__.__name__)
def __eq__(self, other):
test = type(self) == type(other) \
and getattr(self, 'output_types_preference', None) \
== getattr(other, 'output_types_preference', None)
return test
def __hash__(self):
return hash(type(self).__name__) ^ hash(
getattr(self, 'output_types_preference', 0))
def __str__(self):
if hasattr(self, 'name') and self.name:
return self.name
else:
param = [(k, v) for k, v in self.__dict__.items()
if k not in ["name", "_op_use_c_code"]]
if param:
return "%s{%s}" % (self.__class__.__name__,
", ".join("%s=%s" % (k, v)
for k, v in param))
else:
return self.__class__.__name__
def c_code_cache_version(self):
return (4,)
def c_code_contiguous(self, node, name, inp, out, sub):
"""This function is called by Elemwise when all inputs and
outputs are c_contiguous. This allows to use the SIMD version
of this op.
The inputs are the same as c_code except that:
- inp and out must be the names of the variables associated to the
ndarrays in the C code
- node must be the elemwise node (this is needed to know
the inputs/outputs types)
"""
raise theano.gof.utils.MethodNotDefined()
class UnaryScalarOp(ScalarOp):
nin = 1
amd_float32 = None
amd_float64 = None
def c_code_contiguous(self, node, name, (x, ), (z, ), sub):
if (not theano.config.lib.amdlibm or
# We compare the dtype AND the broadcast flag
# as this function do not broadcast
node.inputs[0].type != node.outputs[0].type):
raise theano.gof.utils.MethodNotDefined()
dtype = node.inputs[0].dtype
if dtype == 'float32' and self.amd_float32 is not None:
dtype = 'float'
fct = self.amd_float32
elif dtype == 'float64' and self.amd_float64 is not None:
dtype = 'double'
fct = self.amd_float64
else:
raise theano.gof.utils.MethodNotDefined()
return """
npy_intp n = PyArray_SIZE(%(z)s);
%(dtype)s * x = (%(dtype)s*) PyArray_DATA(%(x)s);
%(dtype)s * z = (%(dtype)s*) PyArray_DATA(%(z)s);
%(fct)s(n, x, z);
""" % locals()
class BinaryScalarOp(ScalarOp):
# One may define in subclasses the following fields:
# - `identity`: for an associative operation, identity corresponds to
# the neutral element. For instance, it will be 0 for addition, 1 for
# multiplication, True for "and", False for "or".
# - `commutative`: whether op(a, b) == op(b, a)
# - `associative`: whether op(op(a, b), c) == op(a, op(b, c))
nin = 2
###############
# Comparisons
###############
class LogicalComparison(BinaryScalarOp):
def output_types(self, *input_dtypes):
return [int8]
def grad(self, inputs, output_gradients):
x, y = inputs
out = self(x, y)
assert str(out.type.dtype).find('int') != -1
return [x.zeros_like().astype(theano.config.floatX),
y.zeros_like().astype(theano.config.floatX)]
class FixedLogicalComparison(UnaryScalarOp):
"""
Comparison to a fixed value.
"""
def output_types(self, *input_dtypes):
return [int8]
def grad(self, inputs, output_gradients):
x ,= inputs
out = self(x)
assert str(out.type.dtype).find('int') != -1
return [x.zeros_like().astype(theano.config.floatX)]
class LT(LogicalComparison):
identity = False
commutative = False
associative = False
def impl(self, x, y):
# built-in < don't support complex
return numpy.less(x, y)
def c_code(self, node, name, (x, y), (z, ), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError()
return "%(z)s = (%(x)s < %(y)s);" % locals()
lt = LT()
class GT(LogicalComparison):
identity = False
commutative = False
associative = False
def impl(self, x, y):
# built-in > don't support complex
return numpy.greater(x, y)
def c_code(self, node, name, (x, y), (z, ), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError()
return "%(z)s = (%(x)s > %(y)s);" % locals()
gt = GT()
class LE(LogicalComparison):
identity = False
commutative = False
associative = False
def impl(self, x, y):
# built-in <= don't support complex
return numpy.less_equal(x, y)
def c_code(self, node, name, (x, y), (z, ), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError()
return "%(z)s = (%(x)s <= %(y)s);" % locals()
le = LE()
class GE(LogicalComparison):
identity = False
commutative = False
associative = False
def impl(self, x, y):
# built-in >= don't support complex
return numpy.greater_equal(x, y)
def c_code(self, node, name, (x, y), (z, ), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError()
return "%(z)s = (%(x)s >= %(y)s);" % locals()
ge = GE()
class EQ(LogicalComparison):
identity = False
commutative = True
associative = False
def impl(self, x, y):
return x == y
def c_code(self, node, name, (x, y), (z, ), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError()
return "%(z)s = (%(x)s == %(y)s);" % locals()
eq = EQ()
class NEQ(LogicalComparison):
identity = False
commutative = True
associative = False
def impl(self, x, y):
return x != y
def c_code(self, node, name, (x, y), (z, ), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError()
return "%(z)s = (%(x)s != %(y)s);" % locals()
neq = NEQ()
class IsNan(FixedLogicalComparison):
def impl(self, x):
return numpy.isnan(x)
def c_code(self, node, name, (x, ), (z, ), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError()
return "%(z)s = isnan(%(x)s);" % locals()
isnan = IsNan()
class IsInf(FixedLogicalComparison):
def impl(self, x):
return numpy.isinf(x)
def c_code(self, node, name, (x, ), (z, ), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError()
# Note that the C isinf returns -1 for -Inf and +1 for +Inf, while
# numpy simply returns True: we mimic numpy's behavior here, thus
# the absolute value.
return "%(z)s = abs(isinf(%(x)s));" % locals()
isinf = IsInf()
class InRange(LogicalComparison):
nin = 3
def __init__(self, openlow, openhi):
self.openlow = openlow
self.openhi = openhi
def impl(self, x, low, hi):
if self.openlow and x <= low:
return False
elif not self.openlow and x < low:
return False
if self.openhi and x >= hi:
return False
elif not self.openhi and x > hi:
return False
return True
def c_code(self, node, name, (x, low, hi), (z, ), sub):
if self.openlow:
cmp1 = '>'
else:
cmp1 = '>='
#backport
#cmp1 = '>' if self.openlow else '>='
if self.openhi:
cmp2 = '<'
else:
cmp2 = '<='
#backport
#cmp2 = '<' if self.openhi else '<='
return ("%(z)s = %(x)s %(cmp1)s %(low)s &&"
" %(x)s %(cmp2)s %(hi)s;" % locals())
def grad(self, (x, low, hi), (gz, )):
return None, None, None
inopenrange = InRange(True, True)
inclosedrange = InRange(False, False)
class Switch(ScalarOp):
nin = 3
def impl(self, cond, ift, iff):
if cond:
return ift
else:
return iff
#backport
#return ift if cond else iff
def c_code(self, node, name, (cond, ift, iff), (z, ), sub):
return "%(z)s = %(cond)s ? %(ift)s : %(iff)s;" % locals()
def grad(self, (cond, ift, iff), (gz, )):
first_part = switch(cond, gz, 0.)
second_part = switch(cond, 0., gz)
out = self(cond, ift, iff)
if out.type.dtype in discrete_types:
first_part = 0.
second_part = 0.
# cond does affect the elements of the output so it is connected.
# For the sake of making the gradient convenient we assume that
# condition + epsilon always triggers the same branch as condition
condition_grad = cond.zeros_like().astype(theano.config.floatX)
return (condition_grad, first_part, second_part)
def output_types(self, (cond_t, ift_t, iff_t)):
return upcast_out(ift_t, iff_t)
switch = Switch()
####################
# BIT-WISE OPERATORS
####################
class UnaryBitOp(UnaryScalarOp):
def output_types(self, *input_types):
for i in input_types[0]:
if i not in (int8, int16, int32, int64):
raise TypeError('input to a BitOp must have type int8,'
' int16, int32 or int64... not %s' % i)
return upcast_out(*input_types[0])
def grad(self, inputs, output_gradients):
return [inputs[0].zeros_like().astype(theano.config.floatX)]
class BinaryBitOp(BinaryScalarOp):
def output_types(self, *input_types):
t0, t1 = input_types[0]
for i in input_types[0]:
if i not in (int8, int16, int32, int64):
raise TypeError('input to a BitOp must have type int8,'
' int16, int32 or int64... not %s' % i)
return upcast_out(*input_types[0])
def grad(self, inputs, output_gradients):
a,b = inputs
return [a.zeros_like().astype(theano.config.floatX), b.zeros_like().astype(theano.config.floatX)]
class OR(BinaryBitOp):
identity = 0
commutative = True
associative = True
def impl(self, x, y):
return x | y
def c_code(self, node, name, (x, y), (z, ), sub):
return "%(z)s = (%(x)s | %(y)s);" % locals()
or_ = OR()
class XOR(BinaryBitOp):
identity = 0
commutative = True
associative = True
def impl(self, x, y):
return x ^ y
def c_code(self, node, name, (x, y), (z, ), sub):
return "%(z)s = (%(x)s ^ %(y)s);" % locals()
xor = XOR()
class AND(BinaryBitOp):
identity = 1
commutative = True
associative = True
def impl(self, x, y):
return x & y
def c_code(self, node, name, (x, y), (z, ), sub):
return "%(z)s = (%(x)s & %(y)s);" % locals()
and_ = AND()
class Invert(UnaryBitOp):
def impl(self, x):
return ~x
def c_code(self, node, name, (x,), (z, ), sub):
return "%(z)s = (~%(x)s);" % locals()
invert = Invert()
##############
# Arithmetic
##############
class Maximum(BinaryScalarOp):
commutative = True
associative = True
def impl(self, *inputs):
# The built-in max function don't support complex type
return numpy.maximum(*inputs)
def c_code(self, node, name, (x, y), (z, ), sub):
if any([i.type in complex_types for i in node.inputs]):
raise NotImplementedError()
# Test for both y>x and x>=y to detect NaN
return ('%(z)s = ((%(y)s)>(%(x)s)? (%(y)s): '
'((%(x)s)>=(%(y)s)? (%(x)s): nan("")));' % locals())
def grad(self, (x, y), (gz, )):
assert gz.type not in complex_types
# max is not defined for complex_types
output = self(x, y)
if output.type in discrete_types:
return [x.zeros_like().astype(theano.config.floatX),
y.zeros_like().astype(theano.config.floatX)]
gx = eq(output, x) * gz
gy = eq(output, y) * gz
return (gx, gy)
maximum = Maximum(upcast_out, name='maximum')
class Minimum(BinaryScalarOp):
commutative = True
associative = True
def impl(self, *inputs):
# The built-in min function don't support complex type
return numpy.minimum(*inputs)
def c_code(self, node, name, (x, y), (z, ), sub):
if any([i.type in complex_types for i in node.inputs]):
raise NotImplementedError()
return ('%(z)s = ((%(y)s)<(%(x)s)? (%(y)s): '
'((%(x)s)<=(%(y)s)? (%(x)s): nan("")));' % locals())
def grad(self, (x, y), (gz, )):
assert gz.type not in complex_types
# max is not defined for complex_types
output = minimum(x, y)
if output.type in discrete_types:
return [x.zeros_like().astype(theano.config.floatX),
y.zeros_like().astype(theano.config.floatX)]
gx = eq(output, x) * gz
gy = eq(output, y) * gz
return (gx, gy)
minimum = Minimum(upcast_out, name='minimum')
class Add(ScalarOp):
identity = 0
commutative = True
associative = True
def impl(self, *inputs):
return sum(inputs)
def c_code(self, node, name, inputs, (z, ), sub):
if not inputs:
return z + " = 0;"
else:
return z + " = " + " + ".join(inputs) + ";"
def grad(self, inputs, (gz, )):
if gz.type in complex_types:
raise NotImplementedError()
if self(*inputs).type in discrete_types:
assert gz is not None
retval = []
for ii, inp in enumerate(inputs):
if hasattr(inp, 'zeros_like'):
retval.append(
inp.zeros_like().astype(theano.config.floatX))
else:
retval.append(grad_undefined(self, ii, inp))
else:
retval = []
for i in inputs:
retval += [gz]
return retval
add = Add(upcast_out, name='add')
class Mul(ScalarOp):
identity = 1
commutative = True
associative = True
def impl(self, *inputs):
return numpy.product(inputs)
def c_code(self, node, name, inputs, (z, ), sub):
if not inputs:
return z + " = 1;"
else:
return z + " = " + " * ".join(inputs) + ";"
def grad(self, inputs, (gz, )):
retval = []
# The following 3 lines verify that gz is complex when the
# output is complex. The rest of this function make this supposition.
output_type = self.output_types([i.type for i in inputs])[0]
if output_type in complex_types:
if not gz.type in complex_types:
raise TypeError('Mul with output_type ' + str(output_type) +\
' expected gz type to be complex, got gz with type ' +\
str(gz.type))
if output_type in discrete_types:
return [ipt.zeros_like().astype(theano.config.floatX)
for ipt in inputs]
for input in inputs:
if gz.type in complex_types:
# zr+zi = (xr + xi)(yr + yi)
# zr+zi = (xr*yr - xi*yi) + (xr yi + xi yr )
otherprod = mul(*(utils.difference(inputs, [input])))
yr = real(otherprod)
yi = imag(otherprod)
if input.type in complex_types:
retval += [complex(yr * real(gz) + yi * imag(gz),
yr * imag(gz) - yi * real(gz))]
else:
retval += [yr * real(gz) + yi * imag(gz)]
else:
retval += [mul(*([gz] + utils.difference(inputs,
[input])))]
return retval
mul = Mul(upcast_out, name='mul')
class Sub(BinaryScalarOp):
def impl(self, x, y):
return x - y
def c_code(self, node, name, (x, y), (z, ), sub):
return "%(z)s = %(x)s - %(y)s;" % locals()
def grad(self, (x, y), (gz, )):
if gz.type in complex_types:
raise NotImplementedError()
if (x - y).type in discrete_types:
return [x.zeros_like().astype(theano.config.floatX),
y.zeros_like().astype(theano.config.floatX)]
first_part = gz
second_part = -gz
return first_part, second_part
sub = Sub(upcast_out, name='sub')
def int_or_true_div(x_discrete, y_discrete):
"""
Return 'int' or 'true' depending on the type of division used for x / y.
:param x_discrete: True if `x` is discrete ([unsigned] integer).
:param y_discrete: True if `x` is discrete ([unsigned] integer).
:returns: 'int' if `x / y` should be an integer division, or `true` if it
should be a true division.
Raises an IntegerDivisionError if both `x_discrete` and `y_discrete` are
True and `config.int_division` is set to 'raise'.
This function is used by both scalar/basic.py and tensor.basic/py.
"""
if (x_discrete and y_discrete):
if config.int_division == 'raise':
raise IntegerDivisionError(
"With `config.int_division` set to 'raise', dividing two "
"integer types with '/' is forbidden to avoid confusion "
"between integer and floating point divisions. Please "
"use // for integer division, or if you want a float result "
"either cast one of the arguments to a float or directly call "
"`x.__truediv__(y)`.")
elif config.int_division == 'int':
warnings.warn(
"Division of two integer types with x / y is deprecated, "
"please use x // y for an integer division.",
DeprecationWarning,
stacklevel=4)
return 'int'
elif config.int_division == 'floatX':
return 'true'
else:
raise NotImplementedError(config.int_division)
else:
return 'true'
def div_proxy(x, y):
"""Proxy for either true_div or int_div, depending on types of x, y."""
f = eval('%s_div' % int_or_true_div(as_scalar(x).type in discrete_types,
as_scalar(y).type in discrete_types))
return f(x, y)
class TrueDiv(BinaryScalarOp):
def output_types(self, types):
if all(t in discrete_types for t in types):
return [Scalar(config.floatX)]
else:
return super(TrueDiv, self).output_types(types)
def impl(self, x, y):
x = numpy.asarray(x)
y = numpy.asarray(y)
if all(a.dtype in discrete_types for a in (x, y)):
return numpy.array(float(x) / y, dtype=config.floatX)
else:
return x / y
def c_code(self, node, name, (x, y), (z, ), sub):
# we generate good c code only when both are complex!
if sum([node.inputs[0].type in complex_types,
node.inputs[1].type in complex_types]) == 1:
raise NotImplementedError('type not supported', type)
if (node.inputs[0].type in discrete_types and
node.inputs[1].type in discrete_types):
return "%(z)s = ((double)%(x)s) / %(y)s;" % locals()
return "%(z)s = %(x)s / %(y)s;" % locals()
def grad(self, (x, y), (gz, )):
if x.type in complex_types:
raise NotImplementedError()
# If the output of this op is discrete, then it
# it is locally flat everywhere, so the gradient
# through it is 0.
# This is different from it not being connected
# to the output; x/y is still a function of x
# and y; it's just a step function.
if (x / y).type in discrete_types:
return [x.zeros_like(), y.zeros_like()]
first_part = gz / y
if y.type in complex_types:
raise NotImplementedError()
second_part = -(gz * x) / (y * y)
return first_part, second_part
true_div = TrueDiv(upcast_out, name='true_div')
class IntDiv(BinaryScalarOp):
complex_error = ComplexError(
"Theano does not support integer division (//) on "
"complex numbers, since numpy deprecated it.")
def impl(self, x, y):
return x // y
def c_support_code(self):
# We use a macro as python use % as a special string character,
# and the output of c_code may be run through another level
# of string formatting.
return "#define THEANO_MACRO_MOD(x,y) (x % y)"
def c_code(self, node, name, (x, y), (z,), sub):
t = node.inputs[0].type.upcast(*[i.type for i in node.inputs[1:]])
if t in imap(str, discrete_types):
x_div_y_pp = '(%(x)s / %(y)s)' % locals()
x_div_y_mp = '((-%(x)s) / %(y)s)' % locals()
x_mod_y_mp = 'THEANO_MACRO_MOD((-%(x)s), %(y)s)' % locals()
x_div_y_pm = '(%(x)s / (-%(y)s))' % locals()
x_mod_y_pm = 'THEANO_MACRO_MOD(%(x)s, (-%(y)s))' % locals()
x_div_y_mm = '((-%(x)s) / (-%(y)s))' % locals()
elif t in imap(str, float_types):
# We need to call different functions of math.h
# depending on the type
if t == 'float32':
floor = 'floorf'
fmod = 'fmodf'
elif t == 'float64':
floor = 'floor'
fmod = 'fmod'
else:
raise NotImplementedError('type not supported', t)
x_div_y_pp = '%(floor)s(%(x)s / %(y)s)' % locals()
x_div_y_mp = '%(floor)s((-%(x)s) / %(y)s)' % locals()
x_mod_y_mp = '%(fmod)s((-%(x)s), %(y)s)' % locals()
x_div_y_pm = '%(floor)s(%(x)s / (-%(y)s))' % locals()
x_mod_y_pm = '%(fmod)s(%(x)s, (-%(y)s))' % locals()
x_div_y_mm = '%(floor)s((-%(x)s) / (-%(y)s))' % locals()
elif t in complex_types:
raise self.complex_error
else:
raise NotImplementedError('type not supported', t)
return dedent("""
if (%(x)s < 0) {
if (%(y)s < 0) {
%(z)s = %(x_div_y_mm)s;
} else {
%(z)s = - %(x_div_y_mp)s - ((%(x_mod_y_mp)s == 0) ? 0 : 1);
}
} else {
if (%(y)s < 0) {
%(z)s = - %(x_div_y_pm)s - ((%(x_mod_y_pm)s == 0) ? 0 : 1);
} else {
%(z)s = %(x_div_y_pp)s;
}
}
""") % locals()
def c_code_cache_version(self):
return (2,)
def grad(self, inputs, g_output):
return [None] * len(inputs)
int_div = IntDiv(upcast_out, name='int_div')
floor_div = int_div
def mod_check(x, y):
if (as_scalar(x).type in complex_types or
as_scalar(y).type in complex_types):
# Currently forbidden.
raise Mod.complex_error
else:
return mod(x, y)
class Mod(BinaryScalarOp):
complex_error = ComplexError(
"Theano does not support the mod operator (%) on "
"complex numbers, since numpy deprecated it.")
def impl(self, x, y):
if isinstance(x, numpy.complex) or isinstance(y, numpy.complex):
raise self.complex_error
return x % y
def c_code_cache_version(self):
return (5,)
def c_support_code(self):
# We use a macro as python use % as a special string character,
# and the output of c_code may be run through another level
# of string formatting.
return "#define THEANO_MACRO_MOD(x,y) (x % y)"
def c_code(self, node, name, (x, y), (z, ), sub):
"""
We want the result to have the same sign as python, not the other
implementation of mod.
"""
# raise NotImplementedError("Unlike Python, C's modulo returns negative
# modulo on negative dividend (to implement)")
t = node.inputs[0].type.upcast(*[i.type for i in node.inputs[1:]])
if (str(t) in imap(str, discrete_types) or
t in ['uint8', 'int8', 'uint16', 'int16'] or
t in ['uint32', 'int32', 'uint64', 'int64'] or
t in discrete_types):
# The above or's should not be needed anymore. However, for now we
# keep them out of safety, and verify they are useless with an
# assert.
assert str(t) in imap(str, discrete_types)
x_mod_y = "THEANO_MACRO_MOD(%(x)s, %(y)s)" % locals()
x_mod_ymm = "THEANO_MACRO_MOD(-%(x)s, -%(y)s)" % locals()
x_mod_ypm = "THEANO_MACRO_MOD(%(x)s, -%(y)s)" % locals()
x_mod_ymp = "THEANO_MACRO_MOD(-%(x)s, %(y)s)" % locals()
elif (str(t) in imap(str, float_types) or
t in ['float32', 'float64'] or
t in float_types):
# The above or's should not be needed anymore. However, for now we
# keep them out of safety, and verify they are useless with an
# assert.
assert str(t) in imap(str, float_types)
x_mod_y = "fmod(%(x)s,%(y)s)" % locals()
x_mod_ymm = "fmod(-%(x)s,-%(y)s)" % locals()
x_mod_ypm = "fmod(%(x)s,-%(y)s)" % locals()
x_mod_ymp = "fmod(-%(x)s,%(y)s)" % locals()
elif str(t) in imap(str, complex_types):
raise self.complex_error
else:
raise NotImplementedError('type not supported', t)
return dedent("""
if (%(x)s < 0){
if (%(y)s < 0){
%(z)s = -(%(x_mod_ymm)s);
}else{
%(z)s = - %(x_mod_ymp)s + (%(x_mod_ymp)s != 0 ? %(y)s : 0);
}
}else if (%(y)s < 0){
%(z)s = (%(x_mod_ypm)s) + (%(x_mod_ypm)s != 0 ? %(y)s : 0);
}else{
%(z)s = %(x_mod_y)s;
}
""") % locals()
def grad(self, (x, y), (gz, )):
return None, None
mod = Mod(upcast_out, name='mod')
class Pow(BinaryScalarOp):
def impl(self, x, y):
return x ** y
def c_code(self, node, name, (x, y), (z, ), sub):
if (node.inputs[0].type in complex_types or
node.inputs[1].type in complex_types):
raise NotImplementedError('type not supported', type)
return "%(z)s = pow(%(x)s, %(y)s);" % locals()
def grad(self, (x, y), (gz, )):
if gz.type in complex_types:
raise NotImplementedError()
if self(x, y).type in discrete_types:
return [x.zeros_like().astype(theano.config.floatX),
y.zeros_like().astype(theano.config.floatX)]
first_part = gz * y * x ** (y - 1)
second_part = gz * log(x) * x ** y
return (first_part, second_part)
def c_code_contiguous(self, node, name, (x, y), (z, ), sub):
if not theano.config.lib.amdlibm:
raise theano.gof.utils.MethodNotDefined()
# We compare the dtype AND the broadcast flag
# as this function do not broadcast
if (node.inputs[0].type == node.outputs[0].type and
node.inputs[1].type == node.outputs[0].type and
# amdlibm 3.0 do not have a float64 version of this SIMD function
node.inputs[0].dtype == 'float32' and
node.inputs[1].dtype == 'float32'):
dtype = 'float'
fct = "amd_vrsa_powf"
return """
npy_intp n = PyArray_SIZE(%(z)s);
%(dtype)s * x = (%(dtype)s*) PyArray_DATA(%(x)s);
%(dtype)s * y = (%(dtype)s*) PyArray_DATA(%(y)s);
%(dtype)s * z = (%(dtype)s*) PyArray_DATA(%(z)s);
%(fct)s(n, x, y, z);
""" % locals()
# We compare the dtype and check we broadcast a scalar
elif (node.inputs[0].type == node.outputs[0].type and
node.inputs[1].dtype == node.outputs[0].dtype and
all(node.inputs[1].broadcastable) and
# amdlibm 3.0 do not have a float64 version of this SIMD function
node.inputs[0].dtype == 'float32' and
node.inputs[1].dtype == 'float32'):
dtype = 'float'
fct = "amd_vrsa_powxf"
return """
npy_intp n = PyArray_SIZE(%(z)s);
%(dtype)s * x = (%(dtype)s*) PyArray_DATA(%(x)s);
%(dtype)s * y = (%(dtype)s*) PyArray_DATA(%(y)s);
%(dtype)s * z = (%(dtype)s*) PyArray_DATA(%(z)s);
%(fct)s(n, x, *y, z);
""" % locals()
raise theano.gof.utils.MethodNotDefined()
pow = Pow(upcast_out, name='pow')
class Clip(ScalarOp):
nin = 3
def impl(self, x, min, max):
if x < min:
return min
elif x > max:
return max
else:
return x
def c_code(self, node, name, (x, min, max), (z, ), sub):
return "%(z)s = %(x)s < %(min)s ? %(min)s : %(x)s > %(max)s ? %(max)s : %(x)s;" % locals()
def grad(self, (x, mn, mx), (gz, )):
assert gz.type not in complex_types
gx = ((x > mn) & (x < mx)) * gz
gmn = (x < mn) * gz
gmx = (x > mx) * gz
out = self(x, mn, mx)
def handle_int(v):
if out.type in int_types:
return v.zeros_like().astype(config.floatX)
return v
return map(handle_int, [gx, gmn, gmx])
# Don't allow complex even if numpy do
# As there is no mathematical reason for this function on complex
clip = Clip(upcast_out_no_complex, name='clip')
class Second(BinaryScalarOp):
def impl(self, x, y):
return y
def c_code(self, node, name, (x, y), (z, ), sub):
return "%(z)s = %(y)s;" % locals()
def connection_pattern(self, node):
# x is never connected because its elements are never used
# y is connected because its elements are copied over
return [[False], [True]]
def grad(self, (x, y), (gz, )):
if y.type in continuous_types:
# x is disconnected because the elements of x are not used
return DisconnectedType()(), gz
else:
#when y is discrete, we assume the function can be extended
#to deal with real-valued inputs by rounding them to the
#nearest integer. f(x+eps) thus equals f(x) so the gradient
#is zero, not disconnected or undefined
return DisconnectedType()(), y.zeros_like()
second = Second(transfer_type(1), name='second')
class Identity(UnaryScalarOp):
def impl(self, input):
return input
def c_code(self, node, name, (x, ), (z, ), sub):
return "%(z)s = %(x)s;" % locals()
def grad(self, (x, ), (gz, )):
if x.type in continuous_types:
return gz,
else:
return None,
identity = Identity(same_out, name='identity')
#### CASTING OPERATIONS
class Cast(UnaryScalarOp):
def __init__(self, o_type, name=None):
if not isinstance(o_type, Scalar):
raise TypeError(o_type)
super(Cast, self).__init__(specific_out(o_type), name=name)
self.o_type = o_type
self.ctor = getattr(numpy, o_type.dtype)
def __str__(self):
return '%s{%s}' % (self.__class__.__name__, self.o_type.dtype)
def impl(self, input):
return self.ctor(input)
def c_code(self, node, name, (x, ), (z, ), sub):
return "%s = (%s)%s;" % (z, node.outputs[0].type.dtype_specs()[1], x)
def grad(self, (x, ), (gz, )):
if self.o_type in continuous_types:
return [gz]
else:
return [x.zeros_like().astype(theano.config.floatX)]
def c_code_cache_version(self):
s = super(Cast, self).c_code_cache_version()
if s:
return (3,) + s
else:
return s
convert_to_int8 = Cast(int8, name='convert_to_int8')
convert_to_int16 = Cast(int16, name='convert_to_int16')
convert_to_int32 = Cast(int32, name='convert_to_int32')
convert_to_int64 = Cast(int64, name='convert_to_int64')
convert_to_uint8 = Cast(uint8, name='convert_to_uint8')
convert_to_uint16 = Cast(uint16, name='convert_to_uint16')
convert_to_uint32 = Cast(uint32, name='convert_to_uint32')
convert_to_uint64 = Cast(uint64, name='convert_to_uint64')
convert_to_float32 = Cast(float32, name='convert_to_float32')
convert_to_float64 = Cast(float64, name='convert_to_float64')
convert_to_complex64 = Cast(complex64, name='convert_to_complex64')
convert_to_complex128 = Cast(complex128, name='convert_to_complex128')
_cast_mapping = {
'int8': convert_to_int8,
'int16': convert_to_int16,
'int32': convert_to_int32,
'int64': convert_to_int64,
'uint8': convert_to_uint8,
'uint16': convert_to_uint16,
'uint32': convert_to_uint32,
'uint64': convert_to_uint64,
'float32': convert_to_float32,
'float64': convert_to_float64,
'complex64': convert_to_complex64,
'complex128': convert_to_complex128}
def cast(x, dtype):
"""Symbolically cast `x` to a Scalar of given `dtype`."""
if dtype == 'floatX':
dtype = config.floatX
_x = as_scalar(x)
if _x.type.dtype == dtype:
return _x
if _x.type.dtype.startswith('complex') and not dtype.startswith('complex'):
raise TypeError('Casting from complex to real is ambiguous: consider'
' real(), imag(), angle() or abs()')
return _cast_mapping[dtype](_x)
class Abs(UnaryScalarOp):
def make_node(self, x):
inputs = [as_scalar(input) for input in [x]]
if inputs[0].type == complex64:
outputs = [float32()]
elif inputs[0].type == complex128:
outputs = [float64()]
else:
outputs = [t() for t in self.output_types(
[input.type for input in inputs])]
return Apply(self, inputs, outputs)
def impl(self, x):
return numpy.abs(x)
def grad(self, (x, ), (gz, )):
if x.type in float_types + complex_types:
return gz * x / abs(x), # formula works for complex and real
else:
return None,
def c_code(self, node, name, (x, ), (z, ), sub):
type = node.inputs[0].type
if type in int_types:
return "%(z)s = abs(%(x)s);" % locals()
if type in float_types:
return "%(z)s = fabs(%(x)s);" % locals()
if type in complex_types:
return "%(z)s = sqrt(%(x)s.real*%(x)s.real + %(x)s.imag*%(x)s.imag);" % locals()
raise NotImplementedError('type not supported', type)
abs_ = Abs(same_out)
class Sgn(UnaryScalarOp):
def impl(self, x):
#casting to output type is handled by filter
return numpy.sign(x)
def grad(self, (x, ), (gz, )):
rval = x.zeros_like()
if rval.type.dtype in discrete_types:
rval = rval.astype(theano.config.floatX)
return [rval]
def c_code(self, node, name, (x, ), (z, ), sub):
#casting is done by compiler
#TODO: use copysign
type = node.inputs[0].type
if type in float_types:
return "%(z)s = (%(x)s >= 0) ? (%(x)s == 0) ? 0.0 : 1.0 : -1.0;" % locals()
if type in int_types:
return "%(z)s = (%(x)s >= 0) ? (%(x)s == 0) ? 0 : 1 : -1;" % locals()
raise TypeError() # complex has no sgn
def c_code_cache_version(self):
s = super(Sgn, self).c_code_cache_version()
if s:
return (3,) + s
else: # if parent is unversioned, we are too
return s
sgn = Sgn(same_out_nocomplex, name='sgn')
class Ceil(UnaryScalarOp):
def impl(self, x):
return numpy.ceil(x)
def grad(self, (x,), (gz,)):
rval = x.zeros_like()
if rval.type.dtype in discrete_types:
rval = rval.astype(theano.config.floatX)
return [rval]
def c_code(self, node, name, (x,), (z,), sub):
return "%(z)s = ceil(%(x)s);" % locals()
ceil = Ceil(same_out_nocomplex, name='ceil')
class Floor(UnaryScalarOp):
def impl(self, x):
return numpy.floor(x)
def grad(self, (x,), (gz,)):
rval = x.zeros_like()
if rval.type.dtype in discrete_types:
rval = rval.astype(theano.config.floatX)
return [rval]
def c_code(self, node, name, (x,), (z,), sub):
return "%(z)s = floor(%(x)s);" % locals()
floor = Floor(same_out_nocomplex, name='floor')
class Trunc(UnaryScalarOp):
def impl(self, x):
return numpy.trunc(x)
def grad(self, (x,), (gz,)):
return [x.zeros_like().astype(theano.config.floatX)]
def c_code(self, node, name, (x,), (z,), sub):
return "%(z)s = %(x)s >= 0? floor(%(x)s): -floor(-%(x)s);" % locals()
trunc = Trunc(same_out_nocomplex, name='trunc')
class RoundHalfToEven(UnaryScalarOp):
"""
This function implement the same rounding than numpy: Round half to even
c/c++ round fct IS DIFFERENT!
See http://en.wikipedia.org/wiki/Rounding for more detail
"""
def impl(self, x):
return numpy.round(x)
def c_code___(self, node, name, (x, ), (z, ), sub):
typ = node.outputs[0].type.dtype
if not node.outputs[0].type.dtype in ['float32', 'float64']:
Exception("The output should be float32 or float64")
return dedent("""
#ifndef ROUNDING_EPSILON
#define ROUNDING_EPSILON 0.0000001
#endif
if (%(x)s < 0.0){
// We implement the else part like that: -else( -%(x)s);
%(typ)s i;
std::modf( -%(x)s, &i );
// If %(x)s is exactly halfway between two integers
if ((-%(x)s -(i +0.5)) < epsilon){
// If 'i' is even then return 'i'
if (std::fmod( i, 2.0 ) < epsilon){
%(z)s = - i;
}else{
// Else return the nearest even integer
%(z)s = - ceil( i +0.5 );
}
}else{
// round to closest
%(z)s = - round(%(x)s+5);
}
}else{
%(typ)s i;
std::modf( %(x)s, &i );
// If %(x)s is exactly halfway between two integers
if ((%(x)s -(i +0.5)) < epsilon){
// If 'i' is even then return 'i'
if (std::fmod( i, 2.0 ) < epsilon){
%(z)s = i;
}else{
// Else return the nearest even integer
%(z)s = ceil( i +0.5 );
}
}else{
// round to closest
%(z)s = round(%(x)s+5);
}
}
#undef ROUNDING_EPSILON
""")
round_half_to_even = RoundHalfToEven(same_out_float_only)
def round_half_away_from_zero_(a):
if a > 0:
return numpy.floor(a + 0.5)
else:
return numpy.ceil(a - 0.5)
round_half_away_from_zero_vec64 = numpy.vectorize(
round_half_away_from_zero_,
doc='round_half_away_from_zero_vec64')
round_half_away_from_zero_vec32 = numpy.vectorize(
round_half_away_from_zero_,
doc='round_half_away_from_zero_vec32',
otypes=['float32'])
def round_half_away_from_zero_vec(a):
if getattr(a, 'dtype', None) == numpy.float32:
return round_half_away_from_zero_vec32(a)
return round_half_away_from_zero_vec64(a)
class RoundHalfAwayFromZero(UnaryScalarOp):
"""
Implement the same rounding algo as c round() fct.
numpy.round fct IS DIFFERENT!
See http://en.wikipedia.org/wiki/Rounding for more detail
"""
def impl(self, x):
return round_half_away_from_zero_vec(x)
def c_code(self, node, name, (x, ), (z, ), sub):
if node.outputs[0].type.dtype in ['float32', 'float64']:
return "%(z)s = round(%(x)s);" % locals()
else:
Exception("The output should be float32 or float64")
round_half_away_from_zero = RoundHalfAwayFromZero(same_out_float_only)
class Neg(UnaryScalarOp):
def impl(self, x):
return -x
def grad(self, (x,), (gz,)):
if x.type in continuous_types:
return -gz,
else:
return None,
def c_code(self, node, name, (x,), (z,), sub):
return "%(z)s = -%(x)s;" % locals()
neg = Neg(same_out, name='neg')
class Inv(UnaryScalarOp):
""" multiplicative inverse. Also called reciprocal"""
def impl(self, x):
return 1.0 / x
def grad(self, (x,), (gz,)):
if x.type in complex_types:
raise NotImplementedError()
if x.type in float_types:
return -gz / (x * x),
else:
return None,
def c_code(self, node, name, (x,), (z,), sub):
return "%(z)s = 1.0 / %(x)s;" % locals()
inv = Inv(upgrade_to_float, name='inv')
class Log(UnaryScalarOp):
""" log base e """
amd_float32 = "amd_vrsa_logf"
amd_float64 = "amd_vrda_log"
def impl(self, x):
return numpy.log(x)
def grad(self, (x,), (gz,)):
if x.type in complex_types:
raise NotImplementedError()
if x.type in float_types:
return gz / x,
else:
return None,
def c_code(self, node, name, (x,), (z,), sub):
#todo: the version using log2 seems to be very slightly faster
# on some machines for some reason, check if it's worth switching
#return "%(z)s = log2(%(x)s) * 0.69314718055994529;" % locals()
if node.inputs[0].type in complex_types:
raise NotImplementedError('type not supported', type)
return "%(z)s = log(%(x)s);" % locals()
log = Log(upgrade_to_float, name='log')
class Log2(UnaryScalarOp):
""" log base 2 """
amd_float32 = "amd_vrsa_log2f"
amd_float64 = "amd_vrda_log2"
def impl(self, x):
return numpy.log2(x)
def grad(self, (x,), (gz,)):
if x.type in complex_types:
raise NotImplementedError()
if x.type in float_types:
return gz / (x * math.log(2.0)),
else:
return None,
def c_code(self, node, name, (x, ), (z, ), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError('type not supported', type)
return "%(z)s = log2(%(x)s);" % locals()
log2 = Log2(upgrade_to_float, name='log2')
class Log10(UnaryScalarOp):
""" log base 10 """
amd_float32 = "amd_vrsa_log10f"
amd_float64 = "amd_vrda_log10"
def impl(self, x):
return numpy.log10(x)
def grad(self, (x,), (gz,)):
if x.type in complex_types:
raise NotImplementedError()
if x.type in float_types:
return gz / (x * numpy.log(10.0)),
else:
return None
def c_code(self, node, name, (x, ), (z, ), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError('type not supported', type)
return "%(z)s = log10(%(x)s);" % locals()
log10 = Log10(upgrade_to_float, name='log10')
class Log1p(UnaryScalarOp):
""" log(1+x) """
def impl(self, x):
return numpy.log1p(x)
def grad(self, (x,), (gz,)):
if gz.type in complex_types:
raise NotImplementedError()
if gz.type in float_types:
return [gz / (1 + x)]
return [None]
def c_code(self, node, name, (x, ), (z, ), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError('type not supported', type)
return "%(z)s = log1p(%(x)s);" % locals()
log1p = Log1p(upgrade_to_float, name='log1p')
class Exp(UnaryScalarOp):
amd_float32 = "amd_vrsa_expf"
amd_float64 = "amd_vrda_exp"
def impl(self, x):
return numpy.exp(x)
def grad(self, (x, ), (gz, )):
if x.type in complex_types:
raise NotImplementedError()
elif x.type in float_types:
return gz * exp(x),
else:
return None,
def c_code(self, node, name, (x, ), (z, ), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError('type not supported', type)
return "%(z)s = exp(%(x)s);" % locals()
exp = Exp(upgrade_to_float, name='exp')
class Exp2(UnaryScalarOp):
def impl(self, x):
return numpy.exp2(x)
def grad(self, (x, ), (gz, )):
if x.type in complex_types:
raise NotImplementedError()
elif x.type in float_types:
return gz * exp2(x) * log(numpy.cast[x.type](2)),
else:
return None,
def c_code(self, node, name, (x, ), (z, ), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError('type not supported', type)
return "%(z)s = exp2(%(x)s);" % locals()
exp2 = Exp2(upgrade_to_float, name='exp2')
class Expm1(UnaryScalarOp):
def impl(self, x):
return numpy.expm1(x)
def grad(self, (x, ), (gz, )):
if x.type in complex_types:
raise NotImplementedError()
elif x.type in float_types:
return gz * exp(x),
else:
return None,
def c_code(self, node, name, (x, ), (z, ), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError('type not supported', type)
return "%(z)s = exp(%(x)s) - 1;" % locals()
expm1 = Expm1(upgrade_to_float, name='expm1')
class Sqr(UnaryScalarOp):
def impl(self, x):
return x * x
def grad(self, (x, ), (gz, )):
if gz.type in complex_types:
raise NotImplementedError()
if x.type in float_types:
return gz * x * 2,
else:
return None,
def c_code(self, node, name, (x, ), (z, ), sub):
return "%(z)s = %(x)s * %(x)s;" % locals()
sqr = Sqr(same_out, name='sqr')
class Sqrt(UnaryScalarOp):
def impl(self, x):
return numpy.sqrt(x)
def grad(self, (x,), (gz,)):
if gz.type in complex_types:
raise NotImplementedError()
if x.type in float_types:
return (gz * 0.5) / sqrt(x),
else:
return None,
def c_code(self, node, name, (x,), (z,), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError('type not supported', type)
return "%(z)s = sqrt(%(x)s);" % locals()
sqrt = Sqrt(upgrade_to_float, name='sqrt')
class Deg2Rad(UnaryScalarOp):
def impl(self, x):
return numpy.deg2rad(x)
def grad(self, (x,), (gz,)):
if gz.type in complex_types:
raise NotImplementedError()
if x.type in float_types:
return gz * numpy.asarray(numpy.pi / 180, gz.type),
else:
return None,
def c_code(self, node, name, (x,), (z,), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError('type not supported', type)
return "%(z)s = %(x)s * (M_PI / 180.0);" % locals()
deg2rad = Deg2Rad(upgrade_to_float, name='deg2rad')
class Rad2Deg(UnaryScalarOp):
def impl(self, x):
return numpy.rad2deg(x)
def grad(self, (x,), (gz,)):
if gz.type in complex_types:
raise NotImplementedError()
if x.type in float_types:
return gz * numpy.asarray(180. / numpy.pi, gz.type),
else:
return None,
def c_code(self, node, name, (x,), (z,), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError('type not supported', type)
return "%(z)s = %(x)s * (180.0 / M_PI);" % locals()
rad2deg = Rad2Deg(upgrade_to_float, name='rad2deg')
class Cos(UnaryScalarOp):
amd_float32 = "amd_vrsa_cosf"
amd_float64 = "amd_vrda_cos"
def impl(self, x):
return numpy.cos(x)
def grad(self, (x, ), (gz, )):
if gz.type in complex_types:
raise NotImplementedError()
if x.type in float_types:
return -gz * sin(x),
else:
return None,
def c_code(self, node, name, (x, ), (z, ), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError('type not supported', type)
return "%(z)s = cos(%(x)s);" % locals()
cos = Cos(upgrade_to_float, name='cos')
class ArcCos(UnaryScalarOp):
def impl(self, x):
return numpy.arccos(x)
def grad(self, (x,), (gz,)):
if gz.type in complex_types:
raise NotImplementedError()
if x.type in float_types:
return - gz / sqrt(numpy.cast[x.type](1) - sqr(x)),
else:
return None,
def c_code(self, node, name, (x,), (z,), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError('type not supported', type)
return "%(z)s = acos(%(x)s);" % locals()
arccos = ArcCos(upgrade_to_float, name='arccos')
class Sin(UnaryScalarOp):
amd_float32 = "amd_vrsa_sinf"
amd_float64 = "amd_vrda_sin"
def impl(self, x):
return numpy.sin(x)
def grad(self, (x, ), (gz, )):
if x.type in complex_types:
raise NotImplementedError()
if x.type in float_types:
return gz * cos(x),
else:
return None,
def c_code(self, node, name, (x, ), (z, ), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError('type not supported', type)
return "%(z)s = sin(%(x)s);" % locals()
sin = Sin(upgrade_to_float, name='sin')
class ArcSin(UnaryScalarOp):
def impl(self, x):
return numpy.arcsin(x)
def grad(self, (x,), (gz,)):
if gz.type in complex_types:
raise NotImplementedError()
if x.type in float_types:
return gz / sqrt(numpy.cast[x.type](1) - sqr(x)),
else:
return None,
def c_code(self, node, name, (x,), (z,), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError('type not supported', type)
return "%(z)s = asin(%(x)s);" % locals()
arcsin = ArcSin(upgrade_to_float, name='arcsin')
class Tan(UnaryScalarOp):
def impl(self, x):
return numpy.tan(x)
def grad(self, (x,), (gz,)):
if x.type in complex_types:
raise NotImplementedError()
if x.type in float_types:
return gz / sqr(cos(x)),
else:
return None,
def c_code(self, node, name, (x, ), (z, ), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError('type not supported', type)
return "%(z)s = tan(%(x)s);" % locals()
tan = Tan(upgrade_to_float, name='tan')
class ArcTan(UnaryScalarOp):
def impl(self, x):
return numpy.arctan(x)
def grad(self, (x,), (gz,)):
if gz.type in complex_types:
raise NotImplementedError()
if x.type in float_types:
return gz / (numpy.cast[x.type](1) + sqr(x)),
else:
return None,
def c_code(self, node, name, (x,), (z,), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError('type not supported', type)
return "%(z)s = atan(%(x)s);" % locals()
arctan = ArcTan(upgrade_to_float, name='arctan')
class ArcTan2(BinaryScalarOp):
def impl(self, y, x):
return numpy.arctan2(y, x)
def grad(self, (y, x), (gz,)):
if gz.type in complex_types:
raise NotImplementedError()
if x.type in float_types and y.type in float_types:
return [gz * x / (sqr(x) + sqr(y)),
gz * neg(y) / (sqr(x) + sqr(y))]
else:
return None,
def c_code(self, node, name, (y, x), (z,), sub):
if (node.inputs[0].type in complex_types or
node.inputs[1].type in complex_types):
raise NotImplementedError('type not supported', type)
return "%(z)s = atan2(%(y)s, %(x)s);" % locals()
arctan2 = ArcTan2(upgrade_to_float, name='arctan2')
class Cosh(UnaryScalarOp):
"""
cosh(x) = (exp(x) + exp(-x)) / 2
"""
def impl(self, x):
return numpy.cosh(x)
def grad(self, (x, ), (gz, )):
if x.type in complex_types:
raise NotImplementedError()
if x.type in float_types:
return gz * sinh(x),
else:
return None,
def c_code(self, node, name, (x, ), (z, ), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError('type not supported', type)
return "%(z)s = cosh(%(x)s);" % locals()
cosh = Cosh(upgrade_to_float, name='cosh')
class ArcCosh(UnaryScalarOp):
def impl(self, x):
return numpy.arccosh(x)
def grad(self, (x, ), (gz, )):
if x.type in complex_types:
raise NotImplementedError()
if x.type in float_types:
return gz / sqrt(sqr(x) - numpy.cast[x.type](1)),
else:
return None,
def c_code(self, node, name, (x, ), (z, ), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError('type not supported', type)
return "%(z)s = acosh(%(x)s);" % locals()
arccosh = ArcCosh(upgrade_to_float, name='arccosh')
class Sinh(UnaryScalarOp):
"""
sinh(x) = (exp(x) - exp(-x)) / 2
"""
def impl(self, x):
return numpy.sinh(x)
def grad(self, (x, ), (gz, )):
if x.type in complex_types:
raise NotImplementedError()
if x.type in float_types:
return gz * cosh(x),
else:
return None,
def c_code(self, node, name, (x, ), (z, ), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError('type not supported', type)
return "%(z)s = sinh(%(x)s);" % locals()
sinh = Sinh(upgrade_to_float, name='sinh')
class ArcSinh(UnaryScalarOp):
def impl(self, x):
return numpy.arcsinh(x)
def grad(self, (x, ), (gz, )):
if x.type in complex_types:
raise NotImplementedError()
if x.type in float_types:
return gz / sqrt(sqr(x) + numpy.cast[x.type](1)),
else:
return None,
def c_code(self, node, name, (x, ), (z, ), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError('type not supported', type)
return "%(z)s = asinh(%(x)s);" % locals()
arcsinh = ArcSinh(upgrade_to_float, name='arcsinh')
class Tanh(UnaryScalarOp):
"""
tanh(x) = sinh(x) / cosh(x)
= (exp(2*x) - 1) / (exp(2*x) + 1)
"""
def impl(self, x):
return numpy.tanh(x)
def grad(self, (x, ), (gz, )):
if x.type in complex_types:
raise NotImplementedError()
if x.type in float_types:
return gz * (1 - sqr(tanh(x))),
else:
return None,
def c_code(self, node, name, (x, ), (z, ), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError('type not supported', type)
return "%(z)s = tanh(%(x)s);" % locals()
tanh = Tanh(upgrade_to_float, name='tanh')
class ArcTanh(UnaryScalarOp):
def impl(self, x):
return numpy.arctanh(x)
def grad(self, (x, ), (gz, )):
if x.type in complex_types:
raise NotImplementedError()
if x.type in float_types:
return gz / (numpy.cast[x.type](1) - sqr(x)),
else:
return None,
def c_code(self, node, name, (x, ), (z, ), sub):
if node.inputs[0].type in complex_types:
raise NotImplementedError('type not supported', type)
return "%(z)s = atanh(%(x)s);" % locals()
arctanh = ArcTanh(upgrade_to_float, name='arctanh')
class Real(UnaryScalarOp):
"""Extract the real coordinate of a complex number. """
def impl(self, x):
return numpy.real(x)
def grad(self, (x, ), (gz, )):
return [complex(gz, 0)]
real = Real(real_out, name='real')
class Imag(UnaryScalarOp):
def impl(self, x):
return numpy.imag(x)
def grad(self, (x, ), (gz, )):
if x.type in complex_types:
return [complex(0, gz)]
elif x.type in float_types:
return [second(x, 0)]
else:
return [None]
imag = Imag(real_out, name='imag')
class Angle(UnaryScalarOp):
def impl(self, x):
return numpy.angle(x)
def grad(self, (c, ), (gtheta, )):
# y = x.imag
# r = sqrt(y**2 + x.real**2)
# g = y/r
# if x == 0 and y == 0:
# theta = 0
# elif x >= 0:
# theta = numpy.arcsin(g)
# else:
# theta = -numpy.arcsin(g)+numpy.pi
x = real(c)
y = imag(c)
r = abs(c)
gr = -gtheta * y / (r ** 2 * sqrt(1 - (y / r) ** 2))
gx = gr * x / r
gy = gr * y / r
if c in complex_types:
return [cast(complex(gx, gy), x.type.dtype)]
elif c in float_types:
return [cast(second(x, 0), x.type.dtype)]
else:
return [None]
angle = Angle(specific_out(float64), name='angle')
class Complex(BinaryScalarOp):
@staticmethod
def output_types_preference(x, y):
if x in complex_types:
raise TypeError(x)
if y in complex_types:
raise TypeError(y)
up = Scalar.upcast(x, y)
if up in ('float64', 'int64', 'uint64', 'int32', 'uint32'):
return [complex128]
else:
return [complex64]
def impl(self, x, y):
return numpy.complex(x, y)
def grad(self, (x, y), (gz,)):
return [cast(real(gz), x.type.dtype),
cast(imag(gz), y.type.dtype)]
complex = Complex(name='complex')
class Conj(UnaryScalarOp):
def impl(self, x):
return numpy.conj(x)
conj = Conj(same_out, name='conj')
class ComplexFromPolar(BinaryScalarOp):
@staticmethod
def output_types_preference(x, y):
return Complex.output_types_preference(x, y)
def impl(self, r, theta):
if r < 0:
raise ValueError('polar radius must be non-negative', r)
x = r * numpy.cos(theta)
y = r * numpy.sin(theta)
if x.dtype == 'float32':
return numpy.complex64(numpy.complex(x, y))
else:
return numpy.complex128(numpy.complex(x, y))
def grad(self, (r, theta), (gz,)):
gr = gz * complex_from_polar(1, theta)
gtheta = gz * complex_from_polar(r, -theta)
return [gr, gtheta]
complex_from_polar = ComplexFromPolar(name='complex_from_polar')
class Composite(ScalarOp):
"""
Composite is an Op that takes a graph of scalar operations and
produces c code for the whole graph. Its purpose is to implement loop
fusion.
Composite depends on all the Ops in its graph having C code.
"""
def __str__(self):
return self.name
def make_new_inplace(self, output_types_preference=None, name=None):
"""
This op.__init__ fct don't have the same parameter as other scalar op.
This break the insert_inplace_optimizer optimization.
This fct allow fix patch this.
"""
out = self.__class__(self.inputs, self.outputs)
if name:
out.name = name
else:
name = out.name
super(Composite, out).__init__(output_types_preference, name)
return out
def init_c_code(self):
"""Return the C code for this Composite Op. """
subd = dict(
zip(self.fgraph.inputs,
["%%(i%i)s" % i for i in xrange(len(self.fgraph.inputs))])
+ zip(self.fgraph.outputs,
["%%(o%i)s" % i for i in xrange(len(self.fgraph.outputs))]))
for orphan in self.fgraph.variables: # fgraph.orphans:
if orphan.owner is None and orphan not in self.fgraph.inputs:
if isinstance(orphan, Constant):
subd[orphan] = orphan.type.c_literal(orphan.data)
else:
raise ValueError(
"All orphans in the fgraph to Composite must"
" be Constant instances.")
_c_code = "{\n"
i = 0
j = 0
self.nodenames = ["%(nodename)s_" + ('subnode%i' % j)
for j, n in enumerate(self.fgraph.toposort())]
for j, node in enumerate(self.fgraph.toposort()):
for output in node.outputs:
if output not in subd:
i += 1
name = "V%%(id)s_tmp%i" % i
subd[output] = name
_c_code += "%s %s;\n" % (
output.type.dtype_specs()[1], name)
s = node.op.c_code(node,
self.nodenames[j],
[subd[input] for input in node.inputs],
[subd[output] for output in node.outputs],
dict(fail="%(fail)s",
id="%%(id)s_%i" % j))
_c_code += s
_c_code += "\n"
_c_code += "}\n"
self._c_code = _c_code
def init_py_impls(self):
"""Return a list of functions that compute each output of self
"""
def compose_impl(r):
# this is not optimal at all eg in add(*1 -> mul(x, y), *1)
# it will calculate *1 twice
# it also doesn't follow fgraph.toposort but that's (presumably)
# still correct since we only have scalar ops
if r in self.fgraph.inputs:
idx = self.fgraph.inputs.index(r)
return lambda inputs: inputs[idx]
elif r.owner is None: # in fgraph.orphans:
return lambda inputs: r.data
node = r.owner
producers = [compose_impl(input) for input in node.inputs]
return lambda inputs: node.op.impl(*[p(inputs) for p in producers])
self._impls = [compose_impl(r) for r in self.fgraph.outputs]
def init_name(self):
"""Return a readable string representation of self.fgraph
"""
try:
rval = self.name
except AttributeError:
if 0:
l = []
for n in self.fgraph.toposort():
if hasattr(n.op, "name") and n.op.name is not None:
v = n.op.name
if v.startswith("Composite"):
v = v[len("Composite"):]
else:
v = n.op.__class__.__name__
l.append(v)
rval = "Composite{" + ",".join(l) + "}"
else:
for i, r in enumerate(self.fgraph.inputs):
r.name = 'i%i' % i
for i, r in enumerate(self.fgraph.outputs):
r.name = 'o%i' % i
io = set(self.fgraph.inputs + self.fgraph.outputs)
for i, r in enumerate(self.fgraph.variables):
if r not in io and len(r.clients) > 1:
r.name = 't%i' % i
rval = "Composite{%s}" % str(self.fgraph)
self.name = rval
def init_fgraph(self):
fgraph = FunctionGraph(*gof.graph.clone(self.inputs, self.outputs))
gof.MergeOptimizer().optimize(fgraph)
for node in fgraph.apply_nodes:
if not isinstance(node.op, ScalarOp):
raise ValueError("The fgraph to Composite must be exclusively"
" composed of ScalarOp instances.")
self.fgraph = fgraph
def __init__(self, inputs, outputs):
self.inputs = copy(inputs)
self.outputs = copy(outputs)
self.inputs_type = tuple([input.type for input in inputs])
self.outputs_type = tuple([output.type for output in outputs])
self.nin = len(inputs)
self.nout = len(outputs)
self.init_fgraph() # self.fgraph
self.init_name() # self.name
self.init_c_code() # self._c_code and self.nodenames
self.init_py_impls() # self._impls
def output_types(self, input_types):
if tuple(input_types) != self.inputs_type:
raise TypeError("Wrong types for Composite. Expected %s, got %s."
% (self.inputs_type, tuple(input_types)))
return self.outputs_type
def make_node(self, *inputs):
if (tuple([i.type for i in self.inputs]) ==
tuple([i.type for i in inputs])):
return super(Composite, self).make_node(*inputs)
else:
# Make a new op with the right input type.
assert len(inputs) == self.nin
res = theano.compile.rebuild_collect_shared(
self.outputs,
replace=dict(zip(self.inputs, inputs)),
rebuild_strict=False)
# After rebuild_collect_shared, the Variable in inputs
# are not necessarily in the graph represented by res.
# res[2][0] is a dict that map from the original variable to the
# cloned variable.
cloned_inputs = [res[2][0][i] for i in inputs]
node = Composite(cloned_inputs, res[1]).make_node(*inputs)
return node
def perform(self, node, inputs, output_storage):
for storage, impl in zip(output_storage, self._impls):
storage[0] = impl(inputs)
def impl(self, *inputs):
output_storage = [[None] for i in xrange(self.nout)]
self.perform(None, inputs, output_storage)
return utils.to_return_values([storage[0] for storage in
output_storage])
def grad(self, inputs, output_grads):
raise NotImplementedError("grad is not implemented for Composite")
def c_code(self, node, nodename, inames, onames, sub):
d = dict(zip(["i%i" % i for i in xrange(len(inames))],
inames) +
zip(["o%i" % i for i in xrange(len(onames))],
onames),
**sub)
d['nodename'] = nodename
if not 'id' in sub:
#The use of a dummy id is safe as the code is in a separate block.
#It won't generate conflicting variable name.
d['id'] = '_DUMMY_ID_'
return self._c_code % d
def c_code_cache_version(self):
rval = [3]
for x in self.fgraph.toposort():
xv = x.op.c_code_cache_version()
if xv:
rval.append(xv)
else:
return ()
return tuple(rval)
def c_support_code(self):
rval = []
for subnode in self.fgraph.toposort():
try:
rval.append(subnode.op.c_support_code())
except gof.utils.MethodNotDefined:
pass
# remove duplicate code blocks
return "\n".join(sorted(set(rval)))
def c_support_code_apply(self, node, name):
rval = []
for subnode, subnodename in zip(self.fgraph.toposort(), self.nodenames):
try:
subnode_support_code = subnode.op.c_support_code_apply(
subnode,
subnodename % dict(nodename=name))
if subnode_support_code:
rval.append(subnode_support_code)
except gof.utils.MethodNotDefined:
pass
# there should be no need to remove duplicate code blocks because
# each block should have been specialized for the given nodename.
# Any block that isn't specialized should be returned via
# c_support_code instead of c_support_code_apply.
return "\n".join(rval)
def __eq__(self, other):
if self is other:
return True
if (type(self) != type(other)
or self.nin != other.nin
or self.nout != other.nout):
return False
# see __hash__ for comment on why there is no mention of fgraph
# or module cache key here.
return (self._c_code == other._c_code)
def __hash__(self):
rval = hash((type(self),
self.nin,
self.nout,
self._c_code))
# Note that in general, the configparser settings at the time
# of code generation (__init__) affect the semantics of this Op.
# This function assumes that all relevant info about the configparser
# is embodied in _c_code. So the _c_code, rather than self.fgraph,
# is the signature of the semantics of this Op.
# _c_code is preserved through unpickling, so the Op will not change
# semantics when it is reloaded with different configparser
# settings.
return rval
def __getstate__(self):
rval = dict(self.__dict__)
del rval['_impls']
del rval['fgraph']
return rval
def __setstate__(self, d):
self.__dict__.update(d)
# We must call init to set fgraph and _impls again, as otherwise
# self.perform will not work.
self.init_fgraph()
self.init_py_impls()
assert self._c_code
| return obj.itemsize |
_newclient.py | # -*- test-case-name: twisted.web.test.test_newclient -*-
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.
"""
An U{HTTP 1.1<http://www.w3.org/Protocols/rfc2616/rfc2616.html>} client.
The way to use the functionality provided by this module is to:
- Connect a L{HTTP11ClientProtocol} to an HTTP server
- Create a L{Request} with the appropriate data
- Pass the request to L{HTTP11ClientProtocol.request}
- The returned Deferred will fire with a L{Response} object
- Create a L{IProtocol} provider which can handle the response body
- Connect it to the response with L{Response.deliverBody}
- When the protocol's C{connectionLost} method is called, the response is
complete. See L{Response.deliverBody} for details.
Various other classes in this module support this usage:
- HTTPParser is the basic HTTP parser. It can handle the parts of HTTP which
are symmetric between requests and responses.
- HTTPClientParser extends HTTPParser to handle response-specific parts of
HTTP. One instance is created for each request to parse the corresponding
response.
"""
__metaclass__ = type
from zope.interface import implements
from twisted.python import log
from twisted.python.components import proxyForInterface
from twisted.python.reflect import fullyQualifiedName
from twisted.python.failure import Failure
from twisted.internet.interfaces import IConsumer, IPushProducer
from twisted.internet.error import ConnectionDone
from twisted.internet.defer import Deferred, succeed, fail, maybeDeferred
from twisted.internet.defer import CancelledError
from twisted.internet.protocol import Protocol
from twisted.protocols.basic import LineReceiver
from twisted.web.iweb import UNKNOWN_LENGTH, IResponse, IClientRequest
from twisted.web.http_headers import Headers
from twisted.web.http import NO_CONTENT, NOT_MODIFIED
from twisted.web.http import _DataLoss, PotentialDataLoss
from twisted.web.http import _IdentityTransferDecoder, _ChunkedTransferDecoder
# States HTTPParser can be in
STATUS = 'STATUS'
HEADER = 'HEADER'
BODY = 'BODY'
DONE = 'DONE'
class BadHeaders(Exception):
"""
Headers passed to L{Request} were in some way invalid.
"""
class ExcessWrite(Exception):
"""
The body L{IBodyProducer} for a request tried to write data after
indicating it had finished writing data.
"""
class ParseError(Exception):
"""
Some received data could not be parsed.
@ivar data: The string which could not be parsed.
"""
def __init__(self, reason, data):
Exception.__init__(self, reason, data)
self.data = data
class BadResponseVersion(ParseError):
"""
The version string in a status line was unparsable.
"""
class _WrapperException(Exception):
"""
L{_WrapperException} is the base exception type for exceptions which
include one or more other exceptions as the low-level causes.
@ivar reasons: A list of exceptions. See subclass documentation for more
details.
"""
def __init__(self, reasons):
Exception.__init__(self, reasons)
self.reasons = reasons
class RequestGenerationFailed(_WrapperException):
"""
There was an error while creating the bytes which make up a request.
@ivar reasons: A C{list} of one or more L{Failure} instances giving the
reasons the request generation was considered to have failed.
"""
class RequestTransmissionFailed(_WrapperException):
"""
There was an error while sending the bytes which make up a request.
@ivar reasons: A C{list} of one or more L{Failure} instances giving the
reasons the request transmission was considered to have failed.
"""
class ConnectionAborted(Exception):
"""
The connection was explicitly aborted by application code.
"""
class WrongBodyLength(Exception):
"""
An L{IBodyProducer} declared the number of bytes it was going to
produce (via its C{length} attribute) and then produced a different number
of bytes.
"""
class ResponseDone(Exception):
"""
L{ResponseDone} may be passed to L{IProtocol.connectionLost} on the
protocol passed to L{Response.deliverBody} and indicates that the entire
response has been delivered.
"""
class ResponseFailed(_WrapperException):
"""
L{ResponseFailed} indicates that all of the response to a request was not
received for some reason.
@ivar reasons: A C{list} of one or more L{Failure} instances giving the
reasons the response was considered to have failed.
@ivar response: If specified, the L{Response} received from the server (and
in particular the status code and the headers).
"""
def __init__(self, reasons, response=None):
_WrapperException.__init__(self, reasons)
self.response = response
class ResponseNeverReceived(ResponseFailed):
"""
A L{ResponseFailed} that knows no response bytes at all have been received.
"""
class RequestNotSent(Exception):
"""
L{RequestNotSent} indicates that an attempt was made to issue a request but
for reasons unrelated to the details of the request itself, the request
could not be sent. For example, this may indicate that an attempt was made
to send a request using a protocol which is no longer connected to a
server.
"""
def _callAppFunction(function):
"""
Call C{function}. If it raises an exception, log it with a minimal
description of the source.
@return: C{None}
"""
try:
function()
except:
log.err(None, "Unexpected exception from %s" % (
fullyQualifiedName(function),))
class HTTPParser(LineReceiver):
"""
L{HTTPParser} handles the parsing side of HTTP processing. With a suitable
subclass, it can parse either the client side or the server side of the
connection.
@ivar headers: All of the non-connection control message headers yet
received.
@ivar state: State indicator for the response parsing state machine. One
of C{STATUS}, C{HEADER}, C{BODY}, C{DONE}.
@ivar _partialHeader: C{None} or a C{list} of the lines of a multiline
header while that header is being received.
"""
# NOTE: According to HTTP spec, we're supposed to eat the
# 'Proxy-Authenticate' and 'Proxy-Authorization' headers also, but that
# doesn't sound like a good idea to me, because it makes it impossible to
# have a non-authenticating transparent proxy in front of an authenticating
# proxy. An authenticating proxy can eat them itself. -jknight
#
# Further, quoting
# http://homepages.tesco.net/J.deBoynePollard/FGA/web-proxy-connection-header.html
# regarding the 'Proxy-Connection' header:
#
# The Proxy-Connection: header is a mistake in how some web browsers
# use HTTP. Its name is the result of a false analogy. It is not a
# standard part of the protocol. There is a different standard
# protocol mechanism for doing what it does. And its existence
# imposes a requirement upon HTTP servers such that no proxy HTTP
# server can be standards-conforming in practice.
#
# -exarkun
# Some servers (like http://news.ycombinator.com/) return status lines and
# HTTP headers delimited by \n instead of \r\n.
delimiter = '\n'
CONNECTION_CONTROL_HEADERS = set([
'content-length', 'connection', 'keep-alive', 'te', 'trailers',
'transfer-encoding', 'upgrade', 'proxy-connection'])
def connectionMade(self):
self.headers = Headers()
self.connHeaders = Headers()
self.state = STATUS
self._partialHeader = None
def switchToBodyMode(self, decoder):
"""
Switch to body parsing mode - interpret any more bytes delivered as
part of the message body and deliver them to the given decoder.
"""
if self.state == BODY:
raise RuntimeError("already in body mode")
self.bodyDecoder = decoder
self.state = BODY
self.setRawMode()
def lineReceived(self, line):
"""
Handle one line from a response.
"""
# Handle the normal CR LF case.
if line[-1:] == '\r':
line = line[:-1]
if self.state == STATUS:
self.statusReceived(line)
self.state = HEADER
elif self.state == HEADER:
if not line or line[0] not in ' \t':
if self._partialHeader is not None:
header = ''.join(self._partialHeader)
name, value = header.split(':', 1)
value = value.strip()
self.headerReceived(name, value)
if not line:
# Empty line means the header section is over.
self.allHeadersReceived()
else:
# Line not beginning with LWS is another header.
self._partialHeader = [line]
else:
# A line beginning with LWS is a continuation of a header
# begun on a previous line.
self._partialHeader.append(line)
def rawDataReceived(self, data):
"""
Pass data from the message body to the body decoder object.
"""
self.bodyDecoder.dataReceived(data)
def isConnectionControlHeader(self, name):
"""
Return C{True} if the given lower-cased name is the name of a
connection control header (rather than an entity header).
According to RFC 2616, section 14.10, the tokens in the Connection
header are probably relevant here. However, I am not sure what the
practical consequences of either implementing or ignoring that are.
So I leave it unimplemented for the time being.
"""
return name in self.CONNECTION_CONTROL_HEADERS
def statusReceived(self, status):
"""
Callback invoked whenever the first line of a new message is received.
Override this.
@param status: The first line of an HTTP request or response message
without trailing I{CR LF}.
@type status: C{str}
"""
def headerReceived(self, name, value):
"""
Store the given header in C{self.headers}.
"""
name = name.lower()
if self.isConnectionControlHeader(name):
headers = self.connHeaders
else:
headers = self.headers
headers.addRawHeader(name, value)
def allHeadersReceived(self):
"""
Callback invoked after the last header is passed to C{headerReceived}.
Override this to change to the C{BODY} or C{DONE} state.
"""
self.switchToBodyMode(None)
class HTTPClientParser(HTTPParser):
"""
An HTTP parser which only handles HTTP responses.
@ivar request: The request with which the expected response is associated.
@type request: L{Request}
@ivar NO_BODY_CODES: A C{set} of response codes which B{MUST NOT} have a
body.
@ivar finisher: A callable to invoke when this response is fully parsed.
@ivar _responseDeferred: A L{Deferred} which will be called back with the
response when all headers in the response have been received.
Thereafter, C{None}.
@ivar _everReceivedData: C{True} if any bytes have been received.
"""
NO_BODY_CODES = set([NO_CONTENT, NOT_MODIFIED])
_transferDecoders = {
'chunked': _ChunkedTransferDecoder,
}
bodyDecoder = None
def __init__(self, request, finisher):
self.request = request
self.finisher = finisher
self._responseDeferred = Deferred()
self._everReceivedData = False
def dataReceived(self, data):
"""
Override so that we know if any response has been received.
"""
self._everReceivedData = True
HTTPParser.dataReceived(self, data)
def parseVersion(self, strversion):
"""
Parse version strings of the form Protocol '/' Major '.' Minor. E.g.
'HTTP/1.1'. Returns (protocol, major, minor). Will raise ValueError
on bad syntax.
"""
try:
proto, strnumber = strversion.split('/')
major, minor = strnumber.split('.')
major, minor = int(major), int(minor)
except ValueError, e:
raise BadResponseVersion(str(e), strversion)
if major < 0 or minor < 0:
raise BadResponseVersion("version may not be negative", strversion)
return (proto, major, minor)
def statusReceived(self, status):
"""
Parse the status line into its components and create a response object
to keep track of this response's state.
"""
parts = status.split(' ', 2)
if len(parts) != 3:
raise ParseError("wrong number of parts", status)
try:
statusCode = int(parts[1])
except ValueError:
raise ParseError("non-integer status code", status)
self.response = Response._construct(
self.parseVersion(parts[0]),
statusCode,
parts[2],
self.headers,
self.transport,
self.request)
def _finished(self, rest):
"""
Called to indicate that an entire response has been received. No more
bytes will be interpreted by this L{HTTPClientParser}. Extra bytes are
passed up and the state of this L{HTTPClientParser} is set to I{DONE}.
@param rest: A C{str} giving any extra bytes delivered to this
L{HTTPClientParser} which are not part of the response being
parsed.
"""
self.state = DONE
self.finisher(rest)
def isConnectionControlHeader(self, name):
"""
Content-Length in the response to a HEAD request is an entity header,
not a connection control header.
"""
if self.request.method == 'HEAD' and name == 'content-length':
return False
return HTTPParser.isConnectionControlHeader(self, name)
def allHeadersReceived(self):
"""
Figure out how long the response body is going to be by examining
headers and stuff.
"""
if (self.response.code in self.NO_BODY_CODES
or self.request.method == 'HEAD'):
self.response.length = 0
# The order of the next two lines might be of interest when adding
# support for pipelining.
self._finished(self.clearLineBuffer())
self.response._bodyDataFinished()
else:
transferEncodingHeaders = self.connHeaders.getRawHeaders(
'transfer-encoding')
if transferEncodingHeaders:
# This could be a KeyError. However, that would mean we do not
# know how to decode the response body, so failing the request
# is as good a behavior as any. Perhaps someday we will want
# to normalize/document/test this specifically, but failing
# seems fine to me for now.
transferDecoder = self._transferDecoders[transferEncodingHeaders[0].lower()]
# If anyone ever invents a transfer encoding other than
# chunked (yea right), and that transfer encoding can predict
# the length of the response body, it might be sensible to
# allow the transfer decoder to set the response object's
# length attribute.
else:
contentLengthHeaders = self.connHeaders.getRawHeaders('content-length')
if contentLengthHeaders is None:
contentLength = None
elif len(contentLengthHeaders) == 1:
contentLength = int(contentLengthHeaders[0])
self.response.length = contentLength
else:
# "HTTP Message Splitting" or "HTTP Response Smuggling"
# potentially happening. Or it's just a buggy server.
raise ValueError(
"Too many Content-Length headers; response is invalid")
if contentLength == 0:
self._finished(self.clearLineBuffer())
transferDecoder = None
else:
transferDecoder = lambda x, y: _IdentityTransferDecoder(
contentLength, x, y)
if transferDecoder is None:
self.response._bodyDataFinished()
else:
# Make sure as little data as possible from the response body
# gets delivered to the response object until the response
# object actually indicates it is ready to handle bytes
# (probably because an application gave it a way to interpret
# them).
self.transport.pauseProducing()
self.switchToBodyMode(transferDecoder(
self.response._bodyDataReceived,
self._finished))
# This must be last. If it were first, then application code might
# change some state (for example, registering a protocol to receive the
# response body). Then the pauseProducing above would be wrong since
# the response is ready for bytes and nothing else would ever resume
# the transport.
self._responseDeferred.callback(self.response)
del self._responseDeferred
def connectionLost(self, reason):
if self.bodyDecoder is not None:
try:
try:
self.bodyDecoder.noMoreData()
except PotentialDataLoss:
self.response._bodyDataFinished(Failure())
except _DataLoss:
self.response._bodyDataFinished(
Failure(ResponseFailed([reason, Failure()],
self.response)))
else:
self.response._bodyDataFinished()
except:
# Handle exceptions from both the except suites and the else
# suite. Those functions really shouldn't raise exceptions,
# but maybe there's some buggy application code somewhere
# making things difficult.
log.err()
elif self.state != DONE:
if self._everReceivedData:
exceptionClass = ResponseFailed
else:
exceptionClass = ResponseNeverReceived
self._responseDeferred.errback(Failure(exceptionClass([reason])))
del self._responseDeferred
class Request:
"""
A L{Request} instance describes an HTTP request to be sent to an HTTP
server.
@ivar method: See L{__init__}.
@ivar uri: See L{__init__}.
@ivar headers: See L{__init__}.
@ivar bodyProducer: See L{__init__}.
@ivar persistent: See L{__init__}.
@ivar _parsedURI: Parsed I{URI} for the request, or C{None}.
@type _parsedURI: L{_URI}
"""
implements(IClientRequest)
def __init__(self, method, uri, headers, bodyProducer, persistent=False):
"""
@param method: The HTTP method to for this request, ex: 'GET', 'HEAD',
'POST', etc.
@type method: L{str}
@param uri: The relative URI of the resource to request. For example,
C{'/foo/bar?baz=quux'}.
@type uri: L{str}
@param headers: Headers to be sent to the server. It is important to
note that this object does not create any implicit headers. So it
is up to the HTTP Client to add required headers such as 'Host'.
@type headers: L{twisted.web.http_headers.Headers}
@param bodyProducer: C{None} or an L{IBodyProducer} provider which
produces the content body to send to the remote HTTP server.
@param persistent: Set to C{True} when you use HTTP persistent
connection, defaults to C{False}.
@type persistent: L{bool}
"""
self.method = method
self.uri = uri
self.headers = headers
self.bodyProducer = bodyProducer
self.persistent = persistent
self._parsedURI = None
@classmethod
def _construct(cls, method, uri, headers, bodyProducer, persistent=False,
parsedURI=None):
"""
Private constructor.
@param method: See L{__init__}.
@param uri: See L{__init__}.
@param headers: See L{__init__}.
@param bodyProducer: See L{__init__}.
@param persistent: See L{__init__}.
@param parsedURI: See L{Request._parsedURI}.
@return: L{Request} instance.
"""
request = cls(method, uri, headers, bodyProducer, persistent)
request._parsedURI = parsedURI
return request
@property
def absoluteURI(self):
"""
The absolute URI of the request as C{bytes}, or C{None} if the
absolute URI cannot be determined.
"""
return getattr(self._parsedURI, 'toBytes', lambda: None)()
def _writeHeaders(self, transport, TEorCL):
hosts = self.headers.getRawHeaders('host', ())
if len(hosts) != 1:
raise BadHeaders("Exactly one Host header required")
# In the future, having the protocol version be a parameter to this
# method would probably be good. It would be nice if this method
# weren't limited to issueing HTTP/1.1 requests.
requestLines = []
requestLines.append(
'%s %s HTTP/1.1\r\n' % (self.method, self.uri))
if not self.persistent:
requestLines.append('Connection: close\r\n')
if TEorCL is not None:
requestLines.append(TEorCL)
for name, values in self.headers.getAllRawHeaders():
requestLines.extend(['%s: %s\r\n' % (name, v) for v in values])
requestLines.append('\r\n')
transport.writeSequence(requestLines)
def _writeToChunked(self, transport):
"""
Write this request to the given transport using chunked
transfer-encoding to frame the body.
"""
self._writeHeaders(transport, 'Transfer-Encoding: chunked\r\n')
encoder = ChunkedEncoder(transport)
encoder.registerProducer(self.bodyProducer, True)
d = self.bodyProducer.startProducing(encoder)
def cbProduced(ignored):
encoder.unregisterProducer()
def ebProduced(err):
encoder._allowNoMoreWrites()
# Don't call the encoder's unregisterProducer because it will write
# a zero-length chunk. This would indicate to the server that the
# request body is complete. There was an error, though, so we
# don't want to do that.
transport.unregisterProducer()
return err
d.addCallbacks(cbProduced, ebProduced)
return d
def _writeToContentLength(self, transport):
"""
Write this request to the given transport using content-length to frame
the body.
"""
self._writeHeaders(
transport,
'Content-Length: %d\r\n' % (self.bodyProducer.length,))
# This Deferred is used to signal an error in the data written to the
# encoder below. It can only errback and it will only do so before too
# many bytes have been written to the encoder and before the producer
# Deferred fires.
finishedConsuming = Deferred()
# This makes sure the producer writes the correct number of bytes for
# the request body.
encoder = LengthEnforcingConsumer(
self.bodyProducer, transport, finishedConsuming)
transport.registerProducer(self.bodyProducer, True)
finishedProducing = self.bodyProducer.startProducing(encoder)
def combine(consuming, producing):
# This Deferred is returned and will be fired when the first of
# consuming or producing fires. If it's cancelled, forward that
# cancellation to the producer.
def cancelConsuming(ign):
finishedProducing.cancel()
ultimate = Deferred(cancelConsuming)
# Keep track of what has happened so far. This initially
# contains None, then an integer uniquely identifying what
# sequence of events happened. See the callbacks and errbacks
# defined below for the meaning of each value.
state = [None]
def ebConsuming(err):
if state == [None]:
# The consuming Deferred failed first. This means the
# overall writeTo Deferred is going to errback now. The
# producing Deferred should not fire later (because the
# consumer should have called stopProducing on the
# producer), but if it does, a callback will be ignored
# and an errback will be logged.
state[0] = 1
ultimate.errback(err)
else:
# The consuming Deferred errbacked after the producing
# Deferred fired. This really shouldn't ever happen.
# If it does, I goofed. Log the error anyway, just so
# there's a chance someone might notice and complain.
log.err(
err,
"Buggy state machine in %r/[%d]: "
"ebConsuming called" % (self, state[0]))
def cbProducing(result):
if state == [None]:
# The producing Deferred succeeded first. Nothing will
# ever happen to the consuming Deferred. Tell the
# encoder we're done so it can check what the producer
# wrote and make sure it was right.
state[0] = 2
try:
encoder._noMoreWritesExpected()
except:
# Fail the overall writeTo Deferred - something the
# producer did was wrong.
ultimate.errback()
else:
# Success - succeed the overall writeTo Deferred.
ultimate.callback(None)
# Otherwise, the consuming Deferred already errbacked. The
# producing Deferred wasn't supposed to fire, but it did
# anyway. It's buggy, but there's not really anything to be
# done about it. Just ignore this result.
def ebProducing(err):
if state == [None]:
# The producing Deferred failed first. This means the
# overall writeTo Deferred is going to errback now.
# Tell the encoder that we're done so it knows to reject
# further writes from the producer (which should not
# happen, but the producer may be buggy).
state[0] = 3
encoder._allowNoMoreWrites()
ultimate.errback(err)
else:
# The producing Deferred failed after the consuming
# Deferred failed. It shouldn't have, so it's buggy.
# Log the exception in case anyone who can fix the code
# is watching.
log.err(err, "Producer is buggy")
consuming.addErrback(ebConsuming)
producing.addCallbacks(cbProducing, ebProducing)
return ultimate
d = combine(finishedConsuming, finishedProducing)
def f(passthrough):
# Regardless of what happens with the overall Deferred, once it
# fires, the producer registered way up above the definition of
# combine should be unregistered.
transport.unregisterProducer()
return passthrough
d.addBoth(f)
return d
def writeTo(self, transport):
"""
Format this L{Request} as an HTTP/1.1 request and write it to the given
transport. If bodyProducer is not None, it will be associated with an
L{IConsumer}.
@return: A L{Deferred} which fires with C{None} when the request has
been completely written to the transport or with a L{Failure} if
there is any problem generating the request bytes.
"""
if self.bodyProducer is not None:
if self.bodyProducer.length is UNKNOWN_LENGTH:
return self._writeToChunked(transport)
else:
return self._writeToContentLength(transport)
else:
self._writeHeaders(transport, None)
return succeed(None)
def stopWriting(self):
"""
Stop writing this request to the transport. This can only be called
after C{writeTo} and before the L{Deferred} returned by C{writeTo}
fires. It should cancel any asynchronous task started by C{writeTo}.
The L{Deferred} returned by C{writeTo} need not be fired if this method
is called.
"""
# If bodyProducer is None, then the Deferred returned by writeTo has
# fired already and this method cannot be called.
_callAppFunction(self.bodyProducer.stopProducing)
class LengthEnforcingConsumer:
"""
An L{IConsumer} proxy which enforces an exact length requirement on the
total data written to it.
@ivar _length: The number of bytes remaining to be written.
@ivar _producer: The L{IBodyProducer} which is writing to this
consumer.
@ivar _consumer: The consumer to which at most C{_length} bytes will be
forwarded.
@ivar _finished: A L{Deferred} which will be fired with a L{Failure} if too
many bytes are written to this consumer.
"""
def __init__(self, producer, consumer, finished):
self._length = producer.length
self._producer = producer
self._consumer = consumer
self._finished = finished
def _allowNoMoreWrites(self):
"""
Indicate that no additional writes are allowed. Attempts to write
after calling this method will be met with an exception.
"""
self._finished = None
def write(self, bytes):
"""
Write C{bytes} to the underlying consumer unless
C{_noMoreWritesExpected} has been called or there are/have been too
many bytes.
"""
if self._finished is None:
# No writes are supposed to happen any more. Try to convince the
# calling code to stop calling this method by calling its
# stopProducing method and then throwing an exception at it. This
# exception isn't documented as part of the API because you're
# never supposed to expect it: only buggy code will ever receive
# it.
self._producer.stopProducing()
raise ExcessWrite()
if len(bytes) <= self._length:
self._length -= len(bytes)
self._consumer.write(bytes)
else:
# No synchronous exception is raised in *this* error path because
# we still have _finished which we can use to report the error to a
# better place than the direct caller of this method (some
# arbitrary application code).
_callAppFunction(self._producer.stopProducing)
self._finished.errback(WrongBodyLength("too many bytes written"))
self._allowNoMoreWrites()
def _noMoreWritesExpected(self):
"""
Called to indicate no more bytes will be written to this consumer.
Check to see that the correct number have been written.
@raise WrongBodyLength: If not enough bytes have been written.
"""
if self._finished is not None:
self._allowNoMoreWrites()
if self._length:
raise WrongBodyLength("too few bytes written")
def makeStatefulDispatcher(name, template):
"""
Given a I{dispatch} name and a function, return a function which can be
used as a method and which, when called, will call another method defined
on the instance and return the result. The other method which is called is
determined by the value of the C{_state} attribute of the instance.
@param name: A string which is used to construct the name of the subsidiary
method to invoke. The subsidiary method is named like C{'_%s_%s' %
(name, _state)}.
@param template: A function object which is used to give the returned
function a docstring.
@return: The dispatcher function.
"""
def dispatcher(self, *args, **kwargs):
func = getattr(self, '_' + name + '_' + self._state, None)
if func is None:
raise RuntimeError(
"%r has no %s method in state %s" % (self, name, self._state))
return func(*args, **kwargs)
dispatcher.__doc__ = template.__doc__
return dispatcher
class Response:
"""
A L{Response} instance describes an HTTP response received from an HTTP
server.
L{Response} should not be subclassed or instantiated.
@ivar _transport: See L{__init__}.
@ivar _bodyProtocol: The L{IProtocol} provider to which the body is
delivered. C{None} before one has been registered with
C{deliverBody}.
@ivar _bodyBuffer: A C{list} of the strings passed to C{bodyDataReceived}
before C{deliverBody} is called. C{None} afterwards.
@ivar _state: Indicates what state this L{Response} instance is in,
particularly with respect to delivering bytes from the response body
to an application-suppled protocol object. This may be one of
C{'INITIAL'}, C{'CONNECTED'}, C{'DEFERRED_CLOSE'}, or C{'FINISHED'},
with the following meanings:
- INITIAL: This is the state L{Response} objects start in. No
protocol has yet been provided and the underlying transport may
still have bytes to deliver to it.
- DEFERRED_CLOSE: If the underlying transport indicates all bytes
have been delivered but no application-provided protocol is yet
available, the L{Response} moves to this state. Data is
buffered and waiting for a protocol to be delivered to.
- CONNECTED: If a protocol is provided when the state is INITIAL,
the L{Response} moves to this state. Any buffered data is
delivered and any data which arrives from the transport
subsequently is given directly to the protocol.
- FINISHED: If a protocol is provided in the DEFERRED_CLOSE state,
the L{Response} moves to this state after delivering all
buffered data to the protocol. Otherwise, if the L{Response} is
in the CONNECTED state, if the transport indicates there is no
more data, the L{Response} moves to this state. Nothing else
can happen once the L{Response} is in this state.
"""
implements(IResponse)
length = UNKNOWN_LENGTH
_bodyProtocol = None
_bodyFinished = False
def __init__(self, version, code, phrase, headers, _transport):
"""
@param version: HTTP version components protocol, major, minor. E.g.
C{('HTTP', 1, 1)} to mean C{'HTTP/1.1'}.
@param code: HTTP status code.
@type code: L{int}
@param phrase: HTTP reason phrase, intended to give a short description
of the HTTP status code.
@param headers: HTTP response headers.
@type headers: L{twisted.web.http_headers.Headers}
@param _transport: The transport which is delivering this response.
"""
self.version = version
self.code = code
self.phrase = phrase
self.headers = headers
self._transport = _transport
self._bodyBuffer = []
self._state = 'INITIAL'
self.request = None
self.previousResponse = None
@classmethod
def _construct(cls, version, code, phrase, headers, _transport, request):
"""
Private constructor.
@param version: See L{__init__}.
@param code: See L{__init__}.
@param phrase: See L{__init__}.
@param headers: See L{__init__}.
@param _transport: See L{__init__}.
@param request: See L{IResponse.request}.
@return: L{Response} instance.
"""
response = Response(version, code, phrase, headers, _transport)
response.request = proxyForInterface(IClientRequest)(request)
return response
def setPreviousResponse(self, previousResponse):
self.previousResponse = previousResponse
def deliverBody(self, protocol):
"""
Dispatch the given L{IProtocol} depending of the current state of the
response.
"""
deliverBody = makeStatefulDispatcher('deliverBody', deliverBody)
def _deliverBody_INITIAL(self, protocol):
"""
Deliver any buffered data to C{protocol} and prepare to deliver any
future data to it. Move to the C{'CONNECTED'} state.
"""
# Now that there's a protocol to consume the body, resume the
# transport. It was previously paused by HTTPClientParser to avoid
# reading too much data before it could be handled.
self._transport.resumeProducing()
protocol.makeConnection(self._transport)
self._bodyProtocol = protocol
for data in self._bodyBuffer:
self._bodyProtocol.dataReceived(data)
self._bodyBuffer = None
self._state = 'CONNECTED'
def _deliverBody_CONNECTED(self, protocol):
"""
It is invalid to attempt to deliver data to a protocol when it is
already being delivered to another protocol.
"""
raise RuntimeError(
"Response already has protocol %r, cannot deliverBody "
"again" % (self._bodyProtocol,))
def _deliverBody_DEFERRED_CLOSE(self, protocol):
"""
Deliver any buffered data to C{protocol} and then disconnect the
protocol. Move to the C{'FINISHED'} state.
"""
# Unlike _deliverBody_INITIAL, there is no need to resume the
# transport here because all of the response data has been received
# already. Some higher level code may want to resume the transport if
# that code expects further data to be received over it.
protocol.makeConnection(self._transport)
for data in self._bodyBuffer:
protocol.dataReceived(data)
self._bodyBuffer = None
protocol.connectionLost(self._reason)
self._state = 'FINISHED'
def _deliverBody_FINISHED(self, protocol):
"""
It is invalid to attempt to deliver data to a protocol after the
response body has been delivered to another protocol.
"""
raise RuntimeError(
"Response already finished, cannot deliverBody now.")
def _bodyDataReceived(self, data):
"""
Called by HTTPClientParser with chunks of data from the response body.
They will be buffered or delivered to the protocol passed to
deliverBody.
"""
_bodyDataReceived = makeStatefulDispatcher('bodyDataReceived',
_bodyDataReceived)
def _bodyDataReceived_INITIAL(self, data):
"""
Buffer any data received for later delivery to a protocol passed to
C{deliverBody}.
| Little or no data should be buffered by this method, since the
transport has been paused and will not be resumed until a protocol
is supplied.
"""
self._bodyBuffer.append(data)
def _bodyDataReceived_CONNECTED(self, data):
"""
Deliver any data received to the protocol to which this L{Response}
is connected.
"""
self._bodyProtocol.dataReceived(data)
def _bodyDataReceived_DEFERRED_CLOSE(self, data):
"""
It is invalid for data to be delivered after it has been indicated
that the response body has been completely delivered.
"""
raise RuntimeError("Cannot receive body data after _bodyDataFinished")
def _bodyDataReceived_FINISHED(self, data):
"""
It is invalid for data to be delivered after the response body has
been delivered to a protocol.
"""
raise RuntimeError("Cannot receive body data after protocol disconnected")
def _bodyDataFinished(self, reason=None):
"""
Called by HTTPClientParser when no more body data is available. If the
optional reason is supplied, this indicates a problem or potential
problem receiving all of the response body.
"""
_bodyDataFinished = makeStatefulDispatcher('bodyDataFinished',
_bodyDataFinished)
def _bodyDataFinished_INITIAL(self, reason=None):
"""
Move to the C{'DEFERRED_CLOSE'} state to wait for a protocol to
which to deliver the response body.
"""
self._state = 'DEFERRED_CLOSE'
if reason is None:
reason = Failure(ResponseDone("Response body fully received"))
self._reason = reason
def _bodyDataFinished_CONNECTED(self, reason=None):
"""
Disconnect the protocol and move to the C{'FINISHED'} state.
"""
if reason is None:
reason = Failure(ResponseDone("Response body fully received"))
self._bodyProtocol.connectionLost(reason)
self._bodyProtocol = None
self._state = 'FINISHED'
def _bodyDataFinished_DEFERRED_CLOSE(self):
"""
It is invalid to attempt to notify the L{Response} of the end of the
response body data more than once.
"""
raise RuntimeError("Cannot finish body data more than once")
def _bodyDataFinished_FINISHED(self):
"""
It is invalid to attempt to notify the L{Response} of the end of the
response body data more than once.
"""
raise RuntimeError("Cannot finish body data after protocol disconnected")
class ChunkedEncoder:
"""
Helper object which exposes L{IConsumer} on top of L{HTTP11ClientProtocol}
for streaming request bodies to the server.
"""
implements(IConsumer)
def __init__(self, transport):
self.transport = transport
def _allowNoMoreWrites(self):
"""
Indicate that no additional writes are allowed. Attempts to write
after calling this method will be met with an exception.
"""
self.transport = None
def registerProducer(self, producer, streaming):
"""
Register the given producer with C{self.transport}.
"""
self.transport.registerProducer(producer, streaming)
def write(self, data):
"""
Write the given request body bytes to the transport using chunked
encoding.
@type data: C{str}
"""
if self.transport is None:
raise ExcessWrite()
self.transport.writeSequence(("%x\r\n" % len(data), data, "\r\n"))
def unregisterProducer(self):
"""
Indicate that the request body is complete and finish the request.
"""
self.write('')
self.transport.unregisterProducer()
self._allowNoMoreWrites()
class TransportProxyProducer:
"""
An L{IPushProducer} implementation which wraps another such thing and
proxies calls to it until it is told to stop.
@ivar _producer: The wrapped L{IPushProducer} provider or C{None} after
this proxy has been stopped.
"""
implements(IPushProducer)
# LineReceiver uses this undocumented attribute of transports to decide
# when to stop calling lineReceived or rawDataReceived (if it finds it to
# be true, it doesn't bother to deliver any more data). Set disconnecting
# to False here and never change it to true so that all data is always
# delivered to us and so that LineReceiver doesn't fail with an
# AttributeError.
disconnecting = False
def __init__(self, producer):
self._producer = producer
def _stopProxying(self):
"""
Stop forwarding calls of L{IPushProducer} methods to the underlying
L{IPushProvider} provider.
"""
self._producer = None
def stopProducing(self):
"""
Proxy the stoppage to the underlying producer, unless this proxy has
been stopped.
"""
if self._producer is not None:
self._producer.stopProducing()
def resumeProducing(self):
"""
Proxy the resumption to the underlying producer, unless this proxy has
been stopped.
"""
if self._producer is not None:
self._producer.resumeProducing()
def pauseProducing(self):
"""
Proxy the pause to the underlying producer, unless this proxy has been
stopped.
"""
if self._producer is not None:
self._producer.pauseProducing()
class HTTP11ClientProtocol(Protocol):
"""
L{HTTP11ClientProtocol} is an implementation of the HTTP 1.1 client
protocol. It supports as few features as possible.
@ivar _parser: After a request is issued, the L{HTTPClientParser} to
which received data making up the response to that request is
delivered.
@ivar _finishedRequest: After a request is issued, the L{Deferred} which
will fire when a L{Response} object corresponding to that request is
available. This allows L{HTTP11ClientProtocol} to fail the request
if there is a connection or parsing problem.
@ivar _currentRequest: After a request is issued, the L{Request}
instance used to make that request. This allows
L{HTTP11ClientProtocol} to stop request generation if necessary (for
example, if the connection is lost).
@ivar _transportProxy: After a request is issued, the
L{TransportProxyProducer} to which C{_parser} is connected. This
allows C{_parser} to pause and resume the transport in a way which
L{HTTP11ClientProtocol} can exert some control over.
@ivar _responseDeferred: After a request is issued, the L{Deferred} from
C{_parser} which will fire with a L{Response} when one has been
received. This is eventually chained with C{_finishedRequest}, but
only in certain cases to avoid double firing that Deferred.
@ivar _state: Indicates what state this L{HTTP11ClientProtocol} instance
is in with respect to transmission of a request and reception of a
response. This may be one of the following strings:
- QUIESCENT: This is the state L{HTTP11ClientProtocol} instances
start in. Nothing is happening: no request is being sent and no
response is being received or expected.
- TRANSMITTING: When a request is made (via L{request}), the
instance moves to this state. L{Request.writeTo} has been used
to start to send a request but it has not yet finished.
- TRANSMITTING_AFTER_RECEIVING_RESPONSE: The server has returned a
complete response but the request has not yet been fully sent
yet. The instance will remain in this state until the request
is fully sent.
- GENERATION_FAILED: There was an error while the request. The
request was not fully sent to the network.
- WAITING: The request was fully sent to the network. The
instance is now waiting for the response to be fully received.
- ABORTING: Application code has requested that the HTTP connection
be aborted.
- CONNECTION_LOST: The connection has been lost.
@ivar _abortDeferreds: A list of C{Deferred} instances that will fire when
the connection is lost.
"""
_state = 'QUIESCENT'
_parser = None
_finishedRequest = None
_currentRequest = None
_transportProxy = None
_responseDeferred = None
def __init__(self, quiescentCallback=lambda c: None):
self._quiescentCallback = quiescentCallback
self._abortDeferreds = []
@property
def state(self):
return self._state
def request(self, request):
"""
Issue C{request} over C{self.transport} and return a L{Deferred} which
will fire with a L{Response} instance or an error.
@param request: The object defining the parameters of the request to
issue.
@type request: L{Request}
@rtype: L{Deferred}
@return: The deferred may errback with L{RequestGenerationFailed} if
the request was not fully written to the transport due to a local
error. It may errback with L{RequestTransmissionFailed} if it was
not fully written to the transport due to a network error. It may
errback with L{ResponseFailed} if the request was sent (not
necessarily received) but some or all of the response was lost. It
may errback with L{RequestNotSent} if it is not possible to send
any more requests using this L{HTTP11ClientProtocol}.
"""
if self._state != 'QUIESCENT':
return fail(RequestNotSent())
self._state = 'TRANSMITTING'
_requestDeferred = maybeDeferred(request.writeTo, self.transport)
def cancelRequest(ign):
# Explicitly cancel the request's deferred if it's still trying to
# write when this request is cancelled.
if self._state in (
'TRANSMITTING', 'TRANSMITTING_AFTER_RECEIVING_RESPONSE'):
_requestDeferred.cancel()
else:
self.transport.abortConnection()
self._disconnectParser(Failure(CancelledError()))
self._finishedRequest = Deferred(cancelRequest)
# Keep track of the Request object in case we need to call stopWriting
# on it.
self._currentRequest = request
self._transportProxy = TransportProxyProducer(self.transport)
self._parser = HTTPClientParser(request, self._finishResponse)
self._parser.makeConnection(self._transportProxy)
self._responseDeferred = self._parser._responseDeferred
def cbRequestWrotten(ignored):
if self._state == 'TRANSMITTING':
self._state = 'WAITING'
self._responseDeferred.chainDeferred(self._finishedRequest)
def ebRequestWriting(err):
if self._state == 'TRANSMITTING':
self._state = 'GENERATION_FAILED'
self.transport.abortConnection()
self._finishedRequest.errback(
Failure(RequestGenerationFailed([err])))
else:
log.err(err, 'Error writing request, but not in valid state '
'to finalize request: %s' % self._state)
_requestDeferred.addCallbacks(cbRequestWrotten, ebRequestWriting)
return self._finishedRequest
def _finishResponse(self, rest):
"""
Called by an L{HTTPClientParser} to indicate that it has parsed a
complete response.
@param rest: A C{str} giving any trailing bytes which were given to
the L{HTTPClientParser} which were not part of the response it
was parsing.
"""
_finishResponse = makeStatefulDispatcher('finishResponse', _finishResponse)
def _finishResponse_WAITING(self, rest):
# Currently the rest parameter is ignored. Don't forget to use it if
# we ever add support for pipelining. And maybe check what trailers
# mean.
if self._state == 'WAITING':
self._state = 'QUIESCENT'
else:
# The server sent the entire response before we could send the
# whole request. That sucks. Oh well. Fire the request()
# Deferred with the response. But first, make sure that if the
# request does ever finish being written that it won't try to fire
# that Deferred.
self._state = 'TRANSMITTING_AFTER_RECEIVING_RESPONSE'
self._responseDeferred.chainDeferred(self._finishedRequest)
# This will happen if we're being called due to connection being lost;
# if so, no need to disconnect parser again, or to call
# _quiescentCallback.
if self._parser is None:
return
reason = ConnectionDone("synthetic!")
connHeaders = self._parser.connHeaders.getRawHeaders('connection', ())
if (('close' in connHeaders) or self._state != "QUIESCENT" or
not self._currentRequest.persistent):
self._giveUp(Failure(reason))
else:
# Just in case we had paused the transport, resume it before
# considering it quiescent again.
self.transport.resumeProducing()
# We call the quiescent callback first, to ensure connection gets
# added back to connection pool before we finish the request.
try:
self._quiescentCallback(self)
except:
# If callback throws exception, just log it and disconnect;
# keeping persistent connections around is an optimisation:
log.err()
self.transport.loseConnection()
self._disconnectParser(reason)
_finishResponse_TRANSMITTING = _finishResponse_WAITING
def _disconnectParser(self, reason):
"""
If there is still a parser, call its C{connectionLost} method with the
given reason. If there is not, do nothing.
@type reason: L{Failure}
"""
if self._parser is not None:
parser = self._parser
self._parser = None
self._currentRequest = None
self._finishedRequest = None
self._responseDeferred = None
# The parser is no longer allowed to do anything to the real
# transport. Stop proxying from the parser's transport to the real
# transport before telling the parser it's done so that it can't do
# anything.
self._transportProxy._stopProxying()
self._transportProxy = None
parser.connectionLost(reason)
def _giveUp(self, reason):
"""
Lose the underlying connection and disconnect the parser with the given
L{Failure}.
Use this method instead of calling the transport's loseConnection
method directly otherwise random things will break.
"""
self.transport.loseConnection()
self._disconnectParser(reason)
def dataReceived(self, bytes):
"""
Handle some stuff from some place.
"""
try:
self._parser.dataReceived(bytes)
except:
self._giveUp(Failure())
def connectionLost(self, reason):
"""
The underlying transport went away. If appropriate, notify the parser
object.
"""
connectionLost = makeStatefulDispatcher('connectionLost', connectionLost)
def _connectionLost_QUIESCENT(self, reason):
"""
Nothing is currently happening. Move to the C{'CONNECTION_LOST'}
state but otherwise do nothing.
"""
self._state = 'CONNECTION_LOST'
def _connectionLost_GENERATION_FAILED(self, reason):
"""
The connection was in an inconsistent state. Move to the
C{'CONNECTION_LOST'} state but otherwise do nothing.
"""
self._state = 'CONNECTION_LOST'
def _connectionLost_TRANSMITTING(self, reason):
"""
Fail the L{Deferred} for the current request, notify the request
object that it does not need to continue transmitting itself, and
move to the C{'CONNECTION_LOST'} state.
"""
self._state = 'CONNECTION_LOST'
self._finishedRequest.errback(
Failure(RequestTransmissionFailed([reason])))
del self._finishedRequest
# Tell the request that it should stop bothering now.
self._currentRequest.stopWriting()
def _connectionLost_TRANSMITTING_AFTER_RECEIVING_RESPONSE(self, reason):
"""
Move to the C{'CONNECTION_LOST'} state.
"""
self._state = 'CONNECTION_LOST'
def _connectionLost_WAITING(self, reason):
"""
Disconnect the response parser so that it can propagate the event as
necessary (for example, to call an application protocol's
C{connectionLost} method, or to fail a request L{Deferred}) and move
to the C{'CONNECTION_LOST'} state.
"""
self._disconnectParser(reason)
self._state = 'CONNECTION_LOST'
def _connectionLost_ABORTING(self, reason):
"""
Disconnect the response parser with a L{ConnectionAborted} failure, and
move to the C{'CONNECTION_LOST'} state.
"""
self._disconnectParser(Failure(ConnectionAborted()))
self._state = 'CONNECTION_LOST'
for d in self._abortDeferreds:
d.callback(None)
self._abortDeferreds = []
def abort(self):
"""
Close the connection and cause all outstanding L{request} L{Deferred}s
to fire with an error.
"""
if self._state == "CONNECTION_LOST":
return succeed(None)
self.transport.loseConnection()
self._state = 'ABORTING'
d = Deferred()
self._abortDeferreds.append(d)
return d | |
cache.go | // Copyright Project Contour Authors
// 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.
// Package status holds pieces for handling status updates propagated from
// the DAG back to Kubernetes
package status
import (
contour_api_v1 "github.com/projectcontour/contour/apis/projectcontour/v1"
"github.com/projectcontour/contour/internal/k8s"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/apimachinery/pkg/types"
gatewayapi_v1alpha1 "sigs.k8s.io/gateway-api/apis/v1alpha1"
)
// ConditionType is used to ensure we only use a limited set of possible values
// for DetailedCondition types. It's cast back to a string before sending off to
// HTTPProxy structs, as those use upstream types which we can't alias easily.
type ConditionType string
// ValidCondition is the ConditionType for Valid.
const ValidCondition ConditionType = "Valid"
// NewCache creates a new Cache for holding status updates.
func NewCache(gateway types.NamespacedName) Cache {
return Cache{
proxyUpdates: make(map[types.NamespacedName]*ProxyUpdate),
gatewayRef: gateway,
routeUpdates: make(map[types.NamespacedName]*ConditionsUpdate),
entries: make(map[string]map[types.NamespacedName]CacheEntry),
}
}
type CacheEntry interface {
AsStatusUpdate() k8s.StatusUpdate
ConditionFor(ConditionType) *contour_api_v1.DetailedCondition
}
// Cache holds status updates from the DAG back towards Kubernetes.
// It holds a per-Kind cache, and is intended to be accessed with a
// KindAccessor.
type Cache struct {
proxyUpdates map[types.NamespacedName]*ProxyUpdate
gatewayRef types.NamespacedName
routeUpdates map[types.NamespacedName]*ConditionsUpdate
// Map of cache entry maps, keyed on Kind.
entries map[string]map[types.NamespacedName]CacheEntry
}
// Get returns a pointer to a the cache entry if it exists, nil
// otherwise. The return value is shared between all callers, who
// should take care to cooperate.
func (c *Cache) Get(obj metav1.Object) CacheEntry {
kind := k8s.KindOf(obj)
if _, ok := c.entries[kind]; !ok |
return c.entries[kind][k8s.NamespacedNameOf(obj)]
}
// Put returns an entry to the cache.
func (c *Cache) Put(obj metav1.Object, e CacheEntry) {
kind := k8s.KindOf(obj)
if _, ok := c.entries[kind]; !ok {
c.entries[kind] = make(map[types.NamespacedName]CacheEntry)
}
c.entries[kind][k8s.NamespacedNameOf(obj)] = e
}
// GetStatusUpdates returns a slice of StatusUpdates, ready to be sent off
// to the StatusUpdater by the event handler.
// As more kinds are handled by Cache, we'll update this method.
func (c *Cache) GetStatusUpdates() []k8s.StatusUpdate {
var flattened []k8s.StatusUpdate
for fullname, pu := range c.proxyUpdates {
update := k8s.StatusUpdate{
NamespacedName: fullname,
Resource: contour_api_v1.HTTPProxyGVR,
Mutator: pu,
}
flattened = append(flattened, update)
}
for fullname, routeUpdate := range c.routeUpdates {
update := k8s.StatusUpdate{
NamespacedName: fullname,
Resource: schema.GroupVersionResource{
Group: gatewayapi_v1alpha1.GroupVersion.Group,
Version: gatewayapi_v1alpha1.GroupVersion.Version,
Resource: routeUpdate.Resource,
},
Mutator: routeUpdate,
}
flattened = append(flattened, update)
}
for _, byKind := range c.entries {
for _, e := range byKind {
flattened = append(flattened, e.AsStatusUpdate())
}
}
return flattened
}
// GetProxyUpdates gets the underlying ProxyUpdate objects
// from the cache, used by various things (`internal/contour/metrics.go` and `internal/dag/status_test.go`)
// to retrieve info they need.
// TODO(youngnick)#2969: This could conceivably be replaced with a Walk pattern.
func (c *Cache) GetProxyUpdates() []*ProxyUpdate {
var allUpdates []*ProxyUpdate
for _, pu := range c.proxyUpdates {
allUpdates = append(allUpdates, pu)
}
return allUpdates
}
// GetRouteUpdates gets the underlying ConditionsUpdate objects from the cache.
func (c *Cache) GetRouteUpdates() []*ConditionsUpdate {
var allUpdates []*ConditionsUpdate
for _, conditionsUpdate := range c.routeUpdates {
allUpdates = append(allUpdates, conditionsUpdate)
}
return allUpdates
}
| {
c.entries[kind] = make(map[types.NamespacedName]CacheEntry)
} |
notifications.rs | use crate::ui::components::container::*;
use oxygengine::user_interface::raui::{core::prelude::*, material::prelude::*};
use serde::{Deserialize, Serialize};
use std::collections::VecDeque;
const DEFAULT_DURATION: Scalar = 2.0;
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct NotificationShow {
pub text: String,
pub side: bool,
pub height: Option<Scalar>,
pub duration: Option<Scalar>,
}
#[derive(MessageData, Debug, Clone)]
pub enum NotificationSignal {
None,
Register,
Unregister,
Show(NotificationShow),
}
impl Default for NotificationSignal {
fn default() -> Self {
Self::None
}
}
#[derive(PropsData, Debug, Default, Clone, Serialize, Deserialize)]
pub struct NotificationsState(pub VecDeque<NotificationShow>);
#[derive(PropsData, Debug, Clone, Serialize, Deserialize)]
pub struct NotificationsProps {
#[serde(default)]
pub side_margin: Scalar,
#[serde(default)]
pub side_external_margin: Scalar,
#[serde(default)]
pub side_internal_margin: Scalar,
#[serde(default)]
pub side_default_height: Scalar,
#[serde(default)]
pub external_margin: Scalar,
#[serde(default)]
pub internal_margin: Scalar,
#[serde(default)]
pub default_height: Scalar,
}
impl Default for NotificationsProps {
fn default() -> Self {
Self {
side_margin: 128.0,
side_external_margin: 16.0,
side_internal_margin: 4.0,
side_default_height: 26.0,
external_margin: 64.0,
internal_margin: 16.0,
default_height: 48.0,
}
}
}
fn make_animation(duration: Scalar) -> Animation {
Animation::Sequence(vec![
Animation::Value(AnimatedValue {
name: "fade-in".to_owned(),
duration: 0.25,
}),
Animation::Value(AnimatedValue {
name: "delay".to_owned(),
duration,
}),
Animation::Value(AnimatedValue {
name: "fade-out".to_owned(),
duration: 0.25,
}),
Animation::Message("next".to_owned()),
])
}
fn use_notifications(context: &mut WidgetContext) {
context.life_cycle.mount(|context| {
drop(context.state.write(NotificationsState::default()));
context.signals.write(NotificationSignal::Register);
});
context.life_cycle.unmount(|context| {
context.signals.write(NotificationSignal::Unregister);
});
context.life_cycle.change(|context| {
for msg in context.messenger.messages { | let duration = state
.0
.front()
.unwrap()
.duration
.unwrap_or(DEFAULT_DURATION);
drop(context.animator.change("", Some(make_animation(duration))));
}
drop(context.state.write(state));
} else if let Some(AnimationMessage(msg)) = msg.as_any().downcast_ref() {
if msg == "next" {
let mut state = context.state.read_cloned_or_default::<NotificationsState>();
state.0.pop_front();
if !state.0.is_empty() {
let duration = state
.0
.front()
.unwrap()
.duration
.unwrap_or(DEFAULT_DURATION);
drop(context.animator.change("", Some(make_animation(duration))));
}
drop(context.state.write(state));
}
}
}
});
}
#[pre_hooks(use_notifications)]
pub fn notifications(mut context: WidgetContext) -> WidgetNode {
let WidgetContext {
key,
props,
state,
animator,
..
} = context;
let NotificationsProps {
side_margin,
side_external_margin,
side_internal_margin,
side_default_height,
external_margin,
internal_margin,
default_height,
} = props.read_cloned_or_default();
let phase = {
let a = animator.value_progress_factor_or_zero("", "fade-in");
let b = animator.value_progress_factor_or_zero("", "fade-out");
a - b
};
let item = if let Ok(state) = state.read::<NotificationsState>() {
if let Some(state) = state.0.front() {
let height = state.height.unwrap_or_else(|| {
if state.side {
side_default_height
} else {
default_height
}
});
let mut props = Props::new(ContainerProps {
variant: "dark".to_owned(),
canvas_color: None,
internal_margin: if state.side {
(0.0, 40.0).into()
} else {
0.0.into()
},
..Default::default()
});
if state.side {
props.write(ContentBoxItemLayout {
anchors: Rect {
left: lerp(1.0, 0.0, phase),
right: 1.0,
top: 0.0,
bottom: 0.0,
},
offset: Vec2 {
x: 0.0,
y: side_external_margin,
},
align: Vec2 { x: 1.0, y: 0.0 },
margin: Rect {
left: side_margin,
right: 0.0,
top: 0.0,
bottom: -height,
},
..Default::default()
});
} else {
props.write(ContentBoxItemLayout {
anchors: Rect {
left: 0.0,
right: 1.0,
top: 1.0,
bottom: 1.0,
},
offset: Vec2 {
x: 0.0,
y: -external_margin * phase,
},
align: Vec2 { x: 0.5, y: 1.0 },
margin: Rect {
left: external_margin,
right: external_margin,
top: -height,
..Default::default()
},
..Default::default()
});
}
let size_props = SizeBoxProps {
width: SizeBoxSizeValue::Fill,
height: SizeBoxSizeValue::Fill,
margin: if state.side {
Rect {
left: side_internal_margin,
right: side_internal_margin,
top: side_internal_margin,
bottom: side_internal_margin,
}
} else {
Rect {
left: internal_margin,
right: internal_margin,
top: internal_margin,
bottom: internal_margin,
}
},
..Default::default()
};
let text_props = TextPaperProps {
text: state.text.to_owned(),
variant: "3".to_owned(),
use_main_color: true,
..Default::default()
};
widget! {
(#{"item"} container: {props} | {WidgetAlpha(phase)} [
(#{"wrapper"} size_box: {size_props} {
content = (#{"text"} text_paper: {text_props})
})
])
}
} else {
widget! {()}
}
} else {
widget! {()}
};
widget! {
(#{key} content_box: {props.clone()} [
{item}
])
}
} | if let Some(NotificationSignal::Show(data)) = msg.as_any().downcast_ref() {
let mut state = context.state.read_cloned_or_default::<NotificationsState>();
state.0.push_back(data.clone());
if !context.animator.has("") { |
auth.module.ts | import { Module } from '@nestjs/common';
import { AuthController } from './auth.controller'; | import { PassportModule } from '@nestjs/passport';
import { JwtStrategy } from './jwt-strategy';
@Module({
imports: [
PassportModule.register({ defaultStrategy: 'jwt' }),
JwtModule.register({
secret: 'topSecret',
signOptions: {
expiresIn: 3600,
},
}),
TypeOrmModule.forFeature([UserRepository]), // now we can consume this in the service
],
controllers: [AuthController],
providers: [AuthService, JwtStrategy],
exports: [JwtStrategy, PassportModule], // now this can be used in other modules
})
export class AuthModule {} | import { AuthService } from './auth.service';
import { TypeOrmModule } from '@nestjs/typeorm';
import { UserRepository } from './user.repository';
import { JwtModule } from '@nestjs/jwt'; |
nav.go | package main
import (
"bufio"
"errors"
"fmt"
"io"
"log"
"os"
"os/exec"
"path/filepath"
"sort"
"strconv"
"strings"
"time"
times "gopkg.in/djherbis/times.v1"
)
type linkState byte
const (
notLink linkState = iota
working
broken
)
type file struct {
os.FileInfo
linkState linkState
path string
dirCount int
accessTime time.Time
changeTime time.Time
ext string
}
func readdir(path string) ([]*file, error) {
f, err := os.Open(path)
if err != nil {
return nil, err
}
names, err := f.Readdirnames(-1)
f.Close()
files := make([]*file, 0, len(names))
for _, fname := range names {
fpath := filepath.Join(path, fname)
lstat, err := os.Lstat(fpath)
if os.IsNotExist(err) {
continue
}
if err != nil {
return files, err
}
var linkState linkState
if lstat.Mode()&os.ModeSymlink != 0 {
stat, err := os.Stat(fpath)
if err == nil {
linkState = working
lstat = stat
} else {
linkState = broken
}
}
ts := times.Get(lstat)
at := ts.AccessTime()
var ct time.Time
// from times docs: ChangeTime() panics unless HasChangeTime() is true
if ts.HasChangeTime() {
ct = ts.ChangeTime()
} else {
// fall back to ModTime if ChangeTime cannot be determined
ct = lstat.ModTime()
}
// returns an empty string if extension could not be determined
// i.e. directories, filenames without extensions
ext := filepath.Ext(fpath)
files = append(files, &file{
FileInfo: lstat,
linkState: linkState,
path: fpath,
dirCount: -1,
accessTime: at,
changeTime: ct,
ext: ext,
})
}
return files, err
}
type dir struct {
loading bool // directory is loading from disk
loadTime time.Time // current loading or last load time
ind int // index of current entry in files
pos int // position of current entry in ui
path string // full path of directory
files []*file // displayed files in directory including or excluding hidden ones
allFiles []*file // all files in directory including hidden ones (same array as files)
sortType sortType // sort method and options from last sort
noPerm bool // whether lf has no permission to open the directory
}
func newDir(path string) *dir {
time := time.Now()
files, err := readdir(path)
if err != nil {
log.Printf("reading directory: %s", err)
}
return &dir{
loadTime: time,
path: path,
files: files,
allFiles: files,
noPerm: os.IsPermission(err),
}
}
func (dir *dir) sort() {
dir.sortType = gOpts.sortType
dir.files = dir.allFiles
switch gOpts.sortType.method {
case naturalSort:
sort.SliceStable(dir.files, func(i, j int) bool {
return naturalLess(strings.ToLower(dir.files[i].Name()), strings.ToLower(dir.files[j].Name()))
})
case nameSort:
sort.SliceStable(dir.files, func(i, j int) bool {
return strings.ToLower(dir.files[i].Name()) < strings.ToLower(dir.files[j].Name())
})
case sizeSort:
sort.SliceStable(dir.files, func(i, j int) bool {
return dir.files[i].Size() < dir.files[j].Size()
})
case timeSort:
sort.SliceStable(dir.files, func(i, j int) bool {
return dir.files[i].ModTime().Before(dir.files[j].ModTime())
})
case atimeSort:
sort.SliceStable(dir.files, func(i, j int) bool {
return dir.files[i].accessTime.Before(dir.files[j].accessTime)
})
case ctimeSort:
sort.SliceStable(dir.files, func(i, j int) bool {
return dir.files[i].changeTime.Before(dir.files[j].changeTime)
})
case extSort:
sort.SliceStable(dir.files, func(i, j int) bool {
leftExt := strings.ToLower(dir.files[i].ext)
rightExt := strings.ToLower(dir.files[j].ext)
// if the extension could not be determined (directories, files without)
// use a zero byte so that these files can be ranked higher
if leftExt == "" {
leftExt = "\x00"
}
if rightExt == "" {
rightExt = "\x00"
}
// in order to also have natural sorting with the filenames
// combine the name with the ext but have the ext at the front
left := leftExt + strings.ToLower(dir.files[i].Name())
right := rightExt + strings.ToLower(dir.files[j].Name())
return left < right
})
}
if gOpts.sortType.option&reverseSort != 0 {
for i, j := 0, len(dir.files)-1; i < j; i, j = i+1, j-1 {
dir.files[i], dir.files[j] = dir.files[j], dir.files[i]
}
}
if gOpts.sortType.option&dirfirstSort != 0 {
sort.SliceStable(dir.files, func(i, j int) bool {
if dir.files[i].IsDir() == dir.files[j].IsDir() {
return i < j
}
return dir.files[i].IsDir()
})
}
// when hidden option is disabled, we move hidden files to the
// beginning of our file list and then set the beginning of displayed
// files to the first non-hidden file in the list
if gOpts.sortType.option&hiddenSort == 0 {
sort.SliceStable(dir.files, func(i, j int) bool {
if isHidden(dir.files[i]) && isHidden(dir.files[j]) {
return i < j
}
return isHidden(dir.files[i])
})
for i, f := range dir.files {
if !isHidden(f) {
dir.files = dir.files[i:]
return
}
}
dir.files = dir.files[len(dir.files):]
}
}
func (dir *dir) name() string {
if len(dir.files) == 0 {
return ""
}
return dir.files[dir.ind].Name()
}
func (dir *dir) sel(name string, height int) {
if len(dir.files) == 0 {
dir.ind, dir.pos = 0, 0
return
}
dir.ind = min(dir.ind, len(dir.files)-1)
if dir.files[dir.ind].Name() != name {
for i, f := range dir.files {
if f.Name() == name {
dir.ind = i
break
}
}
}
edge := min(min(height/2, gOpts.scrolloff), len(dir.files)-dir.ind-1)
dir.pos = min(dir.ind, height-edge-1)
}
type nav struct {
dirs []*dir
copyBytes int64
copyTotal int64
copyUpdate int
moveCount int
moveTotal int
moveUpdate int
deleteCount int
deleteTotal int
deleteUpdate int
copyBytesChan chan int64
copyTotalChan chan int64
moveCountChan chan int
moveTotalChan chan int
deleteCountChan chan int
deleteTotalChan chan int
dirChan chan *dir
regChan chan *reg
dirCache map[string]*dir
regCache map[string]*reg
saves map[string]bool
marks map[string]string
renameCache []string
selections map[string]int
selectionInd int
height int
find string
findBack bool
search string
searchBack bool
searchInd int
searchPos int
}
func (nav *nav) loadDir(path string) *dir {
d, ok := nav.dirCache[path]
if !ok {
go func() {
d := newDir(path)
d.sort()
d.ind, d.pos = 0, 0
nav.dirChan <- d
}()
d := &dir{loading: true, path: path, sortType: gOpts.sortType}
nav.dirCache[path] = d
return d
}
s, err := os.Stat(d.path)
if err != nil {
return d
}
switch {
case s.ModTime().After(d.loadTime):
go func() {
d.loadTime = time.Now()
nd := newDir(path)
nd.sort()
nd.sel(d.name(), nav.height)
nav.dirChan <- nd
}()
case d.sortType != gOpts.sortType:
go func() {
d.loading = true
name := d.name()
d.sort()
d.sel(name, nav.height)
d.loading = false
nav.dirChan <- d
}()
}
return d
}
func (nav *nav) getDirs(wd string) {
var dirs []*dir
for curr, base := wd, ""; !isRoot(base); curr, base = filepath.Dir(curr), filepath.Base(curr) {
dir := nav.loadDir(curr)
dir.sel(base, nav.height)
dirs = append(dirs, dir)
}
for i, j := 0, len(dirs)-1; i < j; i, j = i+1, j-1 {
dirs[i], dirs[j] = dirs[j], dirs[i]
}
nav.dirs = dirs
}
func newNav(height int) *nav {
wd, err := os.Getwd()
if err != nil {
log.Printf("getting current directory: %s", err)
}
nav := &nav{
copyBytesChan: make(chan int64, 1024),
copyTotalChan: make(chan int64, 1024),
moveCountChan: make(chan int, 1024),
moveTotalChan: make(chan int, 1024),
deleteCountChan: make(chan int, 1024),
deleteTotalChan: make(chan int, 1024),
dirChan: make(chan *dir),
regChan: make(chan *reg),
dirCache: make(map[string]*dir),
regCache: make(map[string]*reg),
saves: make(map[string]bool),
marks: make(map[string]string),
renameCache: make([]string, 2),
selections: make(map[string]int),
selectionInd: 0,
height: height,
}
nav.getDirs(wd)
return nav
}
func (nav *nav) renew() {
for _, d := range nav.dirs {
go func(d *dir) {
s, err := os.Stat(d.path)
if err != nil {
log.Printf("getting directory info: %s", err)
return
}
if d.loadTime.After(s.ModTime()) {
return
}
d.loadTime = time.Now()
nd := newDir(d.path)
nd.sort()
nav.dirChan <- nd
}(d)
}
for m := range nav.selections {
if _, err := os.Stat(m); os.IsNotExist(err) {
delete(nav.selections, m)
}
}
if len(nav.selections) == 0 {
nav.selectionInd = 0
}
}
func (nav *nav) reload() error {
nav.dirCache = make(map[string]*dir)
nav.regCache = make(map[string]*reg)
wd, err := os.Getwd()
if err != nil {
return fmt.Errorf("getting current directory: %s", err)
}
curr, err := nav.currFile()
nav.getDirs(wd)
if err == nil {
last := nav.dirs[len(nav.dirs)-1]
last.files = append(last.files, curr)
}
return nil
}
func (nav *nav) position() {
path := nav.currDir().path
for i := len(nav.dirs) - 2; i >= 0; i-- {
nav.dirs[i].sel(filepath.Base(path), nav.height)
path = filepath.Dir(path)
}
}
func (nav *nav) preview() {
curr, err := nav.currFile()
if err != nil {
return
}
var reader io.Reader
if len(gOpts.previewer) != 0 {
cmd := exec.Command(gOpts.previewer, curr.path, strconv.Itoa(nav.height))
out, err := cmd.StdoutPipe()
if err != nil {
log.Printf("previewing file: %s", err)
}
if err := cmd.Start(); err != nil {
log.Printf("previewing file: %s", err)
}
defer cmd.Wait()
defer out.Close()
reader = out
} else {
f, err := os.Open(curr.path)
if err != nil {
log.Printf("opening file: %s", err)
}
defer f.Close()
reader = f
}
reg := ®{loadTime: time.Now(), path: curr.path}
buf := bufio.NewScanner(reader)
for i := 0; i < nav.height && buf.Scan(); i++ {
for _, r := range buf.Text() {
if r == 0 {
reg.lines = []string{"\033[7mbinary\033[0m"}
nav.regChan <- reg
return
}
}
reg.lines = append(reg.lines, buf.Text())
}
if buf.Err() != nil {
log.Printf("loading file: %s", buf.Err())
}
nav.regChan <- reg
}
func (nav *nav) loadReg(path string) *reg {
r, ok := nav.regCache[path]
if !ok {
go nav.preview()
r := ®{loading: true, path: path}
nav.regCache[path] = r
return r
}
s, err := os.Stat(r.path)
if err != nil {
return r
}
if s.ModTime().After(r.loadTime) {
r.loadTime = time.Now()
go nav.preview()
}
return r
}
func (nav *nav) sort() {
for _, d := range nav.dirs {
name := d.name()
d.sort()
d.sel(name, nav.height)
}
}
func (nav *nav) up(dist int) {
dir := nav.currDir()
if dir.ind == 0 {
if gOpts.wrapscroll {
nav.bottom()
}
return
}
dir.ind -= dist
dir.ind = max(0, dir.ind)
dir.pos -= dist
edge := min(min(nav.height/2, gOpts.scrolloff), dir.ind)
dir.pos = max(dir.pos, edge)
}
func (nav *nav) down(dist int) {
dir := nav.currDir()
maxind := len(dir.files) - 1
if dir.ind >= maxind {
if gOpts.wrapscroll {
nav.top()
}
return
}
dir.ind += dist
dir.ind = min(maxind, dir.ind)
dir.pos += dist
edge := min(min(nav.height/2, gOpts.scrolloff), maxind-dir.ind)
// use a smaller value when the height is even and scrolloff is maxed
// in order to stay at the same row as much as possible while up/down
edge = min(edge, nav.height/2+nav.height%2-1)
dir.pos = min(dir.pos, nav.height-edge-1)
dir.pos = min(dir.pos, maxind)
}
func (nav *nav) updir() error {
if len(nav.dirs) <= 1 {
return nil
}
dir := nav.currDir()
nav.dirs = nav.dirs[:len(nav.dirs)-1]
if err := os.Chdir(filepath.Dir(dir.path)); err != nil {
return fmt.Errorf("updir: %s", err)
}
return nil
}
func (nav *nav) open() error {
curr, err := nav.currFile()
if err != nil {
return fmt.Errorf("open: %s", err)
}
path := curr.path
dir := nav.loadDir(path)
nav.dirs = append(nav.dirs, dir)
if err := os.Chdir(path); err != nil {
return fmt.Errorf("open: %s", err)
}
return nil
}
func (nav *nav) top() {
dir := nav.currDir()
dir.ind = 0
dir.pos = 0
}
func (nav *nav) bottom() {
dir := nav.currDir()
dir.ind = len(dir.files) - 1
dir.pos = min(dir.ind, nav.height-1)
}
func (nav *nav) toggleSelection(path string) {
if _, ok := nav.selections[path]; ok {
delete(nav.selections, path)
if len(nav.selections) == 0 {
nav.selectionInd = 0
}
} else {
nav.selections[path] = nav.selectionInd
nav.selectionInd++
}
}
func (nav *nav) toggle() {
curr, err := nav.currFile()
if err != nil {
return
}
nav.toggleSelection(curr.path)
nav.down(1)
}
func (nav *nav) invert() {
last := nav.currDir()
for _, f := range last.files {
path := filepath.Join(last.path, f.Name())
nav.toggleSelection(path)
}
}
func (nav *nav) unselect() {
nav.selections = make(map[string]int)
nav.selectionInd = 0
}
func (nav *nav) save(cp bool) error {
list, err := nav.currFileOrSelections()
if err != nil {
return err
}
if err := saveFiles(list, cp); err != nil {
return err
}
nav.saves = make(map[string]bool)
for _, f := range list {
nav.saves[f] = cp
}
return nil
}
func (nav *nav) copyAsync(ui *ui, srcs []string, dstDir string) {
echo := &callExpr{"echoerr", []string{""}, 1}
_, err := os.Stat(dstDir)
if os.IsNotExist(err) {
echo.args[0] = err.Error()
ui.exprChan <- echo
return
}
total, err := copySize(srcs)
if err != nil {
echo.args[0] = err.Error()
ui.exprChan <- echo
return
}
nav.copyTotalChan <- total
nums, errs := copyAll(srcs, dstDir)
errCount := 0
loop:
for {
select {
case n := <-nums:
nav.copyBytesChan <- n
case err, ok := <-errs:
if !ok {
break loop
}
errCount++
echo.args[0] = fmt.Sprintf("[%d] %s", errCount, err)
ui.exprChan <- echo
}
}
nav.copyTotalChan <- -total
if err := remote("send load"); err != nil {
errCount++
echo.args[0] = fmt.Sprintf("[%d] %s", errCount, err)
ui.exprChan <- echo
}
}
func (nav *nav) moveAsync(ui *ui, srcs []string, dstDir string) {
echo := &callExpr{"echoerr", []string{""}, 1}
_, err := os.Stat(dstDir)
if os.IsNotExist(err) {
echo.args[0] = err.Error()
ui.exprChan <- echo
return
}
nav.moveTotalChan <- len(srcs)
errCount := 0
for _, src := range srcs {
nav.moveCountChan <- 1
srcStat, err := os.Stat(src)
if err != nil {
errCount++
echo.args[0] = fmt.Sprintf("[%d] %s", errCount, err)
ui.exprChan <- echo
continue
}
dst := filepath.Join(dstDir, filepath.Base(src))
dstStat, err := os.Stat(dst)
if os.SameFile(srcStat, dstStat) {
errCount++
echo.args[0] = fmt.Sprintf("[%d] rename %s %s: source and destination are the same file", errCount, src, dst)
ui.exprChan <- echo
continue
} else if !os.IsNotExist(err) {
var newPath string
for i := 1; !os.IsNotExist(err); i++ {
newPath = fmt.Sprintf("%s.~%d~", dst, i)
_, err = os.Stat(newPath)
}
dst = newPath
}
if err := os.Rename(src, dst); err != nil {
errCount++
echo.args[0] = fmt.Sprintf("[%d] %s", errCount, err)
ui.exprChan <- echo
}
}
nav.moveTotalChan <- -len(srcs)
if err := remote("send load"); err != nil {
errCount++
echo.args[0] = fmt.Sprintf("[%d] %s", errCount, err)
ui.exprChan <- echo
}
}
func (nav *nav) paste(ui *ui) error {
srcs, cp, err := loadFiles()
if err != nil {
return err
}
if len(srcs) == 0 {
return errors.New("no file in copy/cut buffer")
}
dstDir := nav.currDir().path
if cp {
go nav.copyAsync(ui, srcs, dstDir)
} else {
go nav.moveAsync(ui, srcs, dstDir)
}
if err := saveFiles(nil, false); err != nil {
return fmt.Errorf("clearing copy/cut buffer: %s", err)
}
if err := remote("send sync"); err != nil {
return fmt.Errorf("paste: %s", err)
}
return nil
}
func (nav *nav) del(ui *ui) error {
list, err := nav.currFileOrSelections()
if err != nil {
return err
}
go func() {
echo := &callExpr{"echoerr", []string{""}, 1}
errCount := 0
nav.deleteTotalChan <- len(list)
for _, path := range list {
nav.deleteCountChan <- 1
if err := os.RemoveAll(path); err != nil {
errCount++
echo.args[0] = fmt.Sprintf("[%d] %s", errCount, err)
ui.exprChan <- echo
}
}
nav.deleteTotalChan <- -len(list)
if err := remote("send load"); err != nil {
errCount++
echo.args[0] = fmt.Sprintf("[%d] %s", errCount, err)
ui.exprChan <- echo
}
}()
return nil
}
func (nav *nav) rename() error {
oldPath := nav.renameCache[0]
newPath := nav.renameCache[1]
dir, _ := filepath.Split(newPath)
os.MkdirAll(dir, os.ModePerm)
if _, err := os.Stat(newPath); err == nil { // file exists
if err := os.Remove(newPath); err != nil {
return err
}
}
if err := os.Rename(oldPath, newPath); err != nil {
return err
}
// TODO: change selection
if err := nav.sel(newPath); err != nil {
return err
}
return nil
}
func (nav *nav) sync() error {
list, cp, err := loadFiles()
if err != nil {
return err
}
nav.saves = make(map[string]bool)
for _, f := range list {
nav.saves[f] = cp
}
return nav.readMarks()
}
func (nav *nav) cd(wd string) error {
wd = strings.Replace(wd, "~", gUser.HomeDir, -1)
wd = filepath.Clean(wd)
if !filepath.IsAbs(wd) {
wd = filepath.Join(nav.currDir().path, wd)
}
if err := os.Chdir(wd); err != nil {
return fmt.Errorf("cd: %s", err)
}
nav.getDirs(wd)
return nil
}
func (nav *nav) sel(path string) error {
path = strings.Replace(path, "~", gUser.HomeDir, -1)
path = filepath.Clean(path)
lstat, err := os.Stat(path)
if err != nil {
return fmt.Errorf("select: %s", err)
}
dir := filepath.Dir(path)
if err := nav.cd(dir); err != nil {
return fmt.Errorf("select: %s", err)
}
base := filepath.Base(path)
last := nav.dirs[len(nav.dirs)-1]
if last.loading {
last.files = append(last.files, &file{FileInfo: lstat})
} else {
last.sel(base, nav.height)
}
return nil
}
func (nav *nav) globSel(pattern string, invert bool) error {
curDir := nav.currDir()
anyMatches := false
for i := 0; i < len(curDir.files); i++ {
match, err := filepath.Match(pattern, curDir.files[i].Name())
if err != nil {
return fmt.Errorf("glob-select: %s", err)
}
if match {
anyMatches = true
fpath := filepath.Join(curDir.path, curDir.files[i].Name())
if _, ok := nav.selections[fpath]; ok == invert {
nav.toggleSelection(fpath)
}
}
}
if !anyMatches {
return fmt.Errorf("glob-select: pattern not found: %s", pattern)
}
return nil
}
func findMatch(name, pattern string) bool {
if gOpts.ignorecase |
if gOpts.ignoredia {
lpattern := removeDiacritics(pattern)
if !gOpts.smartdia || lpattern == pattern {
pattern = lpattern
name = removeDiacritics(name)
}
}
if gOpts.anchorfind {
return strings.HasPrefix(name, pattern)
}
return strings.Contains(name, pattern)
}
func (nav *nav) findSingle() int {
count := 0
index := 0
last := nav.currDir()
for i := 0; i < len(last.files); i++ {
if findMatch(last.files[i].Name(), nav.find) {
count++
if count > 1 {
return count
}
index = i
}
}
if count == 1 {
if index > last.ind {
nav.down(index - last.ind)
} else {
nav.up(last.ind - index)
}
}
return count
}
func (nav *nav) findNext() bool {
last := nav.currDir()
for i := last.ind + 1; i < len(last.files); i++ {
if findMatch(last.files[i].Name(), nav.find) {
nav.down(i - last.ind)
return true
}
}
if gOpts.wrapscan {
for i := 0; i < last.ind; i++ {
if findMatch(last.files[i].Name(), nav.find) {
nav.up(last.ind - i)
return true
}
}
}
return false
}
func (nav *nav) findPrev() bool {
last := nav.currDir()
for i := last.ind - 1; i >= 0; i-- {
if findMatch(last.files[i].Name(), nav.find) {
nav.up(last.ind - i)
return true
}
}
if gOpts.wrapscan {
for i := len(last.files) - 1; i > last.ind; i-- {
if findMatch(last.files[i].Name(), nav.find) {
nav.down(i - last.ind)
return true
}
}
}
return false
}
func searchMatch(name, pattern string) (matched bool, err error) {
if gOpts.ignorecase {
lpattern := strings.ToLower(pattern)
if !gOpts.smartcase || lpattern == pattern {
pattern = lpattern
name = strings.ToLower(name)
}
}
if gOpts.ignoredia {
lpattern := removeDiacritics(pattern)
if !gOpts.smartdia || lpattern == pattern {
pattern = lpattern
name = removeDiacritics(name)
}
}
if gOpts.globsearch {
return filepath.Match(pattern, name)
}
return strings.Contains(name, pattern), nil
}
func (nav *nav) searchNext() error {
last := nav.currDir()
for i := last.ind + 1; i < len(last.files); i++ {
matched, err := searchMatch(last.files[i].Name(), nav.search)
if err != nil {
return err
}
if matched {
nav.down(i - last.ind)
return nil
}
}
if gOpts.wrapscan {
for i := 0; i < last.ind; i++ {
matched, err := searchMatch(last.files[i].Name(), nav.search)
if err != nil {
return err
}
if matched {
nav.up(last.ind - i)
return nil
}
}
}
return nil
}
func (nav *nav) searchPrev() error {
last := nav.currDir()
for i := last.ind - 1; i >= 0; i-- {
matched, err := searchMatch(last.files[i].Name(), nav.search)
if err != nil {
return err
}
if matched {
nav.up(last.ind - i)
return nil
}
}
if gOpts.wrapscan {
for i := len(last.files) - 1; i > last.ind; i-- {
matched, err := searchMatch(last.files[i].Name(), nav.search)
if err != nil {
return err
}
if matched {
nav.down(i - last.ind)
return nil
}
}
}
return nil
}
func (nav *nav) removeMark(mark string) error {
if _, ok := nav.marks[mark]; ok {
delete(nav.marks, mark)
return nil
}
return fmt.Errorf("no such mark")
}
func (nav *nav) readMarks() error {
nav.marks = make(map[string]string)
f, err := os.Open(gMarksPath)
if os.IsNotExist(err) {
return nil
}
if err != nil {
return fmt.Errorf("opening marks file: %s", err)
}
defer f.Close()
scanner := bufio.NewScanner(f)
for scanner.Scan() {
toks := strings.SplitN(scanner.Text(), ":", 2)
if _, ok := nav.marks[toks[0]]; !ok {
nav.marks[toks[0]] = toks[1]
}
}
if err := scanner.Err(); err != nil {
return fmt.Errorf("reading marks file: %s", err)
}
return nil
}
func (nav *nav) writeMarks() error {
if err := os.MkdirAll(filepath.Dir(gMarksPath), os.ModePerm); err != nil {
return fmt.Errorf("creating data directory: %s", err)
}
f, err := os.Create(gMarksPath)
if err != nil {
return fmt.Errorf("creating marks file: %s", err)
}
defer f.Close()
var keys []string
for k := range nav.marks {
keys = append(keys, k)
}
sort.Strings(keys)
for _, k := range keys {
_, err = f.WriteString(fmt.Sprintf("%s:%s\n", k, nav.marks[k]))
if err != nil {
return fmt.Errorf("writing marks file: %s", err)
}
}
return nil
}
func (nav *nav) currDir() *dir {
return nav.dirs[len(nav.dirs)-1]
}
func (nav *nav) currFile() (*file, error) {
last := nav.dirs[len(nav.dirs)-1]
if len(last.files) == 0 {
return nil, fmt.Errorf("empty directory")
}
return last.files[last.ind], nil
}
type indexedSelections struct {
paths []string
indices []int
}
func (m indexedSelections) Len() int { return len(m.paths) }
func (m indexedSelections) Swap(i, j int) {
m.paths[i], m.paths[j] = m.paths[j], m.paths[i]
m.indices[i], m.indices[j] = m.indices[j], m.indices[i]
}
func (m indexedSelections) Less(i, j int) bool { return m.indices[i] < m.indices[j] }
func (nav *nav) currSelections() []string {
paths := make([]string, 0, len(nav.selections))
indices := make([]int, 0, len(nav.selections))
for path, index := range nav.selections {
paths = append(paths, path)
indices = append(indices, index)
}
sort.Sort(indexedSelections{paths: paths, indices: indices})
return paths
}
func (nav *nav) currFileOrSelections() (list []string, err error) {
if len(nav.selections) == 0 {
curr, err := nav.currFile()
if err != nil {
return nil, errors.New("no file selected")
}
return []string{curr.path}, nil
}
return nav.currSelections(), nil
}
| {
lpattern := strings.ToLower(pattern)
if !gOpts.smartcase || lpattern == pattern {
pattern = lpattern
name = strings.ToLower(name)
}
} |
32.js | (function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('@carbon/icon-helpers'), require('prop-types'), require('react')) :
typeof define === 'function' && define.amd ? define(['@carbon/icon-helpers', 'prop-types', 'react'], factory) :
(global.QCU132 = factory(global.CarbonIconHelpers,global.PropTypes,global.React));
}(this, (function (iconHelpers,PropTypes,React) { 'use strict';
PropTypes = PropTypes && PropTypes.hasOwnProperty('default') ? PropTypes['default'] : PropTypes;
React = React && React.hasOwnProperty('default') ? React['default'] : React;
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
var defaultStyle = {
"willChange": "transform"
};
var QCU132 = React.forwardRef(function (_ref, ref) {
var className = _ref.className,
children = _ref.children,
style = _ref.style,
tabIndex = _ref.tabIndex,
rest = _objectWithoutProperties(_ref, ["className", "children", "style", "tabIndex"]);
var _getAttributes = iconHelpers.getAttributes(_objectSpread({}, rest, {
tabindex: tabIndex
})),
tabindex = _getAttributes.tabindex,
props = _objectWithoutProperties(_getAttributes, ["tabindex"]);
if (className) {
props.className = className;
}
if (tabindex !== undefined && tabindex !== null) { | }
if (_typeof(style) === 'object') {
props.style = _objectSpread({}, defaultStyle, style);
} else {
props.style = defaultStyle;
}
if (ref) {
props.ref = ref;
}
return React.createElement('svg', props, children, React.createElement('path', {
d: 'M10 23H5a2 2 0 0 1-2-2v-6a2 2 0 0 1 2-2h5v2H5v6h5zm8 0h-4a2 2 0 0 1-2-2V9h2v12h4V9h2v12a2 2 0 0 1-2 2zm9-2V9.01h-5v2h3V21h-3v2h8v-2h-3z'
}));
});
QCU132.displayName = 'QCU132';
QCU132.propTypes = {
'aria-hidden': PropTypes.bool,
'aria-label': PropTypes.string,
'aria-labelledby': PropTypes.string,
className: PropTypes.string,
children: PropTypes.node,
height: PropTypes.number,
preserveAspectRatio: PropTypes.string,
tabIndex: PropTypes.string,
viewBox: PropTypes.string,
width: PropTypes.number,
xmlns: PropTypes.string
};
QCU132.defaultProps = {
width: 32,
height: 32,
viewBox: '0 0 32 32',
xmlns: 'http://www.w3.org/2000/svg',
preserveAspectRatio: 'xMidYMid meet'
};
return QCU132;
}))); | props.tabIndex = tabindex; |
math.py | import builtins
import warnings
import numpy as np
from aesara import config, printing
from aesara import scalar as aes
from aesara.gradient import DisconnectedType
from aesara.graph.basic import Apply, Variable
from aesara.graph.op import COp, Op
from aesara.graph.params_type import ParamsType
from aesara.graph.type import Generic
from aesara.misc.safe_asarray import _asarray
from aesara.printing import pprint
from aesara.scalar.basic import BinaryScalarOp
from aesara.tensor.basic import (
alloc,
arange,
as_tensor_variable,
cast,
concatenate,
constant,
patternbroadcast,
stack,
switch,
)
from aesara.tensor.elemwise import (
CAReduce,
CAReduceDtype,
DimShuffle,
Elemwise,
scalar_elemwise,
)
from aesara.tensor.shape import shape
from aesara.tensor.type import (
complex_dtypes,
continuous_dtypes,
discrete_dtypes,
int_dtypes,
integer_dtypes,
tensor,
uint_dtypes,
)
from aesara.tensor.type_other import NoneConst
from aesara.tensor.utils import as_list
from aesara.tensor.var import TensorConstant, _tensor_py_operators
# We capture the builtins that we are going to replace to follow the numpy API
_abs = builtins.abs
if int(config.tensor__cmp_sloppy) > 1:
# This config variable is a quick-and-dirty way to get low-precision
# comparisons. For a more precise setting of these tolerances set
# them explicitly in your user code by assigning, for example,
# "aesara.tensor.math.float32_atol = ..."
# When config.tensor__cmp_sloppy>1 we are even more sloppy. This is
# useful to test the GPU as they don't use extended precision and
# this cause some difference bigger then the normal sloppy.
float16_atol = 1e-2
float16_rtol = 5e-2
float32_atol = 5e-4
float32_rtol = 1e-3
float64_rtol = 1e-4
float64_atol = 1e-3
elif int(config.tensor__cmp_sloppy):
float16_atol = 5e-3
float16_rtol = 1e-2
float32_atol = 1e-4
float32_rtol = 1e-3
float64_rtol = 1e-4
float64_atol = 1e-3
else:
# If you change those value in test don't forget to put them back
# when the test end. Don't forget the case when the test fail.
float16_atol = 1e-3
float16_rtol = 1e-3
float32_atol = 1e-5
float32_rtol = 1e-5
# defaults in numpy.allclose
# Don't be more strict then numpy rtol
# It cause useless error.
float64_rtol = 1.0000000000000001e-05
float64_atol = 1e-8
def _get_atol_rtol(a, b):
tiny = ("float16",)
narrow = ("float32", "complex64")
if (str(a.dtype) in tiny) or (str(b.dtype) in tiny):
atol = float16_atol
rtol = float16_rtol
elif (str(a.dtype) in narrow) or (str(b.dtype) in narrow):
atol = float32_atol
rtol = float32_rtol
else:
atol = float64_atol
rtol = float64_rtol
return atol, rtol
def _allclose(a, b, rtol=None, atol=None):
a = np.asarray(a)
b = np.asarray(b)
atol_, rtol_ = _get_atol_rtol(a, b)
if rtol is not None:
rtol_ = rtol
if atol is not None:
atol_ = atol
return np.allclose(a, b, atol=atol_, rtol=rtol_)
class MaxAndArgmax(COp):
"""
Calculate the max and argmax over a given axis or over all axes.
"""
nin = 2 # tensor, axis
nout = 2 # max val, max idx
E_axis = "invalid axis"
params_type = Generic()
__props__ = ("axis",)
_f16_ok = True
def __init__(self, axis):
assert isinstance(axis, list)
self.axis = tuple(axis)
def get_params(self, node):
return self.axis
def make_node(self, x):
x = as_tensor_variable(x)
# We keep the original broadcastable flags for dimensions on which
# we do not perform the max / argmax.
all_axes = set(self.axis)
broadcastable = [
b for i, b in enumerate(x.type.broadcastable) if i not in all_axes
]
inputs = [x]
outputs = [
tensor(x.type.dtype, broadcastable, name="max"),
tensor("int64", broadcastable, name="argmax"),
]
return Apply(self, inputs, outputs)
def perform(self, node, inp, outs, params):
x = inp[0]
axes = params
max, max_idx = outs
if axes is None:
axes = tuple(range(x.ndim))
else:
axes = tuple(int(ax) for ax in axes)
max[0] = _asarray(np.max(x, axes), dtype=node.outputs[0].dtype)
# Numpy does not support multiple axes for argmax
# Work around
keep_axes = np.array([i for i in range(x.ndim) if i not in axes], dtype="int64")
# Not-reduced axes in front
transposed_x = np.transpose(x, np.concatenate((keep_axes, axes)))
kept_shape = transposed_x.shape[: len(keep_axes)]
reduced_shape = transposed_x.shape[len(keep_axes) :]
# Numpy.prod returns 1.0 when arg is empty, so we cast it to int64
# Otherwise reshape would complain citing float arg
new_shape = kept_shape + (np.prod(reduced_shape, dtype="int64"),)
reshaped_x = transposed_x.reshape(new_shape)
max_idx[0] = _asarray(np.argmax(reshaped_x, axis=-1), dtype="int64")
def c_code(self, node, name, inp, out, sub):
if len(self.axis) != 1 and len(self.axis) != node.inputs[0].ndim:
raise NotImplementedError(
"NumPy C-API can compute max and argmax only for 1 axis or for all axes."
)
x = inp[0]
axis = sub["params"]
max, argmax = out
fail = sub["fail"]
ret = """
#if PY_MAJOR_VERSION >= 3
#ifndef PyInt_AS_LONG
#define PyInt_AS_LONG PyLong_AS_LONG
#endif
#endif
int axis;
if (PyTuple_GET_SIZE(%(axis)s) == PyArray_NDIM(%(x)s)) {
axis = NPY_MAXDIMS;
} else if(PyTuple_GET_SIZE(%(axis)s) == 1) {
PyObject* axis_object = PyTuple_GET_ITEM(%(axis)s, 0);
axis = (int)PyInt_AS_LONG(axis_object);
if (axis > PyArray_NDIM(%(x)s)-1 || axis < -PyArray_NDIM(%(x)s)) {
PyErr_SetString(PyExc_ValueError,
"MaxAndArgmax: bad axis argument");
%(fail)s
}
} else {
PyErr_SetString(PyExc_NotImplementedError,
"MaxAndArgmax: NumPy C-API can compute max and argmax only for 1 axis or for all axes.");
%(fail)s
}
Py_CLEAR(%(max)s);
Py_CLEAR(%(argmax)s);//todo pass them as out parameter.
%(max)s = (PyArrayObject*)PyArray_Max(%(x)s, axis, NULL);
if (%(max)s == NULL) {
%(fail)s;
}
if (!PyArray_CheckExact(%(max)s)) {
%(max)s = (PyArrayObject*)PyArray_FromAny((PyObject*)%(max)s, NULL, 0, 0, NPY_ARRAY_ENSUREARRAY, NULL);
if(%(max)s == NULL){
%(fail)s;
}
}
%(argmax)s = (PyArrayObject*)PyArray_ArgMax(%(x)s, axis, NULL);
if (%(argmax)s == NULL) {
Py_CLEAR(%(max)s);
%(fail)s;
}
if (!PyArray_CheckExact(%(argmax)s)) {
%(argmax)s = (PyArrayObject*)PyArray_FromAny((PyObject*)%(argmax)s, NULL, 0, 0, NPY_ARRAY_ENSUREARRAY, NULL);
if(%(argmax)s == NULL){
%(fail)s;
}
}
if (PyArray_TYPE(%(argmax)s) != NPY_INT64) {
PyObject * tmp = PyArray_Cast(%(argmax)s, NPY_INT64);
if (NULL == tmp){
%(fail)s;
}
Py_DECREF(%(argmax)s);
%(argmax)s = (PyArrayObject*)tmp;
}
"""
return ret % locals()
def c_code_cache_version(self):
return (5,)
def infer_shape(self, fgraph, node, shapes):
ishape = shapes[0]
rval = tuple(
ishape[i]
for (i, b) in enumerate(node.inputs[0].type.broadcastable)
if i not in self.axis
)
return [rval, rval]
def R_op(self, inputs, eval_points):
if eval_points[0] is None:
return [None, None]
if len(self.axis) != 1:
raise ValueError("R_op supported for arg_max only for " "one axis!")
if self.axis[0] > 1:
raise ValueError("R_op supported for arg_max only when " " axis is 0 or 1")
if inputs[0].ndim != 2:
raise ValueError(
"R_op supported for arg_max only when " " input is a matrix"
)
max_vals, max_pos = self.make_node(*inputs).outputs
if self.axis[0] == 0:
return [eval_points[0][max_pos, arange(eval_points[0].shape[1])], None]
else:
return [eval_points[0][arange(eval_points[0].shape[0]), max_pos], None]
def grad(self, inp, grads):
# The strict sense mathematical gradient of the maximum function is
# not calculated here for it is not defined at every point where some
# coordinates are identical. However, since the latter set has null
# Lebesgue measure, the result may be interpreted as weak gradient.
# @note: This function should work correctly for L{vector}s.
# (x, y), (gz, gw)
# gz*dz/dx + gw*dw/dx, gz*dz/dy + gw*dw/dy
# gMax * dMax/dx + gArgMax * dArgMax/dx,
# gMax * dMax/daxis + gArgMax * dArgMax/daxis
# g_max has one less dimension than x, so you need to complete
# g_max to x's shape when axis=0 the broadcasting mechanism
# does it automatically
x = inp[0]
axis = as_tensor_variable(self.axis)
g_max, g_max_idx = grads
g_max_disconnected = isinstance(g_max.type, DisconnectedType)
g_max_idx_disconnected = isinstance(g_max_idx.type, DisconnectedType)
# if the op is totally disconnected, so are its inputs
if g_max_disconnected and g_max_idx_disconnected:
return [DisconnectedType()(), DisconnectedType()()]
# if the max is disconnected but the argmax is not,
# the gradient on its inputs is zero
if g_max_disconnected:
return [x.zeros_like()]
if NoneConst.equals(axis):
axis_ = list(range(x.ndim))
else:
axis_ = axis
xmax = max(x, axis_)
# Raise the g_max and xmax to the same number of dim as the input.
pattern = []
out_dim = 0
if NoneConst.equals(axis):
# We are taking the max/argmax over all dimensions.
axis = None
for i in range(x.ndim):
if axis is None or i in axis.data:
pattern.append("x")
else:
pattern.append(out_dim)
out_dim += 1
g_max_pad = DimShuffle(g_max.broadcastable, pattern)(g_max)
xmax_pad = DimShuffle(xmax.broadcastable, pattern)(xmax)
# Set the grad to the correct position.
g_x = eq(xmax_pad, x) * g_max_pad
return (g_x,)
class Argmax(COp):
"""
Calculate the argmax over a given axis or over all axes.
"""
nin = 2 # tensor, axis
nout = 1
E_axis = "invalid axis"
__props__ = ("axis",)
_f16_ok = True
params_type = ParamsType(c_axis=aes.int64)
def __init__(self, axis):
if axis is not None:
axis = tuple(axis)
self.axis = tuple(axis)
def get_params(self, node):
if self.axis is not None and len(self.axis) == 1:
c_axis = np.int64(self.axis[0])
else:
# The value here doesn't matter, it won't be used
c_axis = np.int64(-1)
return self.params_type.get_params(c_axis=c_axis)
def make_node(self, x, axis=None):
x = as_tensor_variable(x)
if self.axis is None:
all_axes = list(range(x.ndim))
else:
all_axes = self.axis
inputs = [x]
# We keep the original broadcastable flags for dimensions on which
# we do not perform the argmax.
broadcastable = [
b for i, b in enumerate(x.type.broadcastable) if i not in all_axes
]
outputs = [tensor("int64", broadcastable, name="argmax")]
return Apply(self, inputs, outputs)
def prepare_node(self, node, storage_map, compute_map, impl):
if len(node.inputs) == 2:
raise ValueError(
"You are trying to compile a graph with an old Argmax node. Either reoptimize your graph or rebuild it to get the new node format."
)
def perform(self, node, inp, outs, params):
(x,) = inp
axes = self.axis
(max_idx,) = outs
if axes is None:
axes = tuple(range(x.ndim))
# Numpy does not support multiple axes for argmax
# Work around
keep_axes = np.array([i for i in range(x.ndim) if i not in axes], dtype="int64")
# Not-reduced axes in front
transposed_x = np.transpose(x, np.concatenate((keep_axes, axes)))
kept_shape = transposed_x.shape[: len(keep_axes)]
reduced_shape = transposed_x.shape[len(keep_axes) :]
new_shape = kept_shape + (np.prod(reduced_shape),)
reshaped_x = transposed_x.reshape(new_shape)
max_idx[0] = _asarray(np.argmax(reshaped_x, axis=-1), dtype="int64")
def c_code(self, node, name, inp, out, sub):
(x,) = inp
(argmax,) = out
fail = sub["fail"]
params = sub["params"]
if self.axis is None:
axis_code = "axis = NPY_MAXDIMS;"
else:
if len(self.axis) > 1:
raise NotImplementedError()
# params is only used here for now
axis_code = (
"""
axis = %(params)s->c_axis;
if(axis > PyArray_NDIM(%(x)s)-1 || axis < -PyArray_NDIM(%(x)s)){
PyErr_SetString(PyExc_ValueError,
"Argmax, bad axis argument");
%(fail)s
}
"""
% locals()
)
ret = """
int axis;
Py_CLEAR(%(argmax)s);//todo pass them as out parameter.
%(axis_code)s
%(argmax)s = (PyArrayObject*)PyArray_ArgMax(%(x)s, axis, NULL);
if(%(argmax)s == NULL){
%(fail)s;
}
if(!PyArray_CheckExact(%(argmax)s)){
%(argmax)s = (PyArrayObject*)PyArray_FromAny((PyObject*)%(argmax)s, NULL, 0, 0, NPY_ARRAY_ENSUREARRAY, NULL);
if(%(argmax)s == NULL){
%(fail)s;
}
}
if(PyArray_TYPE(%(argmax)s) != NPY_INT64){
PyObject * tmp = PyArray_Cast(%(argmax)s, NPY_INT64);
if (NULL == tmp){
%(fail)s;
}
Py_DECREF(%(argmax)s);
%(argmax)s = (PyArrayObject*)tmp;
}
"""
return ret % locals()
def c_code_cache_version(self):
return (1,)
def infer_shape(self, fgraph, node, shapes):
(ishape,) = shapes
if self.axis is None:
return [()]
rval = tuple(
[
ishape[i]
for (i, b) in enumerate(node.inputs[0].type.broadcastable)
if i not in self.axis
]
)
return [rval]
def grad(self, inp, grads):
(x,) = inp
return [x.zeros_like()]
def makeKeepDims(x, y, axis):
"""
Reintroduces in y with length one the axes of x which have been left out
in a prior reduction of x. With this option, the resulting tensor will
broadcast correctly against the original tensor x.
"""
x = as_tensor_variable(x)
y = as_tensor_variable(y)
if axis is None:
axis = list(range(x.type.ndim))
elif isinstance(axis, (int, np.integer)):
axis = [axis]
elif isinstance(axis, np.ndarray) and axis.ndim == 0:
axis = [int(axis)]
else:
axis = [int(a) for a in axis]
newaxis = []
for a in axis:
if not isinstance(a, int):
raise ValueError("keepdims option can be used only with constant axis")
if a < 0:
a += x.type.ndim
newaxis.append(a)
i = 0
new_dims = []
for j, _ in enumerate(x.type.broadcastable):
if j in newaxis:
new_dims.append("x")
else:
new_dims.append(i)
i += 1
return DimShuffle(y.type.broadcastable, new_dims)(y)
def check_and_normalize_axes(x, axis):
"""Check axes, normalize and convert them to a Python list of integers.
Parameters
----------
x: TensorVariable
axis: int, tuple or list of integers
Returns
-------
axis: list of integers
Return an empty list if argument is None.
"""
x = as_tensor_variable(x)
if axis is None:
axis = []
elif isinstance(axis, (int, np.integer)) or (
isinstance(axis, np.ndarray) and axis.ndim == 0
):
axis = [int(axis)]
elif isinstance(axis, (tuple, list, np.ndarray)):
axis = [int(i) for i in axis]
elif isinstance(axis, Variable):
if NoneConst.equals(axis):
axis = []
elif not isinstance(axis, TensorConstant):
raise TypeError(f"Computation needs a constant axis. Got {axis}")
else:
assert axis.dtype in integer_dtypes
if isinstance(axis.data, (int, np.integer)) or (
isinstance(axis.data, np.ndarray) and axis.data.ndim == 0
):
axis = [int(axis.data)]
elif isinstance(axis.data, (list, np.ndarray)):
axis = [int(i) for i in axis.data]
else:
raise TypeError(
f"Axis must be an integer, tuple, list of integers or a TensorVariable. Got {axis}"
)
if len(axis) > 0:
for i in range(len(axis)):
if axis[i] < 0:
axis[i] += x.type.ndim
if axis[i] < 0 or axis[i] >= x.type.ndim:
raise ValueError(
f"Computation needs a valid axis number for {int(x.type.ndim)}-D tensor. Got {int(axis[i])}"
)
axis = list(set(axis))
axis.sort()
return axis
def max_and_argmax(a, axis=None, keepdims=False):
"""
Returns maximum elements and their indices obtained by iterating over
given axis.
When axis is None (the default value), the max is performed
over the flattened tensor.
Parameters
----------
keepdims : bool
If this is set to True, the axes which are reduced are left in
the result as dimensions with size one. With this option, the result
will broadcast correctly against the original tensor.
"""
# Check axis and convert it to a Python list of integers.
# Axis will be used as an op param of MaxAndArgmax.
a = as_tensor_variable(a)
axis = check_and_normalize_axes(a, axis)
if len(axis) == 0:
axis = list(range(a.type.ndim))
out, argout = MaxAndArgmax(axis)(a)
if keepdims:
out = makeKeepDims(a, out, axis)
argout = makeKeepDims(a, argout, axis)
return [out, argout]
class NonZeroCAReduce(CAReduce):
def _c_all(self, node, name, inames, onames, sub):
decl, checks, alloc, loop, end = super()._c_all(node, name, inames, onames, sub)
# We add an additional check for zero-sized dimensions (This seems like
# something that could enabled in `elemwise_cgen.make_checks`.)
iname = inames[0]
axis = self.axis
if axis is None:
axis = list(range(len(node.inputs[0].type.broadcastable)))
pattern = [0] * len(node.inputs[0].broadcastable)
for i in axis:
pattern[i] = 1
pattern_ = str(pattern)[1:-1]
decl += f"""int tosum[]={{{pattern_}}};"""
alloc += f"""
for(int i=0;i<PyArray_NDIM({iname});i++){{
if(PyArray_DIMS({iname})[i]==0 && tosum[i]){{
PyErr_Format(PyExc_ValueError,
"Input of CAReduce{{{node.op.scalar_op}}} has zero-size on axis %%d",i);
{sub["fail"]};
}}
}}
"""
return decl, checks, alloc, loop, end
class Max(NonZeroCAReduce):
nfunc_spec = ("max", 1, 1)
def __init__(self, axis):
super().__init__(aes.scalar_maximum, axis)
class Min(NonZeroCAReduce):
nfunc_spec = ("min", 1, 1)
def __init__(self, axis):
super().__init__(aes.scalar_minimum, axis)
def max(x, axis=None, keepdims=False):
"""
Returns maximum elements obtained by iterating over given axis.
When axis is None (the default value), the max is performed
over the flattened tensor.
Parameters
----------
keepdims: bool
If this is set to True, the axes which are reduced are left in
the result as dimensions with size one. With this option, the result
will broadcast correctly against the original tensor.
Notes
-----
We return an error as numpy when we reduce a dim with a shape of 0.
"""
# We have a choice of implementing this call with the
# CAReduce op or the MaxAndArgmax op.
# MaxAndArgmax supports grad and Rop, so we prefer to use that.
# CAReduce is faster, but optimizations will replace MaxAndArgmax[0]
# with CAReduce at compile time, so at this stage the important
# thing is supporting all user interface features, not speed.
# Some cases can be implemented only with CAReduce.
# We thus prefer to use MaxAndArgmax, if possible. It does not
# support all axis arguments, so we may need to fall back to CAReduce.
try:
out = max_and_argmax(x, axis)[0]
except Exception:
out = Max(axis)(x)
if keepdims:
out = makeKeepDims(x, out, axis)
return out
def argmax(x, axis=None, keepdims=False):
"""
Returns indices of maximum elements obtained by iterating over given axis.
When axis is None (the default value), the argmax is performed
over the flattened tensor.
Parameters
----------
keepdims : bool
If this is set to True, the axes which are reduced are left in
the result as dimensions with size one. With this option, the result
will broadcast correctly against the original tensor.
"""
argout = max_and_argmax(x, axis)[1]
if keepdims:
argout = makeKeepDims(x, argout, axis)
return argout
def min(x, axis=None, keepdims=False):
"""
Returns minimum elements obtained by iterating over given axis.
When axis is None (the default value), the min is performed
over the flattened tensor.
Parameters
----------
keepdims: bool
If this is set to True, the axes which are reduced are left in
the result as dimensions with size one. With this option, the result
will broadcast correctly against the original tensor.
"""
x = as_tensor_variable(x)
str_x_type = str(x.dtype)
if str_x_type.startswith("float") or str_x_type in int_dtypes:
return -max(-x, axis=axis, keepdims=keepdims)
elif str_x_type in uint_dtypes:
itype = np.iinfo(x.dtype)
max_val = np.array(itype.max, dtype=itype.dtype)
return max_val - max(max_val - x, axis=axis, keepdims=keepdims)
elif str_x_type == "bool":
return ~max(~x, axis=axis, keepdims=keepdims)
else:
# Be careful about unsigned integers, complex
raise NotImplementedError()
def argmin(x, axis=None, keepdims=False):
"""
Returns indices of minimum elements obtained by iterating over given axis.
When axis is None (the default value), the argmin is performed
over the flattened tensor.
Parameters
----------
keepdims: bool
If this is set to True, the axes which are reduced are left in
the result as dimensions with size one. With this option, the result
will broadcast correctly against the original tensor.
"""
x = as_tensor_variable(x)
str_x_type = str(x.dtype)
if str_x_type.startswith("float") or str_x_type in int_dtypes:
return argmax(-x, axis=axis, keepdims=keepdims)
elif str_x_type in uint_dtypes:
itype = np.iinfo(x.dtype)
return argmax(itype.max - x, axis=axis, keepdims=keepdims)
elif str_x_type == "bool":
return argmax(~x, axis=axis, keepdims=keepdims)
else:
# Be careful about unsigned integers, complex
raise NotImplementedError()
def smallest(*args):
"""
Return the [elementwise] smallest of a variable number of arguments.
Like python's min.
"""
if len(args) == 2:
a, b = args
return switch(a < b, a, b)
else:
return min(stack(args), axis=0)
def largest(*args):
"""
Return the [elementwise] largest of a variable number of arguments.
Like python's max.
"""
if len(args) == 2:
a, b = args
return switch(a > b, a, b)
else:
return max(stack(args), axis=0)
@scalar_elemwise
def lt(a, b):
"""a < b"""
@scalar_elemwise
def gt(a, b):
"""a > b"""
@scalar_elemwise
def le(a, b):
"""a <= b"""
@scalar_elemwise
def ge(a, b):
"""a >= b"""
@scalar_elemwise
def eq(a, b):
"""a == b"""
@scalar_elemwise
def neq(a, b):
"""a != b"""
@scalar_elemwise
def isnan(a):
"""isnan(a)"""
# Rename isnan to isnan_ to allow to bypass it when not needed.
# glibc 2.23 don't allow isnan on int, so we remove it from the graph.
isnan_ = isnan
def isnan(a):
"""isnan(a)"""
a = as_tensor_variable(a)
if a.dtype in discrete_dtypes:
return alloc(
np.asarray(False, dtype="bool"), *[a.shape[i] for i in range(a.ndim)]
)
return isnan_(a)
@scalar_elemwise
def isinf(a):
"""isinf(a)"""
# Rename isnan to isnan_ to allow to bypass it when not needed.
# glibc 2.23 don't allow isnan on int, so we remove it from the graph.
isinf_ = isinf
def isinf(a):
"""isinf(a)"""
a = as_tensor_variable(a)
if a.dtype in discrete_dtypes:
return alloc(
np.asarray(False, dtype="bool"), *[a.shape[i] for i in range(a.ndim)]
)
return isinf_(a)
def allclose(a, b, rtol=1.0e-5, atol=1.0e-8, equal_nan=False):
"""
Implement Numpy's ``allclose`` on tensors.
``absolute(a - b) <= (atol + rtol * absolute(b))``
Parameters
----------
a : tensor
Input to compare.
b : tensor
Input to compare.
rtol : float
The relative tolerance parameter.
atol : float
The absolute tolerance parameter.
equal_nan: bool
Whether to consider nan's in the same place to be close.
Returns
-------
bool
A boolean value (of type int8 returned by the tensor elementwise `all`
function) whether all elements in a and b are in the tolerance range
defined above.
Notes
-----
Not a symmetric equation. See Numpy's documentation.
"""
return all(isclose(a, b, rtol, atol, equal_nan))
def isclose(a, b, rtol=1.0e-5, atol=1.0e-8, equal_nan=False):
"""
Implements Numpy's ``isclose`` on tensors.
The tolerance values are positive, typically very small numbers. The
relative difference (`rtol` * abs(`b`)) and the absolute difference
`atol` are added together to compare against the absolute difference
between `a` and `b`.
``absolute(a - b) <= (atol + rtol * absolute(b))``
Parameters
----------
a : tensor
Input to compare.
b : tensor
Input to compare.
rtol : float
The relative tolerance parameter.
atol : float
The absolute tolerance parameter.
equal_nan : bool
Whether to consider nan's in the same place to be close
Returns
-------
int8
A boolean (int8) array where two arrays are element-wise equal
within a tolerance.
Notes
-----
Not a symmetric equation. See Numpy's documentation.
Examples
--------
>>> import aesara
>>> import numpy as np
>>> a = _asarray([1e10, 1e-7], dtype="float64")
>>> b = _asarray([1.00001e10, 1e-8], dtype="float64")
>>> aesara.tensor.isclose(a, b).eval()
array([1, 0], dtype=int8)
>>> a = _asarray([1e10, 1e-8], dtype="float64")
>>> b = _asarray([1.00001e10, 1e-9], dtype="float64")
>>> aesara.tensor.isclose(a, b).eval()
array([1, 1], dtype=int8)
>>> a = _asarray([1e10, 1e-8], dtype="float64")
>>> b = _asarray([1.0001e10, 1e-9], dtype="float64")
>>> aesara.tensor.isclose(a, b).eval()
array([0, 1], dtype=int8)
>>> a = _asarray([1.0, np.nan], dtype="float64")
>>> b = _asarray([1.0, np.nan], dtype="float64")
>>> aesara.tensor.isclose(a, b).eval()
array([1, 0], dtype==int8)
>>> a = _asarray([1.0, np.nan], dtype="float64")
>>> b = _asarray([1.0, np.nan], dtype="float64")
>>> aesara.tensor.isclose(a, b, equal_nan=True).eval()
array([1, 1], dtype==int8)
>>> a = _asarray([1.0, np.inf], dtype="float64")
>>> b = _asarray([1.0, -np.inf], dtype="float64")
>>> aesara.tensor.isclose(a, b).eval()
array([1, 0], dtype==int8)
>>> a = _asarray([1.0, np.inf], dtype="float64")
>>> b = _asarray([1.0, np.inf], dtype="float64")
>>> aesara.tensor.isclose(a, b).eval()
array([1, 1], dtype==int8)
"""
# close will be an int8 array of 1 where within tolerance
# and 0 where not within tolerance or there was a nan or inf value.
diff = _abs(a - b)
tolerance = atol + rtol * _abs(b)
close_prelim = le(diff, tolerance)
a_nan = isnan(a)
b_nan = isnan(b)
nans = bitwise_or(a_nan, b_nan)
a_inf = isinf(a)
b_inf = isinf(b)
infs = bitwise_or(a_inf, b_inf)
nans_or_infs = bitwise_or(nans, infs)
# close is now an array of 0's except where elements are not nan or inf
# and are within the tolerance.
close = bitwise_and(close_prelim, bitwise_not(nans_or_infs))
# deal with signed inf values. this will make an array inf_eq of 0's
# except where inf values have the same sign.
both_infs = bitwise_and(a_inf, b_inf)
inf_signs_eq = eq(a_inf * sgn(a), b_inf * sgn(b))
inf_eq = bitwise_and(both_infs, inf_signs_eq)
# now create the potential result combining close and inf_eq
close_with_infs = bitwise_or(close, inf_eq)
# deal with comparing nan's.
if equal_nan:
both_nans = bitwise_and(a_nan, b_nan)
return bitwise_or(close_with_infs, both_nans)
# otherwise nan's aren't considered close.
else:
return close_with_infs
##########################
# Bit-wise
##########################
@scalar_elemwise
def and_(a, b):
"""bitwise a & b"""
bitwise_and = and_ # numpy name for it
@scalar_elemwise
def or_(a, b):
"""bitwise a | b"""
bitwise_or = or_ # numpy name for it
@scalar_elemwise
def xor(a, b):
"""bitwise a ^ b"""
bitwise_xor = xor # numpy name for it
@scalar_elemwise
def invert(a):
"""bitwise ~a"""
bitwise_not = invert # numpy alias for it
##########################
# Math
##########################
@scalar_elemwise
def abs(a):
"""|`a`|"""
# These are deprecated and will be removed
abs_ = abs
pprint.assign(abs, printing.PatternPrinter(("|%(0)s|", -1000)))
@scalar_elemwise
def exp(a):
"""e^`a`"""
@scalar_elemwise
def exp2(a):
"""2^`a`"""
@scalar_elemwise
def expm1(a):
"""e^`a` - 1"""
@scalar_elemwise
def neg(a):
"""-a"""
@scalar_elemwise
def reciprocal(a):
"""1.0/a"""
# This is deprecated and will be removed
inv = reciprocal
@scalar_elemwise
def log(a):
"""base e logarithm of a"""
@scalar_elemwise
def log2(a):
"""base 2 logarithm of a"""
@scalar_elemwise
def log10(a):
"""base 10 logarithm of a"""
@scalar_elemwise
def log1p(a):
"""log(1+a)"""
@scalar_elemwise
def sgn(a):
"""sign of a"""
@scalar_elemwise
def ceil(a):
"""ceiling of a"""
@scalar_elemwise
def floor(a):
"""floor of a"""
@scalar_elemwise
def trunc(a):
"""trunc of a"""
def iround(a, mode=None):
"""cast(round(a,mode),'int64')"""
return cast(round(a, mode), "int64")
def round(a, mode=None):
"""round_mode(a) with mode in [half_away_from_zero, half_to_even].
Default to half_to_even."""
if mode is None:
mode = "half_to_even"
if config.warn__round:
warnings.warn(
"aesara.tensor.round() changed its default from"
" `half_away_from_zero` to `half_to_even` to have"
" the same default as NumPy. Use the Aesara flag"
" `warn__round=False` to disable this warning."
)
if mode == "half_away_from_zero":
return round_half_away_from_zero(a)
elif mode == "half_to_even":
return round_half_to_even(a)
else:
raise Exception(f"round mode {mode} is not implemented.")
@scalar_elemwise
def round_half_to_even(a):
"""round_half_to_even(a)"""
@scalar_elemwise
def round_half_away_from_zero(a):
"""round_half_away_from_zero(a)"""
@scalar_elemwise
def sqr(a):
"""square of a"""
# alias to sqr, included to maintain similarity with numpy interface
square = sqr
def cov(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None, aweights=None):
"""Calculate the covariance matrix.
Covariance indicates the level to which two variables vary together.
If we examine N-dimensional samples, :math:`m = [x_1, x_2, ... x_N]^T`,
then the covariance matrix element :math:`C_{ij}` is the covariance of
:math:`x_i` and :math:`x_j`. The element :math:`C_{ii}` is the variance
of :math:`x_i`. Code and docstring ported from numpy.
Parameters
==========
m : array_like
A 2-D array containing multiple variables and observations.
Each row of `m` represents a variable, and each column is
observations of all those variables.
y : array_like, optional
An additional set of variables and observations. `y` has the same form
as that of `m`.
rowvar : bool, optional
If `rowvar` is True (default), then each row represents a
variable, with observations in the columns. Otherwise, the relationship
is transposed: each column represents a variable, while the rows
contain observations.
bias : bool, optional
Default normalization (False) is by ``(N - 1)``, where ``N`` is the
number of observations given (unbiased estimate). If `bias` is True, then
normalization is by ``N``. These values can be overridden by using the
keyword ``ddof``.
ddof : int, optional
If not ``None`` the default value implied by `bias` is overridden.
The default value is ``None``.
Returns
=======
out : The covariance matrix of the variables.
"""
if fweights is not None:
raise NotImplementedError("fweights are not implemented")
if aweights is not None:
raise NotImplementedError("aweights are not implemented")
if not rowvar and m.shape[0] != 1:
m = m.T
if y is not None:
if not rowvar and y.shape[0] != 1:
y = y.T
m = concatenate((m, y), axis=0)
if ddof is None:
if not bias:
ddof = 1
else:
ddof = 0
# Determine the normalization
fact = m.shape[1] - ddof
m -= m.mean(axis=1, keepdims=1)
c = m.dot(m.T)
c *= constant(1) / fact
return c.squeeze()
@scalar_elemwise
def sqrt(a):
"""square root of a"""
@scalar_elemwise
def deg2rad(a):
"""convert degree a to radian"""
@scalar_elemwise
def rad2deg(a):
"""convert radian a to degree"""
@scalar_elemwise
def cos(a):
"""cosine of a"""
@scalar_elemwise
def arccos(a):
"""arccosine of a"""
@scalar_elemwise
def sin(a):
"""sine of a"""
@scalar_elemwise
def arcsin(a):
"""arcsine of a"""
@scalar_elemwise
def tan(a):
"""tangent of a"""
@scalar_elemwise
def arctan(a):
"""arctangent of a"""
@scalar_elemwise
def arctan2(a, b):
"""arctangent of a / b"""
@scalar_elemwise
def cosh(a):
"""hyperbolic cosine of a"""
@scalar_elemwise
def arccosh(a):
"""hyperbolic arc cosine of a"""
@scalar_elemwise
def sinh(a):
"""hyperbolic sine of a"""
@scalar_elemwise
def arcsinh(a):
"""hyperbolic arc sine of a"""
@scalar_elemwise
def tanh(a):
"""hyperbolic tangent of a"""
@scalar_elemwise
def arctanh(a):
"""hyperbolic arc tangent of a"""
@scalar_elemwise
def erf(a):
"""error function"""
@scalar_elemwise
def erfc(a):
"""complementary error function"""
@scalar_elemwise
def erfcx(a):
"""scaled complementary error function"""
@scalar_elemwise
def erfinv(a):
"""inverse error function"""
@scalar_elemwise
def erfcinv(a):
"""inverse complementary error function"""
@scalar_elemwise
def gamma(a):
"""gamma function"""
@scalar_elemwise
def gammaln(a):
"""log gamma function"""
@scalar_elemwise
def psi(a):
"""derivative of log gamma function"""
@scalar_elemwise
def tri_gamma(a):
"""second derivative of the log gamma function"""
@scalar_elemwise
def chi2sf(x, k):
"""chi squared survival function"""
@scalar_elemwise
def gammainc(k, x):
"""Regularized lower gamma function"""
@scalar_elemwise
def gammaincc(k, x):
"""Regularized upper gamma function"""
@scalar_elemwise
def gammau(k, x):
"""Upper incomplete gamma function."""
@scalar_elemwise
def gammal(k, x):
"""Lower incomplete gamma function."""
@scalar_elemwise
def j0(x):
"""Bessel function of the first kind of order 0."""
@scalar_elemwise
def j1(x):
"""Bessel function of the first kind of order 1."""
@scalar_elemwise
def jv(v, x):
"""Bessel function of the first kind of order v (real)."""
@scalar_elemwise
def i0(x):
"""Modified Bessel function of the first kind of order 0."""
@scalar_elemwise
def i1(x):
"""Modified Bessel function of the first kind of order 1."""
@scalar_elemwise
def iv(v, x):
"""Modified Bessel function of the first kind of order v (real)."""
@scalar_elemwise
def sigmoid(x):
|
expit = sigmoid
@scalar_elemwise
def softplus(x):
"""Compute log(1 + exp(x)), also known as softplus or log1pexp"""
log1pexp = softplus
@scalar_elemwise
def log1mexp(x):
"""Compute log(1 - exp(x)), also known as log1mexp"""
@scalar_elemwise
def betainc(a, b, x):
"""Regularized incomplete beta function"""
@scalar_elemwise
def real(z):
"""Return real component of complex-valued tensor `z`"""
_tensor_py_operators.real = property(real)
@scalar_elemwise
def imag(z):
"""Return imaginary component of complex-valued tensor `z`"""
_tensor_py_operators.imag = property(imag)
@scalar_elemwise
def angle(z):
"""Return polar-coordinate angle of complex-valued tensor `z`"""
@scalar_elemwise # numpy.complex cannot build tensors
def complex(real, imag):
"""Return complex-valued tensor with `real` and `imag` components"""
@scalar_elemwise
def conj(z):
"""Return the complex conjugate of `z`."""
@scalar_elemwise
def complex_from_polar(abs, angle):
"""Return complex-valued tensor from polar coordinate specification."""
class Mean(CAReduce):
def __init__(self, axis=None):
super().__init__(aes.add, axis)
assert self.axis is None or len(self.axis) == 1
def __str__(self):
if self.axis is not None:
return "Mean{%s}" % (", ".join(str(x) for x in self.axis))
else:
return "Mean"
def _output_dtype(self, idtype):
# we want to protect against overflow
return "float64"
def perform(self, node, inp, out):
(input,) = inp
(output,) = out
if self.axis is None:
axis = None
else:
axis = self.axis[0]
# numpy.asarray is needed as otherwise we can end up with a
# numpy scalar.
output[0] = np.asarray(np.mean(input, dtype="float64", axis=axis))
def c_code(self, node, name, inames, onames, sub):
ret = super().c_code(node, name, inames, onames, sub)
if self.axis is not None:
return ret
# TODO: c_code perform support only axis is None
return (
ret
+ f"""
*((double *)PyArray_DATA({onames[0]})) /= PyArray_SIZE({inames[0]});
"""
)
# TODO: implement the grad. When done and tested, you can make this the default
# version.
# def grad(self, (x,), (gout,)):
# import pdb;pdb.set_trace()
# return grad(mean(x, self.axis, op=False),[x])
def mean(input, axis=None, dtype=None, op=False, keepdims=False, acc_dtype=None):
"""
Computes the mean value along the given axis(es) of a tensor `input`.
Parameters
----------
axis : None or int or (list of int) (see `Sum`)
Compute the mean along this axis of the tensor.
None means all axes (like numpy).
dtype: None or string
Dtype to cast the result of the inner summation into.
For instance, by default, a sum of a float32 tensor will be
done in float64 (acc_dtype would be float64 by default),
but that result will be casted back in float32.
keepdims: bool
If this is set to True, the axes which are reduced are
left in the result as dimensions with size one. With this option,
the result will broadcast correctly against the original tensor.
acc_dtype: None or string
Dtype to use for the inner summation. This will not
necessarily be the dtype of the output (in particular
if it is a discrete (int/uint) dtype, the output will
be in a float type). If None, then we use the same rules as `sum()`.
Notes
-----
For gpu, if you specify dtype=float32, everything will be done on the gpu.
"""
input = as_tensor_variable(input)
if op:
if dtype not in (None, "float64"):
raise NotImplementedError(
"The Mean op does not support the dtype argument, "
"and will always use float64. If you want to specify "
"the dtype, call tensor.mean(..., op=False).",
dtype,
)
if acc_dtype not in (None, "float64"):
raise NotImplementedError(
"The Mean op does not support the acc_dtype argument, "
"and will always use float64. If you want to specify "
"acc_dtype, call tensor.mean(..., op=False).",
dtype,
)
out = Mean(axis)(input)
if keepdims:
out = makeKeepDims(input, out, axis)
return out
if dtype is not None:
# The summation will be done with the specified dtype.
# sum() will complain if it is not suitable.
sum_dtype = dtype
else:
sum_dtype = None
# float16 overflows on the cast way too often
if input.dtype == "float16":
sum_dtype = "float32"
s = sum(input, axis=axis, dtype=sum_dtype, keepdims=keepdims, acc_dtype=acc_dtype)
shp = shape(input)
# Cast shp into a float type
# TODO Once we have a consistent casting policy, we could simply
# use true_div.
if s.dtype in ("float16", "float32", "complex64"):
shp = cast(shp, "float32")
else:
shp = cast(shp, "float64")
if axis is None:
axis = list(range(input.ndim))
elif isinstance(axis, (int, np.integer)):
axis = [axis]
elif isinstance(axis, np.ndarray) and axis.ndim == 0:
axis = [int(axis)]
else:
axis = [int(a) for a in axis]
# This sequential division will possibly be optimized by Aesara:
for i in axis:
s = true_div(s, shp[i])
# This can happen when axis is an empty list/tuple
if s.dtype != shp.dtype and s.dtype in discrete_dtypes:
s = cast(s, shp.dtype)
if dtype == "float16" or (dtype is None and input.dtype == "float16"):
s = cast(s, "float16")
s.name = "mean"
return s
def var(input, axis=None, ddof=0, keepdims=False, corrected=False):
"""
Computes the variance along the given axis(es) of a tensor `input`.
Parameters
----------
axis: None or int or (list of int) (see `Sum`)
Compute the variance along this axis of the tensor.
None means all axes (like numpy).
ddof: Degrees of freedom; 0 would compute the ML estimate, 1 would compute
the unbiased estimate.
keepdims : bool
If this is set to True, the axes which are reduced are
left in the result as dimensions with size one. With this option,
the result will broadcast correctly against the original tensor.
corrected : bool
If this is set to True, the 'corrected_two_pass' algorithm is
used to compute the variance.
Refer : http://www.cs.yale.edu/publications/techreports/tr222.pdf
Notes
-----
Default uses the two-pass algorithm (reference below).
https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Two-pass_algorithm
Also supports 'corrected_two_pass' algorithm (using the 'corrected' flag)
which is numerically more stable. There exist other implementations that
offer better stability, but probably slower.
"""
if isinstance(ddof, (bool)):
raise ValueError(
"Parameter keepdims is now at index 3: (input, \
axis=None, ddof=0, keepdims=False, corrected=False)"
)
input_ndim = input.type.ndim
if axis is None:
axis = list(range(input_ndim))
elif isinstance(axis, (int, np.integer)):
axis = [axis]
elif isinstance(axis, np.ndarray) and axis.ndim == 0:
axis = [int(axis)]
else:
axis = [int(a) for a in axis]
# compute the axis-wise mean
mean_input = mean(input, axis, keepdims=True)
# center the input
centered_input = input - mean_input
# return the mean sqr
two = constant(2, dtype=centered_input.dtype)
if ddof == 0:
v = mean((centered_input ** two), axis, keepdims=keepdims)
else:
shp = shape(input) - ddof
v = sum((centered_input ** two), axis=axis, keepdims=keepdims)
for i in axis:
v = true_div(v, shp[i])
# use 'corrected_two_pass' algorithm
if corrected:
if ddof == 0:
error = mean(centered_input, axis, keepdims=keepdims) ** 2
else:
shp = shape(input) - ddof
shp_inp = shape(input)
error = sum(centered_input, axis=axis, keepdims=keepdims) ** 2
for i in axis:
error = true_div(error, shp[i] * shp_inp[i])
v = v - error
v.name = "var"
return v
def std(input, axis=None, ddof=0, keepdims=False, corrected=False):
"""
Computes the standard deviation along the given axis(es) of a tensor `input`.
Parameters
----------
axis: None or int or (list of int) (see `Sum`)
Compute the variance along this axis of the tensor.
None means all axes (like numpy).
ddof: Degrees of freedom; 0 would compute the ML estimate, 1 would compute
the unbiased estimate.
keepdims : bool
If this is set to True, the axes which are reduced are
left in the result as dimensions with size one. With this option,
the result will broadcast correctly against the original tensor.
corrected : bool
If this is set to True, the 'corrected_two_pass' algorithm is
used to compute the variance.
Refer : http://www.cs.yale.edu/publications/techreports/tr222.pdf
Notes
-----
It calls 'var()' and 'var()' uses the two-pass algorithm (reference below).
https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Two-pass_algorithm
Function 'var()' also supports 'corrected_two_pass' algorithm (using the
'corrected' flag) which is numerically more stable. There exist other
implementations that offer better stability, but probably slower.
"""
if isinstance(ddof, (bool)):
raise ValueError(
"Parameter keepdims is now at index 3: (input, \
axis=None, ddof=0, keepdims=False, corrected=False)"
)
ret = sqrt(
var(input=input, axis=axis, ddof=ddof, keepdims=keepdims, corrected=corrected)
)
ret.name = "std"
return ret
@scalar_elemwise(symbolname="scalar_maximum")
def maximum(x, y):
"""elemwise maximum. See max for the maximum in one tensor"""
# see decorator for function body
@scalar_elemwise(symbolname="scalar_minimum")
def minimum(x, y):
"""elemwise minimum. See min for the minimum in one tensor"""
# see decorator for function body
def divmod(x, y):
"""elementvise divmod, using floor_div and mod_check"""
return floor_div(x, y), mod_check(x, y)
@scalar_elemwise
def add(a, *other_terms):
"""elementwise addition"""
# see decorator for function body
@scalar_elemwise
def sub(a, b):
"""elementwise subtraction"""
# see decorator for function body
@scalar_elemwise
def mul(a, *other_terms):
"""elementwise multiplication"""
# see decorator for function body
@scalar_elemwise
def true_div(a, b):
"""elementwise [true] division (inverse of multiplication)"""
# see decorator for function body
@scalar_elemwise
def int_div(a, b):
"""elementwise [floor] division (inverse of multiplication)"""
# see decorator for function body
# floor_div and int_div are the same thing
floor_div = int_div
def ceil_intdiv(a, b):
"""
Safely compute ceil(float_division(a, b)).
Works for all dtypes, but mostly useful when a and b are int.
"""
# If a and b are int with not many significant bits, we could
# cast them to float to avoid doing the modulo. We do not know if this
# is faster or not. But this is not safe for int64 as the cast will
# lose precision.
# e.g.: cast(cast(a, scalar.upcast(a, 'float32')) / b, aes.upcast(a, b))
# We cast for the case when a and b are uint*. Otherwise neq will
# force their upcast to int.
div = int_div(a, b)
ret = cast(neq(a % b, 0), div.dtype) + div
assert ret.dtype == aes.upcast(div.owner.inputs[0], div.owner.inputs[1])
return ret
def mod_check(x, y):
"""Make sure we do not try to use complex numbers."""
if (
as_tensor_variable(x).dtype in complex_dtypes
or as_tensor_variable(y).dtype in complex_dtypes
):
# Currently forbidden.
raise aes.Mod.complex_error
else:
return mod(x, y)
@scalar_elemwise
def mod(a, b):
"""elementwise modulo"""
# see decorator for function body
@scalar_elemwise
def pow(a, b):
"""elementwise power"""
# see decorator for function body
@scalar_elemwise
def clip(x, min, max):
"""
Clip x to be between min and max.
Note that when `x` is equal to the boundaries, the output is considered
to be `x`, so at these points, the gradient of the cost wrt the output
will be propagated to `x`, not to `min` nor `max`. In other words,
on these points, the gradient wrt `x` will be equal to the gradient wrt
the output, and the gradient wrt `min` and `max` will be zero.
"""
# see decorator for function body
# for grep: clamp, bound
pprint.assign(add, printing.OperatorPrinter("+", -2, "either"))
pprint.assign(mul, printing.OperatorPrinter("*", -1, "either"))
pprint.assign(sub, printing.OperatorPrinter("-", -2, "left"))
pprint.assign(neg, printing.OperatorPrinter("-", 0, "either"))
pprint.assign(true_div, printing.OperatorPrinter("/", -1, "left"))
pprint.assign(int_div, printing.OperatorPrinter("//", -1, "left"))
pprint.assign(pow, printing.OperatorPrinter("**", 1, "right"))
class Dot(Op):
"""
Computes the dot product of two variables. For two matrices, this is
equivalent to matrix multiplication. For two vectors, this is the inner
product.
Notes
-----
Matrix-matrix products are sometimes optimized to Dot22 or Gemm ops
(see tensor.blas).
Vector-vector products are sometimes optimized to Ger or CGer (see
tensor.blas).
Matrix-vector products are sometimes optimized to Gemv, CGemv (see
tensor.blas).
"""
__props__ = ()
# the rationale for Dot22 is related to getting GEMM Ops into the
# graph. See Dot22 in tensor.blas for details.
def make_node(self, *inputs):
inputs = list(map(as_tensor_variable, inputs))
if len(inputs) != 2:
raise TypeError(f"Two arguments required, {len(inputs)} given ")
if inputs[0].ndim not in (1, 2):
raise TypeError(
"Input 0 (0-indexed) must have ndim of "
f"1 or 2, {int(inputs[0].ndim)} given. Consider calling "
"aesara.tensor.dot instead."
)
if inputs[1].ndim not in (1, 2):
raise TypeError(
"Input 1 (0-indexed) must have ndim of "
f"1 or 2, {int(inputs[1].ndim)} given. Consider calling "
"aesara.tensor.dot instead."
)
i_broadcastables = [input.type.broadcastable for input in inputs]
bx, by = i_broadcastables
if len(by) == 2: # y is a matrix
bz = bx[:-1] + by[-1:]
elif len(by) == 1: # y is vector
bz = bx[:-1]
i_dtypes = [input.type.dtype for input in inputs]
outputs = [tensor(aes.upcast(*i_dtypes), bz)]
return Apply(self, inputs, outputs)
def perform(self, node, inp, out):
x, y = inp
(z,) = out
# the asarray is here because dot between two vectors
# gives a numpy float object but we need to return a 0d
# ndarray
z[0] = np.asarray(np.dot(x, y))
def grad(self, inp, grads):
x, y = inp
(gz,) = grads
xdim, ydim, gdim = x.type.ndim, y.type.ndim, gz.type.ndim
# grad is scalar, so x is vector and y is vector
if gdim == 0:
xgrad = gz * y
ygrad = gz * x
# x is vector, y is matrix, grad is vector
elif xdim == 1 and ydim == 2:
xgrad = dot(gz, y.T)
ygrad = outer(x.T, gz)
# x is matrix, y is vector, grad is vector
elif xdim == 2 and ydim == 1:
xgrad = outer(gz, y.T)
ygrad = dot(x.T, gz)
# x is matrix, y is matrix, grad is matrix
elif xdim == ydim == 2:
xgrad = dot(gz, y.T)
ygrad = dot(x.T, gz)
# If x or y contain broadcastable dimensions but only one of
# them know that a matching dimensions is broadcastable, the
# above code don't always return the right broadcast pattern.
# This cause problem down the road. See gh-1461.
if xgrad.broadcastable != x.broadcastable:
xgrad = patternbroadcast(xgrad, x.broadcastable)
if ygrad.broadcastable != y.broadcastable:
ygrad = patternbroadcast(ygrad, y.broadcastable)
rval = xgrad, ygrad
for elem in rval:
assert elem.dtype.find("float") != -1
return rval
def R_op(self, inputs, eval_points):
# R_op for a \dot b evaluated at c for a and d for b is
# simply c \dot b + a \dot d
assert len(inputs) == 2
assert len(eval_points) == 2
if eval_points[0] is None and eval_points[1] is None:
return [None]
if eval_points[0]:
t1 = self(eval_points[0], inputs[1])
if eval_points[1]:
t2 = self(inputs[0], eval_points[1])
if eval_points[0] and eval_points[1]:
return [t1 + t2]
elif eval_points[0]:
return [t1]
else:
return [t2]
def infer_shape(self, fgraph, node, shapes):
xshp, yshp = shapes
x, y = node.inputs
# vector / vector
if x.ndim == 1 and y.ndim == 1:
return [()]
# matrix / vector
if x.ndim == 2 and y.ndim == 1:
return [xshp[:-1]]
# vector / matrix
if x.ndim == 1 and y.ndim == 2:
return [yshp[-1:]]
# matrix / matrix
if x.ndim == 2 and y.ndim == 2:
return [xshp[:-1] + yshp[-1:]]
raise NotImplementedError()
def __str__(self):
return "dot"
_dot = Dot()
pprint.assign(
_dot, printing.OperatorPrinter(printing.special["middle_dot"], -1, "left")
)
def dot(l, r):
"""Return a symbolic dot product.
This is designed to work with both sparse and dense tensors types.
"""
if not isinstance(l, Variable):
l = as_tensor_variable(l)
if not isinstance(r, Variable):
r = as_tensor_variable(r)
try:
res = l.__dot__(r)
if res is NotImplemented:
raise NotImplementedError
except (NotImplementedError, AttributeError, TypeError):
res = r.__rdot__(l)
if res is NotImplemented:
raise NotImplementedError()
return res
def dense_dot(a, b):
"""
Computes the dot product of two variables.
For two matrices, this is equivalent to matrix multiplication.
For two vectors, this is the inner product.
When one variable is a scalar, this is like elementwise multiplication.
For N dimensions, this is a sum product over the last axis
of the first array and the second-to-last axis of the second array:
dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])
Note that this dot function does one of three things, in the following
sequence:
1. If either a or b is scalar, it returns the elementwise product
without calling the Aesara Dot op.
2. If either a or b has more than 2 dimensions, it calls Aesara's
tensordot function with appropriate axes. The tensordot function
expresses high-dimensional dot products in terms of 2D matrix
multiplications, so it may be possible to further optimize for
performance.
3. If both a and b have either 1 or 2 dimensions, it calls Aesara's
Dot op on a and b.
Notes
-----
Matrix-matrix products are sometimes optimized to Dot22 or Gemm ops
(see tensor.blas).
Vector-vector products are sometimes optimized to Ger or CGer (see
tensor.blas).
Matrix-vector products are sometimes optimized to Gemv, CGemv (see
tensor.blas).
"""
a, b = as_tensor_variable(a), as_tensor_variable(b)
if a.ndim == 0 or b.ndim == 0:
return a * b
elif a.ndim > 2 or b.ndim > 2:
return tensordot(a, b, [[a.ndim - 1], [np.maximum(0, b.ndim - 2)]])
else:
return _dot(a, b)
def _tensordot_as_dot(a, b, axes, dot, batched):
"""
Reduces a tensor dot product to a matrix or vector dot product. Based
on code from Tijmen Tieleman's gnumpy
(http://www.cs.toronto.edu/~tijmen/gnumpy.html).
Please see the documentation of tensordot for the meaning of the a, b
and axes arguments.
:param dot: a function that accepts two symbolic variables and computes
the appropriate dot product (e.g. dot, batched_dot)
:type dot: function
:param batched: whether to treat the first axis of a and b as a batch
axis. If so, this axis will be preserved in the output,
allowing this function to be used also for batched
tensor dot products.
:type batched: boolean
:returns: a tensor with shape equal to the concatenation of a's shape
(less any dimensions that were summed over) and b's shape
(less the first dimension and any dimensions that were summed
over).
:rtype: symbolic tensor
"""
a, b = as_tensor_variable(a), as_tensor_variable(b)
if not np.isscalar(axes) and len(axes) != 2:
raise ValueError(
"Axes should be an integer or a "
"list/tuple of len 2 ({axes} was provided)"
)
# if 'axes' is a number of axes to multiply and sum over (trailing axes
# of a, leading axes of b), we can just reshape and use dot.
elif np.isscalar(axes):
axes = int(axes)
for operand_name, operand in (("a", a), ("b", b)):
if axes > operand.ndim:
raise ValueError(
f"axes can not be larger than the dimension of {operand_name} "
f"({operand_name}.ndim={operand.ndim}, axes={axes})"
)
if batched and axes == operand.ndim:
raise ValueError(
"axes to sum over must not include the batch axis "
f"of {operand_name} ({operand_name}.ndim={operand.ndim}, axes={axes})"
)
batch_axes = 1 if batched else 0
a_outaxes = slice(0, a.ndim - axes)
b_outaxes = slice(batch_axes + axes, b.ndim)
outshape = concatenate([a.shape[a_outaxes], b.shape[b_outaxes]])
outbcast = a.broadcastable[a_outaxes] + b.broadcastable[b_outaxes]
outndim = len(outbcast)
a_shape = [1] * 2
b_shape = [1] * 2
# compute total size of summed axes
for i in range(0, axes):
a_shape[1] *= a.shape[-(i + 1)]
b_shape[0] *= b.shape[batch_axes + i]
# compute total size of other axes
for i in range(0, a.ndim - axes - batch_axes):
a_shape[0] *= a.shape[batch_axes + i]
for i in range(0, b.ndim - axes - batch_axes):
b_shape[1] *= b.shape[-(i + 1)]
if batched:
a_shape.insert(0, a.shape[0])
b_shape.insert(0, b.shape[0])
a_reshaped = a.reshape(a_shape)
b_reshaped = b.reshape(b_shape)
out_reshaped = dot(a_reshaped, b_reshaped)
out = out_reshaped.reshape(outshape, outndim)
# Make sure the broadcastable pattern of the result is correct,
# since some shape information can be lost in the reshapes.
return patternbroadcast(out, outbcast)
# if 'axes' is a list, transpose a and b such that the summed axes of a
# are last and the summed axes of b are first.
else:
axes = [as_list(axes_) for axes_ in axes]
if len(axes[0]) != len(axes[1]):
raise ValueError("Axes elements must have the same length.")
for i, (operand_name, operand) in enumerate((("a", a), ("b", b))):
if len(axes[i]) > operand.ndim:
raise ValueError(
f"axes[{i}] should be array_like with length less than "
f"the dimensions of {operand_name} ({operand_name}.ndim={operand.ndim}, len(axes[0])={len(axes[i])})."
)
if len(axes[i]) > 0 and np.max(axes[i]) >= operand.ndim:
raise ValueError(
f"axes[{i}] contains dimensions greater than or equal "
f"to {operand_name}.ndim ({operand_name}.ndim={operand.ndim}, max(axes[0])={np.max(np.array(axes[i]))})."
)
if batched and 0 in axes[i]:
raise ValueError(
"axes to sum over must not contain the batch axis "
f"(axes[{i}]={axes[i]})"
)
batch_axes = [0] if batched else []
other_axes = [
[x for x in range(operand.ndim) if x not in axes[i] and x not in batch_axes]
for i, operand in enumerate((a, b))
]
a_shuffled = a.dimshuffle(batch_axes + other_axes[0] + axes[0])
b_shuffled = b.dimshuffle(batch_axes + axes[1] + other_axes[1])
# now that a and b are in the right order, recur with integer axes
return _tensordot_as_dot(
a_shuffled, b_shuffled, len(axes[0]), dot=dot, batched=batched
)
def tensordot(a, b, axes=2):
"""
Compute a generalized dot product over provided axes.
Given two tensors a and b, tensordot computes a generalized dot product over
the provided axes. Aesara's implementation reduces all expressions to
matrix or vector dot products and is based on code from Tijmen Tieleman's
gnumpy (http://www.cs.toronto.edu/~tijmen/gnumpy.html).
Parameters
----------
a: symbolic tensor
The first tensor variable.
b: symbolic tensor
The second tensor variable
axes: int or array-like of length 2
If an integer, the number of axes to sum over.
If an array, it must have two array elements containing the axes
to sum over in each tensor.
Note that the default value of 2 is not guaranteed to work
for all values of a and b, and an error will be raised if
that is the case. The reason for keeping the default is to
maintain the same signature as numpy's tensordot function
(and np.tensordot raises analogous errors for non-compatible
inputs).
If an integer i, it is converted to an array containing
the last i dimensions of the first tensor and the first
i dimensions of the second tensor:
axes = [list(range(a.ndim - i, b.ndim)), list(range(i))]
If an array, its two elements must contain compatible axes
of the two tensors. For example, [[1, 2], [2, 0]] means sum
over the 2nd and 3rd axes of a and the 3rd and 1st axes of b.
(Remember axes are zero-indexed!) The 2nd axis of a and the
3rd axis of b must have the same shape; the same is true for
the 3rd axis of a and the 1st axis of b.
Returns
-------
symbolic tensor
A tensor with shape equal to the concatenation of a's shape
(less any dimensions that were summed over) and b's shape
(less any dimensions that were summed over).
Examples
--------
It may be helpful to consider an example to see what tensordot does.
Aesara's implementation is identical to NumPy's. Here a has shape (2, 3, 4)
and b has shape (5, 6, 4, 3). The axes to sum over are [[1, 2], [3, 2]] --
note that a.shape[1] == b.shape[3] and a.shape[2] == b.shape[2]; these axes
are compatible. The resulting tensor will have shape (2, 5, 6) -- the
dimensions that are not being summed:
>>> a = np.random.random((2,3,4))
>>> b = np.random.random((5,6,4,3))
#tensordot
>>> c = np.tensordot(a, b, [[1,2],[3,2]])
#loop replicating tensordot
>>> a0, a1, a2 = a.shape
>>> b0, b1, _, _ = b.shape
>>> cloop = np.zeros((a0,b0,b1))
#loop over non-summed indices -- these exist
#in the tensor product.
>>> for i in range(a0):
... for j in range(b0):
... for k in range(b1):
... #loop over summed indices -- these don't exist
... #in the tensor product.
... for l in range(a1):
... for m in range(a2):
... cloop[i,j,k] += a[i,l,m] * b[j,k,m,l]
>>> np.allclose(c, cloop)
true
This specific implementation avoids a loop by transposing a and b such that
the summed axes of a are last and the summed axes of b are first. The
resulting arrays are reshaped to 2 dimensions (or left as vectors, if
appropriate) and a matrix or vector dot product is taken. The result is
reshaped back to the required output dimensions.
In an extreme case, no axes may be specified. The resulting tensor
will have shape equal to the concatenation of the shapes of a and b:
>>> c = np.tensordot(a, b, 0)
>>> print(a.shape)
(2,3,4)
>>> print(b.shape)
(5,6,4,3)
>>> print(c.shape)
(2,3,4,5,6,4,3)
See the documentation of numpy.tensordot for more examples.
"""
return _tensordot_as_dot(a, b, axes, dot=dot, batched=False)
def outer(x, y):
"""Return vector-vector outer product.
If an input isn't a vector, we flatten it first.
"""
if x.ndim != 1:
x = x.flatten()
if y.ndim != 1:
y = y.flatten()
return dot(x.dimshuffle(0, "x"), y.dimshuffle("x", 0))
class All(CAReduce):
"""Applies `logical and` to all the values of a tensor along the
specified axis(es).
"""
__props__ = ("axis",)
nfunc_spec = ("all", 1, 1)
def __init__(self, axis=None):
super().__init__(aes.and_, axis)
def _output_dtype(self, idtype):
return "bool"
def __str__(self):
if self.axis is None:
return "All"
else:
return "All{%s}" % ", ".join(map(str, self.axis))
def make_node(self, input):
input = as_tensor_variable(input)
if input.dtype != "bool":
input = neq(input, 0)
ret = super().make_node(input)
return ret
def grad(self, inp, grads):
(x,) = inp
return [x.zeros_like(config.floatX)]
class Any(CAReduce):
"""Applies `bitwise or` to all the values of a tensor along the
specified axis(es).
"""
__props__ = ("axis",)
nfunc_spec = ("any", 1, 1)
def __init__(self, axis=None):
super().__init__(aes.or_, axis)
def _output_dtype(self, idtype):
return "bool"
def __str__(self):
if self.axis is None:
return "Any"
else:
return "Any{%s}" % ", ".join(map(str, self.axis))
def make_node(self, input):
input = as_tensor_variable(input)
if input.dtype != "bool":
input = neq(input, 0)
ret = super().make_node(input)
return ret
def grad(self, inp, grads):
(x,) = inp
return [x.zeros_like(config.floatX)]
class Sum(CAReduceDtype):
"""
Sums all the values of a tensor along the specified axis(es).
Equivalent to `CAReduceDtype(scalar.add, axis=axis, dtype=dtype)`,
with the difference that this defines the gradient of sum wrt its
tensor input.
Parameters
----------
axis
Axis(es) along which the tensor should be summed
(use None to sum over all axes, and a list or tuple to sum along more
than one axis).
dtype
The dtype of the internal accumulator and returned
tensor. If None, then we use the default dtype which is the same as the
input tensor's dtype except when:
- the input dtype is a signed integer of precision < 64 bit, in
which case we use int64
- the input dtype is an unsigned integer of precision < 64 bit, in
which case we use uint64
This value does not depend on the value of "acc_dtype".
acc_dtype
The dtype of the internal accumulator.
If None (default), we use the dtype in the list below,
or the input dtype if its precision is higher:
- for int dtypes, we use at least int64;
- for uint dtypes, we use at least uint64;
- for float dtypes, we use at least float64;
- for complex dtypes, we use at least complex128.
"""
__props__ = ("axis", "dtype", "acc_dtype")
nfunc_spec = ("sum", 1, 1)
def __init__(self, axis=None, dtype=None, acc_dtype=None):
super().__init__(aes.add, axis=axis, dtype=dtype, acc_dtype=acc_dtype)
def __str__(self):
name = self.__class__.__name__
axis = ""
if self.axis is not None:
axis = ", ".join(str(x) for x in self.axis)
axis = f"axis=[{axis}], "
return f"{name}{{{axis}acc_dtype={self.acc_dtype}}}"
def L_op(self, inp, out, grads):
(x,) = inp
if out[0].dtype not in continuous_dtypes:
return [x.zeros_like(dtype=config.floatX)]
(gz,) = grads
gz = as_tensor_variable(gz)
axis = self.axis
if axis is None:
axis = list(range(x.type.ndim))
if axis == ():
return (gz,)
new_dims = []
i = 0
for j, _ in enumerate(x.type.broadcastable):
if j in axis:
new_dims.append("x")
else:
new_dims.append(i)
i += 1
ds_op = DimShuffle(gz.type.broadcastable, new_dims)
gx = Elemwise(aes.second)(x, ds_op(gz))
return [gx]
def R_op(self, inputs, eval_points):
# There is just one element in inputs and eval_points, the axis are
# part of self
if None in eval_points:
return [None]
return self(*eval_points, **dict(return_list=True))
def sum(input, axis=None, dtype=None, keepdims=False, acc_dtype=None):
"""
Computes the sum along the given axis(es) of a tensor `input`.
When axis is None (the default value), the sum is performed
over the flattened tensor.
For full documentation see `Sum`.
In particular please pay attention to the important warning when using
a custom acc_dtype.
Parameters
----------
keepdims: bool
If this is set to True, the axes which are reduced are left in
the result as dimensions with size one. With this option, the result
will broadcast correctly against the original tensor.
"""
out = Sum(axis=axis, dtype=dtype, acc_dtype=acc_dtype)(input)
if keepdims:
out = makeKeepDims(input, out, axis)
return out
pprint.assign(Sum(), printing.FunctionPrinter("sum"))
class Prod(CAReduceDtype):
"""
Multiplies all the values of a tensor along the specified axis(es).
Equivalent to `CAReduce(scalar.mul, axis = axis)`, with the
difference that this defines the gradient of prod wrt its tensor
input.
"""
__props__ = ("axis", "dtype", "acc_dtype")
nfunc_spec = ("prod", 1, 1)
def __init__(self, axis=None, dtype=None, acc_dtype=None, no_zeros_in_input=False):
super().__init__(aes.mul, axis=axis, dtype=dtype, acc_dtype=acc_dtype)
self.no_zeros_in_input = no_zeros_in_input
def __setstate__(self, dct):
super().__setstate__(dct)
# Add default value to be able to reload old pickled objects.
if "no_zeros_in_input" not in dct:
self.no_zeros_in_input = False
def L_op(self, inp, out, grads):
"""
The grad of this Op could be very easy, if it is was not for the case
where zeros are present in a given "group" (ie. elements reduced
together to form the product).
If no zeros are found in the elements of the product, then the
partial derivative of the product relative to one of the elements
(one of the inputs) is simply the product of the other elements.
That's easy to see from the chain rule.
Now the trick (with no zeros) is to take the overall product, then
for every original element, the partial derivative is given by
this product divided by the element itself (which equals the product
of the other terms). This is easy to do by broadcasting the original
product.
(Note that we also need to broadcast-multiply by the
"incoming gradient", ie. the gradient of the cost relative to the
output/product).
With zeros, things get more complicated. For a given group, we have 3
cases:
* No zeros in the group. Use previous trick.
* If only one zero is present, then the gradient for that element is
non-zero, but is zero for all others.
* If more than one zero is present, then all the derivatives are zero.
For the last two cases (with 1 or more zeros), we can't use the
division trick, as this gives divisions by 0.
Implementing that case-by-case logic is not as trivial, so a bunch of
hacks are piled down here to do it. Notably, for the "only one zero"
case, there's a special Op that computes the product of the elements
in the group, minus the zero (see `ProdWithoutZeros`). The trick is then
to use the division trick for groups with no zero, to use the
`ProdWithoutZeros` op where there's only one zero, and to output a
derivative of zero for any element part of a group with more than
one zero.
I do this by first counting the number of zeros in each group (see the
`aet.eq` bits), then taking this or that behavior (see `aet.switch`)
based on the result of this count.
"""
(prod_in,) = inp
(gz,) = grads
if out[0].dtype in discrete_dtypes or self.acc_dtype in discrete_dtypes:
# There is an int conversion in the way
return [prod_in.zeros_like(dtype=config.floatX)]
# Prepare the broadcasting that is used everywhere to broadcast
# over the original groups (ie. broadcast over the elements of a given
# product)
gz = as_tensor_variable(gz)
axis = self.axis
if axis is None:
axis = list(range(prod_in.type.ndim))
if axis == ():
return (gz,)
new_dims = []
i = 0
for j, _ in enumerate(prod_in.type.broadcastable):
if j in axis:
new_dims.append("x")
else:
new_dims.append(i)
i += 1
# result of the product, broadcastable over groups
prod_out = self(prod_in).dimshuffle(new_dims)
# incoming gradient, broadcastable over groups
gz = gz.dimshuffle(new_dims)
# division trick if we don't have zeros. This will contain
# NaNs to be eliminated in the `aet.switch` if we do have zeros.
grad_case_without_zeros = gz * prod_out / prod_in
if self.no_zeros_in_input:
# this handles inputs with zeros, but only certain input shapes
return [grad_case_without_zeros]
else:
where_zeros = eq(prod_in, 0.0)
sum_where_zeros = sum(where_zeros, axis=self.axis)
groups_with_single_zero = eq(sum_where_zeros, 1).dimshuffle(new_dims)
# tensor with 0 everywhere except for those places where
# a 0 part of a group with a single zero was to be found
where_single_zero = groups_with_single_zero * where_zeros
# further optimization to avoid computing ProdWithoutZeros
# if the incoming gradient is 0
where_gz_not_zero = neq(gz, 0.0)
# only take ProdWithoutZeros for the groups with single zeros
# with non-null incoming gradient
where_to_take_prod_without_zeros = (
groups_with_single_zero * where_gz_not_zero
)
# preprocess the original input so that we set 0 everywhere
# except for groups that contain a single zero, to avoid computing
# multiplications on other groups
prod_without_zeros_in = where_to_take_prod_without_zeros * prod_in
# TODO: put lazy switch here, if it'd work
# this is pretty efficient already (no multiplication if 0), but
# it'd be even better if we had a lazy if per element
prod_without_zeros = ProdWithoutZeros(axis=self.axis)(prod_without_zeros_in)
prod_without_zeros = prod_without_zeros.dimshuffle(new_dims)
groups_without_zeros = eq(sum_where_zeros, 0).dimshuffle(new_dims)
final_grad = switch(
groups_without_zeros,
grad_case_without_zeros,
switch(where_single_zero, prod_without_zeros, 0.0) * gz,
)
return [final_grad]
def c_code_cache_version(self):
return (1,)
def prod(
input,
axis=None,
dtype=None,
keepdims=False,
acc_dtype=None,
no_zeros_in_input=False,
):
"""
Computes the product along the given axis(es) of a tensor `input`.
When axis is None (the default value), the product is performed
over the flattened tensor.
For full documentation see ``tensor.elemwise.Prod``.
Parameters
----------
keepdims: bool
If this is set to True, the axes which are reduced are left in
the result as dimensions with size one. With this option, the result
will broadcast correctly against the original tensor.
"""
out = Prod(
axis, dtype=dtype, acc_dtype=acc_dtype, no_zeros_in_input=no_zeros_in_input
)(input)
if keepdims:
out = makeKeepDims(input, out, axis)
return out
class MulWithoutZeros(BinaryScalarOp):
# "identity" here is zero, as in Reduce we don't want to start
# with reducing (1, something_else): this leads to the erroneous
# case where a vector of zeros is reduced by binary reductions
# of (1, 0), which always ends up as 1 (ie. the result for
# the c version, for the product of [0,0,0], is 1.0)
identity = 0.0
commutative = True
associative = True
def impl(self, x, y):
if x == 0:
return y
if y == 0:
return x
return x * y
def c_code(self, node, name, inp, out, sub):
x, y = inp
(z,) = out
return (
"%(z)s = ((%(x)s == 0) ? (%(y)s) : "
+ "((%(y)s == 0) ? (%(x)s) : ((%(y)s)*(%(x)s))) );"
) % locals()
def c_code_cache_version(self):
return (1,)
mul_without_zeros = MulWithoutZeros(aes.upcast_out, name="mul_without_zeros")
class ProdWithoutZeros(CAReduceDtype):
__props__ = ("axis", "dtype", "acc_dtype")
def __init__(self, axis=None, dtype=None, acc_dtype=None):
super().__init__(mul_without_zeros, axis=axis, dtype=dtype, acc_dtype=acc_dtype)
def grad(self, inp, grads):
from aesara.gradient import grad_not_implemented
(a,) = inp
a_grad = grad_not_implemented(
self,
0,
a,
"2nd derivatives of `product(a)` is not currently supported."
"If `a` is guaranteed to contains no zeros, use "
"`product(a, no_zeros_in_input=True)`.",
)
return [a_grad]
def any(x, axis=None, keepdims=False):
out = Any(axis)(x)
if keepdims:
out = makeKeepDims(x, out, axis)
return out
def all(x, axis=None, keepdims=False):
out = All(axis)(x)
if keepdims:
out = makeKeepDims(x, out, axis)
return out
def ptp(a, axis=None):
"""
Range of values (maximum - minimum) along an axis.
The name of the function comes from the acronym for peak to peak.
Parameters
----------
a
Input tensor.
axis
Axis along which to find the peaks. By default, flatten the array.
Returns
-------
array
A new array holding the result.
"""
a = as_tensor_variable(a)
out = max(a, axis) - min(a, axis)
return out
def power(x, y):
return x ** y
def logaddexp(*xs):
"""Logarithm of the sum of exponentiations of the inputs.
See ``numpy.logaddexp``.
Parameters
----------
xs : symbolic tensors
Input
Returns
-------
tensor
"""
return log(add(*[exp(x) for x in xs]))
def logsumexp(x, axis=None, keepdims=False):
"""Compute the log of the sum of exponentials of input elements.
See ``scipy.special.logsumexp``.
Parameters
----------
x : symbolic tensor
Input
axis : None or int or tuple of ints, optional
Axis or axes over which the sum is taken. By default axis is None,
and all elements are summed.
keepdims : bool, optional
If this is set to True, the axes which are reduced are left in the
result as dimensions with size one. With this option, the result will
broadcast correctly against the original array.
Returns
-------
tensor
"""
return log(sum(exp(x), axis=axis, keepdims=keepdims))
__all__ = [
"max_and_argmax",
"max",
"argmax",
"min",
"argmin",
"smallest",
"largest",
"lt",
"gt",
"le",
"ge",
"eq",
"neq",
"isnan",
"isinf",
"allclose",
"isclose",
"and_",
"bitwise_and",
"or_",
"bitwise_or",
"xor",
"bitwise_xor",
"invert",
"bitwise_not",
"abs",
"abs_",
"exp",
"exp2",
"expm1",
"neg",
"reciprocal",
"inv",
"log",
"log2",
"log10",
"log1p",
"sgn",
"ceil",
"floor",
"trunc",
"iround",
"round",
"round_half_to_even",
"round_half_away_from_zero",
"sqr",
"square",
"cov",
"sqrt",
"deg2rad",
"rad2deg",
"cos",
"arccos",
"sin",
"arcsin",
"tan",
"arctan",
"arctan2",
"cosh",
"arccosh",
"sinh",
"arcsinh",
"tanh",
"arctanh",
"erf",
"erfc",
"erfcx",
"erfinv",
"erfcinv",
"gamma",
"gammaln",
"psi",
"tri_gamma",
"chi2sf",
"gammainc",
"gammaincc",
"gammau",
"gammal",
"j0",
"j1",
"jv",
"i0",
"i1",
"iv",
"sigmoid",
"expit",
"softplus",
"log1pexp",
"log1mexp",
"betainc",
"real",
"imag",
"angle",
"complex",
"conj",
"complex_from_polar",
"sum",
"prod",
"mean",
"var",
"std",
"std",
"maximum",
"minimum",
"divmod",
"add",
"sub",
"mul",
"true_div",
"int_div",
"floor_div",
"ceil_intdiv",
"mod",
"pow",
"clip",
"dot",
"dense_dot",
"tensordot",
"outer",
"any",
"all",
"ptp",
"power",
"logaddexp",
"logsumexp",
]
| """Logistic sigmoid function (1 / (1 + exp(x)), also known as expit or inverse logit""" |
lib.rs | // Copyright 2020 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//! A shim impelementation of the libm crate, binding directly to the in-tree libc's versions of
//! these functions.
#[macro_use]
extern crate static_assertions;
// Make sure we aren't building for one of the "esoteric systems" on which c_int is not identical | assert_type_eq_all!(std::os::raw::c_int, i32);
extern "C" {
#[link_name = "cbrt"]
fn cbrt_raw(x: f64) -> f64;
#[link_name = "frexpf"]
fn frexpf_raw(x: f32, exp: *mut i32) -> f32;
#[link_name = "ldexp"]
fn ldexp_raw(x: f64, n: i32) -> f64;
#[link_name = "ldexpf"]
fn ldexpf_raw(x: f32, n: i32) -> f32;
#[link_name = "modf"]
fn modf_raw(x: f64, integer_part: *mut f64) -> f64;
}
/// Cube root
#[inline]
pub fn cbrt(x: f64) -> f64 {
unsafe { cbrt_raw(x) }
}
/// Decomposes given floating point value x into a normalized fraction and an integral power of two.
#[inline]
pub fn frexpf(x: f32) -> (f32, i32) {
let mut exp: i32 = 0;
let v = unsafe { frexpf_raw(x, &mut exp) };
(v, exp)
}
/// Multiplies an f64 arg by the number 2 raised to the exp power.
#[inline]
pub fn ldexp(x: f64, n: i32) -> f64 {
unsafe { ldexp_raw(x, n) }
}
/// Multiplies an f32 arg by the number 2 raised to the exp power.
#[inline]
pub fn ldexpf(x: f32, n: i32) -> f32 {
unsafe { ldexpf_raw(x, n) }
}
/// Returns the fractional and integral parts of an f64. The return ordering `(fractional_part,
/// integral_part)` is based on the libm crate from crates.io.
#[inline]
pub fn modf(x: f64) -> (f64, f64) {
let mut integral_part = 0.0;
let fractional_part = unsafe { modf_raw(x, &mut integral_part) };
(fractional_part, integral_part)
} | // to i32 (https://doc.rust-lang.org/std/os/raw/type.c_int.html). |
main.rs | use clap::{load_yaml, App};
use num_format::{Locale, ToFormattedString};
use std::io::BufRead;
use reqwest::Client;
use std::fs::OpenOptions;
fn main() {
let yaml = load_yaml!("cli.yaml");
let m = App::from(yaml).get_matches();
if let Some(matches) = m.subcommand_matches("gen") {
if let Some(i) = matches.value_of("AMOUNT") |
} else if let Some(_matches) = m.subcommand_matches("check") {
#[allow(unused_imports)]
use std::io::{stdin, stdout, Write};
let url = String::new();
// Fetch range of lines to check
// TODO: Implement RANGE check
// if let Some(_i) = matches.value_of("RANGE") {
// let beginrange = 1;
// let endrange = 10;
// println!("Checking lines {}-{}", beginrange, endrange);
// } else {
// println!("No range specified, checking whole file");
// }
match check_codes(url) {
Ok(i) => {
println!("Code checking succeeded: {:#?}", i);
},
Err(e) => {
println!("Error occured during code checking: '{}'", e);
}
}
} else {
println!("No subcommands, try -h/--help");
}
}
// Check codes for validity against discord
fn check_codes(_url: String) -> Result<(), Box<dyn std::error::Error>> {
use std::io::{prelude::*, BufReader};
let file = std::fs::File::open("./codes.txt").expect("The file 'codes.txt' does not exist!");
let aaa = std::fs::File::create("valids.txt").expect("Could not create 'valids.txt'");
let buf = BufReader::new(file);
// Proxy stuff
// Not active right now, since proxies are not working
let lines: Vec<String> = buf
.lines()
.map(|l| l.expect("[ERROR] Could not parse line"))
.collect();
let client: reqwest::blocking::Client;
client = reqwest::blocking::Client::builder()
.build()?;
for (idx, item) in lines.iter().enumerate() {
let res = client.get(format!("https://discordapp.com/api/v6/entitlements/gift-codes/{}?with_application=false&with_subscription_plan=true", item).as_str())
.send();
let res_json: serde_json::Value;
match res {
Ok(i) => {
match i.text() {
Ok(ii) => {
res_json = serde_json::from_str(ii.as_str())?;
if res_json["code"] != 10038 && res_json["global"] != false {
println!("VALID CODE: {}", item);
let mut juhu = OpenOptions::new().append(true).open("valids.txt").expect("Could not open 'valids.txt'");
juhu.write_all(item.as_bytes()).expect("Writing 'valids.txt' failed");
} else {
if res_json["message"] == "You are being rate limited." {
let retry_length = res_json["retry_after"].as_i64().unwrap_or_default();
println!("{}. Rate limit, sleeping for {}ms", idx + 1, retry_length.to_formatted_string(&Locale::de));
let sleep_dur = res_json["retry_after"].as_i64().unwrap_or(50);
std::thread::sleep(std::time::Duration::from_millis(sleep_dur as u64));
} else {
println!("{}. invalid code", idx + 1);
}
}
},
Err(e) => {
println!("{}", e);
}
}
},
Err(e) => {
println!("[ERROR] {}", e);
}
}
}
Ok(())
}
fn generate_codes(amount: u64) -> String {
println!(
"Generating {} codes",
amount.to_formatted_string(&Locale::de)
);
let mut file = std::fs::File::create("codes.txt")
.expect("Creating 'codes.txt' failed, maybe the file is already there?");
let start = std::time::Instant::now();
let mut big_string = String::new();
use rand::prelude::*;
use std::io::Write;
for i in 0..amount {
let randchar: String = rand::thread_rng()
.sample_iter(&rand::distributions::Alphanumeric)
.take(16)
.map(char::from)
.collect();
// Append random code together with url & newline to BIGSTRING
//big_string.push_str(prefix.as_str());
big_string.push_str(randchar.as_str());
big_string.push_str("\n");
if i % 100_000 == 0 {
file.write_all(big_string.as_bytes())
.expect("Could'nt write to file");
big_string = String::from("");
}
}
file.write_all(big_string.as_bytes())
.expect("Couldn't write to file");
let generating_time = start.elapsed();
println!(
"Generated {} codes | Elapsed time: generating & saving: {:#?}",
amount.to_formatted_string(&Locale::de),
generating_time,
);
return String::from("");
}
| {
let amount = i.parse::<u64>();
match amount {
Ok(i) => {
generate_codes(i);
}
Err(_e) => {
println!("The input amount is not a number!");
}
}
} |
disallow_circular_no_inline_fragments.rs | /*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
use crate::no_inline::NO_INLINE_DIRECTIVE_NAME;
use common::{Diagnostic, DiagnosticsResult, NamedItem};
use graphql_ir::{FragmentDefinition, FragmentSpread, OperationDefinition, Program, Validator};
use intern::string_key::{StringKey, StringKeyMap};
use thiserror::Error;
pub fn disallow_circular_no_inline_fragments(program: &Program) -> DiagnosticsResult<()> {
let mut validator = DisallowCircularNoInlineFragments::new(program);
validator.validate_program(program)
}
enum FragmentStatus {
Visiting,
Visited,
}
struct DisallowCircularNoInlineFragments<'program> {
program: &'program Program,
fragments: StringKeyMap<FragmentStatus>,
}
impl<'program> DisallowCircularNoInlineFragments<'program> {
fn new(program: &'program Program) -> Self {
Self {
program,
fragments: Default::default(),
}
}
}
impl Validator for DisallowCircularNoInlineFragments<'_> {
const NAME: &'static str = "disallow_circular_no_inline_fragments";
const VALIDATE_ARGUMENTS: bool = false;
const VALIDATE_DIRECTIVES: bool = false;
fn validate_operation(&mut self, _: &OperationDefinition) -> DiagnosticsResult<()> {
Ok(())
}
fn validate_fragment(&mut self, fragment: &FragmentDefinition) -> DiagnosticsResult<()> {
match self.fragments.get(&fragment.name.item) {
None => {
self.fragments
.insert(fragment.name.item, FragmentStatus::Visiting);
let result = self.validate_selections(&fragment.selections);
self.fragments
.insert(fragment.name.item, FragmentStatus::Visited);
result
}
Some(FragmentStatus::Visited) => Ok(()),
Some(FragmentStatus::Visiting) => {
if fragment
.directives
.named(*NO_INLINE_DIRECTIVE_NAME)
.is_some()
| else {
Ok(())
}
}
}
}
fn validate_fragment_spread(&mut self, spread: &FragmentSpread) -> DiagnosticsResult<()> {
let fragment = self.program.fragment(spread.fragment.item).unwrap();
self.validate_fragment(fragment)
}
}
#[derive(Debug, Error)]
enum ValidationMessage {
#[error("Found a circular reference from fragment '{fragment_name}'.")]
CircularFragmentReference { fragment_name: StringKey },
}
| {
Err(vec![Diagnostic::error(
ValidationMessage::CircularFragmentReference {
fragment_name: fragment.name.item,
},
fragment.name.location,
)])
} |
region.ts | export interface Region {
regId: number;
regName: string;
bankLink: number;
bankShortName: string;
}
export function compareRegions(c1: Region, c2: Region) {
const compare = c1.regName > c2.regName;
if (compare) {
return 1;
} else if ( c1.regName < c2.regName) {
return -1;
} else { return 0; }
}
export class | implements Region {
regId: number;
regName: string;
bankLink: number;
bankShortName: string;
constructor() {
this.regName = '';
this.bankLink = 0;
this.bankShortName = '';
}
}
| DefaultRegion |
config.js | const { Pool } = require('pg');
const AWS = require("aws-sdk");
const fs = require('fs');
const SQL = require('@nearform/sql');
const config = JSON.parse(fs.readFileSync(`${__dirname}/config.${process.env.ENV}.json`));
AWS.config = {
...AWS.config,
...config.aws.config
};
const sqs = new AWS.SQS();
function sendNewGlamMessage(glam) {
return sqs.sendMessage({
QueueUrl: config.aws.newGlamQueueUrl,
MessageBody: JSON.stringify(glam),
}).promise()
}
config.glamUser.realm = 'User area';
const glamUser = config.glamUser;
glamUser.users.push(config.admin);
config.admin.realm = 'Admin area';
const cassandraPgPool = new Pool(config.postgres);
const glams = {};
async function loadGlams() {
const query = `SELECT * FROM glams`;
const result = await cassandraPgPool.query(query)
result.rows.forEach(element => {
const glam = {
name: element.name,
fullname: element.fullname,
category: element.category,
image: element.image,
website: element.website,
connection: new Pool({
...config.postgres,
database: element.database
})
};
if (element.lastrun) {
glam.lastrun = element.lastrun;
} else {
glam.lastrun = null;
}
if (element.status) {
glam.status = element.status;
} else {
glam.status = null;
}
if (element['http-auth']) {
glam['http-auth'] = element['http-auth'];
glam['http-auth'].realm = element.name + " stats";
}
// Glams are never deleted
glams[glam.name] = glam;
})
return glams;
}
async function | (glam) {
const { name, fullname, category, image, database, website } = glam;
const query = SQL`INSERT INTO glams (name, fullname, category, image, database, status, website)
VALUES (${name}, ${fullname}, ${category}, ${image}, ${database}, 'pending', ${website || null})`;
await cassandraPgPool.query(query)
await sendNewGlamMessage({ name, fullname, category, image, database });
console.log(`Created new GLAM "${name}"`);
}
function updateGlam(glam) {
const { name, fullname, image, website } = glam;
const query = SQL`
UPDATE glams
SET fullname = ${fullname},
image = ${image},
website = ${website},
updated_at = NOW()
WHERE name = ${name}
`;
return cassandraPgPool.query(query);
}
module.exports = {
...config,
glamUser,
glams,
loadGlams,
insertGlam,
updateGlam,
cassandraPgPool
} | insertGlam |
hooks.go | package fixtures
var HookPush = `
{
"ref": "refs/heads/master",
"before": "4b2626259b5a97b6b4eab5e6cca66adb986b672b",
"after": "ef98532add3b2feb7a137426bba1248724367df5",
"compare_url": "http://gogs.golang.org/gordon/hello-world/compare/4b2626259b5a97b6b4eab5e6cca66adb986b672b...ef98532add3b2feb7a137426bba1248724367df5",
"commits": [
{
"id": "ef98532add3b2feb7a137426bba1248724367df5",
"message": "bump\n",
"url": "http://gogs.golang.org/gordon/hello-world/commit/ef98532add3b2feb7a137426bba1248724367df5",
"author": {
"name": "Gordon the Gopher",
"email": "[email protected]",
"username": "gordon"
}
}
],
"repository": { | "name": "hello-world",
"url": "http://gogs.golang.org/gordon/hello-world",
"description": "",
"website": "",
"watchers": 1,
"owner": {
"name": "gordon",
"email": "[email protected]",
"username": "gordon"
},
"private": true
},
"pusher": {
"name": "gordon",
"email": "[email protected]",
"username": "gordon"
},
"sender": {
"login": "gordon",
"id": 1,
"avatar_url": "http://gogs.golang.org///1.gravatar.com/avatar/8c58a0be77ee441bb8f8595b7f1b4e87"
}
}
` | "id": 1, |
test_email_backend.py | """Custom email backend for testing the project."""
import re
from django.core.mail.backends.smtp import EmailBackend as SmtpEmailBackend
from django.core.mail.message import sanitize_address
from . import default_settings as settings
class EmailBackend(SmtpEmailBackend):
"""
Email backend that sends all emails to a defined address, no matter what
the recipient really is.
In order to use it, set this in your local_settings.py::
EMAIL_BACKEND = 'django_libs.test_email_backend.EmailBackend'
TEST_EMAIL_BACKEND_RECIPIENTS = (
('Name', '[email protected]'),
)
"""
def _send(self, email_message):
"""A helper method that does the actual sending."""
if not email_message.recipients() or \
not settings.TEST_EMAIL_BACKEND_RECIPIENTS:
return False
from_email = sanitize_address(
email_message.from_email, email_message.encoding)
recipients = [sanitize_address(addr, email_message.encoding)
for name, addr in settings.TEST_EMAIL_BACKEND_RECIPIENTS]
try:
self.connection.sendmail(
from_email, recipients, email_message.message().as_string())
except:
if not self.fail_silently:
raise
return False
return True
class WhitelistEmailBackend(SmtpEmailBackend):
"""
Email backend that sends only these emails, that match the whitelist
setting.
In order to use it, set this in your local_settings.py::
EMAIL_BACKEND = 'django_libs.test_email_backend.EmailBackend'
EMAIL_BACKEND_WHITELIST = [
r'.*@example\.com',
]
This setting would allow all emails to @example.com to be sent and all
others are discarded. The setting expects regex, so better test it before
adding it here to prevent errors.
If the setting does not exist, no emails are sent at all.
"""
def _send(self, email_message):
|
def clean_recipients(self, email_message):
"""Removes all the unallowed recipients."""
new_recipients = []
recipients = [sanitize_address(addr, email_message.encoding)
for addr in email_message.recipients()]
for recipient in recipients:
if self.matches_whitelist(recipient):
new_recipients.append(recipient)
elif settings.EMAIL_BACKEND_REROUTE_BLACKLIST:
for name, addr in settings.TEST_EMAIL_BACKEND_RECIPIENTS:
new_recipients.append(addr)
# remove duplicates
new_recipients = list(set(new_recipients))
return new_recipients
def matches_whitelist(self, recipient):
"""Checks if the email address matches one of the whitelist entries."""
matches = False
for entry in settings.EMAIL_BACKEND_WHITELIST:
if re.match(entry, recipient):
matches = True
return matches
| """A helper method that does the actual sending."""
from_email = sanitize_address(
email_message.from_email, email_message.encoding)
recipients = self.clean_recipients(email_message)
if not recipients:
return False
try:
self.connection.sendmail(
from_email, recipients, email_message.message().as_string())
except:
if not self.fail_silently:
raise
return False
return True |
weaviate_wellknown_liveness_parameters.go | // _ _
// __ _____ __ ___ ___ __ _| |_ ___
// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
// \ V V / __/ (_| |\ V /| | (_| | || __/
// \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
//
// Copyright © 2016 - 2022 SeMI Technologies B.V. All rights reserved.
//
// CONTACT: [email protected]
//
// Code generated by go-swagger; DO NOT EDIT.
package operations
// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command
import (
"net/http"
"github.com/go-openapi/errors"
"github.com/go-openapi/runtime/middleware"
)
// NewWeaviateWellknownLivenessParams creates a new WeaviateWellknownLivenessParams object
// no default values defined in spec.
func NewWeaviateWellknownLivenessParams() WeaviateWellknownLivenessParams { |
// WeaviateWellknownLivenessParams contains all the bound params for the weaviate wellknown liveness operation
// typically these are obtained from a http.Request
//
// swagger:parameters weaviate.wellknown.liveness
type WeaviateWellknownLivenessParams struct {
// HTTP Request Object
HTTPRequest *http.Request `json:"-"`
}
// BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface
// for simple values it will use straight method calls.
//
// To ensure default values, the struct must have been initialized with NewWeaviateWellknownLivenessParams() beforehand.
func (o *WeaviateWellknownLivenessParams) BindRequest(r *http.Request, route *middleware.MatchedRoute) error {
var res []error
o.HTTPRequest = r
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
}
|
return WeaviateWellknownLivenessParams{}
}
|
attribute.go | /*
* Copyright 2017 XLAB d.o.o.
*
* 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.
*
*/
package cl
import (
"errors"
"fmt"
"math/big"
"strconv"
"github.com/spf13/viper"
)
type Attrs struct {
// attributes that are Known to the credential receiver and issuer
Known []*big.Int
// attributes which are Known only to the credential receiver
Hidden []*big.Int
// attributes for which the issuer knows only commitment
Committed []*big.Int
}
func NewAttrs(known, committed, hidden []*big.Int) *Attrs {
return &Attrs{
Known: known,
Hidden: hidden,
Committed: committed,
}
}
func (a *Attrs) join() []*big.Int {
all := make([]*big.Int, 0)
all = append(all, a.Known...)
all = append(all, a.Hidden...)
all = append(all, a.Committed...)
return all
}
// AttrCount holds the number of Known, Committed and
// Hidden parameters.
type AttrCount struct {
Known int
Committed int
Hidden int
}
func NewAttrCount(known, committed, hidden int) *AttrCount {
return &AttrCount{
Known: known,
Committed: committed,
Hidden: hidden,
}
}
func (c *AttrCount) String() string {
return fmt.Sprintf("Known: %d\ncommitted: %d\nhidden: %d\n",
c.Known, c.Committed, c.Hidden)
}
// CredAttr represents an attribute for the CL scheme.
type CredAttr interface {
getIndex() int
getValue() interface{}
getCond() AttrCond
UpdateValue(interface{}) error
internalValue() *big.Int
updateInternalValue(*big.Int) error
setInternalValue() error
isKnown() bool
hasVal() bool
Name() string
String() string
Validatable
}
// Validatable validates against a credential attribute.
type Validatable interface{
ValidateAgainst(interface{}) (bool, error)
}
type AttrCond int
const (
lessThan AttrCond = iota
lessThanOrEqual
greaterThan
greaterThanOrEqual
equal
none
)
var attrCondStr = []string{"lt", "lte", "gt", "gte", "equal", "none"}
func (c AttrCond) String() string {
return attrCondStr[c]
}
func parseAttrCond(cond string) (AttrCond, error) {
for i, c := range attrCondStr {
if cond == c {
return AttrCond(i), nil
}
}
return -1, fmt.Errorf("invalid condition '%s'", cond)
}
// Attr is part of a credential (RawCredential). In the case of digital identity credential,
// attributes could be for example name, Gender, Date of Birth. In the case of a credential allowing
// access to some internet service (like electronic newspaper), attributes could be
// Type (for example only news related to politics) of the service and Date of Expiration.
type Attr struct {
name string
Known bool
ValSet bool
Val *big.Int
cond AttrCond
Index int
}
func | (name string, known bool) *Attr {
return &Attr{
name: name,
Known: known,
ValSet: false,
}
}
func (a *Attr) getIndex() int {
return a.Index
}
func (a *Attr) getCond() AttrCond {
return a.cond
}
func (a *Attr) isKnown() bool {
return a.Known
}
func (a *Attr) internalValue() *big.Int {
return a.Val
}
func (a *Attr) hasVal() bool {
return a.ValSet
}
func (a *Attr) Name() string {
return a.name
}
func (a *Attr) String() string {
tag := "Known"
if !a.isKnown() {
tag = "revealed"
}
return fmt.Sprintf("%s (%s)", a.name, tag)
}
type Int64Attr struct {
Val int64
*Attr
}
func NewEmptyInt64Attr(name string, known bool) *Int64Attr {
return &Int64Attr{
Attr: newAttr(name, known),
}
}
func NewInt64Attr(name string, val int64, known bool) (*Int64Attr,
error) {
a := &Int64Attr{
Val: val,
Attr: newAttr(name, known),
}
if err := a.setInternalValue(); err != nil {
return nil, err
}
return a, nil
}
func (a *Int64Attr) setInternalValue() error {
a.Attr.Val = big.NewInt(int64(a.Val)) // FIXME
a.ValSet = true
return nil
}
func (a *Int64Attr) updateInternalValue(val *big.Int) error {
v, err := strconv.Atoi(val.String())
if err != nil {
return err
}
a.Val = int64(v)
return nil
}
func (a *Int64Attr) getValue() interface{} {
return a.Val
}
func (a *Int64Attr) UpdateValue(n interface{}) error {
switch n.(type) {
case int:
a.Val = int64(n.(int))
case int64:
a.Val = n.(int64)
}
return a.setInternalValue()
}
func (a *Int64Attr) ValidateAgainst(v interface{}) (bool, error) {
actual, ok := v.(int64)
if !ok {
return false, fmt.Errorf("value provided for '%s' is not int64",
a.Name())
}
var res bool
switch a.cond {
case greaterThan:
res = actual > a.Val
case greaterThanOrEqual:
res = actual >= a.Val
case lessThan:
res = actual < a.Val
case lessThanOrEqual:
res = actual <= a.Val
case equal:
res = actual == a.Val
default:
return false, errors.New("invalid condition")
}
return res, nil
}
func (a *Int64Attr) String() string {
return fmt.Sprintf("%s, type = %T", a.Attr.String(), a.Val)
}
type StrAttr struct {
Val string
*Attr
}
func NewEmptyStrAttr(name string, known bool) *StrAttr {
return &StrAttr{
Attr: newAttr(name, known),
}
}
func NewStrAttr(name, val string, known bool) (*StrAttr,
error) {
a := &StrAttr{
Val: val,
Attr: newAttr(name, known),
}
if err := a.setInternalValue(); err != nil {
return nil, err
}
return a, nil
}
func (a *StrAttr) setInternalValue() error {
a.Attr.Val = new(big.Int).SetBytes([]byte(a.Val)) // FIXME
a.ValSet = true
return nil
}
func (a *StrAttr) updateInternalValue(val *big.Int) error {
v := string(val.Bytes())
a.Val = v
return nil
}
func (a *StrAttr) getValue() interface{} {
return a.Val
}
func (a *StrAttr) UpdateValue(s interface{}) error {
a.Val = s.(string)
return a.setInternalValue()
}
func (a *StrAttr) ValidateAgainst(v interface{}) (bool, error) {
actual, ok := v.(string)
if !ok {
return false, fmt.Errorf("value provided for '%s' is not string",
a.Name())
}
if a.cond != equal {
return false, errors.New("invalid condition")
}
return actual == a.Val, nil
}
func (a *StrAttr) String() string {
return fmt.Sprintf("%s, type = %T", a.Attr.String(), a.Val)
}
// FIXME make nicer
// Hook to organization?
func parseAttrs(v *viper.Viper) ([]CredAttr, *AttrCount, error) {
if !v.IsSet("attributes") {
return nil, nil, fmt.Errorf("missing attributes declaration")
}
specs := v.GetStringMap("attributes")
attrs := make([]CredAttr, len(specs))
var nKnown, nCommitted int
for name, val := range specs { // TODO enforce proper ordering with Index
data, ok := val.(map[string]interface{})
if !ok {
return nil, nil, fmt.Errorf("invalid configuration")
}
index, ok := data["index"]
if !ok {
return nil, nil, fmt.Errorf("missing attribute index")
}
i, ok := index.(int)
if !ok {
return nil, nil, fmt.Errorf("Index must be an integer")
}
if i >= len(attrs) {
return nil, nil,
fmt.Errorf("Index too large for the provided number of attributes")
}
if attrs[i] != nil {
return nil, nil,
fmt.Errorf("duplicate index")
}
t, ok := data["type"]
if !ok {
return nil, nil, fmt.Errorf("missing type specifier")
}
known := true
k, ok := data["known"]
if ok {
res, err := strconv.ParseBool(k.(string))
if err != nil {
return nil, nil, fmt.Errorf("Known must be true or false")
}
known = res
}
if known {
nKnown++
} else {
nCommitted++
}
var condition AttrCond
cond, ok := data["cond"]
if !ok {
condition = none
} else {
c, err := parseAttrCond(cond.(string))
if err != nil {
return nil, nil, err
}
condition = c
}
switch t {
case "string":
a, err := NewStrAttr(name, "", known) // FIXME
if err != nil {
return nil, nil, err
}
a.cond = condition
attrs[i] = a
a.Index = i
case "int64":
a, err := NewInt64Attr(name, 0, known) // FIXME
if err != nil {
return nil, nil, err
}
a.cond = condition
attrs[i] = a
a.Index = i
default:
return nil, nil, fmt.Errorf("unsupported attribute type: %s", t)
}
i++
}
// TODO Hidden params
return attrs, NewAttrCount(nKnown, nCommitted, 0), nil
}
| newAttr |
flux_response.py | # coding: utf-8
"""
Influx API Service
No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501
OpenAPI spec version: 0.1.0
Generated by: https://openapi-generator.tech
"""
import pprint
import re # noqa: F401
import six
class FluxResponse(object):
"""NOTE: This class is auto generated by OpenAPI Generator.
Ref: https://openapi-generator.tech
Do not edit the class manually.
"""
"""
Attributes:
openapi_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
"""
openapi_types = {
'flux': 'str'
}
attribute_map = {
'flux': 'flux'
}
def __init__(self, flux=None): # noqa: E501
"""FluxResponse - a model defined in OpenAPI""" # noqa: E501
self._flux = None
self.discriminator = None
if flux is not None:
self.flux = flux
@property
def flux(self):
"""Gets the flux of this FluxResponse. # noqa: E501
:return: The flux of this FluxResponse. # noqa: E501
:rtype: str
"""
return self._flux
@flux.setter
def flux(self, flux):
"""Sets the flux of this FluxResponse.
:param flux: The flux of this FluxResponse. # noqa: E501
:type: str
"""
self._flux = flux
def to_dict(self):
|
def to_str(self):
"""Returns the string representation of the model"""
return pprint.pformat(self.to_dict())
def __repr__(self):
"""For `print` and `pprint`"""
return self.to_str()
def __eq__(self, other):
"""Returns true if both objects are equal"""
if not isinstance(other, FluxResponse):
return False
return self.__dict__ == other.__dict__
def __ne__(self, other):
"""Returns true if both objects are not equal"""
return not self == other
| """Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.openapi_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
return result |
1080p_187.ts | version https://git-lfs.github.com/spec/v1
oid sha256:41a4985b10f4406224325fe235a6b2804edd54ce91e2b60e8267d7f5b63a976a | size 1468280 | |
json_test.go | ///////////////////////////////////////////////////////////////////////
// Copyright (c) 2017 VMware, Inc. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
///////////////////////////////////////////////////////////////////////
package parser
import (
"bytes"
"encoding/json"
"testing"
"time"
"github.com/google/go-cmp/cmp"
uuid "github.com/satori/go.uuid"
"github.com/stretchr/testify/assert"
"github.com/vmware/dispatch/pkg/events"
)
var testEvent1 = events.CloudEvent{
Namespace: "dispatchframework.io",
EventType: "test.event",
EventTypeVersion: "0.1",
CloudEventsVersion: events.CloudEventsVersion,
SourceType: "test.source",
SourceID: "test.source.id",
EventID: uuid.NewV4().String(),
EventTime: time.Now(),
SchemaURL: "http://some.url.com/file",
ContentType: "application/json",
Extensions: nil,
Data: `{"example":"value"}`,
}
func eventJSON(event *events.CloudEvent) []byte {
val, _ := json.Marshal(event)
return val
}
func TestParsingEmptyList(t *testing.T) {
buf := bytes.NewBufferString("[]")
p := &JSONEventParser{}
evs, err := p.Parse(buf)
assert.NoError(t, err)
assert.Len(t, evs, 0)
}
func TestParsingMalformed(t *testing.T) |
func TestParsingCorrect(t *testing.T) {
buf := bytes.NewBuffer(eventJSON(&testEvent1))
p := &JSONEventParser{}
evs, err := p.Parse(buf)
assert.NoError(t, err)
assert.Len(t, evs, 1)
assert.True(t, cmp.Equal(testEvent1, evs[0]))
}
| {
buf := bytes.NewBufferString("{gdsgsdgs}")
p := &JSONEventParser{}
evs, err := p.Parse(buf)
assert.Error(t, err)
assert.Len(t, evs, 0)
} |
pages.module.ts | import { CommonModule } from '@angular/common';
import { NgModule } from '@angular/core';
import { PagesRoutingModule } from './pages-routing.module';
import { AboutPageComponent } from './about-page.component';
@NgModule({
imports: [
CommonModule,
PagesRoutingModule
],
declarations: [
AboutPageComponent
]
})
export class | {}
| PagesModule |
writeback.rs | // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// Type resolution: the phase that finds all the types in the AST with
// unresolved type variables and replaces "ty_var" types with their
// substitutions.
use self::ResolveReason::*;
use astconv::AstConv;
use check::FnCtxt;
use middle::pat_util;
use middle::ty::{self, Ty, MethodCall, MethodCallee};
use middle::ty_fold::{TypeFolder,TypeFoldable};
use middle::infer;
use write_substs_to_tcx;
use write_ty_to_tcx;
use util::ppaux::Repr;
use std::cell::Cell;
use syntax::ast;
use syntax::codemap::{DUMMY_SP, Span};
use syntax::print::pprust::pat_to_string;
use syntax::visit;
use syntax::visit::Visitor;
///////////////////////////////////////////////////////////////////////////
// Entry point functions
pub fn resolve_type_vars_in_expr(fcx: &FnCtxt, e: &ast::Expr) {
assert_eq!(fcx.writeback_errors.get(), false);
let mut wbcx = WritebackCx::new(fcx);
wbcx.visit_expr(e);
wbcx.visit_upvar_borrow_map();
wbcx.visit_closures();
wbcx.visit_object_cast_map();
}
pub fn resolve_type_vars_in_fn(fcx: &FnCtxt,
decl: &ast::FnDecl,
blk: &ast::Block) {
assert_eq!(fcx.writeback_errors.get(), false);
let mut wbcx = WritebackCx::new(fcx);
wbcx.visit_block(blk);
for arg in decl.inputs.iter() {
wbcx.visit_node_id(ResolvingPattern(arg.pat.span), arg.id);
wbcx.visit_pat(&*arg.pat);
// Privacy needs the type for the whole pattern, not just each binding
if !pat_util::pat_is_binding(&fcx.tcx().def_map, &*arg.pat) {
wbcx.visit_node_id(ResolvingPattern(arg.pat.span),
arg.pat.id);
}
}
wbcx.visit_upvar_borrow_map();
wbcx.visit_closures();
wbcx.visit_object_cast_map();
}
///////////////////////////////////////////////////////////////////////////
// The Writerback context. This visitor walks the AST, checking the
// fn-specific tables to find references to types or regions. It
// resolves those regions to remove inference variables and writes the
// final result back into the master tables in the tcx. Here and
// there, it applies a few ad-hoc checks that were not convenient to
// do elsewhere.
struct WritebackCx<'cx, 'tcx: 'cx> {
fcx: &'cx FnCtxt<'cx, 'tcx>,
}
impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
fn new(fcx: &'cx FnCtxt<'cx, 'tcx>) -> WritebackCx<'cx, 'tcx> {
WritebackCx { fcx: fcx }
}
fn tcx(&self) -> &'cx ty::ctxt<'tcx> {
self.fcx.tcx()
}
}
///////////////////////////////////////////////////////////////////////////
// Impl of Visitor for Resolver
//
// This is the master code which walks the AST. It delegates most of
// the heavy lifting to the generic visit and resolve functions
// below. In general, a function is made into a `visitor` if it must
// traffic in node-ids or update tables in the type context etc.
impl<'cx, 'tcx, 'v> Visitor<'v> for WritebackCx<'cx, 'tcx> {
fn visit_item(&mut self, _: &ast::Item) {
// Ignore items
}
fn visit_stmt(&mut self, s: &ast::Stmt) {
if self.fcx.writeback_errors.get() {
return;
}
self.visit_node_id(ResolvingExpr(s.span), ty::stmt_node_id(s));
visit::walk_stmt(self, s);
}
fn visit_expr(&mut self, e: &ast::Expr) {
if self.fcx.writeback_errors.get() {
return;
}
self.visit_node_id(ResolvingExpr(e.span), e.id);
self.visit_method_map_entry(ResolvingExpr(e.span),
MethodCall::expr(e.id));
match e.node {
ast::ExprClosure(_, _, ref decl, _) => {
for input in decl.inputs.iter() {
let _ = self.visit_node_id(ResolvingExpr(e.span),
input.id);
}
}
_ => {}
}
visit::walk_expr(self, e);
}
fn visit_block(&mut self, b: &ast::Block) {
if self.fcx.writeback_errors.get() {
return;
}
self.visit_node_id(ResolvingExpr(b.span), b.id);
visit::walk_block(self, b);
}
fn visit_pat(&mut self, p: &ast::Pat) {
if self.fcx.writeback_errors.get() {
return;
}
self.visit_node_id(ResolvingPattern(p.span), p.id);
debug!("Type for pattern binding {} (id {}) resolved to {}",
pat_to_string(p),
p.id,
ty::node_id_to_type(self.tcx(), p.id).repr(self.tcx()));
visit::walk_pat(self, p);
}
fn visit_local(&mut self, l: &ast::Local) |
fn visit_ty(&mut self, t: &ast::Ty) {
match t.node {
ast::TyFixedLengthVec(ref ty, ref count_expr) => {
self.visit_ty(&**ty);
write_ty_to_tcx(self.tcx(), count_expr.id, self.tcx().types.uint);
}
_ => visit::walk_ty(self, t)
}
}
}
impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
fn visit_upvar_borrow_map(&self) {
if self.fcx.writeback_errors.get() {
return;
}
for (upvar_id, upvar_capture) in self.fcx.inh.upvar_capture_map.borrow().iter() {
let new_upvar_capture = match *upvar_capture {
ty::UpvarCapture::ByValue => ty::UpvarCapture::ByValue,
ty::UpvarCapture::ByRef(ref upvar_borrow) => {
let r = upvar_borrow.region;
let r = self.resolve(&r, ResolvingUpvar(*upvar_id));
ty::UpvarCapture::ByRef(
ty::UpvarBorrow { kind: upvar_borrow.kind, region: r })
}
};
debug!("Upvar capture for {} resolved to {}",
upvar_id.repr(self.tcx()),
new_upvar_capture.repr(self.tcx()));
self.fcx.tcx().upvar_capture_map.borrow_mut().insert(*upvar_id, new_upvar_capture);
}
}
fn visit_closures(&self) {
if self.fcx.writeback_errors.get() {
return
}
for (def_id, closure) in self.fcx.inh.closures.borrow().iter() {
let closure_ty = self.resolve(&closure.closure_type,
ResolvingClosure(*def_id));
let closure = ty::Closure {
closure_type: closure_ty,
kind: closure.kind,
};
self.fcx.tcx().closures.borrow_mut().insert(*def_id, closure);
}
}
fn visit_object_cast_map(&self) {
if self.fcx.writeback_errors.get() {
return
}
for (&node_id, trait_ref) in self.fcx
.inh
.object_cast_map
.borrow()
.iter()
{
let span = ty::expr_span(self.tcx(), node_id);
let reason = ResolvingExpr(span);
let closure_ty = self.resolve(trait_ref, reason);
self.tcx()
.object_cast_map
.borrow_mut()
.insert(node_id, closure_ty);
}
}
fn visit_node_id(&self, reason: ResolveReason, id: ast::NodeId) {
// Resolve any borrowings for the node with id `id`
self.visit_adjustments(reason, id);
// Resolve the type of the node with id `id`
let n_ty = self.fcx.node_ty(id);
let n_ty = self.resolve(&n_ty, reason);
write_ty_to_tcx(self.tcx(), id, n_ty);
debug!("Node {} has type {}", id, n_ty.repr(self.tcx()));
// Resolve any substitutions
self.fcx.opt_node_ty_substs(id, |item_substs| {
write_substs_to_tcx(self.tcx(), id,
self.resolve(item_substs, reason));
});
}
fn visit_adjustments(&self, reason: ResolveReason, id: ast::NodeId) {
match self.fcx.inh.adjustments.borrow_mut().remove(&id) {
None => {
debug!("No adjustments for node {}", id);
}
Some(adjustment) => {
let adj_object = ty::adjust_is_object(&adjustment);
let resolved_adjustment = match adjustment {
ty::AdjustReifyFnPointer(def_id) => {
ty::AdjustReifyFnPointer(def_id)
}
ty::AdjustDerefRef(adj) => {
for autoderef in 0..adj.autoderefs {
let method_call = MethodCall::autoderef(id, autoderef);
self.visit_method_map_entry(reason, method_call);
}
if adj_object {
let method_call = MethodCall::autoobject(id);
self.visit_method_map_entry(reason, method_call);
}
ty::AdjustDerefRef(ty::AutoDerefRef {
autoderefs: adj.autoderefs,
autoref: self.resolve(&adj.autoref, reason),
})
}
};
debug!("Adjustments for node {}: {:?}", id, resolved_adjustment);
self.tcx().adjustments.borrow_mut().insert(
id, resolved_adjustment);
}
}
}
fn visit_method_map_entry(&self,
reason: ResolveReason,
method_call: MethodCall) {
// Resolve any method map entry
match self.fcx.inh.method_map.borrow_mut().remove(&method_call) {
Some(method) => {
debug!("writeback::resolve_method_map_entry(call={:?}, entry={})",
method_call,
method.repr(self.tcx()));
let new_method = MethodCallee {
origin: self.resolve(&method.origin, reason),
ty: self.resolve(&method.ty, reason),
substs: self.resolve(&method.substs, reason),
};
self.tcx().method_map.borrow_mut().insert(
method_call,
new_method);
}
None => {}
}
}
fn resolve<T:TypeFoldable<'tcx>>(&self, t: &T, reason: ResolveReason) -> T {
t.fold_with(&mut Resolver::new(self.fcx, reason))
}
}
///////////////////////////////////////////////////////////////////////////
// Resolution reason.
#[derive(Copy)]
enum ResolveReason {
ResolvingExpr(Span),
ResolvingLocal(Span),
ResolvingPattern(Span),
ResolvingUpvar(ty::UpvarId),
ResolvingClosure(ast::DefId),
}
impl ResolveReason {
fn span(&self, tcx: &ty::ctxt) -> Span {
match *self {
ResolvingExpr(s) => s,
ResolvingLocal(s) => s,
ResolvingPattern(s) => s,
ResolvingUpvar(upvar_id) => {
ty::expr_span(tcx, upvar_id.closure_expr_id)
}
ResolvingClosure(did) => {
if did.krate == ast::LOCAL_CRATE {
ty::expr_span(tcx, did.node)
} else {
DUMMY_SP
}
}
}
}
}
///////////////////////////////////////////////////////////////////////////
// The Resolver. This is the type folding engine that detects
// unresolved types and so forth.
struct Resolver<'cx, 'tcx: 'cx> {
tcx: &'cx ty::ctxt<'tcx>,
infcx: &'cx infer::InferCtxt<'cx, 'tcx>,
writeback_errors: &'cx Cell<bool>,
reason: ResolveReason,
}
impl<'cx, 'tcx> Resolver<'cx, 'tcx> {
fn new(fcx: &'cx FnCtxt<'cx, 'tcx>,
reason: ResolveReason)
-> Resolver<'cx, 'tcx>
{
Resolver::from_infcx(fcx.infcx(), &fcx.writeback_errors, reason)
}
fn from_infcx(infcx: &'cx infer::InferCtxt<'cx, 'tcx>,
writeback_errors: &'cx Cell<bool>,
reason: ResolveReason)
-> Resolver<'cx, 'tcx>
{
Resolver { infcx: infcx,
tcx: infcx.tcx,
writeback_errors: writeback_errors,
reason: reason }
}
fn report_error(&self, e: infer::fixup_err) {
self.writeback_errors.set(true);
if !self.tcx.sess.has_errors() {
match self.reason {
ResolvingExpr(span) => {
span_err!(self.tcx.sess, span, E0101,
"cannot determine a type for this expression: {}",
infer::fixup_err_to_string(e));
}
ResolvingLocal(span) => {
span_err!(self.tcx.sess, span, E0102,
"cannot determine a type for this local variable: {}",
infer::fixup_err_to_string(e));
}
ResolvingPattern(span) => {
span_err!(self.tcx.sess, span, E0103,
"cannot determine a type for this pattern binding: {}",
infer::fixup_err_to_string(e));
}
ResolvingUpvar(upvar_id) => {
let span = self.reason.span(self.tcx);
span_err!(self.tcx.sess, span, E0104,
"cannot resolve lifetime for captured variable `{}`: {}",
ty::local_var_name_str(self.tcx, upvar_id.var_id).get().to_string(),
infer::fixup_err_to_string(e));
}
ResolvingClosure(_) => {
let span = self.reason.span(self.tcx);
span_err!(self.tcx.sess, span, E0196,
"cannot determine a type for this closure")
}
}
}
}
}
impl<'cx, 'tcx> TypeFolder<'tcx> for Resolver<'cx, 'tcx> {
fn tcx<'a>(&'a self) -> &'a ty::ctxt<'tcx> {
self.tcx
}
fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
match self.infcx.fully_resolve(&t) {
Ok(t) => t,
Err(e) => {
debug!("Resolver::fold_ty: input type `{}` not fully resolvable",
t.repr(self.tcx));
self.report_error(e);
self.tcx().types.err
}
}
}
fn fold_region(&mut self, r: ty::Region) -> ty::Region {
match self.infcx.fully_resolve(&r) {
Ok(r) => r,
Err(e) => {
self.report_error(e);
ty::ReStatic
}
}
}
}
///////////////////////////////////////////////////////////////////////////
// During type check, we store promises with the result of trait
// lookup rather than the actual results (because the results are not
// necessarily available immediately). These routines unwind the
// promises. It is expected that we will have already reported any
// errors that may be encountered, so if the promises store an error,
// a dummy result is returned.
| {
if self.fcx.writeback_errors.get() {
return;
}
let var_ty = self.fcx.local_ty(l.span, l.id);
let var_ty = self.resolve(&var_ty, ResolvingLocal(l.span));
write_ty_to_tcx(self.tcx(), l.id, var_ty);
visit::walk_local(self, l);
} |
extension-manager.helpers.spec.ts | import { TestExtension } from '@remirror/test-fixtures';
import { transformExtensionMap } from '../extension-manager.helpers';
import { DocExtension, TextExtension } from '../nodes';
describe('transformExtensionMap', () => { | const test = new TestExtension();
const text = new TextExtension();
const extensions = [
{ extension: doc, priority: 2 },
{ extension: test, priority: 2 },
{ extension: text, priority: 2 },
];
expect(transformExtensionMap(extensions)).toEqual([doc, test, text]);
});
it('sorts the extensions by priority', () => {
const doc = new DocExtension();
const test = new TestExtension();
const text = new TextExtension();
const extensions = [
{ extension: doc, priority: 1 },
{ extension: test, priority: 2 },
{ extension: text, priority: -1 },
];
expect(transformExtensionMap(extensions)).toEqual([text, doc, test]);
});
it('can sort with default priority', () => {
const doc = new DocExtension();
const test = new TestExtension();
const text = new TextExtension();
const extensions = [{ extension: doc, priority: 1 }, test, { extension: text, priority: -1 }];
expect(transformExtensionMap(extensions)).toEqual([text, doc, test]);
});
}); | it('maps the extensions', () => {
const doc = new DocExtension(); |
snapshot_test.go | package snapshot
import (
"os"
"testing"
"github.com/openebs/maya/pkg/apis/openebs.io/v1alpha1"
menv "github.com/openebs/maya/pkg/env/v1alpha1"
v1_storage "k8s.io/api/storage/v1"
)
func TestGetCreateCASTemplate(t *testing.T) {
sc := &v1_storage.StorageClass{}
sc.Annotations = make(map[string]string)
tests := map[string]struct {
scCreateCASAnnotation string
scCASTypeAnnotation string
envJivaCAST string
envCStorCAST string
expectedCAST string
}{
"CAST annotation is present": {
"cast-create-from-annotation", | "",
"",
"cast-create-from-annotation",
},
"CAST annotation is absent/empty and cas type is cstor": {
"",
"cstor",
"",
"cast-cstor-create-from-env",
"cast-cstor-create-from-env",
},
"CAST annotation is absent/empty and cas type is jiva": {
"",
"jiva",
"cast-jiva-create-from-env",
"",
"cast-jiva-create-from-env",
},
"CAST annotation is absent/empty and cas type unknown": {
"",
"unknown",
"cast-jiva-create-from-env",
"cast-cstor-create-from-env",
"",
},
}
defer func() {
os.Unsetenv(string(menv.CASTemplateToCreateCStorSnapshotENVK))
os.Unsetenv(string(menv.CASTemplateToCreateJivaSnapshotENVK))
}()
for name, test := range tests {
t.Run(name, func(t *testing.T) {
sc.Annotations[string(v1alpha1.CASTemplateKeyForSnapshotCreate)] = test.scCreateCASAnnotation
sc.Annotations[string(v1alpha1.CASTypeKey)] = test.scCASTypeAnnotation
os.Setenv(string(menv.CASTemplateToCreateCStorSnapshotENVK), test.envCStorCAST)
os.Setenv(string(menv.CASTemplateToCreateJivaSnapshotENVK), test.envJivaCAST)
castName := getCreateCASTemplate(sc)
if castName != test.expectedCAST {
t.Fatalf("unexpected cast name, wanted %q got %q", test.expectedCAST, castName)
}
})
}
}
func TestGetReadCASTemplate(t *testing.T) {
sc := &v1_storage.StorageClass{}
sc.Annotations = make(map[string]string)
tests := map[string]struct {
scReadCASAnnotation string
scCASTypeAnnotation string
envJivaCAST string
envCStorCAST string
expectedCAST string
}{
"CAST annotation is present": {
"cast-read-from-annotation",
"",
"",
"",
"cast-read-from-annotation",
},
"CAST annotation is absent/empty and cas type is cstor": {
"",
"cstor",
"",
"cast-cstor-read-from-env",
"cast-cstor-read-from-env",
},
"CAST annotation is absent/empty and cas type is jiva": {
"",
"jiva",
"cast-jiva-read-from-env",
"",
"cast-jiva-read-from-env",
},
"CAST annotation is absent/empty and cas type unknown": {
"",
"unknown",
"cast-jiva-read-from-env",
"cast-cstor-read-from-env",
"",
},
}
defer func() {
os.Unsetenv(string(menv.CASTemplateToReadCStorSnapshotENVK))
os.Unsetenv(string(menv.CASTemplateToReadJivaSnapshotENVK))
}()
for name, test := range tests {
t.Run(name, func(t *testing.T) {
sc.Annotations[string(v1alpha1.CASTemplateKeyForSnapshotRead)] = test.scReadCASAnnotation
sc.Annotations[string(v1alpha1.CASTypeKey)] = test.scCASTypeAnnotation
os.Setenv(string(menv.CASTemplateToReadCStorSnapshotENVK), test.envCStorCAST)
os.Setenv(string(menv.CASTemplateToReadJivaSnapshotENVK), test.envJivaCAST)
castName := getReadCASTemplate(sc)
if castName != test.expectedCAST {
t.Fatalf("unexpected cast name, wanted %q got %q", test.expectedCAST, castName)
}
})
}
}
func TestGetDeleteCASTemplate(t *testing.T) {
sc := &v1_storage.StorageClass{}
sc.Annotations = make(map[string]string)
tests := map[string]struct {
scDeleteCASAnnotation string
scCASTypeAnnotation string
envJivaCAST string
envCStorCAST string
expectedCAST string
}{
"CAST annotation is present": {
"cast-read-from-annotation",
"",
"",
"",
"cast-read-from-annotation",
},
"CAST annotation is absent/empty and cas type is cstor": {
"",
"cstor",
"",
"cast-cstor-read-from-env",
"cast-cstor-read-from-env",
},
"CAST annotation is absent/empty and cas type is jiva": {
"",
"jiva",
"cast-jiva-read-from-env",
"",
"cast-jiva-read-from-env",
},
"CAST annotation is absent/empty and cas type unknown": {
"",
"unknown",
"cast-jiva-read-from-env",
"cast-cstor-read-from-env",
"",
},
}
defer func() {
os.Unsetenv(string(menv.CASTemplateToDeleteCStorSnapshotENVK))
os.Unsetenv(string(menv.CASTemplateToDeleteJivaSnapshotENVK))
}()
for name, test := range tests {
t.Run(name, func(t *testing.T) {
sc.Annotations[string(v1alpha1.CASTemplateKeyForSnapshotDelete)] = test.scDeleteCASAnnotation
sc.Annotations[string(v1alpha1.CASTypeKey)] = test.scCASTypeAnnotation
os.Setenv(string(menv.CASTemplateToDeleteCStorSnapshotENVK), test.envCStorCAST)
os.Setenv(string(menv.CASTemplateToDeleteJivaSnapshotENVK), test.envJivaCAST)
castName := getDeleteCASTemplate(sc)
if castName != test.expectedCAST {
t.Fatalf("unexpected cast name, wanted %q got %q", test.expectedCAST, castName)
}
})
}
} | "", |
indexed_dataset.py | # Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from functools import lru_cache
import os
import shutil
import struct
import numpy as np
import torch
from . import FairseqDataset
def __best_fitting_dtype(vocab_size=None):
if vocab_size is not None and vocab_size < 65500:
return np.uint16
else:
return np.int32
def get_available_dataset_impl():
return ['raw', 'lazy', 'cached', 'mmap']
def infer_dataset_impl(path):
if IndexedRawTextDataset.exists(path):
return 'raw'
elif IndexedDataset.exists(path):
with open(index_file_path(path), 'rb') as f:
magic = f.read(8)
if magic == IndexedDataset._HDR_MAGIC:
return 'cached'
elif magic == MMapIndexedDataset.Index._HDR_MAGIC[:8]:
return 'mmap'
else:
return None
else:
return None
def make_builder(out_file, impl, vocab_size=None):
if impl == 'mmap':
return MMapIndexedDatasetBuilder(out_file, dtype=__best_fitting_dtype(vocab_size))
else:
return IndexedDatasetBuilder(out_file)
def make_dataset(path, impl, fix_lua_indexing=False, dictionary=None):
if impl == 'raw' and IndexedRawTextDataset.exists(path):
assert dictionary is not None
return IndexedRawTextDataset(path, dictionary)
elif impl == 'lazy' and IndexedDataset.exists(path):
return IndexedDataset(path, fix_lua_indexing=fix_lua_indexing)
elif impl == 'cached' and IndexedDataset.exists(path):
return IndexedCachedDataset(path, fix_lua_indexing=fix_lua_indexing)
elif impl == 'mmap' and MMapIndexedDataset.exists(path):
return MMapIndexedDataset(path)
return None
def dataset_exists(path, impl):
if impl == 'raw':
return IndexedRawTextDataset.exists(path)
elif impl == 'mmap':
return MMapIndexedDataset.exists(path)
else:
return IndexedDataset.exists(path)
def read_longs(f, n):
a = np.empty(n, dtype=np.int64)
f.readinto(a)
return a
def write_longs(f, a):
f.write(np.array(a, dtype=np.int64))
dtypes = {
1: np.uint8,
2: np.int8,
3: np.int16,
4: np.int32,
5: np.int64,
6: np.float,
7: np.double,
8: np.uint16
}
def code(dtype):
for k in dtypes.keys():
if dtypes[k] == dtype:
return k
raise ValueError(dtype)
def index_file_path(prefix_path):
return prefix_path + '.idx'
def data_file_path(prefix_path):
return prefix_path + '.bin'
class IndexedDataset(FairseqDataset):
"""Loader for TorchNet IndexedDataset"""
_HDR_MAGIC = b'TNTIDX\x00\x00'
def __init__(self, path, fix_lua_indexing=False):
super().__init__()
self.path = path
self.fix_lua_indexing = fix_lua_indexing
self.data_file = None
self.read_index(path)
def read_index(self, path):
with open(index_file_path(path), 'rb') as f:
magic = f.read(8)
assert magic == self._HDR_MAGIC, (
'Index file doesn\'t match expected format. '
'Make sure that --dataset-impl is configured properly.'
)
version = f.read(8)
assert struct.unpack('<Q', version) == (1,)
code, self.element_size = struct.unpack('<QQ', f.read(16))
self.dtype = dtypes[code]
self._len, self.s = struct.unpack('<QQ', f.read(16))
self.dim_offsets = read_longs(f, self._len + 1)
self.data_offsets = read_longs(f, self._len + 1)
self.sizes = read_longs(f, self.s)
def read_data(self, path):
self.data_file = open(data_file_path(path), 'rb', buffering=0)
def check_index(self, i):
if i < 0 or i >= self._len:
raise IndexError('index out of range')
def __del__(self):
if self.data_file:
self.data_file.close()
@lru_cache(maxsize=8)
def __getitem__(self, i):
if not self.data_file:
self.read_data(self.path)
self.check_index(i)
tensor_size = self.sizes[self.dim_offsets[i]:self.dim_offsets[i + 1]]
a = np.empty(tensor_size, dtype=self.dtype)
self.data_file.seek(self.data_offsets[i] * self.element_size)
self.data_file.readinto(a)
item = torch.from_numpy(a).long()
if self.fix_lua_indexing:
item -= 1 # subtract 1 for 0-based indexing
return item
def __len__(self):
return self._len
def num_tokens(self, index):
return self.sizes[index]
def size(self, index):
|
@staticmethod
def exists(path):
return (
os.path.exists(index_file_path(path)) and os.path.exists(data_file_path(path))
)
@property
def supports_prefetch(self):
return False # avoid prefetching to save memory
class IndexedCachedDataset(IndexedDataset):
def __init__(self, path, fix_lua_indexing=False):
super().__init__(path, fix_lua_indexing=fix_lua_indexing)
self.cache = None
self.cache_index = {}
@property
def supports_prefetch(self):
return True
def prefetch(self, indices):
if all(i in self.cache_index for i in indices):
return
if not self.data_file:
self.read_data(self.path)
indices = sorted(set(indices))
total_size = 0
for i in indices:
total_size += self.data_offsets[i + 1] - self.data_offsets[i]
self.cache = np.empty(total_size, dtype=self.dtype)
ptx = 0
self.cache_index.clear()
for i in indices:
self.cache_index[i] = ptx
size = self.data_offsets[i + 1] - self.data_offsets[i]
a = self.cache[ptx: ptx + size]
self.data_file.seek(self.data_offsets[i] * self.element_size)
self.data_file.readinto(a)
ptx += size
if self.data_file:
# close and delete data file after prefetch so we can pickle
self.data_file.close()
self.data_file = None
@lru_cache(maxsize=8)
def __getitem__(self, i):
self.check_index(i)
tensor_size = self.sizes[self.dim_offsets[i]:self.dim_offsets[i + 1]]
a = np.empty(tensor_size, dtype=self.dtype)
ptx = self.cache_index[i]
np.copyto(a, np.reshape(self.cache[ptx: ptx + a.size], tensor_size))
item = torch.from_numpy(a).long()
if self.fix_lua_indexing:
item -= 1 # subtract 1 for 0-based indexing
return item
class IndexedRawTextDataset(FairseqDataset):
"""Takes a text file as input and binarizes it in memory at instantiation.
Original lines are also kept in memory"""
def __init__(self, path, dictionary, append_eos=True, reverse_order=False):
self.tokens_list = []
self.lines = []
self.sizes = []
self.append_eos = append_eos
self.reverse_order = reverse_order
self.read_data(path, dictionary)
self.size = len(self.tokens_list)
def read_data(self, path, dictionary):
with open(path, 'r', encoding='utf-8') as f:
for line in f:
self.lines.append(line.strip('\n'))
tokens = dictionary.encode_line(
line, add_if_not_exist=False,
append_eos=self.append_eos, reverse_order=self.reverse_order,
).long()
self.tokens_list.append(tokens)
self.sizes.append(len(tokens))
self.sizes = np.array(self.sizes)
def check_index(self, i):
if i < 0 or i >= self.size:
raise IndexError('index out of range')
@lru_cache(maxsize=8)
def __getitem__(self, i):
self.check_index(i)
return self.tokens_list[i]
def get_original_text(self, i):
self.check_index(i)
return self.lines[i]
def __del__(self):
pass
def __len__(self):
return self.size
def num_tokens(self, index):
return self.sizes[index]
def size(self, index):
return self.sizes[index]
@staticmethod
def exists(path):
return os.path.exists(path)
class IndexedDatasetBuilder(object):
element_sizes = {
np.uint8: 1,
np.int8: 1,
np.int16: 2,
np.int32: 4,
np.int64: 8,
np.float: 4,
np.double: 8
}
def __init__(self, out_file, dtype=np.int32):
self.out_file = open(out_file, 'wb')
self.dtype = dtype
self.data_offsets = [0]
self.dim_offsets = [0]
self.sizes = []
self.element_size = self.element_sizes[self.dtype]
def add_item(self, tensor):
# +1 for Lua compatibility
bytes = self.out_file.write(np.array(tensor.numpy() + 1, dtype=self.dtype))
self.data_offsets.append(self.data_offsets[-1] + bytes / self.element_size)
for s in tensor.size():
self.sizes.append(s)
self.dim_offsets.append(self.dim_offsets[-1] + len(tensor.size()))
def merge_file_(self, another_file):
index = IndexedDataset(another_file)
assert index.dtype == self.dtype
begin = self.data_offsets[-1]
for offset in index.data_offsets[1:]:
self.data_offsets.append(begin + offset)
self.sizes.extend(index.sizes)
begin = self.dim_offsets[-1]
for dim_offset in index.dim_offsets[1:]:
self.dim_offsets.append(begin + dim_offset)
with open(data_file_path(another_file), 'rb') as f:
while True:
data = f.read(1024)
if data:
self.out_file.write(data)
else:
break
def finalize(self, index_file):
self.out_file.close()
index = open(index_file, 'wb')
index.write(b'TNTIDX\x00\x00')
index.write(struct.pack('<Q', 1))
index.write(struct.pack('<QQ', code(self.dtype), self.element_size))
index.write(struct.pack('<QQ', len(self.data_offsets) - 1, len(self.sizes)))
write_longs(index, self.dim_offsets)
write_longs(index, self.data_offsets)
write_longs(index, self.sizes)
index.close()
def _warmup_mmap_file(path):
with open(path, 'rb') as stream:
while stream.read(100 * 1024 * 1024):
pass
class MMapIndexedDataset(torch.utils.data.Dataset):
class Index(object):
_HDR_MAGIC = b'MMIDIDX\x00\x00'
@classmethod
def writer(cls, path, dtype):
class _Writer(object):
def __enter__(self):
self._file = open(path, 'wb')
self._file.write(cls._HDR_MAGIC)
self._file.write(struct.pack('<Q', 1))
self._file.write(struct.pack('<B', code(dtype)))
return self
@staticmethod
def _get_pointers(sizes):
dtype_size = dtype().itemsize
address = 0
pointers = []
for size in sizes:
pointers.append(address)
address += size * dtype_size
return pointers
def write(self, sizes):
pointers = self._get_pointers(sizes)
self._file.write(struct.pack('<Q', len(sizes)))
sizes = np.array(sizes, dtype=np.int32)
self._file.write(sizes.tobytes(order='C'))
del sizes
pointers = np.array(pointers, dtype=np.int64)
self._file.write(pointers.tobytes(order='C'))
del pointers
def __exit__(self, exc_type, exc_val, exc_tb):
self._file.close()
return _Writer()
def __init__(self, path):
with open(path, 'rb') as stream:
magic_test = stream.read(9)
assert self._HDR_MAGIC == magic_test, (
'Index file doesn\'t match expected format. '
'Make sure that --dataset-impl is configured properly.'
)
version = struct.unpack('<Q', stream.read(8))
assert (1,) == version
dtype_code, = struct.unpack('<B', stream.read(1))
self._dtype = dtypes[dtype_code]
self._dtype_size = self._dtype().itemsize
self._len = struct.unpack('<Q', stream.read(8))[0]
offset = stream.tell()
_warmup_mmap_file(path)
self._bin_buffer_mmap = np.memmap(path, mode='r', order='C')
self._bin_buffer = memoryview(self._bin_buffer_mmap)
self._sizes = np.frombuffer(self._bin_buffer, dtype=np.int32, count=self._len, offset=offset)
self._pointers = np.frombuffer(self._bin_buffer, dtype=np.int64, count=self._len,
offset=offset + self._sizes.nbytes)
def __del__(self):
self._bin_buffer_mmap._mmap.close()
del self._bin_buffer_mmap
@property
def dtype(self):
return self._dtype
@property
def sizes(self):
return self._sizes
@lru_cache(maxsize=8)
def __getitem__(self, i):
return self._pointers[i], self._sizes[i]
def __len__(self):
return self._len
def __init__(self, path):
super().__init__()
self._path = None
self._index = None
self._bin_buffer = None
self._do_init(path)
def __getstate__(self):
return self._path
def __setstate__(self, state):
self._do_init(state)
def _do_init(self, path):
self._path = path
self._index = self.Index(index_file_path(self._path))
_warmup_mmap_file(data_file_path(self._path))
self._bin_buffer_mmap = np.memmap(data_file_path(self._path), mode='r', order='C')
self._bin_buffer = memoryview(self._bin_buffer_mmap)
def __del__(self):
self._bin_buffer_mmap._mmap.close()
del self._bin_buffer_mmap
del self._index
def __len__(self):
return len(self._index)
@lru_cache(maxsize=8)
def __getitem__(self, i):
ptr, size = self._index[i]
np_array = np.frombuffer(self._bin_buffer, dtype=self._index.dtype, count=size, offset=ptr)
if self._index.dtype != np.int64:
np_array = np_array.astype(np.int64)
return torch.from_numpy(np_array)
@property
def sizes(self):
return self._index.sizes
@property
def supports_prefetch(self):
return False
@staticmethod
def exists(path):
return (
os.path.exists(index_file_path(path)) and os.path.exists(data_file_path(path))
)
class MMapIndexedDatasetBuilder(object):
def __init__(self, out_file, dtype=np.int64):
self._data_file = open(out_file, 'wb')
self._dtype = dtype
self._sizes = []
def add_item(self, tensor):
np_array = np.array(tensor.numpy(), dtype=self._dtype)
self._data_file.write(np_array.tobytes(order='C'))
self._sizes.append(np_array.size)
def merge_file_(self, another_file):
# Concatenate index
index = MMapIndexedDataset.Index(index_file_path(another_file))
assert index.dtype == self._dtype
for size in index.sizes:
self._sizes.append(size)
# Concatenate data
with open(data_file_path(another_file), 'rb') as f:
shutil.copyfileobj(f, self._data_file)
def finalize(self, index_file):
self._data_file.close()
with MMapIndexedDataset.Index.writer(index_file, self._dtype) as index:
index.write(self._sizes)
| return self.sizes[index] |
crash_1554249366815_12283_flaky_4.js | function main() {
function | (v2,v3,v4,v5) {
const v7 = [SharedArrayBuffer];
const v8 = v7.indexOf();
v8.__proto__ = Map;
for (let v12 = 0; v12 < 100; v12++) {
let v14 = undefined;
}
}
const v15 = v1();
const v16 = v1();
}
%NeverOptimizeFunction(main);
main();
| v1 |
cmd_status.go | package main
import (
"database/sql"
"fmt"
"log"
"path/filepath"
"time"
"github.com/tbruyelle/goose/lib/goose"
)
var statusCmd = &Command{
Name: "status",
Usage: "",
Summary: "dump the migration status for the current DB",
Help: `status extended help here...`,
Run: statusRun,
}
type StatusData struct {
Source string
Status string
}
func statusRun(cmd *Command, args ...string) {
conf, err := dbConfFromFlags()
if err != nil {
log.Fatal(err)
}
// collect all migrations
min := int64(0)
max := int64((1 << 63) - 1)
migrations, e := goose.CollectMigrations(conf.MigrationsDir, min, max)
if e != nil { | if e != nil {
log.Fatal("couldn't open DB:", e)
}
defer db.Close()
// must ensure that the version table exists if we're running on a pristine DB
if _, e := goose.EnsureDBVersion(conf, db); e != nil {
log.Fatal(e)
}
fmt.Printf("goose*: status for environment '%v'\n", conf.Env)
fmt.Println(" Applied At Migration")
fmt.Println(" =======================================")
for _, m := range migrations {
printMigrationStatus(db, m.Version, filepath.Base(m.Source))
}
}
func printMigrationStatus(db *sql.DB, version int64, script string) {
var row goose.MigrationRecord
q := fmt.Sprintf("SELECT tstamp, is_applied FROM goose_db_version WHERE version_id=%d ORDER BY tstamp DESC LIMIT 1", version)
e := db.QueryRow(q).Scan(&row.TStamp, &row.IsApplied)
if e != nil && e != sql.ErrNoRows {
log.Fatal(e)
}
var appliedAt string
if row.IsApplied {
appliedAt = row.TStamp.Format(time.ANSIC)
} else {
appliedAt = "Pending"
}
fmt.Printf(" %-24s -- %v\n", appliedAt, script)
} | log.Fatal(e)
}
db, e := goose.OpenDBFromDBConf(conf) |
builder_test.go | // Copyright 2018 Istio Authors
//
// 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.
package routing
import (
"context"
"strings"
"testing"
"github.com/gogo/protobuf/types"
"istio.io/istio/mixer/pkg/adapter"
"istio.io/istio/mixer/pkg/il/compiled"
"istio.io/istio/mixer/pkg/runtime2/config"
"istio.io/istio/mixer/pkg/runtime2/handler"
"istio.io/istio/mixer/pkg/runtime2/testing/data"
"istio.io/istio/mixer/pkg/runtime2/testing/util"
"istio.io/istio/mixer/pkg/template"
)
// tests is a declarative test suite for the routing table. It covers both table building as well as table
// usage scenarios.
var tests = []struct {
// Name of the test
Name string
// Config values to use when using the builder to build the table. If ServiceConfig is empty, the default
// one from the testing/data package is used instead.
ServiceConfig string
Configs []string
Adapters map[string]*adapter.Info
Templates map[string]*template.Info
// ExpectedTable is the expected routing table output w/ debug info. Used by builder tests to verify the
// table structure.
ExpectedTable string
}{
{
Name: "basic",
ServiceConfig: data.ServiceConfig,
Configs: []string{
data.HandlerACheck1,
data.InstanceCheck1,
data.RuleCheck1,
},
ExpectedTable: `
[Routing ExpectedTable]
ID: 1
[#0] TEMPLATE_VARIETY_CHECK {V}
[#0] istio-system {NS}
[#0] hcheck1.acheck.istio-system {H}
[#0]
Condition: <NONE>
[#0] icheck1.tcheck.istio-system {I}
`,
},
{
Name: "multiple-instances-check",
ServiceConfig: data.ServiceConfig,
Configs: []string{
data.HandlerACheck1,
data.InstanceCheck1,
data.InstanceCheck2,
data.RuleCheck1WithInstance1And2,
},
ExpectedTable: `
[Routing ExpectedTable]
ID: 1
[#0] TEMPLATE_VARIETY_CHECK {V}
[#0] istio-system {NS}
[#0] hcheck1.acheck.istio-system {H}
[#0]
Condition: <NONE>
[#0] icheck1.tcheck.istio-system {I}
[#1] icheck2.tcheck.istio-system {I}
`,
},
{
Name: "multiple-instances-report",
ServiceConfig: data.ServiceConfig,
Configs: []string{
data.HandlerAReport1,
data.InstanceReport1,
data.InstanceReport2,
data.RuleReport1And2,
},
ExpectedTable: `
[Routing ExpectedTable]
ID: 1
[#0] TEMPLATE_VARIETY_REPORT {V}
[#0] istio-system {NS}
[#0] hreport1.areport.istio-system {H}
[#0]
Condition: <NONE>
[#0] ireport1.treport.istio-system {I}
[#1] ireport2.treport.istio-system {I}
`,
},
{
Name: "check-instance-with-conditional",
ServiceConfig: data.ServiceConfig,
Configs: []string{
data.HandlerACheck1,
data.InstanceCheck1,
data.RuleCheck1WithMatchClause,
},
ExpectedTable: `
[Routing ExpectedTable]
ID: 1
[#0] TEMPLATE_VARIETY_CHECK {V}
[#0] istio-system {NS}
[#0] hcheck1.acheck.istio-system {H}
[#0]
Condition: match(target.name, "foo*")
[#0] icheck1.tcheck.istio-system {I}
`,
},
{
Name: "instance-with-conditional-true",
ServiceConfig: data.ServiceConfig,
Configs: []string{
data.HandlerACheck1,
data.InstanceCheck1,
data.RuleCheck1TrueCondition,
},
ExpectedTable: `
[Routing ExpectedTable]
ID: 1
[#0] TEMPLATE_VARIETY_CHECK {V}
[#0] istio-system {NS}
[#0] hcheck1.acheck.istio-system {H}
[#0]
Condition: <NONE>
[#0] icheck1.tcheck.istio-system {I}
`,
},
{
Name: "multi-instance-with-conditional",
ServiceConfig: data.ServiceConfig,
Configs: []string{
data.HandlerACheck1,
data.InstanceCheck1,
data.InstanceCheck2,
data.RuleCheck1WithInstance1And2WithMatchClause,
},
ExpectedTable: `
[Routing ExpectedTable]
ID: 1
[#0] TEMPLATE_VARIETY_CHECK {V}
[#0] istio-system {NS}
[#0] hcheck1.acheck.istio-system {H}
[#0]
Condition: match(target.name, "foo*")
[#0] icheck1.tcheck.istio-system {I}
[#1] icheck2.tcheck.istio-system {I}
`,
},
{
Name: "multi-instance-multi-conditional",
ServiceConfig: data.ServiceConfig,
Configs: []string{
data.HandlerACheck1,
data.InstanceCheck1,
data.InstanceCheck2,
data.InstanceCheck3,
data.RuleCheck1WithInstance1And2WithMatchClause,
data.RuleCheck2WithInstance2And3WithMatchClause,
},
ExpectedTable: `
[Routing ExpectedTable]
ID: 1
[#0] TEMPLATE_VARIETY_CHECK {V}
[#0] istio-system {NS}
[#0] hcheck1.acheck.istio-system {H}
[#0]
Condition: match(target.name, "foo*")
[#0] icheck1.tcheck.istio-system {I}
[#1] icheck2.tcheck.istio-system {I}
[#1]
Condition: target.name.startsWith("foo")
[#0] icheck2.tcheck.istio-system {I}
[#1] icheck3.tcheck.istio-system {I}
`,
},
{
Name: "multi-rule-to-same-target",
ServiceConfig: data.ServiceConfig,
Configs: []string{
data.HandlerACheck1,
data.InstanceCheck1,
data.InstanceCheck2,
data.InstanceCheck3,
data.RuleCheck1WithInstance1And2,
data.RuleCheck2WithInstance2And3,
},
// TODO(Issue #2690): We should dedupe instances that are being dispatched to a particular handler.
ExpectedTable: `
[Routing ExpectedTable]
ID: 1
[#0] TEMPLATE_VARIETY_CHECK {V}
[#0] istio-system {NS}
[#0] hcheck1.acheck.istio-system {H}
[#0]
Condition: <NONE>
[#0] icheck1.tcheck.istio-system {I}
[#1] icheck2.tcheck.istio-system {I}
[#2] icheck2.tcheck.istio-system {I}
[#3] icheck3.tcheck.istio-system {I}
`,
},
{
Name: "multi-rule-to-same-target-with-one-conditional",
ServiceConfig: data.ServiceConfig,
Configs: []string{
data.HandlerACheck1,
data.InstanceCheck1,
data.InstanceCheck2,
data.InstanceCheck3,
data.RuleCheck1,
data.RuleCheck2WithInstance2And3WithMatchClause,
},
ExpectedTable: `
[Routing ExpectedTable]
ID: 1
[#0] TEMPLATE_VARIETY_CHECK {V}
[#0] istio-system {NS}
[#0] hcheck1.acheck.istio-system {H}
[#0]
Condition: <NONE>
[#0] icheck1.tcheck.istio-system {I}
[#1]
Condition: target.name.startsWith("foo")
[#0] icheck2.tcheck.istio-system {I}
[#1] icheck3.tcheck.istio-system {I}
`,
},
{
Name: "multi-rule-to-multiple-target",
ServiceConfig: data.ServiceConfig,
Configs: []string{
data.HandlerACheck1,
data.HandlerACheck2,
data.InstanceCheck1,
data.InstanceCheck2,
data.RuleCheck1,
data.RuleCheck2WithHandler2AndInstance2,
},
ExpectedTable: `
[Routing ExpectedTable]
ID: 1
[#0] TEMPLATE_VARIETY_CHECK {V}
[#0] istio-system {NS}
[#0] hcheck1.acheck.istio-system {H}
[#0]
Condition: <NONE>
[#0] icheck1.tcheck.istio-system {I}
[#1] hcheck2.acheck.istio-system {H}
[#0]
Condition: <NONE>
[#0] icheck2.tcheck.istio-system {I}
`,
},
{
Name: "bad-condition",
ServiceConfig: data.ServiceConfig,
Configs: []string{
data.HandlerACheck1,
data.InstanceCheck1,
data.RuleCheck1WithBadCondition,
},
// No routes are set, as the only rule is bad.
ExpectedTable: `
[Routing ExpectedTable]
ID: 1
`,
},
{
Name: "bad-handler-name",
ServiceConfig: data.ServiceConfig,
Configs: []string{
data.HandlerACheck1,
data.InstanceCheck1,
data.RuleCheck1WithBadHandler,
},
// No routes are set, as the only rule is bad.
ExpectedTable: `
[Routing ExpectedTable]
ID: 1
`,
},
{
Name: "bad-handler-builder",
ServiceConfig: data.ServiceConfig,
Configs: []string{
data.HandlerACheck1,
data.InstanceCheck1,
data.RuleCheck1,
},
Adapters: data.BuildAdapters(nil, data.FakeAdapterSettings{Name: "acheck", ErrorAtBuild: true}),
// No routes are set, as the only rule is bad.
ExpectedTable: `
[Routing ExpectedTable]
ID: 1
`,
},
{
Name: "handler-does-not-support-template",
ServiceConfig: data.ServiceConfig,
Configs: []string{
data.HandlerACheck1,
data.InstanceCheck1,
data.RuleCheck1,
},
Templates: data.BuildTemplates(nil, data.FakeTemplateSettings{Name: "tcheck", HandlerDoesNotSupportTemplate: true}),
ExpectedTable: `
[Routing ExpectedTable]
ID: 1
`,
},
{
Name: "different-namespace",
ServiceConfig: data.ServiceConfig,
Configs: []string{
data.HandlerACheck3NS2,
data.InstanceCheck4NS2,
data.RuleCheck3NS2,
},
ExpectedTable: `
[Routing ExpectedTable]
ID: 1
[#0] TEMPLATE_VARIETY_CHECK {V}
[#0] ns2 {NS}
[#0] hcheck3.acheck.ns2 {H}
[#0]
Condition: <NONE>
[#0] icheck4.tcheck.ns2 {I}
`,
},
{
Name: "non-default-namespace-rules-subsume-default-namespace-rules",
ServiceConfig: data.ServiceConfig,
Configs: []string{
// default
data.HandlerACheck1,
data.InstanceCheck1,
data.RuleCheck1,
// ns2
data.HandlerACheck3NS2,
data.InstanceCheck4NS2,
data.RuleCheck3NS2,
},
// ns2 ruleset is a superset of the default set.
ExpectedTable: `
[Routing ExpectedTable]
ID: 1
[#0] TEMPLATE_VARIETY_CHECK {V}
[#0] istio-system {NS}
[#0] hcheck1.acheck.istio-system {H}
[#0]
Condition: <NONE>
[#0] icheck1.tcheck.istio-system {I}
[#1] ns2 {NS}
[#0] hcheck1.acheck.istio-system {H}
[#0]
Condition: <NONE>
[#0] icheck1.tcheck.istio-system {I}
[#1] hcheck3.acheck.ns2 {H}
[#0]
Condition: <NONE>
[#0] icheck4.tcheck.ns2 {I}
`,
},
{
Name: "builder-mapper-error-causes-dependent-rules-to-be-omitted",
ServiceConfig: data.ServiceConfig,
Configs: []string{
data.HandlerACheck1,
data.InstanceCheck1,
data.RuleCheck1,
},
Templates: data.BuildTemplates(nil, data.FakeTemplateSettings{Name: "tcheck", ErrorAtCreateInstanceBuilder: true}),
ExpectedTable: `
[Routing ExpectedTable]
ID: 1
`},
{
Name: "match-condition-wrong-return-type-in-match-claus-causes-rule-to-be-omitted.",
ServiceConfig: data.ServiceConfig,
Configs: []string{
data.HandlerACheck1,
data.InstanceCheck1,
data.RuleCheck1WithNonBooleanCondition,
},
ExpectedTable: `
[Routing ExpectedTable]
ID: 1
`},
{
Name: "apa",
ServiceConfig: data.ServiceConfig,
Configs: []string{
data.HandlerAPA1,
data.InstanceAPA1,
data.RuleApa1,
},
ExpectedTable: `
[Routing ExpectedTable]
ID: 1
[#0] TEMPLATE_VARIETY_ATTRIBUTE_GENERATOR {V}
[#0] istio-system {NS}
[#0] hapa1.apa.istio-system {H}
[#0]
Condition: <NONE>
[#0] iapa1.tapa.istio-system {I}
`},
{
Name: "apa-error-at-output-expressions",
ServiceConfig: data.ServiceConfig,
Configs: []string{
data.HandlerAPA1,
data.InstanceAPA1,
data.RuleApa1,
},
Templates: data.BuildTemplates(nil, data.FakeTemplateSettings{Name: "tapa", ErrorAtCreateOutputExpressions: true}),
ExpectedTable: `
[Routing ExpectedTable]
ID: 1
`,
},
{
Name: "different-templates-in-same-rule",
ServiceConfig: data.ServiceConfig,
Configs: []string{
data.HandlerACheck1,
data.InstanceCheck1,
data.InstanceHalt1,
data.Rule4CheckAndHalt,
},
ExpectedTable: `
[Routing ExpectedTable]
ID: 1
[#0] TEMPLATE_VARIETY_CHECK {V}
[#0] istio-system {NS}
[#0] hcheck1.acheck.istio-system {H}
[#0]
Condition: <NONE>
[#0] icheck1.tcheck.istio-system {I}
[#1] hcheck1.acheck.istio-system {H}
[#0]
Condition: <NONE>
[#0] ihalt1.thalt.istio-system {I}`,
},
}
func TestBuilder(t *testing.T) {
for _, tst := range tests {
t.Run(tst.Name, func(tt *testing.T) {
serviceConfig := tst.ServiceConfig
if len(serviceConfig) == 0 {
serviceConfig = data.ServiceConfig
}
templates := tst.Templates
if templates == nil {
templates = data.BuildTemplates(nil)
}
adapters := tst.Adapters
if adapters == nil {
adapters = data.BuildAdapters(nil)
}
t, s := buildTableWithTemplatesAndAdapters(templates, adapters, serviceConfig, tst.Configs, true)
actual := t.String()
if normalize(actual) != normalize(tst.ExpectedTable) {
tt.Logf("Config:\n%v\n\n", tst.Configs)
tt.Logf("Snapshot:\n%s\n\n", s)
tt.Logf("Debug: true")
tt.Fatalf("got:\n%v\nwant:\n%v\n", actual, tst.ExpectedTable)
}
reachedEnd := false
defer func() {
r := recover()
if !reachedEnd |
}()
// rerun with debug = false to ensure there is no crash.
t, _ = buildTable(serviceConfig, tst.Configs, false)
_ = t.String()
reachedEnd = true
})
}
}
var (
normalizer = strings.NewReplacer("\t", "", "\n", "", " ", "")
)
// Normalize a string for textual comparison.
func normalize(str string) string {
return normalizer.Replace(str)
}
// Convenience method for building a routing Table for tests.
func buildTable(serviceConfig string, globalConfigs []string, debugInfo bool) (*Table, *config.Snapshot) {
return buildTableWithTemplatesAndAdapters(data.BuildTemplates(nil), data.BuildAdapters(nil), serviceConfig, globalConfigs, debugInfo)
}
// Convenience method for building a routing Table for tests.
func buildTableWithTemplatesAndAdapters(templates map[string]*template.Info, adapters map[string]*adapter.Info,
serviceConfig string, globalConfigs []string, debugInfo bool) (*Table, *config.Snapshot) {
if len(serviceConfig) == 0 {
serviceConfig = data.ServiceConfig
}
globalConfig := data.JoinConfigs(globalConfigs...)
s := util.GetSnapshot(templates, adapters, serviceConfig, globalConfig)
ht := handler.NewTable(handler.Empty(), s, nil)
expb := compiled.NewBuilder(s.Attributes)
return BuildTable(ht, s, expb, "istio-system", debugInfo), s
}
func TestNonPointerAdapter(t *testing.T) {
templates := data.BuildTemplates(nil)
adapters := map[string]*adapter.Info{
"acheck": {
Name: "acheck",
SupportedTemplates: []string{"tcheck", "thalt"},
DefaultConfig: &types.Struct{},
NewBuilder: func() adapter.HandlerBuilder {
return nonPointerBuilder{}
},
},
}
globalConfigs := []string{
data.HandlerACheck1,
data.InstanceCheck1,
data.InstanceCheck2,
data.RuleCheck1WithInstance1And2,
}
expected := `
[Routing ExpectedTable]
ID: 1
[#0] TEMPLATE_VARIETY_CHECK {V}
[#0] istio-system {NS}
[#0] hcheck1.acheck.istio-system {H}
[#0]
Condition: <NONE>
[#0] icheck1.tcheck.istio-system {I}
[#1] icheck2.tcheck.istio-system {I}
`
table, _ := buildTableWithTemplatesAndAdapters(templates, adapters, data.ServiceConfig, globalConfigs, true)
actual := table.String()
if normalize(actual) != normalize(expected) {
t.Fatalf("got:\n%v\nwant:\n%v\n", actual, expected)
}
}
type nonPointerBuilder struct{}
var _ adapter.HandlerBuilder = nonPointerBuilder{}
func (n nonPointerBuilder) SetAdapterConfig(adapter.Config) {
}
func (n nonPointerBuilder) Validate() *adapter.ConfigErrors {
return nil
}
func (n nonPointerBuilder) Build(context.Context, adapter.Env) (adapter.Handler, error) {
return nonPointerHandler{fn: func() {}}, nil
}
type nonPointerHandler struct {
// Make handler non-comparable.
fn func()
}
var _ adapter.Handler = nonPointerHandler{}
func (h nonPointerHandler) Close() error {
h.fn()
return nil
}
| {
tt.Fatalf("buildTable(debugInfo=false) failed with a panic: '%v'", r)
} |
testresponse.py | __author__ = 'pather'
import urllib.request
import re
africa_url_response = urllib.request.urlopen('http://worldpopulationreview.com/continents/africa-population/')
africa_url_html = africa_url_response.read()
africa_url_text = africa_url_html.decode('UTF-8')
africa_current_population = re.search('<span>([^<]*)', africa_url_text).group(1)
current_population = africa_current_population
# africa_future_population = current_population
print(africa_current_population)
# this wasn't need in the lab 3
def chosen_continent_pop_finder(name_of_continent):
| if name_of_continent == 'Asia' or name_of_continent == 'asia':
return name_of_continent
elif name_of_continent == 'Africa' or name_of_continent == 'africa':
return name_of_continent
elif name_of_continent == 'Europe' or name_of_continent == 'europe':
return name_of_continent
elif name_of_continent == 'South America' or name_of_continent == 'south america':
return name_of_continent
elif name_of_continent == 'North America' or name_of_continent == 'north america':
return name_of_continent
elif name_of_continent == 'Oceania' or name_of_continent == 'oceania':
return name_of_continent
else:
print("Whoops! Let's try this again")
main() |
|
sync_routes.go | //
// Copyright (c) 2019-2021 Red Hat, 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.
//
package devworkspacerouting
import (
"context"
"fmt"
"github.com/devfile/devworkspace-operator/pkg/constants"
"github.com/google/go-cmp/cmp"
"github.com/google/go-cmp/cmp/cmpopts"
routeV1 "github.com/openshift/api/route/v1"
"k8s.io/apimachinery/pkg/api/errors"
"k8s.io/apimachinery/pkg/labels"
"sigs.k8s.io/controller-runtime/pkg/client"
controllerv1alpha1 "github.com/devfile/devworkspace-operator/apis/controller/v1alpha1"
)
var routeDiffOpts = cmp.Options{
cmpopts.IgnoreFields(routeV1.Route{}, "TypeMeta", "ObjectMeta", "Status"),
cmpopts.IgnoreFields(routeV1.RouteSpec{}, "WildcardPolicy", "Host"),
cmpopts.IgnoreFields(routeV1.RouteTargetReference{}, "Weight"),
}
func (r *DevWorkspaceRoutingReconciler) syncRoutes(routing *controllerv1alpha1.DevWorkspaceRouting, specRoutes []routeV1.Route) (ok bool, clusterRoutes []routeV1.Route, err error) {
routesInSync := true
clusterRoutes, err = r.getClusterRoutes(routing)
if err != nil {
return false, nil, err
}
toDelete := getRoutesToDelete(clusterRoutes, specRoutes)
for _, route := range toDelete {
err := r.Delete(context.TODO(), &route)
if err != nil {
return false, nil, err
}
routesInSync = false
}
for _, specRoute := range specRoutes {
if contains, idx := listContainsRouteByName(specRoute, clusterRoutes); contains {
clusterRoute := clusterRoutes[idx]
if !cmp.Equal(specRoute, clusterRoute, routeDiffOpts) {
r.Log.Info(fmt.Sprintf("Updating route: %s", clusterRoute.Name))
if r.DebugLogging {
r.Log.Info(fmt.Sprintf("Diff: %s", cmp.Diff(specRoute, clusterRoute, routeDiffOpts)))
}
// Update route's spec
clusterRoute.Spec = specRoute.Spec
err := r.Update(context.TODO(), &clusterRoute)
if err != nil && !errors.IsConflict(err) {
return false, nil, err
}
routesInSync = false
}
} else {
err := r.Create(context.TODO(), &specRoute)
if err != nil {
return false, nil, err
}
routesInSync = false
}
}
return routesInSync, clusterRoutes, nil
}
func (r *DevWorkspaceRoutingReconciler) getClusterRoutes(routing *controllerv1alpha1.DevWorkspaceRouting) ([]routeV1.Route, error) {
found := &routeV1.RouteList{}
labelSelector, err := labels.Parse(fmt.Sprintf("%s=%s", constants.DevWorkspaceIDLabel, routing.Spec.DevWorkspaceId))
if err != nil { | }
listOptions := &client.ListOptions{
Namespace: routing.Namespace,
LabelSelector: labelSelector,
}
err = r.List(context.TODO(), found, listOptions)
if err != nil {
return nil, err
}
var routes []routeV1.Route
for _, route := range found.Items {
for _, ownerref := range route.OwnerReferences {
// We need to filter routes that are created automatically for ingresses on OpenShift
if ownerref.Kind == "Ingress" {
continue
}
routes = append(routes, route)
}
}
return routes, nil
}
func getRoutesToDelete(clusterRoutes, specRoutes []routeV1.Route) []routeV1.Route {
var toDelete []routeV1.Route
for _, clusterRoute := range clusterRoutes {
if contains, _ := listContainsRouteByName(clusterRoute, specRoutes); !contains {
toDelete = append(toDelete, clusterRoute)
}
}
return toDelete
}
func listContainsRouteByName(query routeV1.Route, list []routeV1.Route) (exists bool, idx int) {
for idx, listRoute := range list {
if query.Name == listRoute.Name {
return true, idx
}
}
return false, -1
} | return nil, err |
api_data_sci.py | #!/usr/local/bin/python
import sys
import pymongo
import argparse
from bson import ObjectId
from gevent.pywsgi import WSGIServer
from geventwebsocket.handler import WebSocketHandler
import bottle
from bottle import Bottle, redirect, request, response, static_file, request
from bson.json_util import dumps
import author_gene_clustering_module
bottle.BaseRequest.MEMFILE_MAX = 1024 * 1024
import app
api = Bottle()
log = app.get_logger('api_alt')
# generic API for returning the record count for a specific mongo database/collection
@api.get('/ds/getmessage')
def | ():
return {
'message' : 'success'
}
# generic API for returning the record count for a specific mongo database/collection
@api.get('/ds/getbpnet/:genes')
def ds_get_bp_net(genes):
genes_list = genes.split(',')
graph_json = author_gene_clustering_module.analyze_AG_bipartite_network(genes_list)
if (request.query.callback):
response.content_type = "application/javascript"
return "%s(%s);" % (request.query.callback, graph_json)
return graph_json
return {
'message' : graph_json
}
# run the web server
def main():
status = 0
parser = argparse.ArgumentParser()
parser.add_argument('port', nargs='?', type=int, help='HTTP port', default=80)
args = parser.parse_args()
print 'starting web server on port %s' % args.port
print 'press control-c to quit'
try:
server = WSGIServer(('0.0.0.0', args.port), api, handler_class=WebSocketHandler)
log.info('entering main loop')
server.serve_forever()
except KeyboardInterrupt:
log.info('exiting main loop')
except Exception as e:
str = 'could not start web server: %s' % e
log.error(str)
print str
status = 1
log.info('exiting with status %d', status)
return status
if __name__ == '__main__':
sys.exit(main()) | ds_getmessage |
system_test.rs | //! A system test:
//! (i) Sets up test configuration,
//! (ii) interacts with the Internet Computer under test
//! (iii) makes assertions about the test results.
//!
//! The SystemTest encodes the test configuration (including the initial network
//! topology, i.e. number of subnetworks and nodes). When the test starts, an
//! Internet Computer instance is created with the test configuration using
//! processes on the local machine. The test author can describe interactions
//! with the IC in a programmatic using the API provided by `IcInstance`, an
//! of which is returned by the `start()` method on `InternetComputer`.
//!
//! The following exemplifies the structure of a system test:
//!
//! ```
//! use ic_scenario_tests::{system_test::InternetComputer};
//! use ic_scenario_tests::api::system::builder::Subnet;
//!
//! #[tokio::test]
//! async fn test_name() {
//! // This should be removed in the future when system tests are identified prior to running
//! // the tests.
//! if InternetComputer::is_system_test_environment().is_err() {
//! return;
//! }
//! let ic = InternetComputer::new()
//! .with_subnet(Subnet::new().add_nodes(4))
//! .with_registered(2)
//! .start();
//! /* test logic */
//! }
//! ```
use crate::api::system::handle::{InitialReplica, SystemTestError, SystemTestResult};
use crate::api::system::{builder::Subnet, handle::IcHandle};
use crate::ltl::*;
use ic_config::logger::Config as LoggerConfig;
use ic_logger::{new_replica_logger, LoggerImpl};
use ic_registry_transport::pb::v1::RegistryMutation;
use ic_types::malicious_behaviour::MaliciousBehaviour;
use ic_types::NodeId;
use ic_utils::command::is_file_on_path;
use log_analyzer::*;
use std::collections::BTreeMap;
use std::sync::Arc;
pub const NODEMANAGER_EXECUTABLE: &str = "nodemanager";
pub const REPLICA_EXECUTABLE: &str = "replica";
#[derive(Clone, Debug)]
pub struct InternetComputer {
pub initial_replica: Option<InitialReplica>,
pub subnets: Vec<Subnet>,
/// `true` iff the initial configuration of the IC contains an NNS subnet.
/// The configuration for the NNS subnet is placed at index 0 of the
/// `subnets` vector.
pub nns_subnet_present: bool,
pub registered_nodes: usize,
pub malicious_behaviours: BTreeMap<NodeId, MaliciousBehaviour>,
pub actix_flag: bool,
pub initial_mutations: Vec<RegistryMutation>,
}
impl InternetComputer {
pub fn new() -> Self {
Self::default()
}
/// A subnet with `nodes` nodes.
pub fn with_subnet(mut self, subnet: Subnet) -> Self {
self.subnets.push(subnet);
self
}
pub fn with_nns_subnet(mut self, subnet: Subnet) -> Self {
if self.nns_subnet_present {
panic!("Called with_nns_subnet() more than once.");
}
self.subnets.insert(0, subnet);
self.nns_subnet_present = true;
self
}
/// Assume an initial condition where `nodes` nodes are registered, but not
/// assigned to a network.
pub fn with_registered_nodes(mut self, nodes: usize) -> Self {
self.registered_nodes = nodes;
self
}
pub fn with_initial_replica(mut self, initial_replica: InitialReplica) -> Self {
self.initial_replica = Some(initial_replica);
self
}
pub fn with_actix_flag(mut self) -> Self {
self.actix_flag = true;
self
}
pub fn with_initial_mutation(mut self, mutation: RegistryMutation) -> Self {
self.initial_mutations.push(mutation);
self
}
/// Collects CLI arguments from the environment and runs the test.
pub async fn start(self) -> Arc<IcHandle> |
/// Collects CLI arguments from the environment and runs the test. Moreover,
/// runs the provided `Analyzer`, if any, with the log from all started
/// processes.
pub async fn start_with_analyzer(
self,
_with_analyzer: Analyzer<'static, LogEntryFrom>,
) -> Arc<IcHandle> {
Self::is_system_test_environment().unwrap();
let logger_config = LoggerConfig::default();
let base_logger = LoggerImpl::new(&logger_config, "scenario_test".into());
let logger = new_replica_logger(base_logger.root.clone(), &logger_config);
let actix_flag = self.actix_flag;
IcHandle::from_internet_computer(
self,
logger,
base_logger,
// , with_analyzer
actix_flag,
)
.await
.expect("Could not instantiate IC")
}
pub fn is_system_test_environment() -> SystemTestResult<()> {
Self::is_file_on_path(NODEMANAGER_EXECUTABLE)
.and_then(|_| Self::is_file_on_path(REPLICA_EXECUTABLE))
}
fn is_file_on_path(f: &str) -> SystemTestResult<()> {
if !is_file_on_path(f) {
return Err(SystemTestError::InitializationError(format!(
"Executable '{}' not found on the path.",
f
)));
}
Ok(())
}
}
impl Default for InternetComputer {
fn default() -> Self {
Self {
initial_replica: None,
subnets: vec![],
nns_subnet_present: false,
registered_nodes: 0,
malicious_behaviours: Default::default(),
actix_flag: false,
initial_mutations: vec![],
}
}
}
#[cfg(test)]
mod tests {
use crate::api::system::builder::Subnet;
use crate::system_test::InternetComputer;
use canister_test::Wasm;
use ic_test_utilities::universal_canister::{wasm, UNIVERSAL_CANISTER_WASM};
#[ignore]
#[tokio::test]
async fn can_query_using_universal_canister() {
let ic = InternetComputer::new()
.with_subnet(Subnet::new().add_nodes(4))
.start()
.await
.ready()
.await
.expect("Not ready yet");
let node0 = ic.subnet_by_idx(0).node_by_idx(0);
let api0 = node0.api();
let c0 = Wasm::from_bytes(UNIVERSAL_CANISTER_WASM)
.install_(&api0, vec![])
.await
.unwrap();
let arbitrary_bytes = b"l49sdk";
let response = c0
.query_(
"query",
on_wire::bytes,
wasm().reply_data(arbitrary_bytes).build(),
)
.await
.unwrap();
assert_eq!(response, arbitrary_bytes.to_vec());
}
}
| {
self.start_with_analyzer(analyzer()).await
} |
api_individual_sm_context.go | /*
* Nsmf_PDUSession
*
* SMF PDU Session Service
*
* API version: 1.0.0
* Generated by: OpenAPI Generator (https://openapi-generator.tech)
*/
package Nsmf_PDUSession
import (
"context"
"fmt"
"io/ioutil"
"net/http"
"net/url"
"strings"
"github.com/5g-core/openapi"
"github.com/5g-core/openapi/models"
"github.com/antihax/optional"
)
// Linger please
var (
_ context.Context
)
type IndividualSMContextApiService service
/*
IndividualSMContextApiService Release SM Context
* @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param smContextRef SM context reference
* @param optional nil or *ReleaseSmContextParamOpts - Optional Parameters:
* @param "SmContextReleaseData" (optional.Interface of SmContextReleaseData) - representation of the data to be sent to the SMF when releasing the SM context
*/
type ReleaseSmContextParamOpts struct {
SmContextReleaseData optional.Interface
}
func (a *IndividualSMContextApiService) ReleaseSmContext(ctx context.Context, smContextRef string, releaseSmContextRequest models.ReleaseSmContextRequest) (*http.Response, error) {
var (
localVarHttpMethod = strings.ToUpper("Post")
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
)
// create path and map variables
localVarPath := a.client.cfg.BasePath() + "/sm-contexts/{smContextRef}/release"
localVarPath = strings.Replace(localVarPath, "{"+"smContextRef"+"}", fmt.Sprintf("%v", smContextRef), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
if releaseSmContextRequest.BinaryDataN2SmInformation != nil {
localVarHeaderParams["Content-Type"] = "multipart/related"
localVarPostBody = &releaseSmContextRequest
} else {
localVarHeaderParams["Content-Type"] = "application/json"
localVarPostBody = releaseSmContextRequest.JsonData
}
// to determine the Accept header
localVarHttpHeaderAccepts := []string{"application/problem+json"}
// set Accept header
localVarHttpHeaderAccept := openapi.SelectHeaderAccept(localVarHttpHeaderAccepts)
if localVarHttpHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
}
r, err := openapi.PrepareRequest(ctx, a.client.cfg, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return nil, err
}
localVarHttpResponse, err := openapi.CallAPI(a.client.cfg, r)
if err != nil || localVarHttpResponse == nil {
return localVarHttpResponse, err
}
localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
localVarHttpResponse.Body.Close()
if err != nil {
return localVarHttpResponse, err
}
apiError := openapi.GenericOpenAPIError{
RawBody: localVarBody,
ErrorStatus: localVarHttpResponse.Status,
}
switch localVarHttpResponse.StatusCode {
case 204:
return localVarHttpResponse, nil
case 400:
var v models.ProblemDetails
err = openapi.Deserialize(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
return localVarHttpResponse, apiError
}
apiError.ErrorModel = v
return localVarHttpResponse, apiError
case 403:
var v models.ProblemDetails
err = openapi.Deserialize(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
return localVarHttpResponse, apiError
}
apiError.ErrorModel = v
return localVarHttpResponse, apiError
case 404:
var v models.ProblemDetails
err = openapi.Deserialize(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
return localVarHttpResponse, apiError
}
apiError.ErrorModel = v
return localVarHttpResponse, apiError
case 411:
var v models.ProblemDetails
err = openapi.Deserialize(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
return localVarHttpResponse, apiError
}
apiError.ErrorModel = v
return localVarHttpResponse, apiError
case 413:
var v models.ProblemDetails
err = openapi.Deserialize(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
return localVarHttpResponse, apiError
}
apiError.ErrorModel = v
return localVarHttpResponse, apiError
case 415:
var v models.ProblemDetails
err = openapi.Deserialize(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
return localVarHttpResponse, apiError
}
apiError.ErrorModel = v
return localVarHttpResponse, apiError
case 429:
var v models.ProblemDetails
err = openapi.Deserialize(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
return localVarHttpResponse, apiError
}
apiError.ErrorModel = v
return localVarHttpResponse, apiError
case 500:
var v models.ProblemDetails
err = openapi.Deserialize(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
return localVarHttpResponse, apiError
}
apiError.ErrorModel = v
return localVarHttpResponse, apiError
case 503:
var v models.ProblemDetails
err = openapi.Deserialize(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
return localVarHttpResponse, apiError
}
apiError.ErrorModel = v
return localVarHttpResponse, apiError
default:
return localVarHttpResponse, openapi.ReportError("%d is not a valid status code in ReleaseSmContext", localVarHttpResponse.StatusCode)
}
}
/*
IndividualSMContextApiService Retrieve SM Context
* @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param smContextRef SM context reference
* @param optional nil or *RetrieveSmContextParamOpts - Optional Parameters:
* @param "SmContextRetrieveData" (optional.Interface of SmContextRetrieveData) - parameters used to retrieve the SM context
@return SmContextRetrievedData
*/
type RetrieveSmContextParamOpts struct {
SmContextRetrieveData optional.Interface
}
func (a *IndividualSMContextApiService) RetrieveSmContext(ctx context.Context, smContextRef string, localVarOptionals *RetrieveSmContextParamOpts) (models.SmContextRetrievedData, *http.Response, error) {
var (
localVarHttpMethod = strings.ToUpper("Post")
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue models.SmContextRetrievedData
)
// create path and map variables
localVarPath := a.client.cfg.BasePath() + "/sm-contexts/{smContextRef}/retrieve"
localVarPath = strings.Replace(localVarPath, "{"+"smContextRef"+"}", fmt.Sprintf("%v", smContextRef), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
localVarHttpContentTypes := []string{"application/json"}
localVarHeaderParams["Content-Type"] = localVarHttpContentTypes[0] // use the first content type specified in 'consumes'
// to determine the Accept header
localVarHttpHeaderAccepts := []string{"application/json", "application/problem+json"}
// set Accept header
localVarHttpHeaderAccept := openapi.SelectHeaderAccept(localVarHttpHeaderAccepts)
if localVarHttpHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
}
// body params
if localVarOptionals != nil && localVarOptionals.SmContextRetrieveData.IsSet() |
r, err := openapi.PrepareRequest(ctx, a.client.cfg, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHttpResponse, err := openapi.CallAPI(a.client.cfg, r)
if err != nil || localVarHttpResponse == nil {
return localVarReturnValue, localVarHttpResponse, err
}
localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
localVarHttpResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHttpResponse, err
}
apiError := openapi.GenericOpenAPIError{
RawBody: localVarBody,
ErrorStatus: localVarHttpResponse.Status,
}
switch localVarHttpResponse.StatusCode {
case 200:
err = openapi.Deserialize(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
}
return localVarReturnValue, localVarHttpResponse, nil
case 400:
var v models.ProblemDetails
err = openapi.Deserialize(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
return localVarReturnValue, localVarHttpResponse, apiError
}
apiError.ErrorModel = v
return localVarReturnValue, localVarHttpResponse, apiError
case 403:
var v models.ProblemDetails
err = openapi.Deserialize(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
return localVarReturnValue, localVarHttpResponse, apiError
}
apiError.ErrorModel = v
return localVarReturnValue, localVarHttpResponse, apiError
case 404:
var v models.ProblemDetails
err = openapi.Deserialize(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
return localVarReturnValue, localVarHttpResponse, apiError
}
apiError.ErrorModel = v
return localVarReturnValue, localVarHttpResponse, apiError
case 411:
var v models.ProblemDetails
err = openapi.Deserialize(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
return localVarReturnValue, localVarHttpResponse, apiError
}
apiError.ErrorModel = v
return localVarReturnValue, localVarHttpResponse, apiError
case 413:
var v models.ProblemDetails
err = openapi.Deserialize(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
return localVarReturnValue, localVarHttpResponse, apiError
}
apiError.ErrorModel = v
return localVarReturnValue, localVarHttpResponse, apiError
case 415:
var v models.ProblemDetails
err = openapi.Deserialize(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
return localVarReturnValue, localVarHttpResponse, apiError
}
apiError.ErrorModel = v
return localVarReturnValue, localVarHttpResponse, apiError
case 429:
var v models.ProblemDetails
err = openapi.Deserialize(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
return localVarReturnValue, localVarHttpResponse, apiError
}
apiError.ErrorModel = v
return localVarReturnValue, localVarHttpResponse, apiError
case 500:
var v models.ProblemDetails
err = openapi.Deserialize(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
return localVarReturnValue, localVarHttpResponse, apiError
}
apiError.ErrorModel = v
return localVarReturnValue, localVarHttpResponse, apiError
case 503:
var v models.ProblemDetails
err = openapi.Deserialize(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
return localVarReturnValue, localVarHttpResponse, apiError
}
apiError.ErrorModel = v
return localVarReturnValue, localVarHttpResponse, apiError
default:
return localVarReturnValue, localVarHttpResponse, openapi.ReportError("%d is not a valid status code in RetrieveSmContext", localVarHttpResponse.StatusCode)
}
}
/*
IndividualSMContextApiService Update SM Context
* @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
* @param smContextRef SM context reference
* @param smContextUpdateData representation of the updates to apply to the SM context
@return SmContextUpdatedData
*/
func (a *IndividualSMContextApiService) UpdateSmContext(ctx context.Context, smContextRef string, updateSmContextRequest models.UpdateSmContextRequest) (models.UpdateSmContextResponse, *http.Response, error) {
var (
localVarHttpMethod = strings.ToUpper("Post")
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []byte
localVarReturnValue models.UpdateSmContextResponse
)
// create path and map variables
localVarPath := a.client.cfg.BasePath() + "/sm-contexts/{smContextRef}/modify"
localVarPath = strings.Replace(localVarPath, "{"+"smContextRef"+"}", fmt.Sprintf("%v", smContextRef), -1)
localVarHeaderParams := make(map[string]string)
localVarQueryParams := url.Values{}
localVarFormParams := url.Values{}
// to determine the request Content-Type header
if updateSmContextRequest.BinaryDataN1SmMessage != nil || updateSmContextRequest.BinaryDataN2SmInformation != nil {
localVarHeaderParams["Content-Type"] = "multipart/related"
localVarPostBody = &updateSmContextRequest
} else {
localVarHeaderParams["Content-Type"] = "application/json"
localVarPostBody = updateSmContextRequest.JsonData
}
// to determine the Accept header
localVarHttpHeaderAccepts := []string{"application/json", "multipart/related", "application/problem+json"}
// set Accept header
localVarHttpHeaderAccept := openapi.SelectHeaderAccept(localVarHttpHeaderAccepts)
if localVarHttpHeaderAccept != "" {
localVarHeaderParams["Accept"] = localVarHttpHeaderAccept
}
r, err := openapi.PrepareRequest(ctx, a.client.cfg, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFormFileName, localVarFileName, localVarFileBytes)
if err != nil {
return localVarReturnValue, nil, err
}
localVarHttpResponse, err := openapi.CallAPI(a.client.cfg, r)
if err != nil || localVarHttpResponse == nil {
return localVarReturnValue, localVarHttpResponse, err
}
localVarBody, err := ioutil.ReadAll(localVarHttpResponse.Body)
localVarHttpResponse.Body.Close()
if err != nil {
return localVarReturnValue, localVarHttpResponse, err
}
apiError := openapi.GenericOpenAPIError{
RawBody: localVarBody,
ErrorStatus: localVarHttpResponse.Status,
}
switch localVarHttpResponse.StatusCode {
case 200:
err = openapi.Deserialize(&localVarReturnValue, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
}
return localVarReturnValue, localVarHttpResponse, nil
case 204:
return localVarReturnValue, localVarHttpResponse, nil
case 400:
var v models.UpdateSmContextErrorResponse
err = openapi.Deserialize(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
return localVarReturnValue, localVarHttpResponse, apiError
}
apiError.ErrorModel = v
return localVarReturnValue, localVarHttpResponse, apiError
case 403:
var v models.UpdateSmContextErrorResponse
err = openapi.Deserialize(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
return localVarReturnValue, localVarHttpResponse, apiError
}
apiError.ErrorModel = v
return localVarReturnValue, localVarHttpResponse, apiError
case 404:
var v models.UpdateSmContextErrorResponse
err = openapi.Deserialize(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
return localVarReturnValue, localVarHttpResponse, apiError
}
apiError.ErrorModel = v
return localVarReturnValue, localVarHttpResponse, apiError
case 411:
var v models.ProblemDetails
err = openapi.Deserialize(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
return localVarReturnValue, localVarHttpResponse, apiError
}
apiError.ErrorModel = v
return localVarReturnValue, localVarHttpResponse, apiError
case 413:
var v models.ProblemDetails
err = openapi.Deserialize(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
return localVarReturnValue, localVarHttpResponse, apiError
}
apiError.ErrorModel = v
return localVarReturnValue, localVarHttpResponse, apiError
case 415:
var v models.ProblemDetails
err = openapi.Deserialize(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
return localVarReturnValue, localVarHttpResponse, apiError
}
apiError.ErrorModel = v
return localVarReturnValue, localVarHttpResponse, apiError
case 429:
var v models.ProblemDetails
err = openapi.Deserialize(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
return localVarReturnValue, localVarHttpResponse, apiError
}
apiError.ErrorModel = v
return localVarReturnValue, localVarHttpResponse, apiError
case 500:
var v models.UpdateSmContextErrorResponse
err = openapi.Deserialize(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
return localVarReturnValue, localVarHttpResponse, apiError
}
apiError.ErrorModel = v
return localVarReturnValue, localVarHttpResponse, apiError
case 503:
var v models.UpdateSmContextErrorResponse
err = openapi.Deserialize(&v, localVarBody, localVarHttpResponse.Header.Get("Content-Type"))
if err != nil {
apiError.ErrorStatus = err.Error()
return localVarReturnValue, localVarHttpResponse, apiError
}
apiError.ErrorModel = v
return localVarReturnValue, localVarHttpResponse, apiError
default:
return localVarReturnValue, localVarHttpResponse, openapi.ReportError("%d is not a valid status code in UpdateSmContext", localVarHttpResponse.StatusCode)
}
}
| {
localVarOptionalSmContextRetrieveData, localVarOptionalSmContextRetrieveDataok := localVarOptionals.SmContextRetrieveData.Value().(models.SmContextRetrieveData)
if !localVarOptionalSmContextRetrieveDataok {
return localVarReturnValue, nil, openapi.ReportError("smContextRetrieveData should be SmContextRetrieveData")
}
localVarPostBody = &localVarOptionalSmContextRetrieveData
} |
handlers.ts | import {
BackendDestinationEnum,
getEndpoint,
} from '../../lib/utils/functions/getEndpoint'
import { mockSchemaBinding } from '../mockSchema'
import { rest } from 'msw'
import {
mockFileEntity,
mockFileEntityBundle,
mockProjectEntity,
mockProjectEntityBundle,
mockPaginatedEntityHeaders,
MOCK_FILE_ENTITY_ID,
MOCK_FILE_NAME,
MOCK_INVALID_PROJECT_NAME,
MOCK_PROJECT_ID,
MOCK_PROJECT_NAME,
mockFileEntityJson,
} from '../entity/mockEntity'
import {
mockUserBundle,
mockUserProfileData,
MOCK_USER_ID,
} from '../user/mock_user_profile'
import {
ENTITY,
ENTITY_BUNDLE_V2,
ENTITY_SCHEMA_BINDING,
FAVORITES,
USER_ID_BUNDLE,
USER_PROFILE_ID,
USER_PROFILE,
ENTITY_JSON,
} from '../../lib/utils/APIConstants'
const handlers = [
rest.options('*', async (req, res, ctx) => {
return res(ctx.status(200))
}),
rest.get(
`${getEndpoint(BackendDestinationEnum.REPO_ENDPOINT)}${USER_PROFILE_ID(
':id',
)}`,
async (req, res, ctx) => {
let response: any = {
reason: `Mock Service worker could not find a user profile with ID ${req.params.id}`,
}
let status = 404
if (req.params.id === MOCK_USER_ID.toString()) {
response = mockUserProfileData
status = 200
}
return res(ctx.status(status), ctx.json(response))
},
),
rest.get(
`${getEndpoint(BackendDestinationEnum.REPO_ENDPOINT)}${USER_PROFILE}`,
async (req, res, ctx) => {
// default return a mock UserProfile.
let response: any = mockUserProfileData
let status = 200
return res(ctx.status(status), ctx.json(response))
},
),
rest.get(
`${getEndpoint(BackendDestinationEnum.REPO_ENDPOINT)}${USER_ID_BUNDLE(
':id',
)}`,
async (req, res, ctx) => {
let response: any = {
reason: `Mock Service worker could not find a user bundle with ID ${req.params.id}`,
}
let status = 404
if (req.params.id === MOCK_USER_ID.toString()) {
response = mockUserBundle
status = 200
}
return res(ctx.status(status), ctx.json(response))
},
),
// create entity
rest.post(
`${getEndpoint(BackendDestinationEnum.REPO_ENDPOINT)}${ENTITY}`,
async (req, res, ctx) => {
let response: any = {
reason: `Mock Service worker could not find a matching mock entity for this request : ${JSON.stringify(
req.body,
)}`,
}
let status = 404
if (req.body) {
// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
const requestBody = req.body as any
if (requestBody.name === MOCK_FILE_NAME) {
response = mockFileEntity
status = 200
} else if (requestBody.name === MOCK_PROJECT_NAME) {
response = mockProjectEntity
status = 200
} else if (requestBody.name === MOCK_INVALID_PROJECT_NAME) {
response.reason = 'Invalid project name'
status = 403
}
} | return res(ctx.status(status), ctx.json(response))
},
),
rest.post(
`${getEndpoint(BackendDestinationEnum.REPO_ENDPOINT)}${ENTITY_BUNDLE_V2(
':entityId',
)}`,
async (req, res, ctx) => {
let response: any = {
reason: `Mock Service worker could not find a mock entity bundle with ID ${req.params.entityId}`,
}
let status = 404
if (req.params.entityId === MOCK_FILE_ENTITY_ID) {
response = mockFileEntityBundle
status = 200
} else if (req.params.entityId === MOCK_PROJECT_ID) {
response = mockProjectEntityBundle
status = 200
}
return res(ctx.status(status), ctx.json(response))
},
),
rest.get(
`${getEndpoint(
BackendDestinationEnum.REPO_ENDPOINT,
)}${ENTITY_SCHEMA_BINDING(':entityId')}`,
async (req, res, ctx) => {
return res(ctx.status(200), ctx.json(mockSchemaBinding))
},
),
rest.get(
`${getEndpoint(BackendDestinationEnum.REPO_ENDPOINT)}${FAVORITES}`,
async (req, res, ctx) => {
return res(ctx.status(200), ctx.json(mockPaginatedEntityHeaders))
},
),
rest.get(
`${getEndpoint(BackendDestinationEnum.REPO_ENDPOINT)}${ENTITY_JSON(
':entityId',
)}`,
async (req, res, ctx) => {
const response = mockFileEntityJson
return res(ctx.status(200), ctx.json(response))
},
),
]
export { handlers } | |
workflow_test.go | // Copyright 2017 Google Inc. 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.
package daisy
import (
"bytes"
"context"
"errors"
"fmt"
"io"
"io/ioutil"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"regexp"
"strings"
"sync"
"testing"
"time"
"cloud.google.com/go/storage"
"google.golang.org/api/compute/v1"
"google.golang.org/api/option"
)
func TestAddDependency(t *testing.T) {
w := &Workflow{}
a, _ := w.NewStep("a")
b, _ := w.NewStep("b")
otherW := &Workflow{}
c, _ := otherW.NewStep("c")
tests := []struct {
desc string
in1, in2 *Step
shouldErr bool
}{
{"good case", a, b, false},
{"idempotent good case", a, b, false},
{"bad case 1", a, c, true},
{"bad case 2", c, b, true},
}
for _, tt := range tests {
if err := w.AddDependency(tt.in1, tt.in2); err == nil && tt.shouldErr {
t.Errorf("%s: should have erred but didn't", tt.desc)
} else if err != nil && !tt.shouldErr {
t.Errorf("%s: unexpected error: %v", tt.desc, err)
}
}
wantDeps := map[string][]string{"a": {"b"}}
if diffRes := diff(w.Dependencies, wantDeps, 0); diffRes != "" {
t.Errorf("incorrect dependencies: (-got,+want)\n%s", diffRes)
}
}
func TestDaisyBkt(t *testing.T) {
client, err := newTestGCSClient()
if err != nil {
t.Fatal(err)
}
project := "foo-project"
got, err := daisyBkt(context.Background(), client, project)
if err != nil {
t.Fatal(err)
}
want := project + "-daisy-bkt"
if got != project+"-daisy-bkt" {
t.Errorf("bucket does not match, got: %q, want: %q", got, want)
}
project = "bar-project"
got, err = daisyBkt(context.Background(), client, project)
if err != nil {
t.Fatal(err)
}
want = project + "-daisy-bkt"
if got != project+"-daisy-bkt" {
t.Errorf("bucket does not match, got: %q, want: %q", got, want)
}
}
func TestCleanup(t *testing.T) {
cleanedup1 := false
cleanedup2 := false
cleanup1 := func() dErr {
cleanedup1 = true
return nil
}
cleanup2 := func() dErr {
cleanedup2 = true
return nil
}
cleanupFail := func() dErr {
return errf("failed cleanup")
}
w := testWorkflow()
w.addCleanupHook(cleanup1)
w.addCleanupHook(cleanupFail)
w.addCleanupHook(cleanup2)
w.cleanup()
if !cleanedup1 {
t.Error("cleanup1 was not run")
}
if !cleanedup2 {
t.Error("cleanup2 was not run")
}
}
func TestGenName(t *testing.T) {
tests := []struct{ name, wfName, wfID, want string }{
{"name", "wfname", "123456789", "name-wfname-123456789"},
{"super-long-name-really-long", "super-long-workflow-name-like-really-really-long", "1", "super-long-name-really-long-super-long-workflow-name-lik-1"},
{"super-long-name-really-long", "super-long-workflow-name-like-really-really-long", "123456789", "super-long-name-really-long-super-long-workflow-name-lik-123456"},
}
w := &Workflow{}
for _, tt := range tests {
w.id = tt.wfID
w.Name = tt.wfName
result := w.genName(tt.name)
if result != tt.want {
t.Errorf("bad result, i: name=%s wfName=%s wfId=%s; got: %s; want: %s", tt.name, tt.wfName, tt.wfID, result, tt.want)
}
if len(result) > 64 {
t.Errorf("result > 64 characters, i: name=%s wfName=%s wfId=%s; got: %s", tt.name, tt.wfName, tt.wfID, result)
}
}
}
func TestGetSourceGCSAPIPath(t *testing.T) {
w := testWorkflow()
w.sourcesPath = "my/sources"
got := w.getSourceGCSAPIPath("foo")
want := "https://storage.cloud.google.com/my/sources/foo"
if got != want {
t.Errorf("unexpected result: got: %q, want %q", got, want)
}
}
func TestNewFromFileError(t *testing.T) {
td, err := ioutil.TempDir(os.TempDir(), "")
if err != nil {
t.Fatalf("error creating temp dir: %v", err)
}
defer os.RemoveAll(td)
tf := filepath.Join(td, "test.wf.json")
tests := []struct{ data, error string }{
{
`{"test":["1", "2",]}`,
tf + ": JSON syntax error in line 1: invalid character ']' looking for beginning of value \n{\"test\":[\"1\", \"2\",]}\n ^",
},
{
`{"test":{"key1":"value1" "key2":"value2"}}`,
tf + ": JSON syntax error in line 1: invalid character '\"' after object key:value pair \n{\"test\":{\"key1\":\"value1\" \"key2\":\"value2\"}}\n ^",
},
{
`{"test": value}`,
tf + ": JSON syntax error in line 1: invalid character 'v' looking for beginning of value \n{\"test\": value}\n ^",
},
{
`{"test": "value"`,
tf + ": JSON syntax error in line 1: unexpected end of JSON input \n{\"test\": \"value\"\n ^",
},
{
"{\n\"test\":[\"1\", \"2\",],\n\"test2\":[\"1\", \"2\"]\n}",
tf + ": JSON syntax error in line 2: invalid character ']' looking for beginning of value \n\"test\":[\"1\", \"2\",],\n ^",
},
}
for i, tt := range tests {
if err := ioutil.WriteFile(tf, []byte(tt.data), 0600); err != nil {
t.Fatalf("error creating json file: %v", err)
}
if _, err := NewFromFile(tf); err == nil {
t.Errorf("expected error, got nil for test %d", i+1)
} else if err.Error() != tt.error {
t.Errorf("did not get expected error from NewFromFile():\ngot: %q\nwant: %q", err.Error(), tt.error)
}
}
}
func TestNewFromFile(t *testing.T) {
got, err := NewFromFile("./test_data/test.wf.json")
if err != nil {
t.Fatal(err)
}
wd, err := os.Getwd()
if err != nil {
t.Fatal(err)
}
want := New()
// These are difficult to validate and irrelevant, so we cheat.
want.id = got.ID()
want.Cancel = got.Cancel
want.cleanupHooks = got.cleanupHooks
want.disks = newDiskRegistry(want)
want.images = newImageRegistry(want)
want.instances = newInstanceRegistry(want)
want.networks = newNetworkRegistry(want)
want.workflowDir = filepath.Join(wd, "test_data")
want.Name = "some-name"
want.Project = "some-project"
want.Zone = "us-central1-a"
want.GCSPath = "gs://some-bucket/images"
want.OAuthPath = filepath.Join(wd, "test_data", "somefile")
want.Sources = map[string]string{}
want.autovars = map[string]string{}
want.Vars = map[string]Var{
"bootstrap_instance_name": {Value: "bootstrap-${NAME}", Required: true},
"machine_type": {Value: "n1-standard-1"},
"key1": {Value: "var1"},
"key2": {Value: "var2"},
}
want.Steps = map[string]*Step{
"create-disks": {
name: "create-disks",
CreateDisks: &CreateDisks{
{
Disk: compute.Disk{
Name: "bootstrap",
SourceImage: "projects/windows-cloud/global/images/family/windows-server-2016-core",
Type: "pd-ssd",
},
SizeGb: "50",
},
{
Disk: compute.Disk{
Name: "image",
SourceImage: "projects/windows-cloud/global/images/family/windows-server-2016-core",
Type: "pd-standard",
},
SizeGb: "50",
},
},
},
"${bootstrap_instance_name}": {
name: "${bootstrap_instance_name}",
CreateInstances: &CreateInstances{
{
Instance: compute.Instance{
Name: "${bootstrap_instance_name}",
Disks: []*compute.AttachedDisk{{Source: "bootstrap"}, {Source: "image"}},
MachineType: "${machine_type}",
},
StartupScript: "shutdown /h",
Metadata: map[string]string{"test_metadata": "this was a test"},
},
},
},
"${bootstrap_instance_name}-stopped": {
name: "${bootstrap_instance_name}-stopped",
Timeout: "1h",
WaitForInstancesSignal: &WaitForInstancesSignal{{Name: "${bootstrap_instance_name}", Stopped: true, Interval: "1s"}},
},
"postinstall": {
name: "postinstall",
CreateInstances: &CreateInstances{
{
Instance: compute.Instance{
Name: "postinstall",
Disks: []*compute.AttachedDisk{{Source: "image"}, {Source: "bootstrap"}},
MachineType: "${machine_type}",
},
StartupScript: "shutdown /h",
},
},
},
"postinstall-stopped": {
name: "postinstall-stopped",
WaitForInstancesSignal: &WaitForInstancesSignal{{Name: "postinstall", Stopped: true}},
},
"create-image": {
name: "create-image",
CreateImages: &CreateImages{{Image: compute.Image{Name: "image-from-disk", SourceDisk: "image"}}},
},
"include-workflow": {
name: "include-workflow",
IncludeWorkflow: &IncludeWorkflow{
Vars: map[string]string{
"key": "value",
},
Path: "./test_sub.wf.json",
},
},
"sub-workflow": {
name: "sub-workflow",
SubWorkflow: &SubWorkflow{
Vars: map[string]string{
"key": "value",
},
Path: "./test_sub.wf.json",
},
},
}
want.Dependencies = map[string][]string{
"create-disks": {},
"bootstrap": {"create-disks"},
"bootstrap-stopped": {"bootstrap"},
"postinstall": {"bootstrap-stopped"},
"postinstall-stopped": {"postinstall"},
"create-image": {"postinstall-stopped"},
"include-workflow": {"create-image"},
"sub-workflow": {"create-image"},
}
for _, s := range want.Steps {
s.w = want
}
if diffRes := diff(got, want, 0); diffRes != "" {
t.Errorf("parsed workflow does not match expectation: (-got +want)\n%s", diffRes)
}
}
func TestNewStep(t *testing.T) {
w := &Workflow{}
s, err := w.NewStep("s")
wantS := &Step{name: "s", w: w}
if s == nil || s.name != "s" || s.w != w {
t.Errorf("step does not meet expectation: got: %v, want: %v", s, wantS)
}
if err != nil {
t.Error("unexpected error when creating new step")
}
s, err = w.NewStep("s")
if s != nil {
t.Errorf("step should not have been created: %v", s)
}
if err == nil {
t.Error("should have erred, but didn't")
}
}
func TestPopulate(t *testing.T) {
ctx := context.Background()
client, err := newTestGCSClient()
if err != nil {
t.Fatal(err)
}
td, err := ioutil.TempDir(os.TempDir(), "")
if err != nil {
t.Fatalf("error creating temp dir: %v", err)
}
defer os.RemoveAll(td)
tf := filepath.Join(td, "test.cred")
if err := ioutil.WriteFile(tf, []byte(`{ "type": "service_account" }`), 0600); err != nil {
t.Fatalf("error creating temp file: %v", err)
}
called := false
var stepPopErr dErr
stepPop := func(ctx context.Context, s *Step) dErr {
called = true
return stepPopErr
}
got := New()
got.Name = "${wf_name}"
got.Zone = "wf-zone"
got.Project = "bar-project"
got.OAuthPath = tf
got.Logger = &MockLogger{}
got.Vars = map[string]Var{
"bucket": {Value: "wf-bucket", Required: true},
"step_name": {Value: "step1"},
"timeout": {Value: "60m"},
"path": {Value: "./test_sub.wf.json"},
"wf_name": {Value: "wf-name"},
"test-var": {Value: "${ZONE}-this-should-populate-${NAME}"},
}
got.Steps = map[string]*Step{
"${NAME}-${step_name}": {
w: got,
Timeout: "${timeout}",
testType: &mockStep{
populateImpl: stepPop,
},
},
}
got.StorageClient = client
got.externalLogging = true
if err := got.populate(ctx); err != nil {
t.Fatalf("error populating workflow: %v", err)
}
want := New()
// These are difficult to validate and irrelevant, so we cheat.
want.id = got.id
want.Cancel = got.Cancel
want.cleanupHooks = got.cleanupHooks
want.StorageClient = got.StorageClient
want.cloudLoggingClient = got.cloudLoggingClient
want.Logger = got.Logger
want.disks = newDiskRegistry(want)
want.images = newImageRegistry(want)
want.instances = newInstanceRegistry(want)
want.networks = newNetworkRegistry(want)
want.Name = "wf-name"
want.GCSPath = "gs://bar-project-daisy-bkt"
want.Zone = "wf-zone"
want.Project = "bar-project"
want.OAuthPath = tf
want.externalLogging = true
want.Sources = map[string]string{}
want.DefaultTimeout = defaultTimeout
want.defaultTimeout = 10 * time.Minute
want.Vars = map[string]Var{
"bucket": {Value: "wf-bucket", Required: true},
"step_name": {Value: "step1"},
"timeout": {Value: "60m"},
"path": {Value: "./test_sub.wf.json"},
"wf_name": {Value: "wf-name"},
"test-var": {Value: "wf-zone-this-should-populate-wf-name"},
}
want.autovars = got.autovars
want.bucket = "bar-project-daisy-bkt"
want.scratchPath = got.scratchPath
want.sourcesPath = fmt.Sprintf("%s/sources", got.scratchPath)
want.logsPath = fmt.Sprintf("%s/logs", got.scratchPath)
want.outsPath = fmt.Sprintf("%s/outs", got.scratchPath)
want.username = got.username
want.Steps = map[string]*Step{
"wf-name-step1": {
name: "wf-name-step1",
Timeout: "60m",
timeout: time.Duration(60 * time.Minute),
testType: &mockStep{
populateImpl: stepPop,
},
},
}
want.Dependencies = map[string][]string{}
for _, s := range want.Steps {
s.w = want
}
if diffRes := diff(got, want, 0); diffRes != "" {
t.Errorf("parsed workflow does not match expectation: (-got +want)\n%s", diffRes)
}
if !called {
t.Error("did not call step's populate")
}
stepPopErr = errf("error")
wantErr := errf("error populating step \"wf-name-step1\": %v", stepPopErr)
if err := got.populate(ctx); err.Error() != wantErr.Error() {
t.Errorf("did not get proper step populate error: %v != %v", err, wantErr)
}
}
func TestRequiredVars(t *testing.T) {
w := testWorkflow()
tests := []struct {
desc string
vars map[string]Var
shouldErr bool
}{
{"normal case", map[string]Var{"foo": {Value: "foo", Required: true, Description: "foo"}}, false},
{"missing req case", map[string]Var{"foo": {Value: "", Required: true, Description: "foo"}}, true},
}
for _, tt := range tests {
w.Vars = tt.vars
err := w.populate(context.Background())
if tt.shouldErr && err == nil {
t.Errorf("%s: should have erred, but didn't", tt.desc)
} else if !tt.shouldErr && err != nil {
t.Errorf("%s: unexpected error: %v", tt.desc, err)
}
}
}
func testTraverseWorkflow(mockRun func(i int) func(context.Context, *Step) dErr) *Workflow {
// s0---->s1---->s3
// \ /
// --->s2---
// s4
w := testWorkflow()
w.Steps = map[string]*Step{
"s0": {name: "s0", testType: &mockStep{runImpl: mockRun(0)}, w: w},
"s1": {name: "s1", testType: &mockStep{runImpl: mockRun(1)}, w: w},
"s2": {name: "s2", testType: &mockStep{runImpl: mockRun(2)}, w: w},
"s3": {name: "s3", testType: &mockStep{runImpl: mockRun(3)}, w: w},
"s4": {name: "s4", testType: &mockStep{runImpl: mockRun(4)}, w: w},
}
w.Dependencies = map[string][]string{
"s1": {"s0"},
"s2": {"s0"},
"s3": {"s1", "s2"},
}
return w
}
func TestTraverseDAG(t *testing.T) {
ctx := context.Background()
var callOrder []int
errs := make([]dErr, 5)
var rw sync.Mutex
mockRun := func(i int) func(context.Context, *Step) dErr {
return func(_ context.Context, _ *Step) dErr {
rw.Lock()
defer rw.Unlock()
callOrder = append(callOrder, i)
return errs[i]
}
}
// Check call order: s1 and s2 must be after s0, s3 must be after s1 and s2.
checkCallOrder := func() error {
rw.Lock()
defer rw.Unlock()
stepOrderNum := []int{-1, -1, -1, -1, -1}
for i, stepNum := range callOrder {
stepOrderNum[stepNum] = i
}
// If s1 was called, check it was called after s0.
if stepOrderNum[1] != -1 && stepOrderNum[1] < stepOrderNum[0] {
return errors.New("s1 was called before s0")
}
// If s2 was called, check it was called after s0.
if stepOrderNum[2] != -1 && stepOrderNum[2] < stepOrderNum[0] {
return errors.New("s2 was called before s0")
}
// If s3 was called, check it was called after s1 and s2.
if stepOrderNum[3] != -1 {
if stepOrderNum[3] < stepOrderNum[1] {
return errors.New("s3 was called before s1")
}
if stepOrderNum[3] < stepOrderNum[2] {
return errors.New("s3 was called before s2")
}
}
return nil
}
// Normal, good run.
w := testTraverseWorkflow(mockRun)
if err := w.Run(ctx); err != nil {
t.Errorf("unexpected error: %s", err)
}
if err := checkCallOrder(); err != nil {
t.Errorf("call order error: %s", err)
}
callOrder = []int{}
errs = make([]dErr, 5)
// s2 failure.
w = testTraverseWorkflow(mockRun)
errs[2] = errf("failure")
want := w.Steps["s2"].wrapRunError(errs[2])
if err := w.Run(ctx); err.Error() != want.Error() {
t.Errorf("unexpected error: %s != %s", err, want)
}
if err := checkCallOrder(); err != nil {
t.Errorf("call order error: %s", err)
}
}
func TestPrint(t *testing.T) {
data := []byte(`{
"Name": "some-name",
"Project": "some-project",
"Zone": "some-zone",
"GCSPath": "gs://some-bucket/images",
"Vars": {
"instance_name": "i1",
"machine_type": {"Value": "n1-standard-1", "Required": true}
},
"Steps": {
"${instance_name}Delete": {
"DeleteResources": {
"Instances": ["${instance_name}"]
}
}
}
}`)
want := `{
"Name": "some-name",
"Project": "some-project",
"Zone": "some-zone",
"GCSPath": "gs://some-bucket/images",
"Vars": {
"instance_name": {
"Value": "i1"
},
"machine_type": {
"Value": "n1-standard-1",
"Required": true
}
},
"Steps": {
"i1Delete": {
"Timeout": "10m",
"DeleteResources": {
"Instances": [
"i1"
]
}
}
},
"DefaultTimeout": "10m"
}
`
td, err := ioutil.TempDir(os.TempDir(), "")
if err != nil {
t.Fatalf("error creating temp dir: %v", err)
}
defer os.RemoveAll(td)
tf := filepath.Join(td, "test.wf.json")
ioutil.WriteFile(tf, data, 0600)
got, err := NewFromFile(tf)
if err != nil {
t.Fatal(err)
}
got.ComputeClient, _ = newTestGCEClient()
got.StorageClient, _ = newTestGCSClient()
old := os.Stdout
r, w, err := os.Pipe()
if err != nil {
t.Fatal(err)
}
os.Stdout = w
got.Print(context.Background())
w.Close()
os.Stdout = old
var buf bytes.Buffer
if _, err := io.Copy(&buf, r); err != nil {
t.Fatal(err)
}
if diffRes := diff(buf.String(), want, 0); diffRes != "" {
t.Errorf("printed workflow does not match expectation: (-got +want)\n%s", diffRes)
}
}
func | (w *Workflow, want string) error {
if err := w.Validate(context.Background()); err == nil {
return errors.New("expected error, got nil")
} else if err.Error() != want {
return fmt.Errorf("did not get expected error from Validate():\ngot: %q\nwant: %q", err.Error(), want)
}
select {
case <-w.Cancel:
return nil
default:
return errors.New("expected cancel to be closed after error")
}
}
func TestValidateErrors(t *testing.T) {
// Error from validateRequiredFields().
w := testWorkflow()
w.Name = "1"
want := "error validating workflow: workflow field 'Name' must start with a letter and only contain letters, numbers, and hyphens"
if err := testValidateErrors(w, want); err != nil {
t.Error(err)
}
// Error from populate().
w = testWorkflow()
w.Steps = map[string]*Step{"s0": {Timeout: "10", testType: &mockStep{}}}
want = "error populating workflow: error populating step \"s0\": time: missing unit in duration 10"
if err := testValidateErrors(w, want); err != nil {
t.Error(err)
}
// Error from validate().
w = testWorkflow()
w.Steps = map[string]*Step{"s0": {testType: &mockStep{}}}
w.Project = "foo"
want = "error validating workflow: bad project lookup: \"foo\", error: APIError: bad project"
if err := testValidateErrors(w, want); err != nil {
t.Error(err)
}
}
func TestWrite(t *testing.T) {
var buf bytes.Buffer
testBucket := "bucket"
testObject := "object"
var gotObj string
var gotBkt string
nameRgx := regexp.MustCompile(`"name":"([^"].*)"`)
uploadRgx := regexp.MustCompile(`/b/([^/]+)/o?.*uploadType=multipart.*`)
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
u := r.URL.String()
m := r.Method
if match := uploadRgx.FindStringSubmatch(u); m == "POST" && match != nil {
body, _ := ioutil.ReadAll(r.Body)
buf.Write(body)
gotObj = nameRgx.FindStringSubmatch(string(body))[1]
gotBkt = match[1]
fmt.Fprintf(w, `{"kind":"storage#object","bucket":"%s","name":"%s"}`, gotBkt, gotObj)
}
}))
gcsClient, err := storage.NewClient(context.Background(), option.WithEndpoint(ts.URL), option.WithHTTPClient(http.DefaultClient))
if err != nil {
t.Fatal(err)
}
l := GCSLogger{
client: gcsClient,
bucket: testBucket,
object: testObject,
ctx: context.Background(),
}
tests := []struct {
test, want string
}{
{"test log 1\n", "test log 1\n"},
{"test log 2\n", "test log 1\ntest log 2\n"},
}
for _, tt := range tests {
l.Write([]byte(tt.test))
if gotObj != testObject {
t.Errorf("object does not match, want: %q, got: %q", testObject, gotObj)
}
if gotBkt != testBucket {
t.Errorf("bucket does not match, want: %q, got: %q", testBucket, gotBkt)
}
if !strings.Contains(buf.String(), tt.want) {
t.Errorf("expected text did not get sent to GCS, want: %q, got: %q", tt.want, buf.String())
}
if l.buf.String() != tt.want {
t.Errorf("buffer does mot match expectation, want: %q, got: %q", tt.want, l.buf.String())
}
}
}
func TestRunStepTimeout(t *testing.T) {
w := testWorkflow()
s, _ := w.NewStep("test")
s.timeout = 1 * time.Nanosecond
s.testType = &mockStep{runImpl: func(ctx context.Context, s *Step) dErr {
time.Sleep(1 * time.Second)
return nil
}}
want := `step "test" did not complete within the specified timeout of 1ns`
if err := w.runStep(context.Background(), s); err == nil || err.Error() != want {
t.Errorf("did not get expected error, got: %q, want: %q", err.Error(), want)
}
}
func TestPopulateClients(t *testing.T) {
w := testWorkflow()
initialComputeClient := w.ComputeClient
w.PopulateClients(context.Background())
if w.ComputeClient != initialComputeClient {
t.Errorf("Should not repopulate compute client.")
}
w.ComputeClient = nil
w.PopulateClients(context.Background())
if w.ComputeClient == nil {
t.Errorf("Did not populate compute client.")
}
initialStorageClient := w.StorageClient
w.PopulateClients(context.Background())
if w.StorageClient != initialStorageClient {
t.Errorf("Should not repopulate storage client.")
}
w.StorageClient = nil
w.PopulateClients(context.Background())
if w.StorageClient == nil {
t.Errorf("Did not populate storage client.")
}
initialCloudLoggingClient := w.cloudLoggingClient
w.PopulateClients(context.Background())
if w.cloudLoggingClient != initialCloudLoggingClient {
t.Errorf("Should not repopulate logging client.")
}
w.cloudLoggingClient = nil
w.externalLogging = false
w.PopulateClients(context.Background())
if w.cloudLoggingClient != nil {
t.Errorf("Should not populate Cloud Logging client.")
}
w.cloudLoggingClient = nil
w.externalLogging = true
w.PopulateClients(context.Background())
if w.cloudLoggingClient == nil {
t.Errorf("Did not populate Cloud Logging client.")
}
}
| testValidateErrors |
DragSource.js | "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var checkDecoratorArguments_1 = require("./utils/checkDecoratorArguments");
var decorateHandler_1 = require("./decorateHandler");
var registerSource_1 = require("./registerSource");
var createSourceFactory_1 = require("./createSourceFactory");
var DragSourceMonitorImpl_1 = require("./DragSourceMonitorImpl");
var SourceConnector_1 = require("./SourceConnector");
var isValidType_1 = require("./utils/isValidType");
var discount_lodash_1 = require("./utils/discount_lodash");
var invariant = require('invariant');
/**
* Decorates a component as a dragsource
* @param type The dragsource type
* @param spec The drag source specification
* @param collect The props collector function
* @param options DnD options
*/
function | (type, spec, collect, options) {
if (options === void 0) { options = {}; }
checkDecoratorArguments_1.default('DragSource', 'type, spec, collect[, options]', type, spec, collect, options);
var getType = type;
if (typeof type !== 'function') {
invariant(isValidType_1.default(type), 'Expected "type" provided as the first argument to DragSource to be ' +
'a string, or a function that returns a string given the current props. ' +
'Instead, received %s. ' +
'Read more: http://react-dnd.github.io/react-dnd/docs/api/drag-source', type);
getType = function () { return type; };
}
invariant(discount_lodash_1.isPlainObject(spec), 'Expected "spec" provided as the second argument to DragSource to be ' +
'a plain object. Instead, received %s. ' +
'Read more: http://react-dnd.github.io/react-dnd/docs/api/drag-source', spec);
var createSource = createSourceFactory_1.default(spec);
invariant(typeof collect === 'function', 'Expected "collect" provided as the third argument to DragSource to be ' +
'a function that returns a plain object of props to inject. ' +
'Instead, received %s. ' +
'Read more: http://react-dnd.github.io/react-dnd/docs/api/drag-source', collect);
invariant(discount_lodash_1.isPlainObject(options), 'Expected "options" provided as the fourth argument to DragSource to be ' +
'a plain object when specified. ' +
'Instead, received %s. ' +
'Read more: http://react-dnd.github.io/react-dnd/docs/api/drag-source', collect);
return function decorateSource(DecoratedComponent) {
return decorateHandler_1.default({
containerDisplayName: 'DragSource',
createHandler: createSource,
registerHandler: registerSource_1.default,
createConnector: function (backend) { return new SourceConnector_1.default(backend); },
createMonitor: function (manager) {
return new DragSourceMonitorImpl_1.default(manager);
},
DecoratedComponent: DecoratedComponent,
getType: getType,
collect: collect,
options: options,
});
};
}
exports.default = DragSource;
| DragSource |
edit_test.go | //go:build unit
// +build unit
package edit_test
import ( | "path/filepath"
"testing"
"github.com/jenkins-x-plugins/jx-gitops/pkg/cmd/requirement/edit"
"github.com/jenkins-x/jx-helpers/v3/pkg/files"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
jxcore "github.com/jenkins-x/jx-api/v4/pkg/apis/core/v4beta1"
)
func TestCmdRequirementsEdit(t *testing.T) {
t.Parallel()
type testData struct {
name string
args []string
callback func(t *testing.T, req *jxcore.RequirementsConfig)
fail bool
initialFile string
}
gitOpsEnabled := filepath.Join("test_data", "gitops-enabled.yml")
tests := []testData{
{
name: "bbs",
args: []string{"--git-kind=bitbucketserver"},
callback: func(t *testing.T, req *jxcore.RequirementsConfig) {
assert.Equal(t, "bitbucketserver", req.Cluster.GitKind, "req.Cluster.GitKind")
},
initialFile: gitOpsEnabled,
},
{
name: "bucket-logs",
args: []string{"--bucket-logs", "gs://foo"},
callback: func(t *testing.T, req *jxcore.RequirementsConfig) {
assert.Equal(t, "gs://foo", req.GetStorageURL("logs"), "req.Storage.Logs.URL")
},
initialFile: gitOpsEnabled,
},
{
name: "bad-git-kind",
args: []string{"--git-kind=gitlob"},
fail: true,
initialFile: gitOpsEnabled,
},
{
name: "bad-secret",
args: []string{"--secret=vaulx"},
fail: true,
initialFile: gitOpsEnabled,
},
}
tmpDir, err := ioutil.TempDir("", "jx-cmd-req-")
require.NoError(t, err, "failed to create temp dir")
require.DirExists(t, tmpDir, "could not create temp dir for running tests")
for i, tt := range tests {
if tt.name == "" {
tt.name = fmt.Sprintf("test%d", i)
}
t.Logf("running test %s", tt.name)
dir := filepath.Join(tmpDir, tt.name)
err = os.MkdirAll(dir, files.DefaultDirWritePermissions)
require.NoError(t, err, "failed to create dir %s", dir)
localReqFile := filepath.Join(dir, jxcore.RequirementsConfigFileName)
if tt.initialFile != "" {
err = files.CopyFile(tt.initialFile, localReqFile)
require.NoError(t, err, "failed to copy %s to %s", tt.initialFile, localReqFile)
require.FileExists(t, localReqFile, "file should have been copied")
}
cmd, _ := edit.NewCmdRequirementsEdit()
args := append(tt.args, "--dir", dir)
err := cmd.ParseFlags(args)
require.NoError(t, err, "failed to parse arguments %#v for test %", args, tt.name)
old := os.Args
os.Args = args
err = cmd.RunE(cmd, args)
if err != nil {
if tt.fail {
t.Logf("got exected failure for test %s: %s", tt.name, err.Error())
continue
}
t.Errorf("test %s reported error: %s", tt.name, err)
continue
}
os.Args = old
// now lets parse the requirements
file := localReqFile
require.FileExists(t, file, "should have generated the requirements file")
req, _, err := jxcore.LoadRequirementsConfig(dir, jxcore.DefaultFailOnValidationError)
require.NoError(t, err, "failed to load requirements from dir %s", dir)
if tt.callback != nil {
tt.callback(t, &req.Spec)
}
}
} | "fmt"
"io/ioutil"
"os" |
comments.module.ts | import { Module } from "@nestjs/common";
import { TypeOrmModule } from "@nestjs/typeorm";
import { CommentsEntity } from "src/entities/comments.entity";
import { PostsEntity } from "src/entities/posts.entity";
import { CommentsController } from "./comments.controller";
import { CommentsService } from "./comments.service";
| providers: [CommentsService],
})
export class CommentsModule { } |
@Module({
imports: [TypeOrmModule.forFeature([CommentsEntity])],
controllers: [CommentsController], |
denon_receiver_xml.py | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
This python program saves test XMLs from denon receiver to current directory.
Usage: python denon_receiver_xml.py --host 192.168.0.250 --prefix AVR-X4100W
:copyright: (c) 2017 by Oliver Goetz.
:license: MIT, see LICENSE for more details.
"""
import argparse
from io import BytesIO
import requests
import xml.etree.ElementTree as ET
from collections import namedtuple
XML = namedtuple("XML", ["port", "type", "path", "tags", "filename"])
SAVED_XML = [XML("80", "post", "/goform/AppCommand.xml",
["GetFriendlyName"],
"AppCommand-setup"),
XML("80", "post", "/goform/AppCommand.xml",
["GetAllZonePowerStatus", "GetAllZoneSource",
"GetRenameSource", "GetDeletedSource",
"GetSurroundModeStatus", "GetToneControl",
"GetAllZoneVolume", "GetAllZoneMuteStatus"],
"AppCommand-update"),
XML("80", "get", "/goform/Deviceinfo.xml", [], "Deviceinfo.xml"),
XML("80", "get", "/goform/formMainZone_MainZoneXmlStatus.xml",
[], "formMainZone_MainZoneXmlStatus"),
XML("80", "get", "/goform/formMainZone_MainZoneXml.xml",
[], "formMainZone_MainZoneXml"),
XML("80", "get", "/goform/formNetAudio_StatusXml.xml",
[], "formNetAudio_StatusXml"),
XML("80", "get", "/goform/formTuner_TunerXml.xml",
[], "formTuner_TunerXml"),
XML("80", "get", "/goform/formTuner_HdXml.xml",
[], "formTuner_HdXml"),
XML("80", "get", "/goform/formZone2_Zone2XmlStatus.xml",
[], "formZone2_Zone2XmlStatus"),
XML("80", "get", "/goform/formZone3_Zone3XmlStatus.xml",
[], "formZone3_Zone3XmlStatus"),
XML("8080", "post", "/goform/AppCommand.xml",
["GetFriendlyName"],
"AppCommand-setup"),
XML("8080", "post", "/goform/AppCommand.xml",
["GetAllZonePowerStatus", "GetAllZoneSource",
"GetRenameSource", "GetDeletedSource",
"GetSurroundModeStatus", "GetToneControl",
"GetAllZoneVolume", "GetAllZoneMuteStatus"],
"AppCommand-update"),
XML("8080", "get", "/goform/Deviceinfo.xml", [],
"Deviceinfo.xml"),
XML("8080", "get", "/goform/formMainZone_MainZoneXmlStatus.xml",
[], "formMainZone_MainZoneXmlStatus"),
XML("8080", "get", "/goform/formMainZone_MainZoneXml.xml",
[], "formMainZone_MainZoneXml"),
XML("8080", "get", "/goform/formNetAudio_StatusXml.xml",
[], "formNetAudio_StatusXml"),
XML("8080", "get", "/goform/formTuner_TunerXml.xml",
[], "formTuner_TunerXml"),
XML("8080", "get", "/goform/formTuner_HdXml.xml",
[], "formTuner_HdXml"),
XML("8080", "get", "/goform/formZone2_Zone2XmlStatus.xml",
[], "formZone2_Zone2XmlStatus"),
XML("8080", "get", "/goform/formZone3_Zone3XmlStatus.xml",
[], "formZone3_Zone3XmlStatus")]
def create_post_body(attribute_list):
# Buffer XML body as binary IO
body = BytesIO()
chunks = [attribute_list[i:i+5] for i in range(
0, len(attribute_list), 5)]
for i, chunk in enumerate(chunks):
# Prepare POST XML body for AppCommand.xml
post_root = ET.Element("tx")
for attribute in chunk:
# Append tags for each attribute
item = ET.Element("cmd")
item.set("id", "1")
item.text = attribute
post_root.append(item)
post_tree = ET.ElementTree(post_root)
post_tree.write(body, encoding="utf-8", xml_declaration=bool(i == 0))
body_bytes = body.getvalue()
body.close()
return body_bytes
def http_post(host, port, path, tags, filename):
filename = filename + "-" + str(port)
data = create_post_body(tags)
try:
r = requests.post(
"http://{host}:{port}/{path}".format(
host=host, port=port, path=path), data=data)
except requests.exceptions.ConnectionError:
print("ConnectionError retrieving data from host {} port {} \
path {}".format(host, port, path))
filename = filename + "-ConnectionError.xml"
with open("./{}".format(filename), "wb") as file:
file.write("".encode())
except requests.exceptions.Timeout:
print("Timeout retrieving data from host {} port {} path {}".format(
host, port, path))
filename = filename + "-Timeout.xml"
with open("./{}".format(filename), "wb") as file:
file.write("".encode())
else:
print("HTTP Status Code of {}: {}".format(path, r.status_code))
filename = filename + "-" + str(r.status_code) + ".xml"
with open("./{}".format(filename), "wb") as file:
file.write(r.content)
def | (host, port, path, filename):
filename = filename + "-" + str(port)
try:
r = requests.get(
"http://{host}:{port}/{path}".format(
host=host, port=port, path=path))
except requests.exceptions.ConnectionError:
print("ConnectionError retrieving data from host {} path {}".format(
host, path))
filename = filename + "-ConnectionError.xml"
with open("./{}".format(filename), "wb") as file:
file.write("".encode())
except requests.exceptions.Timeout:
print("Timeout retrieving data from host {} path {}".format(
host, path))
filename = filename + "-Timeout.xml"
with open("./{}".format(filename), "wb") as file:
file.write("".encode())
else:
print("HTTP Status Code of {}: {}".format(path, r.status_code))
filename = filename + "-" + str(r.status_code) + ".xml"
with open("./{}".format(filename), "wb") as file:
file.write(r.content)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--host', type=str,
default='192.168.0.250',
help='host of Denon AVR receiver')
parser.add_argument('--prefix', type=str,
default='AVR',
help='prefix of filenames to be saved')
args = parser.parse_args()
for entry in SAVED_XML:
if entry.type == "post":
http_post(args.host, entry.port, entry.path, entry.tags,
"{}-{}".format(args.prefix, entry.filename))
elif entry.type == "get":
http_get(args.host, entry.port, entry.path, "{}-{}".format(
args.prefix, entry.filename))
else:
print("wrong type, only \"get\" and \"post\" are allowed")
| http_get |
md_analysis.py | """
MD Analysis
===========
#. :class:`.MDAnalysis`
Class for converting a molecule to and back from an MDAnalysis object.
"""
import logging
from ...utilities import WrapperNotInstalledException
try:
import MDAnalysis as mda
except ModuleNotFoundError:
mda = None
logger = logging.getLogger(__name__)
class MDAnalysis:
"""
Converter for :class:`stk.Molecule` to and from MDAnalysis.
Examples
--------
An stk molecule can be converted into an MDAnalysis Universe.
.. code-block:: python
| position=np.array((10, 10, 10))
)
universe = stko.MDAnalysis().get_universe(stkmol)
print('R_g:', universe.atoms.radius_of_gyration())
print('B_sphere:', universe.atoms.bsphere())
print('Universe COM:', universe.atoms.center_of_mass())
print('stk centroid:', stkmol.get_centroid())
"""
def __init__(self):
if mda is None:
raise WrapperNotInstalledException(
'MDAnalysis is not installed; see README for '
'installation.'
)
def get_universe(self, mol):
"""
Get an MDAnalysis object.
Parameters
----------
mol : :class:`stk.Molecule`
Molecule to convert.
Returns
-------
:class:`MDAnalysis.Universe`
The MDAnalysis Universe of the molecule.
"""
rdkit_mol = mol.to_rdkit_mol()
return mda.Universe(rdkit_mol) | import stk
import stko
stkmol = stk.BuildingBlock('NCCNCCN').with_centroid( |
test_model_builder.py | import filecmp
from deliverable_model.builder.model.model_builder import ModelBuilder
def test_build(datadir, tmpdir):
model_builder = ModelBuilder()
model_builder.add_keras_h5_model(datadir / "fixture" / "keras_h5_model")
model_builder.save()
config = model_builder.serialize(tmpdir)
assert config == {
"converter_for_request": "converter_for_request",
"converter_for_response": "converter_for_response",
"custom_object_dependency": [],
"type": "keras_h5_model", | dircmp_obj = filecmp.dircmp(datadir / "expected", tmpdir)
assert not dircmp_obj.diff_files
assert model_builder.get_dependency() == ["tensorflow"] | "version": "1.0",
}
|
issue-5478.ts | import "reflect-metadata";
import {Connection} from "../../../src";
import {createTestingConnections, closeTestingConnections} from "../../utils/test-utils";
import {expect} from "chai";
import {UserEntity} from "./entity/UserEntity";
describe("github issues > #5478 Setting enumName doesn't change how migrations get generated", () => {
let connections: Connection[];
before(async () => connections = await createTestingConnections({
migrations: [],
enabledDrivers: ["postgres"],
schemaCreate: true,
dropSchema: true,
entities: [UserEntity],
}));
after(() => closeTestingConnections(connections));
it("should correctly rename enum", () => Promise.all(connections.map(async connection => {
const queryRunner = connection.createQueryRunner();
// add `enumName`
let table = await queryRunner.getTable("user");
const column = table!.findColumnByName("userType")!;
const newColumn = column.clone();
newColumn.enumName = "UserTypeEnum"
// change column
await queryRunner.changeColumn(table!, column, newColumn)
// check if `enumName` changed
table = await queryRunner.getTable("user");
let changedColumn = table!.findColumnByName("userType")!;
expect(changedColumn.enumName).to.equal("UserTypeEnum");
// revert changes
await queryRunner.executeMemoryDownSql()
// check if `enumName` reverted
table = await queryRunner.getTable("user"); | expect(changedColumn.enumName).to.undefined;
await queryRunner.release();
})));
}); | changedColumn = table!.findColumnByName("userType")!; |
utils.py | from pyteomics import mzml
import numpy as np
from collections import defaultdict, Counter
from os import path
import math
from scipy.optimize import curve_fit
import logging
logger = logging.getLogger(__name__)
from .cutils import get_fast_dict, get_and_calc_apex_intensity_and_scan
class MS1OnlyMzML(mzml.MzML):
_default_iter_path = '//spectrum[./*[local-name()="cvParam" and @name="ms level" and @value="1"]]'
_use_index = False
_iterative = False
def noisygaus(x, a, x0, sigma, b):
return a * np.exp(-(x - x0) ** 2 / (2 * sigma ** 2)) + b
def calibrate_mass(bwidth, mass_left, mass_right, true_md):
bbins = np.arange(-mass_left, mass_right, bwidth)
H1, b1 = np.histogram(true_md, bins=bbins)
b1 = b1 + bwidth
b1 = b1[:-1]
popt, pcov = curve_fit(noisygaus, b1, H1, p0=[1, np.median(true_md), 1, 1])
mass_shift, mass_sigma = popt[1], abs(popt[2])
return mass_shift, mass_sigma, pcov[0][0]
def calc_peptide_features(hills_dict, peptide_features, negative_mode, faims_val, RT_dict, data_start_id):
for pep_feature in peptide_features:
pep_feature['mz'] = pep_feature['hill_mz_1']
pep_feature['isoerror'] = pep_feature['isotopes'][0]['mass_diff_ppm']
pep_feature['isoerror2'] = pep_feature['isotopes'][1]['mass_diff_ppm'] if len(pep_feature['isotopes']) > 1 else -100
pep_feature['nScans'] = hills_dict['hills_lengths'][pep_feature['monoisotope idx']]
pep_feature['massCalib'] = pep_feature['mz'] * pep_feature['charge'] - 1.0072765 * pep_feature['charge'] * (-1 if negative_mode else 1)
hills_dict, _, _ = get_and_calc_apex_intensity_and_scan(hills_dict, pep_feature['monoisotope idx'])
pep_feature['scanApex'] = hills_dict['hills_scan_apex'][pep_feature['monoisotope idx']]
pep_feature['rtApex'] = RT_dict[hills_dict['hills_scan_apex'][pep_feature['monoisotope idx']]+data_start_id]
pep_feature['intensityApex'] = hills_dict['hills_intensity_apex'][pep_feature['monoisotope idx']]
pep_feature['rtStart'] = RT_dict[hills_dict['hills_scan_lists'][pep_feature['monoisotope idx']][0]+data_start_id]
pep_feature['rtEnd'] = RT_dict[hills_dict['hills_scan_lists'][pep_feature['monoisotope idx']][-1]+data_start_id]
pep_feature['mono_hills_scan_lists'] = hills_dict['hills_scan_lists'][pep_feature['monoisotope idx']]
pep_feature['mono_hills_intensity_list'] = hills_dict['hills_intensity_array'][pep_feature['monoisotope idx']]
return peptide_features
def write_output(peptide_features, args, write_header=True):
input_mzml_path = args['file']
if args['o']:
output_file = args['o']
else:
output_file = path.splitext(input_mzml_path)[0]\
+ path.extsep + 'features.tsv'
columns_for_output = [
'massCalib',
'rtApex',
'intensityApex',
'charge',
'nIsotopes',
'nScans',
'mz', | 'rtStart',
'rtEnd',
'FAIMS',
'im',
'mono_hills_scan_lists',
'mono_hills_intensity_list',
'scanApex',
'isoerror2',
]
if write_header:
out_file = open(output_file, 'w')
out_file.write('\t'.join(columns_for_output) + '\n')
out_file.close()
out_file = open(output_file, 'a')
for pep_feature in peptide_features:
out_file.write('\t'.join([str(pep_feature[col]) for col in columns_for_output]) + '\n')
out_file.close()
def centroid_pasef_data(data_for_analyse_tmp, args, mz_step):
cnt_ms1_scans = len(data_for_analyse_tmp)
for spec_idx, z in enumerate(data_for_analyse_tmp):
logger.info('PASEF scans analysis: %d/%d', spec_idx+1, cnt_ms1_scans)
logger.info('number of m/z peaks in scan: %d', len(z['m/z array']))
if 'ignore_ion_mobility' not in z:
mz_ar_new = []
intensity_ar_new = []
ion_mobility_ar_new = []
mz_ar = z['m/z array']
intensity_ar = z['intensity array']
ion_mobility_ar = z['mean inverse reduced ion mobility array']
ion_mobility_accuracy = args['paseftol']
ion_mobility_step = max(ion_mobility_ar) * ion_mobility_accuracy
ion_mobility_ar_fast = (ion_mobility_ar/ion_mobility_step).astype(int)
mz_ar_fast = (mz_ar/mz_step).astype(int)
idx = np.argsort(mz_ar_fast)
mz_ar_fast = mz_ar_fast[idx]
ion_mobility_ar_fast = ion_mobility_ar_fast[idx]
mz_ar = mz_ar[idx]
intensity_ar = intensity_ar[idx]
ion_mobility_ar = ion_mobility_ar[idx]
max_peak_idx = len(mz_ar)
banned_idx = set()
peak_idx = 0
while peak_idx < max_peak_idx:
if peak_idx not in banned_idx:
mass_accuracy_cur = mz_ar[peak_idx] * 1e-6 * args['itol']
mz_val_int = mz_ar_fast[peak_idx]
ion_mob_val_int = ion_mobility_ar_fast[peak_idx]
tmp = [peak_idx, ]
peak_idx_2 = peak_idx + 1
while peak_idx_2 < max_peak_idx:
if peak_idx_2 not in banned_idx:
mz_val_int_2 = mz_ar_fast[peak_idx_2]
if mz_val_int_2 - mz_val_int > 1:
break
elif abs(mz_ar[peak_idx]-mz_ar[peak_idx_2]) <= mass_accuracy_cur:
ion_mob_val_int_2 = ion_mobility_ar_fast[peak_idx_2]
if abs(ion_mob_val_int - ion_mob_val_int_2) <= 1:
tmp.append(peak_idx_2)
peak_idx = peak_idx_2
peak_idx_2 += 1
all_intensity = [intensity_ar[p_id] for p_id in tmp]
i_val_new = sum(all_intensity)
if i_val_new >= args['pasefmini'] and len(all_intensity) >= args['pasefminlh']:
all_mz = [mz_ar[p_id] for p_id in tmp]
all_ion_mob = [ion_mobility_ar[p_id] for p_id in tmp]
mz_val_new = np.average(all_mz, weights=all_intensity)
ion_mob_new = np.average(all_ion_mob, weights=all_intensity)
intensity_ar_new.append(i_val_new)
mz_ar_new.append(mz_val_new)
ion_mobility_ar_new.append(ion_mob_new)
banned_idx.update(tmp)
peak_idx += 1
data_for_analyse_tmp[spec_idx]['m/z array'] = np.array(mz_ar_new)
data_for_analyse_tmp[spec_idx]['intensity array'] = np.array(intensity_ar_new)
data_for_analyse_tmp[spec_idx]['mean inverse reduced ion mobility array'] = np.array(ion_mobility_ar_new)
logger.info('number of m/z peaks in scan after centroiding: %d', len(data_for_analyse_tmp[spec_idx]['m/z array']))
data_for_analyse_tmp = [z for z in data_for_analyse_tmp if len(z['m/z array'] > 0)]
logger.info('Number of MS1 scans after combining ion mobility peaks: %d', len(data_for_analyse_tmp))
# fast_dict = defaultdict(set)
# for peak_idx, (mz_val_int, ion_mob_val_int) in enumerate(zip(mz_ar_fast, ion_mobility_ar_fast)):
# fast_dict[(mz_val_int-1, ion_mob_val_int)].add(peak_idx)
# fast_dict[(mz_val_int, ion_mob_val_int)].add(peak_idx)
# fast_dict[(mz_val_int+1, ion_mob_val_int)].add(peak_idx)
# fast_dict[(mz_val_int-1, ion_mob_val_int-1)].add(peak_idx)
# fast_dict[(mz_val_int, ion_mob_val_int-1)].add(peak_idx)
# fast_dict[(mz_val_int+1, ion_mob_val_int-1)].add(peak_idx)
# fast_dict[(mz_val_int-1, ion_mob_val_int+1)].add(peak_idx)
# fast_dict[(mz_val_int, ion_mob_val_int+1)].add(peak_idx)
# fast_dict[(mz_val_int+1, ion_mob_val_int+1)].add(peak_idx)
# print('HERE2')
# hill_length = []
# peak_idx_array = []
# for peak_idx, (mz_val_int, ion_mob_val_int) in enumerate(zip(mz_ar_fast, ion_mobility_ar_fast)):
# hill_length.append(len(fast_dict[(mz_val_int, ion_mob_val_int)]))
# peak_idx_array.append(peak_idx)
# peak_idx_array = np.array(peak_idx_array)
# print('HERE3')
# added_idx = set()
# idx_sort = np.argsort(hill_length)[::-1]
# for peak_idx in peak_idx_array[idx_sort]:
# if peak_idx not in added_idx:
# mz_val_int = mz_ar_fast[peak_idx]
# ion_mob_val_int = ion_mobility_ar_fast[peak_idx]
# all_idx = set([p_id for p_id in fast_dict[(mz_val_int, ion_mob_val_int)] if p_id not in added_idx])
# if len(all_idx):
# added_idx.update(all_idx)
# all_intensity = [intensity_ar[p_id] for p_id in all_idx]
# i_val_new = sum(all_intensity)
# if i_val_new >= args['pasefmini']:
# all_mz = [mz_ar[p_id] for p_id in all_idx]
# all_ion_mob = [ion_mobility_ar[p_id] for p_id in all_idx]
# mz_val_new = np.average(all_mz, weights=all_intensity)
# ion_mob_new = np.average(all_ion_mob, weights=all_intensity)
# intensity_ar_new.append(i_val_new)
# mz_ar_new.append(mz_val_new)
# ion_mobility_ar_new.append(ion_mob_new)
# data_for_analyse_tmp[spec_idx]['m/z array'] = np.array(mz_ar_new)
# data_for_analyse_tmp[spec_idx]['intensity array'] = np.array(intensity_ar_new)
# data_for_analyse_tmp[spec_idx]['mean inverse reduced ion mobility array'] = np.array(ion_mobility_ar_new)
# data_for_analyse_tmp = [z for z in data_for_analyse_tmp if len(z['m/z array'] > 0)]
# print('Number of MS1 scans after combining ion mobility peaks: ', len(data_for_analyse_tmp))
return data_for_analyse_tmp
def process_profile(data_for_analyse_tmp):
data_for_analyse_tmp_out = []
for z in data_for_analyse_tmp:
best_mz = 0
best_int = 0
best_im = 0
prev_mz = False
prev_int = False
threshold = 0.05
ar1 = []
ar2 = []
ar3 = []
for mzv, intv, imv in zip(z['m/z array'], z['intensity array'], z['mean inverse reduced ion mobility array']):
if prev_mz is False:
best_mz = mzv
best_int = intv
best_im = imv
elif mzv - prev_mz > threshold:
ar1.append(best_mz)
ar2.append(best_int)
ar3.append(best_im)
best_mz = mzv
best_int = intv
best_im = imv
elif best_int > prev_int and intv > prev_int:
ar1.append(best_mz)
ar2.append(best_int)
ar3.append(best_im)
best_mz = mzv
best_int = intv
best_im = imv
elif intv > best_int:
best_mz = mzv
best_int = intv
best_im = imv
prev_mz = mzv
prev_int = intv
ar1.append(best_mz)
ar2.append(best_int)
ar3.append(best_im)
z['m/z array'] = np.array(ar1)
z['intensity array'] = np.array(ar2)
z['mean inverse reduced ion mobility array'] = np.array(ar3)
data_for_analyse_tmp_out.append(z)
return data_for_analyse_tmp_out
def process_tof(data_for_analyse_tmp):
# print(len(z['m/z array']))
universal_dict = {}
cnt = 0
for z in data_for_analyse_tmp:
fast_set = z['m/z array'] // 50
if cnt == 1:
for l in set(fast_set):
idxt = fast_set == l
true_i = np.log10(z['intensity array'])[idxt]
if len(true_i) > 150:
i_left = true_i.min()
i_right = true_i.max()
i_shift, i_sigma, covvalue = calibrate_mass(0.05, i_left, i_right, true_i)
# median_val =
print(i_shift, i_sigma, covvalue)
universal_dict[l] = 10**(i_shift + 3 * i_sigma)#10**(np.median(true_i[idxt]) * 2)
thresholds = [universal_dict.get(zz, 150) for zz in list(fast_set)]
idxt2 = z['intensity array'] <= thresholds
z['intensity array'][idxt2] = -1
idx = z['intensity array'] > 0
z['intensity array'] = z['intensity array'][idx]
z['m/z array'] = z['m/z array'][idx]
z['mean inverse reduced ion mobility array'] = z['mean inverse reduced ion mobility array'][idx]
cnt += 1
data_for_analyse_tmp = [z for z in data_for_analyse_tmp if len(z['m/z array'])]
return data_for_analyse_tmp
def process_mzml(args):
input_mzml_path = args['file']
min_intensity = args['mini']
min_mz = args['minmz']
max_mz = args['maxmz']
skipped = 0
data_for_analyse = []
cnt = 0
for z in MS1OnlyMzML(source=input_mzml_path):
if z['ms level'] == 1:
if 'mean inverse reduced ion mobility array' not in z:
z['ignore_ion_mobility'] = True
z['mean inverse reduced ion mobility array'] = np.zeros(len(z['m/z array']))
idx = z['intensity array'] >= min_intensity
z['intensity array'] = z['intensity array'][idx]
z['m/z array'] = z['m/z array'][idx]
z['mean inverse reduced ion mobility array'] = z['mean inverse reduced ion mobility array'][idx]
idx = z['m/z array'] >= min_mz
z['m/z array'] = z['m/z array'][idx]
z['intensity array'] = z['intensity array'][idx]
z['mean inverse reduced ion mobility array'] = z['mean inverse reduced ion mobility array'][idx]
idx = z['m/z array'] <= max_mz
z['m/z array'] = z['m/z array'][idx]
z['intensity array'] = z['intensity array'][idx]
z['mean inverse reduced ion mobility array'] = z['mean inverse reduced ion mobility array'][idx]
idx = np.argsort(z['m/z array'])
z['m/z array'] = z['m/z array'][idx]
z['intensity array'] = z['intensity array'][idx]
z['mean inverse reduced ion mobility array'] = z['mean inverse reduced ion mobility array'][idx]
cnt += 1
# if len(data_for_analyse) > 50:
# break
if len(z['m/z array']):
data_for_analyse.append(z)
else:
skipped += 1
logger.info('Number of MS1 scans: %d', len(data_for_analyse))
logger.info('Number of skipped MS1 scans: %d', skipped)
if len(data_for_analyse) == 0:
raise Exception('no MS1 scans in input file')
return data_for_analyse
def process_mzml_dia(args):
input_mzml_path = args['file']
# min_intensity = args['mini']
# min_mz = args['minmz']
# max_mz = args['maxmz']
min_intensity = 0
min_mz = 1
max_mz = 1e6
skipped = 0
data_for_analyse = []
cnt = 0
for z in mzml.read(input_mzml_path):
if z['ms level'] == 2:
if 'mean inverse reduced ion mobility array' not in z:
z['ignore_ion_mobility'] = True
z['mean inverse reduced ion mobility array'] = np.zeros(len(z['m/z array']))
idx = z['intensity array'] >= min_intensity
z['intensity array'] = z['intensity array'][idx]
z['m/z array'] = z['m/z array'][idx]
z['mean inverse reduced ion mobility array'] = z['mean inverse reduced ion mobility array'][idx]
idx = z['m/z array'] >= min_mz
z['m/z array'] = z['m/z array'][idx]
z['intensity array'] = z['intensity array'][idx]
z['mean inverse reduced ion mobility array'] = z['mean inverse reduced ion mobility array'][idx]
idx = z['m/z array'] <= max_mz
z['m/z array'] = z['m/z array'][idx]
z['intensity array'] = z['intensity array'][idx]
z['mean inverse reduced ion mobility array'] = z['mean inverse reduced ion mobility array'][idx]
idx = np.argsort(z['m/z array'])
z['m/z array'] = z['m/z array'][idx]
z['intensity array'] = z['intensity array'][idx]
z['mean inverse reduced ion mobility array'] = z['mean inverse reduced ion mobility array'][idx]
cnt += 1
# if len(data_for_analyse) > 5000:
# break
if len(z['m/z array']):
data_for_analyse.append(z)
else:
skipped += 1
logger.info('Number of MS2 scans: %d', len(data_for_analyse))
logger.info('Number of skipped MS2 scans: %d', skipped)
return data_for_analyse | |
uci.rs | // Copyright 2020-2021, Benjamin Ludewig, Florian Bonetti, Jeffrey Munstermann, Luca Nittscher, Hugo Damer, Michael Bach
// SPDX-License-Identifier: MIT OR Apache-2.0
#[cfg(not(feature = "uci"))]
pub use mock::*;
#[cfg(feature = "uci")]
pub use rust_uci::*;
#[cfg(not(feature = "uci"))]
#[allow(clippy::unused_self)]
mod mock {
use crate::error::{self, Result};
pub struct Uci {}
impl Uci {
pub fn new() -> Result<Self> {
Ok(Self {})
}
pub fn set_config_dir(&mut self, config_dir: &str) -> Result<()> {
debug!("set_config_dir {}", config_dir);
Ok(())
}
pub fn | (&mut self, save_dir: &str) -> Result<()> {
debug!("set_save_dir {}", save_dir);
Ok(())
}
pub fn revert(&mut self, package: &str) -> Result<()> {
debug!("revert {}", package);
Ok(())
}
pub fn delete(&mut self, key: &str) -> Result<()> {
debug!("delete {}", key);
Ok(())
}
pub fn get(&mut self, key: &str) -> Result<String> {
debug!("get {}", key);
error::NoneError {}.fail()
}
pub fn set(&mut self, key: &str, value: &str) -> Result<()> {
debug!("set {}={}", key, value);
Ok(())
}
pub fn commit(&mut self, package: &str) -> Result<()> {
debug!("commit {}", package);
Ok(())
}
}
}
#[cfg(test)]
mod tests {
use std::{fs, fs::File, io::Read};
use super::*;
use crate::error::Result;
fn init() -> Result<Uci> {
let _ = env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("warn"))
.is_test(true)
.try_init();
let mut uci = Uci::new()?;
uci.set_config_dir("tests/config")?;
uci.set_save_dir("/tmp/.uci_tests")?;
Ok(uci)
}
#[test]
fn test_reading_key() -> Result<()> {
let mut uci = init()?;
assert_eq!(uci.get("network.wan")?, "interface");
assert_eq!(uci.get("network.@interface[0]")?, "interface");
assert_eq!(uci.get("network.a")?, "alias");
assert_eq!(uci.get("network.@alias[-1]")?, "alias");
assert_eq!(uci.get("network.wan.proto")?, "dhcp");
assert_eq!(uci.get("network.@interface[-1].proto")?, "dhcp");
assert_eq!(uci.get("network.lan.proto")?, "static");
assert_eq!(uci.get("network.@interface[0].proto")?, "static");
assert_eq!(uci.get("broken.a").is_err(), true);
assert_eq!(uci.get("broken.a.b").is_err(), true);
assert_eq!(uci.get("inexistant.c").is_err(), true);
assert_eq!(uci.get("inexistant.c.d").is_err(), true);
Ok(())
}
#[test]
fn test_writing_key() -> Result<()> {
let mut uci = init()?;
File::create("tests/config/new_network")?;
uci.set("new_network.a", "alias")?;
uci.set("new_network.a.interface", "lan")?;
uci.set("new_network.b", "alias")?;
uci.set("new_network.b.interface", "lan")?;
uci.set("new_network.lan", "interface")?;
uci.set("new_network.lan.proto", "static")?;
uci.set("new_network.lan.ifname", "eth0")?;
uci.set("new_network.lan.test", "123")?;
uci.set("new_network.lan.enabled", "off")?;
uci.set("new_network.lan.ipaddr", "2.3.4.5")?;
uci.set("new_network.wan", "interface")?;
uci.set("new_network.wan.proto", "dhcp")?;
uci.set("new_network.wan.ifname", "eth1")?;
uci.set("new_network.wan.enabled", "on")?;
uci.set("new_network.wan.aliases", "c d")?;
uci.set("new_network.c", "alias")?;
uci.set("new_network.c.interface", "wan")?;
uci.set("new_network.d", "alias")?;
uci.set("new_network.d.interface", "wan")?;
uci.commit("new_network")?;
let mut file = File::open("tests/config/new_network")?;
let mut contents = String::new();
file.read_to_string(&mut contents)?;
let mut file = File::open("tests/config/network")?;
let mut actual_contents = String::new();
file.read_to_string(&mut actual_contents)?;
fs::remove_file("tests/config/new_network")?;
assert_eq!(contents, actual_contents);
Ok(())
}
#[test]
fn test_delete() -> Result<()> {
let mut uci = init()?;
assert_eq!(uci.get("network.wan.proto")?, "dhcp");
assert_eq!(uci.get("network.wan.ifname")?, "eth1");
uci.delete("network.wan")?;
assert_eq!(uci.get("network.wan.proto").is_err(), true);
assert_eq!(uci.get("network.wan.ifname").is_err(), true);
uci.revert("network")?;
assert_eq!(uci.get("network.wan.proto")?, "dhcp");
assert_eq!(uci.get("network.wan.ifname")?, "eth1");
Ok(())
}
}
| set_save_dir |
day22.rs | #[macro_use]
extern crate clap;
use clap::App;
extern crate regex;
use std::error::Error;
use std::fs::File;
use std::io::prelude::*;
use regex::Regex;
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
#[derive(Clone,Debug)]
struct GameState {
player : Character,
boss : Character,
players_turn : bool,
turns : u32,
minimum_mana_usage : Arc<AtomicUsize>
}
impl GameState {
fn new(player : Character, boss : Character) -> GameState {
GameState {
player : player,
boss : boss,
players_turn : true,
turns : 0,
minimum_mana_usage : Arc::new(AtomicUsize::new(std::usize::MAX))
}
}
fn apply_boss_damage(&mut self) {
if !self.players_turn {
let damage = std::cmp::max(1, self.boss.damage - self.player.armor);
self.player.hp -= damage as i32;
}
}
fn apply_spells(&mut self) {
self.player.armor = 0; // Init to no shield
for s in &mut self.player.active_spells {
self.player.mana += s.mana_gain;// Recharge
self.player.armor += s.armor;// Shield
s.turns -= 1;
}
self.player.active_spells.retain(|x| x.turns != 0);
for s in &mut self.boss.active_spells {
self.boss.hp -= s.damage as i32; // Poison
s.turns -= 1;
}
self.boss.active_spells.retain(|x| x.turns != 0);
}
fn spell_in_effect(&self, spell : &Spell) -> bool {
let mut on = false;
for s in &self.player.active_spells {
if s.name == spell.name {
on = true;
break;
}
}
if !on {
for s in &self.boss.active_spells {
if s.name == spell.name {
on = true;
break;
}
}
}
on
}
fn add_spell(&mut self, spell : Spell) {
self.player.mana -= spell.mana_cost;
self.player.mana_usage += spell.mana_cost;
if spell.turns > 0 {
if spell.name == "Shield" || spell.name == "Recharge" {
self.player.active_spells.push(spell);
} else {
self.boss.active_spells.push(spell);
}
} else {
self.player.hp += spell.heal as i32;
self.boss.hp -= spell.damage as i32;
}
}
}
#[derive(Clone,Debug)]
struct Character {
hp : i32,
damage : u32,
armor : u32,
mana : u32,
mana_usage : u32,
active_spells : Vec<Spell>
}
impl Character {
fn new(hp : i32, damage : u32, mana : u32) -> Character {
Character {
hp : hp,
damage : damage,
armor : 0,
mana : mana,
mana_usage : 0,
active_spells : Vec::new()
}
}
}
#[derive(Clone,Debug)]
struct Spell {
name : String,
mana_cost : u32,
damage : u32,
heal : u32,
armor : u32,
mana_gain : u32,
turns : u32, // If turns = 0, instant
}
impl Spell {
fn new(name : &str, cost : u32, damage : u32, heal : u32, armor : u32, gain : u32, turns : u32) -> Spell {
Spell {
name : String::from(name),
mana_cost : cost,
damage : damage,
heal : heal,
armor : armor,
mana_gain : gain,
turns : turns
}
}
}
fn main() {
let yaml = load_yaml!("cli.yml");
let matches = App::from_yaml(yaml).get_matches();
let hp = matches.value_of("HP").unwrap_or("50").parse::<i32>().unwrap();
let mana = matches.value_of("MANA").unwrap_or("500").parse::<u32>().unwrap();
let filename = matches.value_of("FILE").unwrap();
let mut file = match File::open(filename) {
Err(why) => panic!("Couldn't open {}: {}", filename, Error::description(&why)),
Ok(file) => file,
};
let mut s = String::new();
match file.read_to_string(&mut s) {
Err(why) => panic!("Couldn't read {}: {}", filename, Error::description(&why)),
Ok(_) => println!("Read file {}", filename),
}
let boss = parse_input(s.trim().split('\n').collect());
let player = Character::new(hp, 0, mana);
let spells = build_spell_list();
let easy = GameState::new(player.clone(), boss.clone());
find_min_mana_usage(easy.clone(), &spells, false);
println!("Easy Mode: Min mana used: {}", easy.minimum_mana_usage.load(Ordering::SeqCst));
let hard = GameState::new(player.clone(), boss.clone());
find_min_mana_usage(hard.clone(), &spells, true);
println!("Hard Mode: Min mana used: {}", hard.minimum_mana_usage.load(Ordering::SeqCst));
}
fn find_min_mana_usage(state : GameState, spells : &Vec<Spell>, hard_mode : bool) -> u32 {
let mut mana_usage = std::u32::MAX;
let mut game = state.clone();
| game.turns += 1;
if hard_mode && game.players_turn {
game.player.hp -= 1;
}
if game.player.hp > 0 {
game.apply_spells(); //Apply existing spells to player and boss
if game.boss.hp <= 0 {
// Player won
mana_usage = game.player.mana_usage;
} else if game.players_turn {
game.players_turn = false;
for s in spells {
if !game.spell_in_effect(s) && game.player.mana >= s.mana_cost && ((game.player.mana_usage + s.mana_cost) as usize) < game.minimum_mana_usage.load(Ordering::SeqCst) {
let mut new_game_state = game.clone();
new_game_state.add_spell(s.clone());
let new_mana_usage = find_min_mana_usage(new_game_state, spells, hard_mode);
if new_mana_usage < mana_usage && (new_mana_usage as usize) < game.minimum_mana_usage.load(Ordering::SeqCst) {
mana_usage = new_mana_usage;
game.minimum_mana_usage.store(mana_usage as usize, Ordering::SeqCst);
}
}
}
} else {
// Run boss code
game.apply_boss_damage();
if game.player.hp > 0 {
game.players_turn = true;
// If neither player or boss won, start next round
let new_mana_usage = find_min_mana_usage(game.clone(), spells, hard_mode);
if new_mana_usage < mana_usage && (new_mana_usage as usize) < game.minimum_mana_usage.load(Ordering::SeqCst) {
mana_usage = new_mana_usage;
game.minimum_mana_usage.store(mana_usage as usize, Ordering::SeqCst);
}
}
}
}
mana_usage
}
fn build_spell_list() -> Vec<Spell> {
let mut spells = Vec::new();
spells.push(Spell::new("Shield", 113, 0, 0, 7, 0, 6));
spells.push(Spell::new("Poison", 173, 3, 0, 0, 0, 6));
spells.push(Spell::new("Magic Missle", 53, 4, 0, 0, 0, 0));
spells.push(Spell::new("Drain", 73, 2, 2, 0, 0, 0));
spells.push(Spell::new("Recharge", 229, 0, 0, 0, 101, 5));
spells
}
fn parse_input(input : Vec<&str>) -> Character {
let mut hp = 0;
let mut damage = 0;
for s in input {
if s.trim().len() > 0 {
let re = Regex::new(r"(.*): (\d+)").unwrap();
for cap in re.captures_iter(s) {
if cap.at(1).unwrap() == "Hit Points" {
hp = cap.at(2).unwrap().parse::<i32>().unwrap();
} else if cap.at(1).unwrap() == "Damage" {
damage = cap.at(2).unwrap().parse::<u32>().unwrap();
}
}
}
}
Character::new(hp, damage, 0)
} | |
index.js | import DetailUser from "./pages/detailUser";
import MainUser from "./pages/mainUser";
function UserPage() {
const match = useRouteMatch();
return (
<Switch>
<Route path={`${match.url}/`} exact component={MainUser} />
<Route path={`${match.url}/:id`} component={DetailUser} />
</Switch>
);
}
export default UserPage; | import React from "react";
import { Route, Switch, useRouteMatch } from "react-router-dom"; |
|
test03.js | function AVLTree() {
| this.left = null;
this.right = null;
};
let root = null;
this.getRoot = function () {
return root;
};
let heightNode = function (node) {
if (node === null) {
return -1;
} else {
return Math.max(heightNode(node.left), heightNode(node.right)) + 1;
}
};
let rotationLL = function (node) {
let tmp = node.left;
node.left = tmp.right;
tmp.right = node;
return tmp;
};
let rotationRR = function (node) {
let tmp = node.right;
node.right = tmp.left;
tmp.left = node;
return tmp;
};
let rotationLR = function (node) {
node.left = rotationRR(node.left);
return rotationLL(node);
};
let rotationRL = function (node) {
node.right = rotationLL(node.right);
return rotationRR(node);
};
let insertNode = function (node, ele) {
if (node === null) {
node = new Node(ele);
} else if (ele < node.key) {
node.left = insertNode(node.left, ele);
if (node.left !== null) {
if ((heightNode(node.left) - heightNode(node.right)) > 1) {
if (ele < node.left.key) {
node = rotationLL(node);
} else {
node = rotationLR(node);
}
}
}
} else if (ele > node.key) {
node.right = insertNode(node.right, ele);
if (node.right !== null) {
if ((heightNode(node.right) - heightNode(node.left)) > 1) {
if (ele > node.right.key) {
node = rotationRR(node);
} else {
node = rotationRL(node);
}
}
}
}
return node;
};
this.insert = function (ele) {
root = insertNode(root, ele);
};
let parentNode;
let nodeToBeDeleted;
let removeNode = function (node, ele) {
if (node === null) {
return null;
}
parentNode = node;
if (ele < node.key) {
node.left = removeNode(node.left, ele);
} else {
nodeToBeDeleted = node;
node.right = removeNode(node.right, ele);
}
if (node === parentNode) {
if (nodeToBeDeleted !== null && ele === nodeToBeDeleted.key) {
if (nodeToBeDeleted === parentNode) {
node = node.left;
} else {
let tmp = nodeToBeDeleted.key;
nodeToBeDeleted.key = parentNode.key;
parentNode.key = tmp;
node = node.right;
}
}
} else {
if (node.left === undefined) {
node.left = null;
}
if (node.right === undefined) {
node.right = null;
}
if ((heightNode(node.left) - heightNode(node.right)) === 2) {
if (ele < node.left.key) {
node = rotationLR(node);
} else {
node = rotationLL(node);
}
}
if ((heightNode(node.right) - heightNode(node.left)) === 2) {
if (ele > node.right.key) {
node = rotationRL(node);
} else {
node = rotationRR(node);
}
}
}
return node;
};
this.remove = function (ele) {
parentNode = null;
nodeToBeDeleted = null;
root = removeNode(root, ele);
};
this.inOrderTraverse = function (callback) {
inOrderTraverseNode(root, callback);
};
let inOrderTraverseNode = function (node, callback) {
if (node !== null) {
inOrderTraverseNode(node.left, callback);
callback(node.key);
inOrderTraverseNode(node.right, callback);
}
};
this.preOrderTraverse = function (callback) {
preOrderTraverseNode(root, callback);
};
let preOrderTraverseNode = function (node, callback) {
if (node !== null) {
callback(node.key);
preOrderTraverseNode(node.left, callback);
preOrderTraverseNode(node.right, callback);
}
};
};
var avlTree = new AVLTree();
function printNode(value) {
console.log(value);
}
/*avlTree.insert(1);
avlTree.insert(2);
avlTree.insert(3);
avlTree.insert(4);
avlTree.insert(5);
avlTree.insert(6);
avlTree.insert(7);
avlTree.insert(14);
avlTree.insert(15);
avlTree.insert(13);
avlTree.insert(12);
avlTree.insert(11);*/
//RR rotation
avlTree.insert(50);
avlTree.insert(30);
avlTree.insert(70);
avlTree.insert(60);
avlTree.insert(80);
avlTree.insert(90);
//LL rotation
/*avlTree.insert(50);
avlTree.insert(30);
avlTree.insert(70);
avlTree.insert(10);
avlTree.insert(40);
avlTree.insert(5);*/
//LR rotation
/*avlTree.insert(50);
avlTree.insert(30);
avlTree.insert(70);
avlTree.insert(40);
avlTree.insert(10);
avlTree.insert(35);*/
//RL rotation
/*avlTree.insert(70);
avlTree.insert(50);
avlTree.insert(80);
avlTree.insert(72);
avlTree.insert(90);
avlTree.insert(75);*/
/*avlTree.remove(12);
avlTree.remove(15);
avlTree.remove(11);
avlTree.remove(14);
avlTree.remove(13);
avlTree.remove(7);
avlTree.remove(6);
avlTree.remove(2);
avlTree.remove(4);*/
console.log('***** in-order transverse *****');
avlTree.inOrderTraverse(printNode);
console.log('***** pre-order transverse *****');
avlTree.preOrderTraverse(printNode); | let Node = function (key) {
this.key = key;
|
gdb_core_transaction.go | // Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
package gdb
import (
"context"
"database/sql"
"github.com/gogf/gf/errors/gcode"
"github.com/gogf/gf/errors/gerror"
"reflect"
"github.com/gogf/gf/container/gtype"
"github.com/gogf/gf/os/gtime"
"github.com/gogf/gf/util/gconv"
"github.com/gogf/gf/util/guid"
"github.com/gogf/gf/text/gregex"
)
// TX is the struct for transaction management.
type TX struct {
db DB // db is the current gdb database manager.
tx *sql.Tx // tx is the raw and underlying transaction manager.
ctx context.Context // ctx is the context for this transaction only.
master *sql.DB // master is the raw and underlying database manager.
transactionId string // transactionId is an unique id generated by this object for this transaction.
transactionCount int // transactionCount marks the times that Begins.
isClosed bool // isClosed marks this transaction has already been committed or rolled back.
}
const (
transactionPointerPrefix = "transaction"
contextTransactionKeyPrefix = "TransactionObjectForGroup_"
transactionIdForLoggerCtx = "TransactionId"
)
var (
transactionIdGenerator = gtype.NewUint64()
)
// Begin starts and returns the transaction object.
// You should call Commit or Rollback functions of the transaction object
// if you no longer use the transaction. Commit or Rollback functions will also
// close the transaction automatically.
func (c *Core) Begin() (tx *TX, err error) {
return c.doBeginCtx(c.GetCtx())
}
func (c *Core) doBeginCtx(ctx context.Context) (*TX, error) {
if master, err := c.db.Master(); err != nil {
return nil, err
} else {
var (
tx *TX
sqlStr = "BEGIN"
mTime1 = gtime.TimestampMilli()
rawTx, err = master.Begin()
mTime2 = gtime.TimestampMilli()
sqlObj = &Sql{
Sql: sqlStr,
Type: "DB.Begin",
Args: nil,
Format: sqlStr,
Error: err,
Start: mTime1,
End: mTime2,
Group: c.db.GetGroup(),
IsTransaction: true,
}
)
if err == nil {
tx = &TX{
db: c.db,
tx: rawTx,
ctx: context.WithValue(ctx, transactionIdForLoggerCtx, transactionIdGenerator.Add(1)),
master: master,
transactionId: guid.S(),
}
ctx = tx.ctx
}
// Tracing and logging.
c.addSqlToTracing(ctx, sqlObj)
if c.db.GetDebug() {
c.writeSqlToLogger(ctx, sqlObj)
}
return tx, err
}
}
// Transaction wraps the transaction logic using function `f`.
// It rollbacks the transaction and returns the error from function `f` if
// it returns non-nil error. It commits the transaction and returns nil if
// function `f` returns nil.
//
// Note that, you should not Commit or Rollback the transaction in function `f`
// as it is automatically handled by this function.
func (c *Core) Transaction(ctx context.Context, f func(ctx context.Context, tx *TX) error) (err error) {
var (
tx *TX
)
if ctx == nil {
ctx = c.GetCtx()
}
// Check transaction object from context.
tx = TXFromCtx(ctx, c.db.GetGroup())
if tx != nil {
return tx.Transaction(ctx, f)
}
tx, err = c.doBeginCtx(ctx)
if err != nil {
return err
}
// Inject transaction object into context.
tx.ctx = WithTX(tx.ctx, tx)
defer func() {
if err == nil {
if exception := recover(); exception != nil {
if v, ok := exception.(error); ok {
err = v
} else {
err = gerror.NewCodef(gcode.CodeInternalError, "%+v", exception)
}
}
}
if err != nil {
if e := tx.Rollback(); e != nil {
err = e
}
} else {
if e := tx.Commit(); e != nil {
err = e
}
}
}()
err = f(tx.ctx, tx)
return
}
// WithTX injects given transaction object into context and returns a new context.
func WithTX(ctx context.Context, tx *TX) context.Context {
if tx == nil {
return ctx
}
// Check repeat injection from given.
group := tx.db.GetGroup()
if tx := TXFromCtx(ctx, group); tx != nil && tx.db.GetGroup() == group {
return ctx
}
dbCtx := tx.db.GetCtx()
if tx := TXFromCtx(dbCtx, group); tx != nil && tx.db.GetGroup() == group {
return dbCtx
}
// Inject transaction object and id into context.
ctx = context.WithValue(ctx, transactionKeyForContext(group), tx)
return ctx
}
// TXFromCtx retrieves and returns transaction object from context.
// It is usually used in nested transaction feature, and it returns nil if it is not set previously.
func | (ctx context.Context, group string) *TX {
if ctx == nil {
return nil
}
v := ctx.Value(transactionKeyForContext(group))
if v != nil {
tx := v.(*TX)
if tx.IsClosed() {
return nil
}
tx.ctx = ctx
return tx
}
return nil
}
// transactionKeyForContext forms and returns a string for storing transaction object of certain database group into context.
func transactionKeyForContext(group string) string {
return contextTransactionKeyPrefix + group
}
// transactionKeyForNestedPoint forms and returns the transaction key at current save point.
func (tx *TX) transactionKeyForNestedPoint() string {
return tx.db.GetCore().QuoteWord(transactionPointerPrefix + gconv.String(tx.transactionCount))
}
// Ctx sets the context for current transaction.
func (tx *TX) Ctx(ctx context.Context) *TX {
tx.ctx = ctx
return tx
}
// Commit commits current transaction.
// Note that it releases previous saved transaction point if it's in a nested transaction procedure,
// or else it commits the hole transaction.
func (tx *TX) Commit() error {
if tx.transactionCount > 0 {
tx.transactionCount--
_, err := tx.Exec("RELEASE SAVEPOINT " + tx.transactionKeyForNestedPoint())
return err
}
var (
sqlStr = "COMMIT"
mTime1 = gtime.TimestampMilli()
err = tx.tx.Commit()
mTime2 = gtime.TimestampMilli()
sqlObj = &Sql{
Sql: sqlStr,
Type: "TX.Commit",
Args: nil,
Format: sqlStr,
Error: err,
Start: mTime1,
End: mTime2,
Group: tx.db.GetGroup(),
IsTransaction: true,
}
)
tx.isClosed = true
tx.db.GetCore().addSqlToTracing(tx.ctx, sqlObj)
if tx.db.GetDebug() {
tx.db.GetCore().writeSqlToLogger(tx.ctx, sqlObj)
}
return err
}
// Rollback aborts current transaction.
// Note that it aborts current transaction if it's in a nested transaction procedure,
// or else it aborts the hole transaction.
func (tx *TX) Rollback() error {
if tx.transactionCount > 0 {
tx.transactionCount--
_, err := tx.Exec("ROLLBACK TO SAVEPOINT " + tx.transactionKeyForNestedPoint())
return err
}
var (
sqlStr = "ROLLBACK"
mTime1 = gtime.TimestampMilli()
err = tx.tx.Rollback()
mTime2 = gtime.TimestampMilli()
sqlObj = &Sql{
Sql: sqlStr,
Type: "TX.Rollback",
Args: nil,
Format: sqlStr,
Error: err,
Start: mTime1,
End: mTime2,
Group: tx.db.GetGroup(),
IsTransaction: true,
}
)
tx.isClosed = true
tx.db.GetCore().addSqlToTracing(tx.ctx, sqlObj)
if tx.db.GetDebug() {
tx.db.GetCore().writeSqlToLogger(tx.ctx, sqlObj)
}
return err
}
// IsClosed checks and returns this transaction has already been committed or rolled back.
func (tx *TX) IsClosed() bool {
return tx.isClosed
}
// Begin starts a nested transaction procedure.
func (tx *TX) Begin() error {
_, err := tx.Exec("SAVEPOINT " + tx.transactionKeyForNestedPoint())
if err != nil {
return err
}
tx.transactionCount++
return nil
}
// SavePoint performs `SAVEPOINT xxx` SQL statement that saves transaction at current point.
// The parameter `point` specifies the point name that will be saved to server.
func (tx *TX) SavePoint(point string) error {
_, err := tx.Exec("SAVEPOINT " + tx.db.GetCore().QuoteWord(point))
return err
}
// RollbackTo performs `ROLLBACK TO SAVEPOINT xxx` SQL statement that rollbacks to specified saved transaction.
// The parameter `point` specifies the point name that was saved previously.
func (tx *TX) RollbackTo(point string) error {
_, err := tx.Exec("ROLLBACK TO SAVEPOINT " + tx.db.GetCore().QuoteWord(point))
return err
}
// Transaction wraps the transaction logic using function `f`.
// It rollbacks the transaction and returns the error from function `f` if
// it returns non-nil error. It commits the transaction and returns nil if
// function `f` returns nil.
//
// Note that, you should not Commit or Rollback the transaction in function `f`
// as it is automatically handled by this function.
func (tx *TX) Transaction(ctx context.Context, f func(ctx context.Context, tx *TX) error) (err error) {
if ctx != nil {
tx.ctx = ctx
}
// Check transaction object from context.
if TXFromCtx(tx.ctx, tx.db.GetGroup()) == nil {
// Inject transaction object into context.
tx.ctx = WithTX(tx.ctx, tx)
}
err = tx.Begin()
if err != nil {
return err
}
defer func() {
if err == nil {
if exception := recover(); exception != nil {
if v, ok := exception.(error); ok {
err = v
} else {
err = gerror.NewCodef(gcode.CodeInternalError, "%+v", exception)
}
}
}
if err != nil {
if e := tx.Rollback(); e != nil {
err = e
}
} else {
if e := tx.Commit(); e != nil {
err = e
}
}
}()
err = f(tx.ctx, tx)
return
}
// Query does query operation on transaction.
// See Core.Query.
func (tx *TX) Query(sql string, args ...interface{}) (rows *sql.Rows, err error) {
return tx.db.DoQuery(tx.ctx, &txLink{tx.tx}, sql, args...)
}
// Exec does none query operation on transaction.
// See Core.Exec.
func (tx *TX) Exec(sql string, args ...interface{}) (sql.Result, error) {
return tx.db.DoExec(tx.ctx, &txLink{tx.tx}, sql, args...)
}
// Prepare creates a prepared statement for later queries or executions.
// Multiple queries or executions may be run concurrently from the
// returned statement.
// The caller must call the statement's Close method
// when the statement is no longer needed.
func (tx *TX) Prepare(sql string) (*Stmt, error) {
return tx.db.DoPrepare(tx.ctx, &txLink{tx.tx}, sql)
}
// GetAll queries and returns data records from database.
func (tx *TX) GetAll(sql string, args ...interface{}) (Result, error) {
rows, err := tx.Query(sql, args...)
if err != nil || rows == nil {
return nil, err
}
defer rows.Close()
return tx.db.GetCore().convertRowsToResult(rows)
}
// GetOne queries and returns one record from database.
func (tx *TX) GetOne(sql string, args ...interface{}) (Record, error) {
list, err := tx.GetAll(sql, args...)
if err != nil {
return nil, err
}
if len(list) > 0 {
return list[0], nil
}
return nil, nil
}
// GetStruct queries one record from database and converts it to given struct.
// The parameter `pointer` should be a pointer to struct.
func (tx *TX) GetStruct(obj interface{}, sql string, args ...interface{}) error {
one, err := tx.GetOne(sql, args...)
if err != nil {
return err
}
return one.Struct(obj)
}
// GetStructs queries records from database and converts them to given struct.
// The parameter `pointer` should be type of struct slice: []struct/[]*struct.
func (tx *TX) GetStructs(objPointerSlice interface{}, sql string, args ...interface{}) error {
all, err := tx.GetAll(sql, args...)
if err != nil {
return err
}
return all.Structs(objPointerSlice)
}
// GetScan queries one or more records from database and converts them to given struct or
// struct array.
//
// If parameter `pointer` is type of struct pointer, it calls GetStruct internally for
// the conversion. If parameter `pointer` is type of slice, it calls GetStructs internally
// for conversion.
func (tx *TX) GetScan(pointer interface{}, sql string, args ...interface{}) error {
t := reflect.TypeOf(pointer)
k := t.Kind()
if k != reflect.Ptr {
return gerror.NewCodef(gcode.CodeInvalidParameter, "params should be type of pointer, but got: %v", k)
}
k = t.Elem().Kind()
switch k {
case reflect.Array, reflect.Slice:
return tx.GetStructs(pointer, sql, args...)
case reflect.Struct:
return tx.GetStruct(pointer, sql, args...)
}
return gerror.NewCodef(gcode.CodeInvalidParameter, "element type should be type of struct/slice, unsupported: %v", k)
}
// GetValue queries and returns the field value from database.
// The sql should query only one field from database, or else it returns only one
// field of the result.
func (tx *TX) GetValue(sql string, args ...interface{}) (Value, error) {
one, err := tx.GetOne(sql, args...)
if err != nil {
return nil, err
}
for _, v := range one {
return v, nil
}
return nil, nil
}
// GetCount queries and returns the count from database.
func (tx *TX) GetCount(sql string, args ...interface{}) (int, error) {
if !gregex.IsMatchString(`(?i)SELECT\s+COUNT\(.+\)\s+FROM`, sql) {
sql, _ = gregex.ReplaceString(`(?i)(SELECT)\s+(.+)\s+(FROM)`, `$1 COUNT($2) $3`, sql)
}
value, err := tx.GetValue(sql, args...)
if err != nil {
return 0, err
}
return value.Int(), nil
}
// Insert does "INSERT INTO ..." statement for the table.
// If there's already one unique record of the data in the table, it returns error.
//
// The parameter `data` can be type of map/gmap/struct/*struct/[]map/[]struct, etc.
// Eg:
// Data(g.Map{"uid": 10000, "name":"john"})
// Data(g.Slice{g.Map{"uid": 10000, "name":"john"}, g.Map{"uid": 20000, "name":"smith"})
//
// The parameter `batch` specifies the batch operation count when given data is slice.
func (tx *TX) Insert(table string, data interface{}, batch ...int) (sql.Result, error) {
if len(batch) > 0 {
return tx.Model(table).Ctx(tx.ctx).Data(data).Batch(batch[0]).Insert()
}
return tx.Model(table).Ctx(tx.ctx).Data(data).Insert()
}
// InsertIgnore does "INSERT IGNORE INTO ..." statement for the table.
// If there's already one unique record of the data in the table, it ignores the inserting.
//
// The parameter `data` can be type of map/gmap/struct/*struct/[]map/[]struct, etc.
// Eg:
// Data(g.Map{"uid": 10000, "name":"john"})
// Data(g.Slice{g.Map{"uid": 10000, "name":"john"}, g.Map{"uid": 20000, "name":"smith"})
//
// The parameter `batch` specifies the batch operation count when given data is slice.
func (tx *TX) InsertIgnore(table string, data interface{}, batch ...int) (sql.Result, error) {
if len(batch) > 0 {
return tx.Model(table).Ctx(tx.ctx).Data(data).Batch(batch[0]).InsertIgnore()
}
return tx.Model(table).Ctx(tx.ctx).Data(data).InsertIgnore()
}
// InsertAndGetId performs action Insert and returns the last insert id that automatically generated.
func (tx *TX) InsertAndGetId(table string, data interface{}, batch ...int) (int64, error) {
if len(batch) > 0 {
return tx.Model(table).Ctx(tx.ctx).Data(data).Batch(batch[0]).InsertAndGetId()
}
return tx.Model(table).Ctx(tx.ctx).Data(data).InsertAndGetId()
}
// Replace does "REPLACE INTO ..." statement for the table.
// If there's already one unique record of the data in the table, it deletes the record
// and inserts a new one.
//
// The parameter `data` can be type of map/gmap/struct/*struct/[]map/[]struct, etc.
// Eg:
// Data(g.Map{"uid": 10000, "name":"john"})
// Data(g.Slice{g.Map{"uid": 10000, "name":"john"}, g.Map{"uid": 20000, "name":"smith"})
//
// The parameter `data` can be type of map/gmap/struct/*struct/[]map/[]struct, etc.
// If given data is type of slice, it then does batch replacing, and the optional parameter
// `batch` specifies the batch operation count.
func (tx *TX) Replace(table string, data interface{}, batch ...int) (sql.Result, error) {
if len(batch) > 0 {
return tx.Model(table).Ctx(tx.ctx).Data(data).Batch(batch[0]).Replace()
}
return tx.Model(table).Ctx(tx.ctx).Data(data).Replace()
}
// Save does "INSERT INTO ... ON DUPLICATE KEY UPDATE..." statement for the table.
// It updates the record if there's primary or unique index in the saving data,
// or else it inserts a new record into the table.
//
// The parameter `data` can be type of map/gmap/struct/*struct/[]map/[]struct, etc.
// Eg:
// Data(g.Map{"uid": 10000, "name":"john"})
// Data(g.Slice{g.Map{"uid": 10000, "name":"john"}, g.Map{"uid": 20000, "name":"smith"})
//
// If given data is type of slice, it then does batch saving, and the optional parameter
// `batch` specifies the batch operation count.
func (tx *TX) Save(table string, data interface{}, batch ...int) (sql.Result, error) {
if len(batch) > 0 {
return tx.Model(table).Ctx(tx.ctx).Data(data).Batch(batch[0]).Save()
}
return tx.Model(table).Ctx(tx.ctx).Data(data).Save()
}
// Update does "UPDATE ... " statement for the table.
//
// The parameter `data` can be type of string/map/gmap/struct/*struct, etc.
// Eg: "uid=10000", "uid", 10000, g.Map{"uid": 10000, "name":"john"}
//
// The parameter `condition` can be type of string/map/gmap/slice/struct/*struct, etc.
// It is commonly used with parameter `args`.
// Eg:
// "uid=10000",
// "uid", 10000
// "money>? AND name like ?", 99999, "vip_%"
// "status IN (?)", g.Slice{1,2,3}
// "age IN(?,?)", 18, 50
// User{ Id : 1, UserName : "john"}
func (tx *TX) Update(table string, data interface{}, condition interface{}, args ...interface{}) (sql.Result, error) {
return tx.Model(table).Ctx(tx.ctx).Data(data).Where(condition, args...).Update()
}
// Delete does "DELETE FROM ... " statement for the table.
//
// The parameter `condition` can be type of string/map/gmap/slice/struct/*struct, etc.
// It is commonly used with parameter `args`.
// Eg:
// "uid=10000",
// "uid", 10000
// "money>? AND name like ?", 99999, "vip_%"
// "status IN (?)", g.Slice{1,2,3}
// "age IN(?,?)", 18, 50
// User{ Id : 1, UserName : "john"}
func (tx *TX) Delete(table string, condition interface{}, args ...interface{}) (sql.Result, error) {
return tx.Model(table).Ctx(tx.ctx).Where(condition, args...).Delete()
}
| TXFromCtx |
useGraphNodeResource.tsx | /**
* @license
* MIT License
*
* Copyright (c) 2020 Alexis Munsayac
* 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, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following 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 MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS 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.
*
*
* @author Alexis Munsayac <[email protected]>
* @copyright Alexis Munsayac 2020
*/
import { GraphNodeResource } from 'graph-state';
import { useDebugValue } from 'react';
import { useGraphDomainRestriction } from '../GraphDomainCore';
import useGraphNodeValue from './useGraphNodeValue';
export default function | <S>(node: GraphNodeResource<S>): S {
useGraphDomainRestriction();
const value = useGraphNodeValue(node);
useDebugValue(value.status === 'success' ? value.data : value);
if (value.status === 'success') {
return value.data;
}
throw value.data;
}
| useGraphNodeResource |
default.rs | use crate::error::DatamodelError;
use crate::validator::directive::{Args, DirectiveValidator};
use crate::{ast, dml};
use std::convert::TryInto;
/// Prismas builtin `@default` directive.
pub struct DefaultDirectiveValidator {}
impl DirectiveValidator<dml::Field> for DefaultDirectiveValidator {
fn directive_name(&self) -> &'static str {
&"default"
}
fn validate_and_apply(&self, args: &mut Args, field: &mut dml::Field) -> Result<(), DatamodelError> {
// If we allow list default values, we need to adjust the types below properly for that case. | if let dml::FieldType::Base(scalar_type) = field.field_type {
match args.default_arg("value")?.as_type(scalar_type) {
// TODO: Here, a default value directive can override the default value syntax sugar.
Ok(value) => {
let dv: dml::DefaultValue = value.try_into()?;
if dv.get_type() != scalar_type {
return self.error(
&format!(
"Default value type {:?} doesn't match expected type {:?}.",
dv.get_type(),
scalar_type
),
args.span(),
);
}
field.default_value = Some(dv)
}
Err(err) => return Err(self.parser_error(&err)),
}
} else if let dml::FieldType::Enum(_) = &field.field_type {
match args.default_arg("value")?.as_constant_literal() {
// TODO: We should also check if this value is a valid enum value.
Ok(value) => field.default_value = Some(dml::ScalarValue::ConstantLiteral(value).try_into()?),
Err(err) => return Err(self.parser_error(&err)),
}
} else {
return self.error("Cannot set a default value on a relation field.", args.span());
}
Ok(())
}
fn serialize(
&self,
field: &dml::Field,
_datamodel: &dml::Datamodel,
) -> Result<Vec<ast::Directive>, DatamodelError> {
if let Some(default_value) = &field.default_value {
return Ok(vec![ast::Directive::new(
self.directive_name(),
vec![ast::Argument::new("", default_value.clone().into())],
)]);
}
Ok(vec![])
}
} | if field.arity == dml::FieldArity::List {
return self.error("Cannot set a default value on list field.", args.span());
}
|
data_flow.py | # Copyright 2013 - Mirantis, Inc.
# Copyright 2015 - StackStorm, 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.
from oslo_config import cfg
from oslo_log import log as logging
from mistral import context as auth_ctx
from mistral.db.v2 import api as db_api
from mistral.db.v2.sqlalchemy import models
from mistral import exceptions as exc
from mistral import expressions as expr
from mistral.lang import parser as spec_parser
from mistral import utils
from mistral.utils import inspect_utils
from mistral.workflow import states
LOG = logging.getLogger(__name__)
CONF = cfg.CONF
class ContextView(dict):
"""Workflow context view.
It's essentially an immutable composite structure providing fast lookup
over multiple dictionaries w/o having to merge those dictionaries every
time. The lookup algorithm simply iterates over provided dictionaries
one by one and returns a value taken from the first dictionary where
the provided key exists. This means that these dictionaries must be
provided in the order of decreasing priorities.
Note: Although this class extends built-in 'dict' it shouldn't be
considered a normal dictionary because it may not implement all
methods and account for all corner cases. It's only a read-only view.
"""
def __init__(self, *dicts):
super(ContextView, self).__init__()
self.dicts = dicts or []
def __getitem__(self, key):
for d in self.dicts:
if key in d:
return d[key]
raise KeyError(key)
def get(self, key, default=None):
for d in self.dicts:
if key in d:
return d[key]
return default
def __contains__(self, key):
return any(key in d for d in self.dicts)
def keys(self):
keys = set()
for d in self.dicts:
keys.update(d.keys())
return keys
def items(self):
return [(k, self[k]) for k in self.keys()]
def values(self):
return [self[k] for k in self.keys()]
def iteritems(self):
# NOTE: This is for compatibility with Python 2.7
# YAQL converts output objects after they are evaluated
# to basic types and it uses six.iteritems() internally
# which calls d.items() in case of Python 2.7 and d.iteritems()
# for Python 2.7
return iter(self.items())
def iterkeys(self):
# NOTE: This is for compatibility with Python 2.7
# See the comment for iteritems().
return iter(self.keys())
def itervalues(self):
# NOTE: This is for compatibility with Python 2.7
# See the comment for iteritems().
return iter(self.values())
def __len__(self):
return len(self.keys())
@staticmethod
def _raise_immutable_error():
raise exc.MistralError('Context view is immutable.')
def __setitem__(self, key, value):
self._raise_immutable_error()
def update(self, E=None, **F):
self._raise_immutable_error()
def clear(self):
self._raise_immutable_error()
def pop(self, k, d=None):
self._raise_immutable_error()
def popitem(self):
self._raise_immutable_error()
def __delitem__(self, key):
self._raise_immutable_error()
def evaluate_upstream_context(upstream_task_execs):
published_vars = {}
ctx = {}
for t_ex in upstream_task_execs:
# TODO(rakhmerov): These two merges look confusing. So it's a
# temporary solution. There's still the bug
# https://bugs.launchpad.net/mistral/+bug/1424461 that needs to be
# fixed using context variable versioning.
published_vars = utils.merge_dicts(
published_vars,
t_ex.published
)
utils.merge_dicts(ctx, evaluate_task_outbound_context(t_ex))
return utils.merge_dicts(ctx, published_vars)
def _extract_execution_result(ex):
if isinstance(ex, models.WorkflowExecution):
return ex.output
if ex.output:
return ex.output['result']
def invalidate_task_execution_result(task_ex):
for ex in task_ex.executions:
ex.accepted = False
def get_task_execution_result(task_ex):
execs = task_ex.executions
execs.sort(
key=lambda x: x.runtime_context.get('index')
)
results = [
_extract_execution_result(ex)
for ex in execs
if hasattr(ex, 'output') and ex.accepted
]
task_spec = spec_parser.get_task_spec(task_ex.spec)
if task_spec.get_with_items():
# TODO(rakhmerov): Smell: violation of 'with-items' encapsulation.
with_items_ctx = task_ex.runtime_context.get('with_items')
if with_items_ctx and with_items_ctx.get('count') > 0:
return results
else:
return []
return results[0] if len(results) == 1 else results
def publish_variables(task_ex, task_spec):
if task_ex.state not in [states.SUCCESS, states.ERROR]:
return
wf_ex = task_ex.workflow_execution
expr_ctx = ContextView(
get_current_task_dict(task_ex),
task_ex.in_context,
get_workflow_environment_dict(wf_ex),
wf_ex.context,
wf_ex.input
)
if task_ex.name in expr_ctx:
LOG.warning(
'Shadowing context variable with task name while '
'publishing: %s',
task_ex.name
)
publish_spec = task_spec.get_publish(task_ex.state)
if not publish_spec:
return
# Publish branch variables.
branch_vars = publish_spec.get_branch()
task_ex.published = expr.evaluate_recursively(branch_vars, expr_ctx)
# Publish global variables.
global_vars = publish_spec.get_global()
utils.merge_dicts(
task_ex.workflow_execution.context,
expr.evaluate_recursively(global_vars, expr_ctx)
)
# TODO(rakhmerov):
# 1. Publish atomic variables.
# 2. Add the field "publish" in TaskExecution model similar to "published"
# but containing info as
# {'branch': {vars}, 'global': {vars}, 'atomic': {vars}}
def evaluate_task_outbound_context(task_ex):
"""Evaluates task outbound Data Flow context.
This method assumes that complete task output (after publisher etc.)
has already been evaluated.
:param task_ex: DB task.
:return: Outbound task Data Flow context.
"""
# NOTE(rakhmerov): 'task_ex.in_context' has the SQLAlchemy specific
# type MutableDict. So we need to create a shallow copy using dict(...)
# initializer and use it. It's enough to be safe in order to manipulate
# with entries of the result dictionary, like adding more entries.
# However, we must not change values themselves because they are
# shared between the original dictionary and the newly created.
# It's better to avoid using the method copy.deepcopy() because on
# dictionaries with many entries it significantly increases memory
# footprint and reduces performance.
in_context = (
dict(task_ex.in_context)
if task_ex.in_context is not None else {}
)
return utils.update_dict(in_context, task_ex.published)
def evaluate_workflow_output(wf_ex, wf_output, ctx):
"""Evaluates workflow output.
:param wf_ex: Workflow execution.
:param wf_output: Workflow output.
:param ctx: Final Data Flow context (cause task's outbound context).
"""
# Evaluate workflow 'output' clause using the final workflow context.
ctx_view = ContextView(
ctx,
get_workflow_environment_dict(wf_ex),
wf_ex.context,
wf_ex.input
)
output = expr.evaluate_recursively(wf_output, ctx_view)
# TODO(rakhmerov): Many don't like that we return the whole context
# if 'output' is not explicitly defined.
return output or ctx
def get_current_task_dict(task_ex):
return {
'__task_execution': {
'id': task_ex.id,
'name': task_ex.name
}
}
def add_openstack_data_to_context(wf_ex):
wf_ex.context = wf_ex.context or {}
if CONF.pecan.auth_enable:
exec_ctx = auth_ctx.ctx()
if exec_ctx:
wf_ex.context.update({'openstack': exec_ctx.to_dict()})
def | (wf_ex):
wf_ex.context = wf_ex.context or {}
wf_ex.context['__execution'] = {'id': wf_ex.id}
def add_workflow_variables_to_context(wf_ex, wf_spec):
wf_ex.context = wf_ex.context or {}
# The context for calculating workflow variables is workflow input
# and other data already stored in workflow initial context.
ctx_view = ContextView(
get_workflow_environment_dict(wf_ex),
wf_ex.context,
wf_ex.input
)
wf_vars = expr.evaluate_recursively(wf_spec.get_vars(), ctx_view)
utils.merge_dicts(wf_ex.context, wf_vars)
def evaluate_object_fields(obj, context):
fields = inspect_utils.get_public_fields(obj)
evaluated_fields = expr.evaluate_recursively(fields, context)
for k, v in evaluated_fields.items():
setattr(obj, k, v)
def get_workflow_environment_dict(wf_ex):
if not wf_ex:
return {}
if wf_ex.root_execution_id:
return get_workflow_environment_dict(
db_api.get_workflow_execution(wf_ex.root_execution_id)
)
env_dict = wf_ex.params['env'] if 'env' in wf_ex.params else {}
return {'__env': env_dict}
| add_execution_to_context |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.