content
stringlengths 0
1.05M
| origin
stringclasses 2
values | type
stringclasses 2
values |
|---|---|---|
from __future__ import print_function, division
from argparse import ArgumentParser
from sys import exc_info
from time import ctime
from datetime import datetime
from decimal import Decimal
from traceback import print_tb
from random import randint
from tqdm import trange
from .api import TradewaveAPI
from .data import FileDataSource
from .util import TqdmFileWrapper, parse_date, parse_time
def create_argument_parser():
parser = ArgumentParser()
parser.add_argument('-p', '--pair', default=None,
help='primary currency pair')
parser.add_argument('-P', '--portfolio', metavar='AMOUNT',
help='starting portfolio',
type=float, nargs=2, default=(1.0, 0.0))
parser.add_argument('-b', '--begin', type=parse_date, default=None,
metavar='DATETIME',
help='start time (default: data start time)')
parser.add_argument('-e', '--end', type=parse_date, default=None,
metavar='DATETIME',
help='end time (default: data end time)')
parser.add_argument('-i', '--interval', type=parse_time, default=None,
metavar='TIME',
help='interval (default: data interval)')
parser.add_argument('-v', '--verbose', action='store_true',
help='log strategy operations')
parser.add_argument('-np', '--no-progress', action='store_true')
parser.add_argument('-nP', '--no-plot', action='store_true')
parser.add_argument('data')
parser.add_argument('strategy', nargs='+')
return parser
def tick(strategies, i, exit_on_error):
for strategy in strategies:
try:
strategy.tick(i)
except Exception: # pylint: disable=broad-except
err = exc_info()
print('[ERROR] [{0}] tick {1}: {2}'
.format(strategy, i, repr(err[1])))
print_tb(err[2])
if exit_on_error:
exit(1)
strategy.stop()
def run(strategies, ticks, progress=True, exit_on_error=True):
for strategy in strategies:
try:
strategy.start()
except Exception: # pylint: disable=broad-except
err = exc_info()
print('[ERROR] [{0}] start: {1}'
.format(strategy, repr(err[1])))
print_tb(err[2])
if exit_on_error:
exit(1)
if progress:
with TqdmFileWrapper.stdout() as stdout:
for i in trange(ticks, leave=False, dynamic_ncols=True, file=stdout):
tick(strategies, i, exit_on_error)
else:
for i in xrange(ticks):
tick(strategies, i, exit_on_error)
for strategy in strategies:
try:
strategy.stop()
except Exception: # pylint: disable=broad-except
err = exc_info()
print('[ERROR] [{0}] stop: {1}'
.format(strategy, repr(err[1])))
print_tb(err[2])
if exit_on_error:
exit(1)
return [strategy.state for strategy in strategies]
def plot(strategies, data, args):
import numpy as np
import matplotlib.cm as cm
import matplotlib.pyplot as plt
from matplotlib.ticker import FuncFormatter
plt.style.use('dark_background')
start = args.begin
step = args.interval
date_formatter = FuncFormatter(
lambda x, _: datetime.fromtimestamp((int(start + x * step)))
)
fig, ax = plt.subplots()
price = data.get_plot(args.pair)
plot_data = [strategy.get_plots() for strategy in strategies]
n_subplots = max(1, *(len(d) for d in plot_data))
subplots = [
plt.subplot(n_subplots, 1, n_subplots - i, sharex=ax)
for i in range(n_subplots)
]
colors = [
(
iter(cm.rainbow(np.linspace(
0, 1,
int(i == 0) +
sum(len(subplot[i][0]) if len(subplot) > i else 0
for subplot in plot_data)
))),
iter(cm.Pastel1(np.linspace(
0, 1,
sum(len(subplot[i][0]) if len(subplot) > i else 0
for subplot in plot_data)
)))
)
for i in range(n_subplots)
]
plots = [[] for _ in range(n_subplots)]
plots[0].append(
subplots[0].plot(
price,
color=next(colors[0][0]),
alpha=0.75,
label='price'
)[0]
)
for pdata in plot_data:
size = randint(100, 400)
for subplot, handles, (plot_colors, scatter_colors), (plots_, points_) \
in zip(subplots, plots, colors, pdata):
for label, values in plots_.items():
color = next(plot_colors)
handles.append(
subplot.plot(
values,
color=color,
alpha=0.9,
label=label
)[0]
)
for label, (xs, ys) in points_.items():
color = next(scatter_colors)
handles.append(
subplot.scatter(
xs, ys,
s=size,
color=color,
alpha=0.6,
marker='o',
label=label
)
)
for subplot, handles in zip(subplots, plots):
subplot.grid(True)
subplot.legend(handles=handles, scatterpoints=1)
ax.xaxis.set_major_formatter(date_formatter)
ax.set_xlim(0, args.max_ticks - 1)
fig.autofmt_xdate()
plt.show()
def buy_and_hold(portfolio, data, max_ticks, pair):
currencies = pair.split('_')
start_price = Decimal(
data.get_current(0, pair)[data.CANDLE.close]
)
end_price = Decimal(
data.get_current(max_ticks - 1, pair)[data.CANDLE.close]
)
start_asset = Decimal(portfolio.get(currencies[0], 0))
start_currency = Decimal(portfolio.get(currencies[1], 0))
start_asset += start_currency / start_price
start_currency = 0
start_max_currency = start_asset * start_price
end_max_currency = start_asset * end_price
return (start_price, end_price, start_asset,
start_max_currency, end_max_currency)
def print_result(strategies, results, data, args):
(start_price, end_price,
start_max_asset, start_max_currency, bnh_end_currency) = buy_and_hold(
args.portfolio, data, args.max_ticks, args.pair
)
pair = args.pair
get_asset, get_currency = tuple(currency for currency in pair.split('_'))
pair = args.pair.upper()
asset, currency = tuple(currency for currency in pair.split('_'))
fmt = '{0}\t{1:.8f} {2}\t{3:.2f}\t{4:.8f} {5}\t{6:.2f}'
print('-' * 60)
print('Pair ', pair)
print('Start date ', ctime(args.begin))
print('End date ', ctime(args.end))
print('Start price ', '{0:.8f}'.format(start_price))
print('End price ', '{0:.8f}'.format(end_price))
print('Start portfolio ', args.portfolio)
print('Start max currency ',
'{0:.8f}'.format(start_max_currency),
currency)
print('Start max asset ',
'{0:.8f}'.format(start_max_asset),
asset)
print('-' * 60)
print('Strategy\tMax currency\tROI currency\tMax asset\tROI asset')
print(fmt.format(
'buy and hold',
bnh_end_currency, currency, bnh_end_currency / start_max_currency,
start_max_asset, asset, 1.0
))
for strategy, res in zip(strategies, results):
res_asset = Decimal(res.get(get_asset, 0))
res_currency = Decimal(res.get(get_currency, 0))
res_max_asset = res_asset + res_currency / end_price
res_max_currency = res_asset * end_price + res_currency
print(fmt.format(
strategy,
res_max_currency, currency, res_max_currency / start_max_currency,
res_max_asset, asset, res_max_asset / start_max_asset
))
print('-' * 60)
def main():
parser = create_argument_parser()
args = parser.parse_args()
data = FileDataSource(
args.data,
start_time=args.begin,
tick_size=args.interval
)
if args.begin is None:
args.begin = data.start_time
if args.interval is None:
args.interval = data.tick_size
if args.end is None:
args.max_ticks = data.get_max_ticks()
args.end = args.begin + (args.max_ticks - 1) * args.interval
else:
args.max_ticks = (args.end - args.begin) // args.interval
args.max_ticks += 1
if args.max_ticks <= 0:
print('Error: invalid interval: {0} -- {1}'
.format(ctime(args.begin), ctime(args.end)))
exit(1)
args.max_ticks = min(args.max_ticks, data.get_max_ticks())
if args.pair is None:
try:
args.pair = next(iter(data.datasets()))
except StopIteration:
print('Error: data source is empty')
exit(1)
else:
args.pair = args.pair.lower()
TradewaveAPI.add_pair(args.pair)
args.portfolio = dict(zip(args.pair.split('_'), args.portfolio))
strategies = [
TradewaveAPI(fname, args.portfolio, data,
max_ticks=args.max_ticks,
primary_pair=args.pair,
verbose=args.verbose)
for fname in args.strategy
]
res = run(strategies, args.max_ticks, not args.no_progress)
print_result(strategies, res, data, args)
if not args.no_plot:
plot(strategies, data, args)
|
nilq/baby-python
|
python
|
import copy
import floppyforms as forms
from crispy_forms.bootstrap import Tab, TabHolder
from crispy_forms.layout import HTML, Field, Fieldset, Layout
from django import forms as django_forms
from django.forms.models import modelform_factory
from django.utils.text import slugify
from django.utils.translation import ugettext_lazy as _
from django_select2.forms import Select2Widget
from horizon.utils.memoized import memoized
from horizon_contrib.common import get_class
from leonardo.forms import SelfHandlingForm, SelfHandlingModelForm
from leonardo.forms.fields.sites import SiteSelectField
from ..models import Page, PageColorScheme, PageTheme
from .fields import PageSelectField
class SwitchableFormFieldMixin(object):
def get_switched_form_field_attrs(self, prefix, input_type, name):
"""Creates attribute dicts for the switchable theme form
"""
attributes = {'class': 'switched', 'data-switch-on': prefix + 'field'}
attributes['data-' + prefix + 'field-' + input_type] = name
return attributes
def switchable_field_attrs(self):
return {'class': 'switchable',
'data-slug': 'switchablefield'
}
class PageColorSchemeSwitchableFormMixin(SwitchableFormFieldMixin):
def init_color_scheme_switch(self, color_scheme=None, field_kwargs={}):
color_scheme_fields = []
for theme in self.fields['theme'].queryset:
name = 'theme__%s' % theme.id
attributes = self.get_switched_form_field_attrs(
'switchable', '%s' % theme.id, ('Color Scheme'))
field = django_forms.ModelChoiceField(
label=_('Color Scheme'),
queryset=theme.templates.all(),
required=False,
**field_kwargs)
# inital for color scheme
if color_scheme and theme.templates.filter(
id=color_scheme.id).exists():
field.initial = color_scheme
elif 'parent' in self.fields and self.fields['parent'].initial:
field.initial = self.fields['parent'].initial.color_scheme
elif hasattr(self, 'instance') \
and hasattr(self.instance, 'color_scheme'):
field.initial = self.instance.color_scheme
else:
field.initial = theme.templates.first()
field.widget.attrs = attributes
self.fields[name] = field
color_scheme_fields.append(name)
# update theme widget attributes
self.fields['theme'].widget.attrs = self.switchable_field_attrs()
return color_scheme_fields
class PageCreateForm(PageColorSchemeSwitchableFormMixin,
SelfHandlingModelForm):
slug = forms.SlugField(required=False, initial=None)
parent = PageSelectField(required=False)
translation_of = PageSelectField(required=False)
symlinked_page = PageSelectField(required=False)
site = SiteSelectField()
class Meta:
model = Page
widgets = {
'parent': forms.widgets.HiddenInput,
'theme': Select2Widget,
'language': Select2Widget,
}
exclude = tuple()
def clean_slug(self):
"""slug title if is not provided
"""
slug = self.cleaned_data.get('slug', None)
if slug is None or len(slug) == 0 and 'title' in self.cleaned_data:
slug = slugify(self.cleaned_data['title'])
return slug
def __init__(self, request, *args, **kwargs):
parent = kwargs.pop('parent', None)
super(PageCreateForm, self).__init__(*args, **kwargs)
if parent:
self.fields['parent'].initial = parent
if request.method == 'GET':
color_scheme_fields = self.init_color_scheme_switch(
color_scheme=kwargs['initial'].get('color_scheme', None))
self.helper.layout = Layout(
TabHolder(
Tab(_('Main'),
'title',
'language',
'translation_of',
'parent',
'site',
css_id='page-main'
),
Tab(_('Navigation'),
'in_navigation', 'slug',
'override_url', 'redirect_to',
'symlinked_page', 'navigation_extension'
),
Tab(_('Heading'),
'_content_title', '_page_title',
css_id='page-heading'
),
Tab(_('Publication'),
'active', 'featured', 'publication_date',
'publication_end_date', 'meta_description',
'meta_keywords'
),
Tab(_('Theme'),
'template_key', 'layout', Fieldset(
'Themes', 'theme', *color_scheme_fields),
css_id='page-theme-settings'
),
)
)
self.fields['color_scheme'].required = False
def clean(self):
cleaned = super(PageCreateForm, self).clean()
if 'theme' in cleaned:
if cleaned['parent']:
theme = cleaned['parent'].theme
cleaned['theme'] = theme
else:
theme = cleaned['theme']
# small combo
value = self.fields['color_scheme'].widget.value_from_datadict(
self.data, self.files, self.add_prefix('theme__%s' % theme.id))
cleaned['color_scheme'] = self.fields['color_scheme'].clean(value)
return cleaned
class PageUpdateForm(PageColorSchemeSwitchableFormMixin,
SelfHandlingModelForm):
parent = PageSelectField(required=False)
translation_of = PageSelectField(required=False)
symlinked_page = PageSelectField(required=False)
site = SiteSelectField()
class Meta:
model = Page
widgets = {
'publication_date': forms.widgets.DateInput,
'language': Select2Widget,
'navigation_extension': Select2Widget
}
exclude = tuple()
def clean(self):
cleaned = super(PageUpdateForm, self).clean()
if 'theme' in cleaned:
theme = cleaned['theme']
cleaned['color_scheme'] = self.cleaned_data['theme__%s' % theme.id]
return cleaned
def __init__(self, *args, **kwargs):
request = kwargs.pop('request', None)
super(PageUpdateForm, self).__init__(*args, **kwargs)
color_scheme_fields = self.init_color_scheme_switch()
self.helper.layout = Layout(
TabHolder(
Tab(_('Main'),
'title',
'language',
'translation_of',
'parent',
'site',
css_id='page-main'
),
Tab(_('Heading'),
'_content_title', '_page_title',
css_id='page-heading'
),
Tab(_('Publication'),
'active', 'featured', 'publication_date',
'publication_end_date', 'meta_description',
'meta_keywords'
),
Tab(_('Navigation'),
'in_navigation', 'slug',
'override_url', 'redirect_to',
'symlinked_page', 'navigation_extension'
),
Tab(_('Theme'),
'template_key', 'layout', Fieldset(
'Themes', 'theme', *color_scheme_fields),
css_id='page-theme-settings'
),
)
)
if request:
_request = copy.copy(request)
_request.POST = {}
if kwargs.get('instance', None):
page = kwargs['instance']
from .tables import PageDimensionTable
table = PageDimensionTable(
_request, page=page, data=page.dimensions,
needs_form_wrapper=False)
dimensions = Tab(_('Dimensions'),
HTML(
table.render()),
css_id='page-dimensions'
)
self.helper.layout[0].append(dimensions)
self.fields['color_scheme'].required = False
class PageDeleteForm(SelfHandlingForm):
def handle(self, request, data):
pass
|
nilq/baby-python
|
python
|
#! /usr/bin/env python3
# Copyright 2022 Tier IV, 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 autoware_auto_vehicle_msgs.msg import VelocityReport
import rclpy
from rclpy.node import Node
from rclpy.qos import QoSDurabilityPolicy
from rclpy.qos import QoSHistoryPolicy
from rclpy.qos import QoSProfile
from rclpy.qos import QoSReliabilityPolicy
from tier4_vehicle_msgs.msg import ActuationStatusStamped
class ActuationStatusPublisher(Node):
def __init__(self):
super().__init__("actuation_status_publisher")
qos_profile = QoSProfile(depth=1)
qos_profile.reliability = QoSReliabilityPolicy.RELIABLE
qos_profile.history = QoSHistoryPolicy.KEEP_LAST
qos_profile.durability = QoSDurabilityPolicy.VOLATILE
self.pub = self.create_publisher(
ActuationStatusStamped, "/vehicle/status/actuation_status", qos_profile
)
self.sub = self.create_subscription(
VelocityReport, "/vehicle/status/velocity_status", self.callback, qos_profile
)
def callback(self, msg):
data = ActuationStatusStamped()
data.header = msg.header
data.status.accel_status = msg.longitudinal_velocity * 0.1
data.status.brake_status = 0.1
data.status.steer_status = 0.1
self.pub.publish(data)
def main(args=None):
rclpy.init(args=args)
node = ActuationStatusPublisher()
rclpy.spin(node)
node.destroy_node()
rclpy.shutdown()
if __name__ == "__main__":
main()
|
nilq/baby-python
|
python
|
from setuptools import setup
setup(
name='django-subquery',
version='1.0.4',
description='SubQuery support in Django < 1.11',
url='https://github.com/schinckel/django-subquery/',
author='Matthew Schinckel',
author_email='matt@schinckel.net',
packages=['django_subquery']
)
|
nilq/baby-python
|
python
|
from easygraphics import *
x = 0
y = 0
def draw_compositon(x, y, mode, alpha_value):
set_background_color(Color.TRANSPARENT)
set_font_size(18)
set_line_width(3)
set_color("black")
set_composition_mode(CompositionMode.SOURCE)
draw_rect_text(x, y + 175, 200, 25, mode)
set_fill_color(to_alpha("orange", alpha_value))
draw_circle(x + 120, y + 80, 70)
set_composition_mode(eval("CompositionMode." + mode))
set_fill_color(to_alpha("darkblue", alpha_value))
draw_rect(x + 20, y + 80, x + 120, y + 170)
def draw_background(size, width, height):
mx = width // size
my = height // size
for i in range(0, mx + 1):
for t in range(0, my + 1):
if (i + t) % 2 == 1:
set_color("lightgray")
set_fill_color("lightgray")
else:
set_color("white")
set_fill_color("white")
draw_rect(i * size, t * size, (i + 1) * size, (t + 1) * size)
def draw_compositon_and_save(mode, alpha_value):
global x, y
img1 = create_image(200, 200)
set_target(img1)
draw_compositon(0, 0, mode, alpha_value)
img2 = create_image(200, 200)
set_target(img2)
draw_background(20, 200, 200)
set_target()
draw_image(0, 0, img1, composition_mode=CompositionMode.SOURCE_OVER, dst_image=img2)
# img2.save("%s_%d.png" % (mode.lower(), alpha_value))
draw_image(x, y, img2)
x += 200
if x >= 1200:
y += 200
x = 0
def draw_compositions(alpha_value):
draw_compositon_and_save("SOURCE_OVER", alpha_value)
draw_compositon_and_save("SOURCE_IN", alpha_value)
draw_compositon_and_save("SOURCE_OUT", alpha_value)
draw_compositon_and_save("SOURCE_AT_TOP", alpha_value)
draw_compositon_and_save("SOURCE", alpha_value)
draw_compositon_and_save("XOR", alpha_value)
def draw_compositions2(alpha_value):
draw_compositon_and_save("DESTINATION_OVER", alpha_value)
draw_compositon_and_save("DESTINATION_IN", alpha_value)
draw_compositon_and_save("DESTINATION_OUT", alpha_value)
draw_compositon_and_save("DESTINATION_AT_TOP", alpha_value)
draw_compositon_and_save("DESTINATION", alpha_value)
draw_compositon_and_save("XOR", alpha_value)
def main():
init_graph(1200, 800)
draw_compositions(255)
draw_compositions(150)
draw_compositions2(255)
draw_compositions2(150)
pause()
close_graph()
easy_run(main)
|
nilq/baby-python
|
python
|
#!/usr/bin/python3
import tensorflow as tf
import numpy as np
from tensorflow.keras import Model
from tensorflow.keras.layers import Dense
class Addressing(Model):
def __init__(self, memory_locations=128, memory_vector_size=20, maximum_shifts=3, reading=True):
super(Addressing, self).__init__()
self.memory_locations = memory_locations # N locations
self.memory_vector_size = memory_vector_size # M vector size
self.maximum_shifts = maximum_shifts
self.reading = reading
self.read_split = [self.memory_vector_size, 1, 1, self.maximum_shifts, 1]
self.write_split = [self.memory_vector_size, 1, 1, self.maximum_shifts, 1,
self.memory_vector_size, self.memory_vector_size]
if self.reading:
self.emit_len = np.sum(self.read_split)
else:
self.emit_len = np.sum(self.write_split)
self.fc_addr = Dense(units=self.emit_len, activation=tf.nn.tanh, name="emit_params",
kernel_initializer='glorot_uniform', bias_initializer='glorot_normal')
self.k_t = None
self.beta_t = None
self.g_t = None
self.s_t = None
self.gamma_t = None
self.e_t = None
self.a_t = None
# All of the below are the weights over N locations produced by the addressing mechanism
# [Batch size, N]
self.w_c_t = None
self.w_g_t = None
self.w_tidle_t = None
self.w_t = None
def emit_addressing_params(self, k_t, beta_t, g_t, s_t, gamma_t):
self.k_t = k_t # Key vector
self.beta_t = tf.nn.softplus(beta_t) # Key strength
self.g_t = tf.nn.sigmoid(g_t) # Interpolation gate
self.s_t = tf.nn.softmax(s_t, axis=-1) # Shift weighting
self.gamma_t = 1.0 + tf.nn.softplus(gamma_t) # Sharpen
def emit_head_params(self, fc_output):
if self.reading:
k_t, beta_t, g_t, s_t, gamma_t = tf.split(fc_output, self.read_split, axis=-1)
self.emit_addressing_params(k_t, beta_t, g_t, s_t, gamma_t)
else:
k_t, beta_t, g_t, s_t, gamma_t, e_t, a_t = tf.split(fc_output, self.write_split, axis=-1)
self.emit_addressing_params(k_t, beta_t, g_t, s_t, gamma_t)
self.e_t = tf.nn.sigmoid(e_t) # Erase vector
self.a_t = a_t # Add vector
@staticmethod
def cosine_similarity(k, m):
k_mag = tf.sqrt(tf.reduce_sum(tf.square(k), axis=-1))
m_mag = tf.sqrt(tf.reduce_sum(tf.square(m), axis=-1))
mag_prod = tf.multiply(k_mag, m_mag)
dot = tf.squeeze(tf.keras.layers.dot([k, m], axes=(-1, -1)), axis=1)
return tf.divide(dot, mag_prod)
@staticmethod
def circular_convolution(w, s):
kernels = tf.TensorArray(dtype=s.dtype, size=s.shape[0])
for i in tf.range(0, s.shape[0]):
kernels = kernels.write(i, tf.roll(w, shift=(i-tf.math.floordiv(s.shape[0], 2)), axis=0))
w_circ_conv = tf.transpose(kernels.stack())
return tf.reduce_sum(w_circ_conv*s, axis=1)
def content_addressing(self, M_t):
k_t = tf.expand_dims(self.k_t, axis=1)
self.w_c_t = tf.nn.softmax(self.beta_t * self.cosine_similarity(k_t, M_t), axis=-1)
def interpolation(self, w_t_prev):
self.w_g_t = (self.g_t * self.w_c_t) + ((1 - self.g_t)*w_t_prev)
def convolutional_shift(self):
convolved_weights = tf.TensorArray(dtype=self.w_g_t.dtype, size=self.w_g_t.shape[0])
for i in tf.range(self.s_t.shape[0]):
cc = self.circular_convolution(self.w_g_t[i], self.s_t[i])
convolved_weights = convolved_weights.write(i, cc)
self.w_tidle_t = convolved_weights.stack()
def sharpening(self):
w_raised = tf.pow(self.w_tidle_t, self.gamma_t)
self.w_t = tf.divide(w_raised, tf.reduce_sum(w_raised, axis=-1, keepdims=True))
def call(self, controller_output, w_t_prev, M_t):
# Controller outputs used for addressing
self.emit_head_params(self.fc_addr(controller_output))
# Addressing mechanism
self.content_addressing(M_t)
self.interpolation(w_t_prev)
self.convolutional_shift()
self.sharpening()
if self.reading:
return self.w_t # The new weight over the N locations of the memory matrix, and
else:
return self.w_t, self.e_t, self.a_t
|
nilq/baby-python
|
python
|
# grep a csv file for an expression and copy the csv header into the output
import os
import sys
from misc import *
if len(sys.argv) < 3:
err("usage: csv_grep [pattern] [input csv file]")
pattern, filename = sys.argv[1], sys.argv[2]
grep_file = filename + "_grep" # grep results go here
a = os.system("grep " + pattern + " " + filename + " > " + grep_file)
f = open(filename)
fields = f.readline().strip() + "\n"
f.close()
fields_file = filename + "_fields" # names of fields go in this file
open(fields_file, "wb").write(fields)
a = os.system("cat " + fields_file + " " + grep_file + " > " + filename + "_grep_" + pattern + ".csv")
run("rm -f " + grep_file)
run("rm -f " + fields_file)
|
nilq/baby-python
|
python
|
import glob
import os
import numpy as np
import pandas as pd
from common.paths import POWER_FC, ADHD, PLS_WEIGHTS, RIDGE_WEIGHTS, BIOBANK_LABELS
from common.power_atlas import to_power_fc_vector, get_power_fc_vector_labels
from common.wisc import WISC_LEVEL
def get_data(wisc_level=5, label_path=ADHD):
"""
Get functional connectivity data, cognition data, and demographic data.
Functional connectivity data is in the form of functional connectivity matrices
derived from the Power et al. atlas of 264 ROIs.
Cognition data is in the form of WISC-V measures.
Demographic data is in the form of age and sex.
"""
fcs = get_fc_data()
labels = get_label_data(label_path)
subject_ids = labels.index
demographic_measures = ['Age', 'Sex']
wisc_measures = WISC_LEVEL[wisc_level]
population = check_population_diagnosis(labels)
fc_matrices = []
# fc_ids = []
demographics = {measure: [] for measure in demographic_measures}
wiscs = {measure: [] for measure in wisc_measures}
for subject_id in subject_ids:
if subject_id not in fcs:
continue
# fc_ids.append(subject_id)
fc_matrices.append(fcs[subject_id])
for measure in demographic_measures:
demographics[measure].append(
labels.at[subject_id, f'assessment Basic_Demos,{measure}'])
for measure in wisc_measures:
wiscs[measure].append(
labels.at[subject_id, f'assessment WISC,{measure}'])
wiscs = _convert_dict_list_to_dict_numpy(wiscs)
demographics = _convert_dict_list_to_dict_numpy(demographics)
return np.array(fc_matrices), wiscs, demographics, population
def get_fc_data():
"""
Search for all functional connectivity files and load them.
"""
fc_paths = glob.glob(POWER_FC + f'/**/power_fc.npy', recursive=True)
fcs = {}
for path in fc_paths:
subject_id = get_subject_id_from_path(path)
subject_fc = np.load(path)
fcs[subject_id] = to_power_fc_vector(subject_fc)
return fcs
def get_label_data(label_path):
"""
Get label file and read as a Pandas dataframe.
"""
return pd.read_csv(label_path, index_col='assessment WISC,EID')
def get_subject_id_from_path(path):
"""
Get subject ID from subject path.
"""
normalized_path = os.path.normpath(path)
path_components = normalized_path.split(os.sep)
return path_components[-2][4:]
def _convert_dict_list_to_dict_numpy(dict_list):
"""
Convert a dictionary with list values into a dictionary with
numpy array values.
Used because numpy array is more flexible to work with and has more functions.
"""
dict_numpy = {}
for k, v in dict_list.items():
dict_numpy[k] = np.array(v)
return dict_numpy
def check_population_diagnosis(labels):
"""
Get diagnosis for the dataset.
"""
has_diagnosis_col = 'assessment Diagnosis_ClinicianConsensus,NoDX'
has_diagnosis = labels[has_diagnosis_col] == 'Yes'
return 'adhd' if any(has_diagnosis) else 'healthy'
def get_model_weights(model, population, measure, age_group):
"""
Read the model weights for a specific model, diagnosis, WISC measure, and age bin.
"""
weight_filepath = None
if model == 'pls':
weight_filepath = os.path.join(PLS_WEIGHTS, f'{model}_{population}_{measure}_{age_group}.npy')
else:
weight_filepath = os.path.join(RIDGE_WEIGHTS, f'{model}_{population}_{measure}_{age_group}_coef.npy')
return np.load(weight_filepath)
def get_subjects(subject_folder, desired_subjects=None):
"""
Get a list of subjects only if they are subjects we want; ignores unspecificed subjects.
"""
subjects = [folder for folder in os.listdir(subject_folder) if folder.startswith("sub-")]
if desired_subjects:
subjects = [subject for subject in subjects if subject in desired_subjects]
return subjects
def generate_fake_data(X, y):
X_mean, X_std = np.mean(X), np.std(X)
y_mean, y_std = np.mean(y), np.std(y)
X_fake = np.random.default_rng().normal(X_mean, X_std, size=X.shape)
y_fake = np.random.default_rng().normal(y_mean, y_std, size=y.shape)
return X_fake, y_fake
def filter_data_by_network(X, network, only_within_network=False, only_connections=True):
vector_labels = get_power_fc_vector_labels(True)
if only_within_network:
network_connection_indices = [index for (index, connection) in enumerate(vector_labels) if connection[0] == network and connection[1] == network]
else:
network_connection_indices = [index for (index, connection) in enumerate(vector_labels) if connection[0] == network or connection[1] == network]
if only_connections:
X_filtered = X[:, network_connection_indices]
else:
X_filtered = np.zeros(X.shape)
X_filtered[:, network_connection_indices] = X[:, network_connection_indices]
return X_filtered
|
nilq/baby-python
|
python
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
if __name__ == "__main__":
s = input("Введите строку:")
count = 0
vowels = {'е', 'ы', 'а', 'о', 'э', 'я', 'и', 'ю'}
for letter in s:
if letter in vowels:
count += 1
print("Количество гласных равно:")
print(count)
|
nilq/baby-python
|
python
|
try:
from sshtunnel import SSHTunnelForwarder
except ImportError:
from sshtunnel.sshtunnel import SSHTunnelForwarder
from cm_api.api_client import ApiResource, ApiException
from cm_api.endpoints.services import ApiService, ApiServiceSetupInfo
import paramiko
import json
import yaml
import requests
import subprocess
import zipfile
import shutil
import os
import logger
import base64
class CdhConfExtractor(object):
def __init__(self, config_filename=None):
self._logger = logger.get_info_logger(__name__)
self.config_filename = config_filename if config_filename else 'fetcher_config.yml'
config = self._load_config_yaml(self.config_filename)
self._hostname = config['machines']['cdh-launcher']['hostname']
self._hostport = config['machines']['cdh-launcher']['hostport']
self._username = config['machines']['cdh-launcher']['username']
self._key_filename = config['machines']['cdh-launcher']['key_filename']
self._key = os.path.expanduser(self._key_filename)
self._key_password = config['machines']['cdh-launcher']['key_password']
self._is_openstack = config['openstack_env']
self._is_kerberos = config['kerberos_used']
self._cdh_manager_ip = config['machines']['cdh-manager']['ip']
self._cdh_manager_user = config['machines']['cdh-manager']['user']
self._cdh_manager_sshtunnel_required = config['machines']['cdh-manager']['sshtunnel_required']
self._cdh_manager_password = config['machines']['cdh-manager']['password']
def __enter__(self):
extractor = self
try:
if self._cdh_manager_sshtunnel_required:
self._logger.info('Creating tunnel to CDH-Manager.')
extractor.create_tunnel_to_cdh_manager()
extractor.start_cdh_manager_tunneling()
self._logger.info('Tunnel to CDH-Manager has been created.')
else:
self._logger.info('Connection to CDH-Manager host without ssh tunnel.')
self._local_bind_address = self.extract_cdh_manager_host()
self._local_bind_port = 7180
return extractor
except Exception as exc:
self._logger.error('Cannot creating tunnel to CDH-Manager machine.')
raise exc
def __exit__(self, exc_type, exc_val, exc_tb):
try:
if self._cdh_manager_sshtunnel_required:
self.stop_cdh_manager_tunneling()
self._logger.info('Tunelling to CDH-Manager stopped.')
except Exception as exc:
self._logger.error('Cannot close tunnel to CDH-Manager machine.')
raise exc
# Cdh launcher methods
def create_ssh_connection(self, hostname, username, key_filename, key_password):
try:
self._logger.info('Creating connection to remote host {0}.'.format(hostname))
self.ssh_connection = paramiko.SSHClient()
self.ssh_connection.set_missing_host_key_policy(paramiko.AutoAddPolicy())
self.ssh_connection.connect(hostname, username=username, key_filename=key_filename, password=key_password)
self._logger.info('Connection to host {0} established.'.format(hostname))
except Exception as exc:
self._logger.error('Cannot creating connection to host {0} machine. Check your settings '
'in fetcher_config.yml file.'.format(hostname))
raise exc
def close_ssh_connection(self):
try:
self.ssh_connection.close()
self._logger.info('Connection to remote host closed.')
except Exception as exc:
self._logger.error('Cannot close connection to the remote host.')
raise exc
def ssh_call_command(self, command, subcommands=None):
self._logger.info('Calling remote command: "{0}" with subcommands "{1}"'.format(command, subcommands))
ssh_in, ssh_out, ssh_err = self.ssh_connection.exec_command(command, get_pty=True)
if subcommands != None:
for subcommand in subcommands:
ssh_in.write(subcommand + '\n')
ssh_in.flush()
return ssh_out.read() if ssh_out is not None else ssh_err.read()
def extract_cdh_manager_host(self):
self._logger.info('Extracting CDH-Manager address.')
if self._cdh_manager_ip is None:
self.create_ssh_connection(self._hostname, self._username, self._key_filename, self._key_password)
if self._is_openstack:
ansible_ini = self.ssh_call_command('cat ansible-cdh/platform-ansible/inventory/cdh')
else:
ansible_ini = self.ssh_call_command('cat ansible-cdh/inventory/cdh')
self._cdh_manager_ip = self._get_host_ip('cdh-manager', ansible_ini)
self.close_ssh_connection()
self._logger.info('CDH-Manager adress extracted: {}'.format(self._cdh_manager_ip))
return self._cdh_manager_ip
# Cdh manager methods
def create_tunnel_to_cdh_manager(self, local_bind_address='localhost', local_bind_port=7180, remote_bind_port=7180):
self._local_bind_address = local_bind_address
self._local_bind_port = local_bind_port
self.cdh_manager_tunnel = SSHTunnelForwarder(
(self._hostname, self._hostport),
ssh_username=self._username,
local_bind_address=(local_bind_address, local_bind_port),
remote_bind_address=(self.extract_cdh_manager_host(), remote_bind_port),
ssh_private_key_password=self._key_password,
ssh_private_key=self._key
)
def start_cdh_manager_tunneling(self):
try:
self.cdh_manager_tunnel.start()
except Exception as e:
self._logger.error('Cannot start tunnel: ' + e.message)
def stop_cdh_manager_tunneling(self):
try:
self.cdh_manager_tunnel.stop()
except Exception as e:
self._logger.error('Cannot stop tunnel: ' + e.message)
def extract_cdh_manager_details(self, settings):
for host in settings['hosts']:
if 'cdh-manager' in host['hostname']:
return host
def extract_nodes_info(self, name, settings):
nodes = []
for host in settings['hosts']:
if name in host['hostname']:
nodes.append(host)
return nodes
def extract_service_namenode(self, service_name, role_name, settings):
hdfs_service = self._find_item_by_attr_value(service_name, 'name', settings['clusters'][0]['services'])
hdfs_namenode = self._find_item_by_attr_value(role_name, 'name', hdfs_service['roles'])
host_id = hdfs_namenode['hostRef']['hostId']
return self._find_item_by_attr_value(host_id, 'hostId', settings['hosts'])['hostname']
def get_client_config_for_service(self, service_name):
result = requests.get('http://{0}:{1}/api/v10/clusters/CDH-cluster/services/{2}/clientConfig'.format(self._local_bind_address, self._local_bind_port, service_name))
return base64.standard_b64encode(result.content)
def generate_keytab(self, principal_name):
self._logger.info('Generating keytab for {} principal.'.format(principal_name))
self.create_ssh_connection(self._hostname, self._username, self._key_filename, self._key_password)
sftp = self.ssh_connection.open_sftp()
sftp.put('utils/generate_keytab_script.sh', '/tmp/generate_keytab_script.sh')
self.ssh_call_command('scp -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no /tmp/generate_keytab_script.sh {0}:/tmp/'.format(self._cdh_manager_ip))
self.ssh_call_command('ssh -t {0} -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no "chmod 700 /tmp/generate_keytab_script.sh"'.format(self._cdh_manager_ip))
keytab_hash = self.ssh_call_command('ssh -t {0} -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no "/tmp/generate_keytab_script.sh {1}"'
.format(self._cdh_manager_ip, principal_name))
self.close_ssh_connection()
lines = keytab_hash.splitlines()
self._logger.info('Keytab for {} principal has been generated.'.format(principal_name))
return '"{}"'.format(''.join(lines[2:-2]))
def generate_base64_for_file(self, file_path, hostname):
self._logger.info('Generating base64 for {} file.'.format(file_path))
self.create_ssh_connection(self._hostname, self._username, self._key_filename, self._key_password)
base64_file_hash = self.ssh_call_command('ssh -t {0} -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no "base64 {1}"'.format(hostname, file_path))
self.close_ssh_connection()
lines = base64_file_hash.splitlines()
self._logger.info('Base64 hash for {0} file on {1} machine has been generated.'.format(file_path, hostname))
return '"{}"'.format(''.join(lines[2:-2]))
def get_all_deployments_conf(self):
result = {}
deployments_settings = json.loads(requests.get('http://' + self._local_bind_address + ':'
+ str(self._local_bind_port) + '/api/v10/cm/deployment',
auth=(self._cdh_manager_user, self._cdh_manager_password)).content)
result['cloudera_manager_internal_host'] = self.extract_cdh_manager_details(deployments_settings)['hostname']
if self._is_kerberos:
result['kerberos_host'] = result['cloudera_manager_internal_host']
result['hdfs_keytab_value'] = self.generate_keytab('hdfs')
result['auth_gateway_keytab_value'] = self.generate_keytab('authgateway/sys')
result['hgm_keytab_value'] = self.generate_keytab('hgm/sys')
result['vcap_keytab_value'] = self.generate_keytab('vcap')
result['krb5_base64'] = self.generate_base64_for_file('/etc/krb5.conf', self._cdh_manager_ip)
result['kerberos_cacert'] = self.generate_base64_for_file('/var/krb5kdc/cacert.pem', self._cdh_manager_ip)
helper = CdhApiHelper(ApiResource(self._local_bind_address, username=self._cdh_manager_user, password=self._cdh_manager_password, version=9))
hgm_service = helper.get_service_from_cdh('HADOOPGROUPSMAPPING')
result['hgm_adress'] = 'http://' + helper.get_host(hgm_service, 'HADOOPGROUPSMAPPING-HADOOPGROUPSMAPPING_RESTSERVER') + ':' \
+ helper.get_entry_from_group(hgm_service, 'rest_port', 'HADOOPGROUPSMAPPING-HADOOPGROUPSMAPPING_RESTSERVER-BASE')
result['hgm_password'] = helper.get_entry_from_group(hgm_service, 'basic_auth_pass', 'HADOOPGROUPSMAPPING-HADOOPGROUPSMAPPING_RESTSERVER-BASE')
result['hgm_username'] = helper.get_entry_from_group(hgm_service, 'basic_auth_user', 'HADOOPGROUPSMAPPING-HADOOPGROUPSMAPPING_RESTSERVER-BASE')
sentry_service = helper.get_service_from_cdh('SENTRY')
result['sentry_port'] = helper.get_entry(sentry_service, 'sentry_service_server_rpc_port')
result['sentry_address'] = helper.get_host(sentry_service)
result['sentry_keytab_value'] = self.generate_keytab('hive/sys')
result['auth_gateway_profile'] = 'cloud,zookeeper-auth-gateway,hdfs-auth-gateway,kerberos-hgm-auth-gateway,sentry-auth-gateway'
else:
result['sentry_port'] = "''"
result['sentry_address'] = "''"
result['sentry_keytab_value'] = "''"
result['hdfs_keytab_value'] = "''"
result['auth_gateway_keytab_value'] = "''"
result['vcap_keytab_value'] = '""'
result['hgm_keytab_value'] = '""'
result['krb5_base64'] = '""'
result['kerberos_cacert'] = '""'
result['auth_gateway_profile'] = 'cloud,zookeeper-auth-gateway,hdfs-auth-gateway,https-hgm-auth-gateway'
helper = CdhApiHelper(ApiResource(self._local_bind_address, username=self._cdh_manager_user, password=self._cdh_manager_password, version=9))
hgm_service = helper.get_service_from_cdh('HADOOPGROUPSMAPPING')
result['hgm_adress'] = 'https://' + helper.get_host(hgm_service, 'HADOOPGROUPSMAPPING-HADOOPGROUPSMAPPING_RESTSERVER') + ':' \
+ helper.get_entry_from_group(hgm_service, 'rest_port', 'HADOOPGROUPSMAPPING-HADOOPGROUPSMAPPING_RESTSERVER-BASE')
result['hgm_password'] = helper.get_entry_from_group(hgm_service, 'basic_auth_pass', 'HADOOPGROUPSMAPPING-HADOOPGROUPSMAPPING_RESTSERVER-BASE')
result['hgm_username'] = helper.get_entry_from_group(hgm_service, 'basic_auth_user', 'HADOOPGROUPSMAPPING-HADOOPGROUPSMAPPING_RESTSERVER-BASE')
master_nodes = self.extract_nodes_info('cdh-master', deployments_settings)
for i, node in enumerate(master_nodes):
result['master_node_host_' + str(i+1)] = node['hostname']
result['namenode_internal_host'] = self.extract_service_namenode('HDFS', 'HDFS-NAMENODE', deployments_settings)
result['hue_node'] = self.extract_service_namenode('HUE', 'HUE-HUE_SERVER', deployments_settings)
result['h2o_node'] = self.extract_nodes_info('cdh-worker-0', deployments_settings)[0]['hostname']
result['arcadia_node'] = self.extract_nodes_info('cdh-worker-0', deployments_settings)[0]['hostname']
result['import_hadoop_conf_hdfs'] = self.get_client_config_for_service('HDFS')
result['import_hadoop_conf_hbase'] = self.get_client_config_for_service('HBASE')
result['import_hadoop_conf_yarn'] = self.get_client_config_for_service('YARN')
return result
# helpful methods
def _find_item_by_attr_value(self, attr_value, attr_name, array_with_dicts):
return next(item for item in array_with_dicts if item[attr_name] == attr_value)
def _get_host_ip(self, host, ansible_ini):
host_info = []
for line in ansible_ini.split('\n'):
if host in line:
host_info.append(line.strip())
return host_info[host_info.index('[' + host + ']') + 1].split(' ')[1].split('=')[1]
def _load_config_yaml(self, filename):
with open(filename, 'r') as stream:
return yaml.load(stream)
class CdhApiHelper(object):
def __init__(self, cdhApi):
self.cdhApi = cdhApi
def get_service_from_cdh(self, name):
cluster = self.cdhApi.get_all_clusters()[0]
try:
return next(service for service in cluster.get_all_services() if service.type == name)
except StopIteration:
raise NoCdhServiceError('No {} in CDH services.'.format(name))
# get host ip for service or specified service role
def get_host(self, service, role = None):
if role is None:
id = service.get_all_roles()[0].hostRef.hostId
else:
id = service.get_role(role).hostRef.hostId
return self.cdhApi.get_host(id).hostname
def get_entry(self, service, name):
config = service.get_all_roles()[0].get_config('full')
for config_entry in config:
if name == config_entry:
entry = config[config_entry].value or config[config_entry].default
return entry
def get_entry_from_group(self, service, name, group):
config = service.get_role_config_group(group).get_config('full')
for config_entry in config:
if name == config_entry:
entry = config[config_entry].value or config[config_entry].default
return entry
class NoCdhServiceError(Exception):
pass
|
nilq/baby-python
|
python
|
# Copyright (c) Microsoft Corporation
# All rights reserved.
#
# MIT License
#
# 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.
"""
Delete k8s resources using AppsV1Api.
"""
from __future__ import print_function
import time
import argparse
from kubernetes import client, config
from kubernetes.client.rest import ApiException
def get_api_resources(apps_v1_api):
api_resources = {
'daemonset': {
'list': apps_v1_api.list_namespaced_daemon_set,
'delete': apps_v1_api.delete_namespaced_daemon_set
},
'statefulset': {
'list': apps_v1_api.list_namespaced_stateful_set,
'delete': apps_v1_api.delete_namespaced_stateful_set,
},
}
return api_resources
def delete_resource(apps_v1_api, api_resource, name, namespace='default'):
api_resources = get_api_resources(apps_v1_api)
body = client.V1DeleteOptions(
propagation_policy='Foreground',
grace_period_seconds=0)
if api_resource in api_resources:
api = api_resources[api_resource]
while True:
items = api['list'](namespace=namespace).items
if name not in map(lambda x: x.metadata.name, items):
break
print('Trying to stop {} ...'.format(name))
try:
api['delete'](name=name, namespace=namespace, body=body)
except ApiException as e:
continue
time.sleep(5)
else:
raise Exception('Unsupported resource {}.'.format(api_resource))
def main():
parser = argparse.ArgumentParser(description='Update service resources.')
parser.add_argument('--operation', help='operation type')
parser.add_argument('--resource', help='api resource type')
parser.add_argument('--name', help='resource name')
parser.add_argument('--namespace', help='resource namespace', default='default')
args = parser.parse_args()
config.load_kube_config()
apps_v1_api = client.AppsV1Api()
if (args.operation == 'delete'):
delete_resource(apps_v1_api, args.resource, args.name, args.namespace)
else:
raise Exception('Unknown operation {}.'.format(args.operation))
if __name__ == '__main__':
main()
|
nilq/baby-python
|
python
|
#!/usr/bin/env python
# -*- coding: utf8 -*-
# *****************************************************************
# ** PTS -- Python Toolkit for working with SKIRT **
# ** © Astronomical Observatory, Ghent University **
# *****************************************************************
## \package pts.dustpedia.database Contains the DustPediaDatabase class,
# which provides an interface to the DustPedia database.
# -----------------------------------------------------------------
# Ensure Python 3 functionality
from __future__ import absolute_import, division, print_function
# Import standard modules
import tempfile
import numpy as np
import requests
from lxml import html
# Import the relevant PTS classes and modules
from ...core.tools.logging import log
from ...core.tools import tables
from ...magic.core.image import Image
from ...magic.core.frame import Frame
from ...core.tools import filesystem as fs
from ...core.tools import introspection
# -----------------------------------------------------------------
# The base link
base_link = "http://dustpedia.astro.noa.gr"
# login: http://dustpedia.astro.noa.gr/Account/Login
login_link = "http://dustpedia.astro.noa.gr/Account/Login"
# data: http://dustpedia.astro.noa.gr/Data
data_link = "http://dustpedia.astro.noa.gr/Data"
# user
user_link = "http://dustpedia.astro.noa.gr/Account/UserProfile"
# print preview
print_preview_link = "http://dustpedia.astro.noa.gr/Data/GalaxiesPrintView"
# -----------------------------------------------------------------
# The path to the dustpedia account file
account_path = fs.join(introspection.pts_user_accounts_dir, "dustpedia.txt")
# -----------------------------------------------------------------
class DustPediaDatabase(object):
"""
This class ...
"""
def __init__(self):
"""
The constructor ...
:return:
"""
# Determine the path to a temporary directory
self.temp_path = tempfile.gettempdir()
# Create the session
self.session = requests.session()
# A flag that states whether we are connected
self.connected = False
# -----------------------------------------------------------------
def login(self, username, password):
"""
This function ...
:param username:
:param password:
:return:
"""
# Inform the user
log.info("Logging in to the DustPedia database ...")
r = self.session.get(user_link)
p = self.session.post(login_link, {'UserName': username, 'password': password})
# Check login
r = self.session.get(user_link)
# Check whether the login was succesful
self.connected = username in r.content
# If the login failed, raise an error
if not self.connected: raise RuntimeError("Login failed")
# -----------------------------------------------------------------
def logout(self):
"""
This function ...
:return:
"""
# Inform the user
log.info("Logging out from the DustPedia database ...")
# Disconnect
if self.connected: self.session.close()
# -----------------------------------------------------------------
def __del__(self):
"""
The destructor ...
:return:
"""
# Log out from the database
self.logout()
# -----------------------------------------------------------------
def get_galaxy_names(self, parameters):
"""
This function ...
:param parameters:
:return:
"""
link = page_link_from_parameters(parameters)
r = self.session.get(link)
r = self.session.get(print_preview_link)
page_as_string = r.content
tree = html.fromstring(page_as_string)
tables = [e for e in tree.iter() if e.tag == 'table']
table = tables[-1]
table_rows = [e for e in table.iter() if e.tag == 'tr']
column_headings = [e.text_content() for e in table_rows[0].iter() if e.tag == 'th']
galaxy_names = []
for row in table_rows[1:]:
column_index = 0
for e in row.iter():
if e.tag != "td": continue
galaxy_info = e.text_content()
galaxy_name = galaxy_info.split("Name: ")[1].split(" \r\n")[0]
galaxy_names.append(galaxy_name)
break
return galaxy_names
# -----------------------------------------------------------------
def get_galaxies(self, parameters):
"""
This function ...
:param parameters:
:return:
"""
name_column = []
ra_column = []
dec_column = []
stage_column = []
type_column = []
v_column = []
d25_column = []
i_column = []
link = page_link_from_parameters(parameters)
r = self.session.get(link)
r = self.session.get(print_preview_link)
page_as_string = r.content
tree = html.fromstring(page_as_string)
page_tables = [e for e in tree.iter() if e.tag == 'table']
table = page_tables[-1]
table_rows = [e for e in table.iter() if e.tag == 'tr']
column_headings = [e.text_content() for e in table_rows[0].iter() if e.tag == 'th']
info_boxes = []
for row in table_rows[1:]:
column_index = 0
for e in row.iter():
if e.tag != "td": continue
galaxy_info = e.text_content()
#galaxy_name = galaxy_info.split("Name: ")[1].split(" \r\n")[0]
#galaxy_names.append(galaxy_name)
info_boxes.append(galaxy_info)
break
for box in info_boxes:
lines = box.split("\r\n")
name = None
ra = None
dec = None
stage = None
type = None
v = None
d25 = None
i = None
for line in lines:
if "Name" in line: name = line.split(": ")[1].strip()
elif "RA(2000)" in line: ra = float(line.split(": ")[1])
elif "DEC(2000)" in line: dec = float(line.split(": ")[1])
elif "Hubble Stage(T)" in line: stage = float(line.split(": ")[1])
elif "Hubble Type: Sab" in line: type = line.split(": ")[1].strip()
elif "V (km/s)" in line: v = float(line.split(": ")[1])
elif "D25 (arcmin)" in line: d25 = float(line.split(": ")[1])
elif "Inclination (deg.)" in line: i = float(line.split(": ")[1])
if add_hubble_type(type, parameters):
name_column.append(name)
ra_column.append(ra)
dec_column.append(dec)
stage_column.append(stage)
type_column.append(type)
v_column.append(v)
d25_column.append(d25)
i_column.append(i)
# Create the table
names = ["Name", "RA", "DEC", "Hubble stage", "Hubble type", "V", "D25", "Inclination"]
data = [name_column, ra_column, dec_column, stage_column, type_column, v_column, d25_column, i_column]
table = tables.new(data, names)
return table
# -----------------------------------------------------------------
def get_image_urls(self, galaxy_name):
"""
This function ...
:param galaxy_name:
:return:
"""
# Inform the user
log.info("Getting the URLs of the available images for galaxy '" + galaxy_name + "' ...")
# Go to the page
r = self.session.get(data_link + "?GalaxyName="+galaxy_name+"&tLow=&tHigh=&vLow=&vHigh=&inclLow=&inclHigh=&d25Low=&d25High=&SearchButton=Search")
page_as_string = r.content
tree = html.fromstring(page_as_string)
tables = [ e for e in tree.iter() if e.tag == 'table']
table = tables[-1]
table_rows = [ e for e in table.iter() if e.tag == 'tr']
column_headings = [ e.text_content() for e in table_rows[0].iter() if e.tag == 'th']
galaxy_info = None
image_links = []
for row in table_rows[1:]:
column_index = 0
#row_content = []
for e in row.iter():
if e.tag != "td": continue
if column_index == 0:
galaxy_info = e.text_content()
else:
#print("CHILDREN")
#for ee in e.iterchildren(): print(ee)
#print()
#print("DESCENDANTS")
#for ee in e.iterdescendants(): print(ee)
#print()
#print("LINKS")
for ee in e.iterlinks():
link = base_link + ee[2]
image_links.append(link)
#print()
#print("SIBLINGS")
#for ee in e.itersiblings(): print(ee)
column_index += 1
return image_links
# -----------------------------------------------------------------
def get_image_names(self, galaxy_name):
"""
This function ...
:param galaxy_name:
:return:
"""
# Inform the user
log.info("Getting the names of the images that are available for galaxy '" + galaxy_name + "' ...")
# Example link: http://dustpedia.astro.noa.gr/Data/GetImage?imageName=NGC3031_Planck_10600.fits&instrument=Planck
names = []
for url in self.get_image_urls(galaxy_name):
name = url.split("imageName=")[1].split("&instrument")[0]
names.append(name)
return names
# -----------------------------------------------------------------
def get_image(self, galaxy_name, image_name):
"""
This function ...
:param galaxy_name:
:param image_name:
:return:
"""
# Inform the user
log.info("Getting the image '" + image_name + "' for galaxy '" + galaxy_name + "' ...")
# Determine a temporary path for the image file
local_path = fs.join(self.temp_path, image_name)
# Download the image to the temporary directory
self.download_image(galaxy_name, image_name, local_path)
# Open the image
frame = Frame.from_file(local_path)
# Remove the file
fs.remove_file(local_path)
# Return the image frame
return frame
# -----------------------------------------------------------------
def download_image(self, galaxy_name, image_name, path):
"""
This function ...
:param galaxy_name:
:param image_name:
:param path:
:return:
"""
# Inform the user
log.info("Downloading the image '" + image_name + "' for galaxy '" + galaxy_name + "' to '" + path + " ...")
get_link = None
for url in self.get_image_urls(galaxy_name):
link_name = url.split("imageName=")[1].split("&instrument")[0]
if link_name == image_name:
get_link = url
break
self.download_file(get_link, path)
# -----------------------------------------------------------------
def get_galaxy_info(self, galaxy_name):
"""
This function ...
:param galaxy_name:
:return:
"""
# Inform the user
log.info("Getting general information about galaxy '" + galaxy_name + "' ...")
# Set the names of the table columns
names = ["Name", "RA", "DEC", "Hubble Stage", "Hubble Type", "V", "D25", "Inclination"]
r = self.session.get(data_link + "?GalaxyName="+galaxy_name+"&tLow=&tHigh=&vLow=&vHigh=&inclLow=&inclHigh=&d25Low=&d25High=&SearchButton=Search")
page_as_string = r.content
tree = html.fromstring(page_as_string)
table_list = [ e for e in tree.iter() if e.tag == 'table']
table = table_list[-1]
table_rows = [ e for e in table.iter() if e.tag == 'tr']
galaxy_info = None
for row in table_rows[1:]:
column_index = 0
for e in row.iter():
if e.tag != "td": continue
if column_index == 0:
#for ee in e.iterchildren(): print(ee.text_content())
#for ee in e.iterdescendants(): print(ee.text_content())
#for ee in e.itersiblings(): print(ee.text_content())
galaxy_info = e.text_content()
#print(galaxy_info)
column_index += 1
splitted = galaxy_info.split("\r\n")
lines = [split.strip() for split in splitted if split.strip()]
name = None
ra = None
dec = None
stage = None
type = None
v = None
d25 = None
i = None
for line in lines:
if "Name" in line: name = line.split(": ")[1]
elif "RA(2000)" in line: ra = float(line.split(": ")[1])
elif "DEC(2000)" in line: dec = float(line.split(": ")[1])
elif "Hubble Stage(T)" in line: stage = float(line.split(": ")[1])
elif "Hubble Type: Sab" in line: type = line.split(": ")[1]
elif "V (km/s)" in line: v = float(line.split(": ")[1])
elif "D25 (arcmin)" in line: d25 = float(line.split(": ")[1])
elif "Inclination (deg.)" in line: i = float(line.split(": ")[1])
data = [[name], [ra], [dec], [stage], [type], [v], [d25], [i]]
table = tables.new(data, names)
return table
# -----------------------------------------------------------------
def get_sed(self, galaxy_name):
"""
This function ...
:param galaxy_name:
:return:
"""
pass
# -----------------------------------------------------------------
def download_file(self, link, local_path):
"""
This function ...
:param link:
:param local_path:
:return:
"""
# NOTE the stream=True parameter
r = self.session.get(link, stream=True)
with open(local_path, 'wb') as f:
for chunk in r.iter_content(chunk_size=1024):
if chunk: # filter out keep-alive new chunks
f.write(chunk)
#f.flush() # commented by recommendation from J.F.Sebastian
# -----------------------------------------------------------------
def page_link_from_parameters(parameters):
"""
This function ...
:param parameters:
:return:
"""
if "T" in parameters:
tlow = str(parameters["T"][0]) if parameters["T"][0] is not None else ""
thigh = str(parameters["T"][1]) if parameters["T"][1] is not None else ""
else:
tlow = thigh = ""
if "V" in parameters:
vlow = str(parameters["V"][0]) if parameters["V"][0] is not None else ""
vhigh = str(parameters["V"][1]) if parameters["V"][1] is not None else ""
else:
vlow = vhigh = ""
if "inclination" in parameters:
incllow = str(parameters["inclination"][0]) if parameters["inclination"][0] is not None else ""
inclhigh = str(parameters["inclination"][1]) if parameters["inclination"][1] is not None else ""
else:
incllow = inclhigh = ""
if "D25" in parameters:
d25low = str(parameters["D25"][0]) if parameters["D25"][0] is not None else ""
d25high = str(parameters["D25"][1]) if parameters["D25"][1] is not None else ""
else:
d25low = d25high = ""
return data_link + "?GalaxyName=&tLow=" + tlow + "&tHigh=" + thigh + "&vLow=" + vlow + \
"&vHigh=" + vhigh + "&inclLow=" + incllow + "&inclHigh=" + inclhigh + "&d25Low=" + d25low + \
"&d25High=" + d25high + "&SearchButton=Search"
# -----------------------------------------------------------------
def get_account():
"""
This function ...
:return:
"""
username, password = np.loadtxt(account_path, dtype=str)
return username, password
# -----------------------------------------------------------------
def add_hubble_type(hubble_type, parameters):
"""
This function ...
:param hubble_type:
:param parameters:
:return:
"""
if "Hubble type" in parameters:
if isinstance(parameters["Hubble type"], basestring): return hubble_type == parameters["Hubble type"]
else: return hubble_type in parameters["Hubble type"]
else: return True
# -----------------------------------------------------------------
|
nilq/baby-python
|
python
|
from abc import ABCMeta, abstractmethod
from copy import deepcopy
import attr
from utensor_cgen.utils import MUST_OVERWRITEN
class Morphism(object):
__metaclass__ = ABCMeta
@abstractmethod
def apply(self, from_op):
raise RuntimeError('abstract transform invoked')
@attr.s
class TypedMorphism(Morphism):
from_op_type = MUST_OVERWRITEN
def __attrs_post_init__(self):
if self.from_op_type is MUST_OVERWRITEN:
raise ValueError(
"must overwrite {}.from_op_type".format(type(self).__name__)
)
class GenericMorphism(Morphism):
pass
class IdentityMorphism(GenericMorphism):
def apply(self, from_op):
return from_op
@attr.s
class Const2InlineMorphism(TypedMorphism):
from_op_type = 'Const'
def apply(self, from_op):
new_op = deepcopy(from_op, memo={'ugraph': from_op.ugraph})
new_op.op_type = 'Inline'
return new_op
@attr.s
class Inline2ConstMorphism(TypedMorphism):
from_op_type = 'Inline'
def apply(self, from_op):
new_op = deepcopy(from_op, memo={'ugraph': from_op.ugraph})
new_op.op_type = 'Const'
return new_op
|
nilq/baby-python
|
python
|
# Copyright 2021 Alibaba Group Holding Limited. All Rights Reserved.
from essmc2.utils.registry import Registry
HOOKS = Registry("HOOKS")
|
nilq/baby-python
|
python
|
## Yoni Schirris. 06/10/2020
## Exact copy of main.py (now main_unsupervised.py)
## Idea is to keep functionality of both supervised and unsupervised in here, with some switches that change only minor
## things to switch between supervised and unsupervised learning.
## Thus, in the end, we should again have a single "main.py" file.
import os
import torch
import torchvision
import argparse
from torch.utils.tensorboard import SummaryWriter
apex = False
try:
from apex import amp
apex = True
except ImportError:
print(
"Install the apex package from https://www.github.com/nvidia/apex to use fp16 for training"
)
from model import load_model, save_model
from modules import NT_Xent
from modules.sync_batchnorm import convert_model
from modules.transformations import TransformsSimCLR
from modules.transformations.supervised_transform import TransformsSupervised
from utils import post_config_hook
from msidata.dataset_msi import PreProcessedMSIDataset as dataset_msi
#### pass configuration
from experiment import ex
def train(args, train_loader, model, criterion, optimizer, writer):
loss_epoch = 0
for step, (data, _, _, _) in enumerate(train_loader):
# TODO fix the object we get from the dataloader. This is bound to get super messy.
# Also, what will be the nicest thing for later?
# Or not think about that too much?
optimizer.zero_grad()
if args.feature_learning=='unsupservised':
x_i = data[0]
x_j = data[1]
x_i = x_i.to(args.device)
x_j = x_j.to(args.device)
# positive pair, with encoding
h_i, z_i = model(x_i)
h_j, z_j = model(x_j)
loss = criterion(z_i, z_j)
elif args.feature_learning=='supervised':
x = data[0]
if apex and args.fp16:
with amp.scale_loss(loss, optimizer) as scaled_loss:
scaled_loss.backward()
else:
loss.backward()
optimizer.step()
if step % 50 == 0:
print(f"Step [{step}/{len(train_loader)}]\t Loss: {loss.item()}")
writer.add_scalar("Loss/train_epoch", loss.item(), args.global_step)
loss_epoch += loss.item()
args.global_step += 1
return loss_epoch
@ex.automain
def main(_run, _log):
args = argparse.Namespace(**_run.config)
args = post_config_hook(args, _run)
args.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
args.n_gpu = torch.cuda.device_count()
root = "./datasets"
train_sampler = None
if args.dataset == "STL10":
train_dataset = torchvision.datasets.STL10(
root, split="unlabeled", download=True, transform=TransformsSimCLR(size=96)
)
elif args.dataset == "CIFAR10":
train_dataset = torchvision.datasets.CIFAR10(
root, download=True, transform=TransformsSimCLR(size=32)
)
elif args.dataset == 'msi':
if args.feature_learning == "unsupervised":
transform = TransformsSimCLR(size=224)
elif args.feature_learning == "supervised":
transform = TransformsSupervised(size=224)
train_dataset = dataset_msi(
root_dir=args.path_to_msi_data, ## TODO: Add way of getting the correct "new" file of self-assigned labels per tile
transform=transform,
data_fraction=args.data_pretrain_fraction)
else:
raise NotImplementedError
train_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=args.batch_size,
shuffle=(train_sampler is None),
drop_last=True,
num_workers=args.workers,
sampler=train_sampler, ## TODO: Add train & validate sampler
)
model, optimizer, scheduler = load_model(args, train_loader, reload_model=args.reload_model)
print(f"Using {args.n_gpu}'s")
if args.n_gpu > 1:
model = torch.nn.DataParallel(model)
model = convert_model(model)
model = model.to(args.device)
#TODO Check the batch size.. are we only training with 32 total so 8 per GPU? That's veeeery few.
print(model)
tb_dir = os.path.join(args.out_dir, _run.experiment_info["name"])
os.makedirs(tb_dir)
writer = SummaryWriter(log_dir=tb_dir)
if args.feature_learning == "unsupservised":
criterion = NT_Xent(args.batch_size, args.temperature, args.device)
elif args.feature_learning == "supervised":
#TODO Add class distribution weights
criterion = torch.nn.CrossEntropyLoss()
args.global_step = 0
args.current_epoch = 0
for epoch in range(args.start_epoch, args.epochs):
lr = optimizer.param_groups[0]['lr']
loss_epoch = train(args, train_loader, model, criterion, optimizer, writer)
if scheduler:
scheduler.step()
if epoch % 10 == 0:
save_model(args, model, optimizer)
writer.add_scalar("Loss/train", loss_epoch / len(train_loader), epoch)
writer.add_scalar("Misc/learning_rate", lr, epoch)
print(
f"Epoch [{epoch}/{args.epochs}]\t Loss: {loss_epoch / len(train_loader)}\t lr: {round(lr, 5)}"
)
args.current_epoch += 1
## end training
save_model(args, model, optimizer)
|
nilq/baby-python
|
python
|
"""
Deuce Valere - Tests - API - System - Manager
"""
import datetime
import unittest
from deuceclient.tests import *
from deucevalere.api.system import *
class DeuceValereApiSystemManagerTest(unittest.TestCase):
def setUp(self):
super().setUp()
def tearDown(self):
super().tearDown()
def test_create_default(self):
manager = Manager()
self.assertIsNone(manager.start_block)
self.assertIsNone(manager.end_block)
self.assertIsInstance(manager.validation_timer, TimeManager)
self.assertIsInstance(manager.cleanup_timer, TimeManager)
self.assertIsInstance(manager.expired_counter, CounterManager)
self.assertIsInstance(manager.missing_counter, CounterManager)
self.assertIsInstance(manager.orphaned_counter, CounterManager)
self.assertIsInstance(manager.delete_expired_counter, CounterManager)
self.assertIsInstance(manager.delete_orphaned_counter, CounterManager)
self.assertIsInstance(manager.metadata, ListManager)
self.assertIsInstance(manager.storage, ListManager)
self.assertIsInstance(manager.cross_reference, dict)
self.assertIsInstance(manager.expire_age, datetime.timedelta)
def test_create_cases(self):
cases = [
# Both Start and End Markers
(create_block()[0], create_block()[0], None),
# Start Marker, No End Marker
(create_block()[0], None, None),
# No Start Marker, End Marker
(None, create_block()[0], None),
# Neither Starr nor End Markers
(None, None, None),
(None, None, datetime.timedelta(seconds=5)),
]
for start, end, expire_age in cases:
x = Manager(marker_start=start,
marker_end=end,
expire_age=expire_age)
self.assertEqual(x.start_block, start)
self.assertEqual(x.end_block, end)
if expire_age is None:
self.assertIsInstance(x.expire_age, datetime.timedelta)
else:
self.assertEqual(x.expire_age, expire_age)
def test_expire_age_set(self):
manager = Manager()
old_age = manager.expire_age
new_age = datetime.timedelta(seconds=3600)
manager.expire_age = new_age
self.assertNotEqual(manager.expire_age, old_age)
self.assertEqual(manager.expire_age, new_age)
|
nilq/baby-python
|
python
|
# sum_of_multiplications([(1, 2), (5, 10)]) should return 52
# because (1 * 2 + 5 * 10) is 52
def sum_of_multiplications(l):
sum = 0
for value1, value2 in l:
sum += value1 * value2
return sum
if __name__ == '__main__':
print(sum_of_multiplications([(1, 2), (5, 10)]))
|
nilq/baby-python
|
python
|
"""
This is the plugin code for threshold segmentation(binary) of rectilinear grid.
This plugin is designed to segment a grid such that cells with magnitude greater than the threshold value are
labelled as 1, otherwise labelled as 0. This provides the ground truth results for
such a fluid segmentation.
Accepted input data models: VTK Rectilinear Grid
Output data model: VTK Rectilinear Grid
It takes from user two parameters: Threshold value.
"""
from paraview.util.vtkAlgorithm import *
from paraview.vtk.util import numpy_support as ns
from vtkmodules.numpy_interface import dataset_adapter as DA
import numpy as np
@smproxy.filter()
@smproperty.input(name="InputRectilinear", port_index=0)
@smdomain.datatype(dataTypes=["vtkRectilinearGrid"], composite_data_supported=True)
class Threshold_Fluid_Segment(VTKPythonAlgorithmBase):
threshold_cut = 0.01
input_data_type = ""
t_port = 0
t_index = 0
def __init__(self):
self.threshold_cut = 0.01
VTKPythonAlgorithmBase.__init__(
self, nInputPorts=1, nOutputPorts=1, outputType="vtkRectilinearGrid")
# First step in pipeline: set Port info
def FillInputPortInformation(self, port, info):
if port == 0:
self.t_port = port
self.t_index = info.Get(self.INPUT_CONNECTION()) # connection
print("port info set")
return 1
# Request Data from input and create output
def RequestData(self, request, inInfoVec, outInfoVec):
from vtkmodules.vtkCommonDataModel import vtkRectilinearGrid
'''inInfoVec = tuple
inInfoVec[0] = vtkInformationVector
outInfoVec = vtkInformationVector (not subscribtable)'''
self.input_data_type = self.GetInputDataObject(
self.t_port, self.t_index).GetClassName()
if self.input_data_type == "vtkRectilinearGrid":
x, y, z, xCoords, yCoords, zCoords, vtk_double_array = self.Process_RectlinearGrid(
inInfoVec, outInfoVec)
output = vtkRectilinearGrid.GetData(outInfoVec, 0)
output.SetDimensions(x, y, z)
output.SetXCoordinates(xCoords)
output.SetYCoordinates(yCoords)
output.SetZCoordinates(zCoords)
output.GetPointData().SetScalars(vtk_double_array)
return 1
def Process_RectlinearGrid(self, inInfoVec, outInfoVec):
"""
Helper function to process info from input and carry out threshold segmentation.
Args:
inInfoVec: input information vector
outInfoVec: output information vector
Returns:
x, y, z: output x,y,z dimensions respectively
xCoords, yCoords, zCoords: output's x co-ordinates, y-coordinates, z-coordinates respectively
output_vtk_array: VTK array for output
"""
from vtkmodules.vtkCommonDataModel import vtkRectilinearGrid
pdi = vtkRectilinearGrid.GetData(inInfoVec[0], 0)
x, y, z = pdi.GetDimensions()
xCoords = pdi.GetXCoordinates()
yCoords = pdi.GetYCoordinates()
zCoords = pdi.GetZCoordinates()
float_array = pdi.GetPointData().GetAbstractArray(0)
numpy_array = ns.vtk_to_numpy(float_array)
if float_array.GetNumberOfComponents() > 1:
mag = np.array([np.sqrt(x.dot(x)) for x in numpy_array])
tf_array = mag > self.threshold_cut
else:
tf_array = numpy_array > self.threshold_cut
seg_array = tf_array.astype(int)
output_vtk_array = DA.numpyTovtkDataArray(
seg_array, name="numpy_array")
return x, y, z, xCoords, yCoords, zCoords, output_vtk_array
@ smproperty.xml("""
<DoubleVectorProperty name="Threshold Value"
number_of_elements="1"
default_values="0.01"
command="SetThresholdR">
<DoubleRangeDomain name="range" />
<Documentation>Set threshold pixel value to segment(binary)</Documentation>
</DoubleVectorProperty>""")
def SetThresholdR(self, x):
print("Threshold set", x)
self.threshold_cut = x
self.Modified()
|
nilq/baby-python
|
python
|
"""
对Kaiming He新提出的MAE的简要实现
"""
# ----------------------------------------------------------------
# borrowed from https://github.com/IcarusWizard/MAE.git
# ----------------------------------------------------------------
import numpy as np, torch
import torch.nn as nn
from .transformer import Encoder
def random_index(size: int):
"""
产生随机的patch序列 用于产生mask机制
"""
assert size > 0
# 用于mask机制的随机索引
forward_indexes = np.arange(size)
np.random.shuffle(forward_indexes)
# 用于重建图像的正确的排序索引
backward_indexes = np.argsort(forward_indexes)
return forward_indexes, backward_indexes
class Projection(nn.Module):
"""
图像和嵌入之间的投射
"""
def __init__(
self,
image_size,
patch_num,
embedding_dim,
):
"""
Args:
image_size: 图像大小
patch_num: 每条边对应的Patch数目
embedding_dim: 嵌入的维度
"""
super(Projection, self).__init__()
assert image_size % patch_num == 0
self.image_size = image_size
self.patch_num = patch_num
self.embedding_dim = embedding_dim
self.patch_size = self.image_size // self.patch_num
self.in_projection = nn.Linear(self.patch_size ** 2 * 3, self.embedding_dim)
self.out_projection = nn.Linear(self.embedding_dim, self.patch_size ** 2 * 3)
def img2embeddings(
self,
imgs: torch.Tensor
):
"""
将图像投影为嵌入向量: batch * 3 * h * w --> batch * r^2 * 3 * h / r * w / 2 --> batch * r^2 * (3 * h / r * w / r)
"""
b,c,h,w = imgs.size()
# ========================================
# TODO find a faster way for patching
# ========================================
patches = torch.zeros(size = (b, self.patch_num ** 2, c, h // self.patch_num, w // self.patch_num)).to(imgs.device)
for i in range(self.patch_num):
for j in range(self.patch_num):
patches[:,i * self.patch_num + j] = imgs[:, :, i * self.patch_size:(i + 1) * self.patch_size, j * self.patch_size:(j + 1) * self.patch_size]
patches = patches.contiguous()
b, total_num, c, h, w = patches.size()
origin_embeddings = patches.view(b, total_num, -1)
projected_embeddings = self.in_projection(origin_embeddings)
return origin_embeddings, projected_embeddings
def embeddings2img(
self,
embeddings: torch.Tensor,
):
"""
将嵌入向量重新变换为图像: batch * 3 * h * w --> batch * r^2 * 3 * h / r * w / 2 --> batch * r^2 * (3 * h / r * w / r)
"""
out_embeddings = self.out_projection(embeddings)
b, total_num, _ = out_embeddings.size()
embeddings = out_embeddings.view(b, total_num, 3, self.patch_size, self.patch_size)
# ========================================
# TODO find a faster way for patching
# ========================================
out_img = torch.zeros(size = (b, 3, self.image_size, self.image_size)).to(embeddings.device)
for i in range(self.patch_num):
for j in range(self.patch_num):
index = i * self.patch_num + j
out_img[:, :, i * self.patch_size:(i + 1) * self.patch_size, j * self.patch_size:(j + 1) * self.patch_size] = embeddings[:, index]
return out_embeddings, out_img
class PatchShuffle(nn.Module):
"""
对各个Patch进行挑选并且返回索引
"""
def __init__(
self,
patch_num,
):
"""
Args:
patch_num: 每条边的Patch数目
"""
super(PatchShuffle, self).__init__()
self.patch_num = patch_num
def forward(self, b):
indexes = [random_index(self.patch_num ** 2) for i in range(b)]
forward_indexes = [indexes[i][0] for i in range(b)] # b * total_num
backward_indexes = [indexes[i][1] for i in range(b)] # b * total_num
forward_indexes = torch.tensor(forward_indexes, dtype=torch.int64, requires_grad=False)
backward_indexes = torch.tensor(backward_indexes, dtype=torch.int64, requires_grad=False)
return forward_indexes, backward_indexes
class MAE_Encoder(nn.Module):
"""
MAE中非对称的编码器
"""
def __init__(
self,
layers,
embedding_dim,
patch_num,
):
"""
Args:
layers: Encoder的编码器层数
embedding_dim: 输入的嵌入维度
patch_num: 每条边对应的Patch
"""
super(MAE_Encoder, self).__init__()
self.layers = layers
self.patch_num = patch_num
self.embedding_dim = embedding_dim
# ========================================================
# TODO 不同之处在于没有使用cls_token机制 仅仅当作一个特征抽取
# ========================================================
self.transformer = Encoder(layers, embedding_dim, embedding_dim, 8, embedding_dim * 4, 0.0)
self.pos_embeddings = nn.parameter.Parameter(torch.zeros(size = (1, patch_num ** 2, embedding_dim), dtype=torch.float32, requires_grad=True))
def forward(self, inputs, forward_indexes, mask_ratio):
"""
Args:
inputs: 输入嵌入 batch * total_num * embedding_dim
forward_indexes: shuffle之后的indexes
mask_ratio: 遮挡的比例
"""
b = inputs.size()[0]
inputs = inputs + self.pos_embeddings
indexes_in_kept = forward_indexes[:, :int((self.patch_num ** 2) * (1 - mask_ratio))] if forward_indexes is not None else None
if indexes_in_kept is not None:
unmasked_embeddings = torch.stack(
[inputs[i][indexes_in_kept[i]] for i in range(b)], dim=0
)
inputs = unmasked_embeddings
return self.transformer(inputs)
class MAE_Decoder(nn.Module):
"""
MAE中非对称的解码器
"""
def __init__(
self,
layers,
embedding_dim,
patch_num,
):
"""
Args:
layers: 层数
embedding_dim: 中间向量的维度
patch_num: 每条边的Patch数目
"""
super(MAE_Decoder, self).__init__()
self.layers = layers
self.embedding_dim = embedding_dim
self.patch_num = patch_num
self.pos_embeddings = nn.parameter.Parameter(torch.zeros(size = (self.patch_num ** 2, self.embedding_dim), requires_grad=True))
self.mask_token = nn.parameter.Parameter(torch.zeros(size = (1, 1, self.embedding_dim), requires_grad=True))
self.transformer = Encoder(self.layers, self.embedding_dim, self.embedding_dim, 8, self.embedding_dim * 4, dropout=0.0)
def forward(
self,
x,
forward_indexes
):
b, kept_num, dim = x.size()
# 补全所有的嵌入向量
full_embeddings = torch.cat([x, self.mask_token.expand(b, self.patch_num ** 2 - kept_num, dim)], dim = 1) if forward_indexes is not None else x
# 调整正确的位置编码
full_embeddings = torch.stack(
[full_embeddings[i] + self.pos_embeddings[forward_indexes[i]] for i in range(b)], dim=0
) if forward_indexes is not None else (full_embeddings + self.pos_embeddings.unsqueeze(0))
output_embeddings = self.transformer(full_embeddings)
# 得到输出
return output_embeddings
class MAE(nn.Module):
"""
Mask-Auto-Encoder
将输入的图像按照尺寸定义划分为多个Patch
先线性投射为嵌入
"""
def __init__(
self,
image_size,
patch_num,
embedding_dim,
encoder_layers,
decoder_layers,
mask_ratio,
):
"""
Args:
image_size: 输入的图像大小
patch_num: 每条边可以划分的Patch数目
embedding_dim: 编码器内部投影的向量维度
encoder_layers: 编码器结构对应的层数
decoder_layers: 解码器结果对应的层数
mask_ratio: 遮挡比例
"""
super(MAE, self).__init__()
self.image_size = image_size
self.patch_num = patch_num
self.embedding_dim = embedding_dim
self.encoder_layers = encoder_layers
self.decoder_layers = decoder_layers
self.mask_ratio = mask_ratio
self.projection = Projection(image_size, patch_num, embedding_dim)
self.pshuffle = PatchShuffle(self.patch_num)
self.encoder = MAE_Encoder(self.encoder_layers, self.embedding_dim, self.patch_num)
self.decoder = MAE_Decoder(self.decoder_layers, self.embedding_dim, self.patch_num)
def forward(
self,
imgs,
encoder_mode = False
):
"""
Args:
imgs: 多个图像Patch构成的张量
encoder_mode: 是否处于特征提取模式 即仅仅使用编码器
"""
b, _, _, _ = imgs.size()
# b * total_num * (c * h * w), b * total_num * embeddings
origin_embeddings, input_embeddings = self.projection.img2embeddings(imgs)
forward_indexes, backward_indexes = None, None
if self.training and not encoder_mode:
# shuffle index, correct index in order for shuffled embeddings
forward_indexes, backward_indexes = self.pshuffle(b)
# encoding
middle_feat_embeddings = self.encoder(input_embeddings, forward_indexes, self.mask_ratio)
if encoder_mode:
return middle_feat_embeddings
# decoding
dec_embeddings = self.decoder(middle_feat_embeddings, forward_indexes)
dec_embeddings = torch.stack(
[dec_embeddings[i][backward_indexes[i]] for i in range(b)], dim = 0
) if backward_indexes is not None else dec_embeddings
output_embeddings, output_img = self.projection.embeddings2img(dec_embeddings)
return origin_embeddings, output_embeddings, output_img, forward_indexes
|
nilq/baby-python
|
python
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
class Migration(migrations.Migration):
dependencies = [
('barsystem', '0037_auto_20150721_1500'),
]
operations = [
migrations.RenameField(
model_name='product',
old_name='person_price',
new_name='member_price',
),
migrations.RenameField(
model_name='product',
old_name='cash_price',
new_name='standard_price',
),
]
|
nilq/baby-python
|
python
|
import unittest
from unittest.mock import Mock, MagicMock
import math
import shapely as sh
import shapely.geometry
import numpy as np
import numpy.testing
import shart
from shart.box import *
class TestMain(unittest.TestCase):
def test_attribute(self):
g = Group.rect(0, 0, 100, 100)
self.assertEqual({}, {k: d for k, d in g.geom_attributes_manager.attributes})
g = g.add_geom_attribute("attrib_key", "attrib_value")
self.assertDictEqual({0: {"attrib_key": "attrib_value"}}, dict(g.geom_attributes_manager.attributes))
def test_add_group_attributes(self):
g0 = Group.rect(0, 0, 100, 100).add_geom_attribute("g0", "g0_val")
g1 = Group.rect(10, 10, 80, 80).add_geom_attribute("g1", "g1_val")
self.assertDictEqual(
{0: {"g0": "g0_val"}, 1: {"g1": "g1_val"}},
dict(g0.add(g1).geom_attributes_manager.attributes))
def test_filter_group_attribute(self):
g0 = Group.rect(0, 0, 100, 100).add_geom_attribute("g0", "g0_val")
g1 = Group.rect(10, 10, 80, 80).add_geom_attribute("g1", "g1_val")
# filter to select the second group
combined_and_filtered = g0.add(g1).filter(lambda g: g.bounds_width == 80)
self.assertDictEqual(
{0: {"g1": "g1_val"}},
dict(combined_and_filtered.geom_attributes_manager.attributes))
def test_single_group_union_attributes(self):
g0 = Group.rect(0, 0, 100, 100) \
.add(Group.rect(50, 50, 100, 100)) \
.add_geom_attribute("g0", "g0_val")
g_union = g0.union()
self.assertDictEqual(
{0: {"g0": "g0_val"}},
dict(g_union.geom_attributes_manager.attributes))
def test_multiple_group_union_attributes(self):
g0 = Group.rect(0, 0, 100, 100).add_geom_attribute("g0", "g0_val")
g1 = Group.rect(10, 10, 80, 80).add_geom_attribute("g1", "g1_val")
g_union = g0.union(g1)
self.assertDictEqual(
{ 0: { "g0": "g0_val", "g1": "g1_val" } },
dict(g_union.geom_attributes_manager.attributes))
def test_multiple_group_union_key_collsion(self):
g0 = Group.rect(0, 0, 100, 100).add_geom_attribute("g", "g0_val")
g1 = Group.rect(10, 10, 80, 80).add_geom_attribute("g", "g1_val")
g_union = g0.union(g1)
self.assertDictEqual(
{0: {"g": "g1_val"}},
dict(g_union.geom_attributes_manager.attributes))
def test_multiple_attributes(self):
g0 = Group.rect(0, 0, 100, 100).add_geom_attribute("a", "aval").add_geom_attribute("b", "bval")
self.assertDictEqual(
{0: {"a": "aval", "b": "bval"}},
dict(g0.geom_attributes_manager.attributes))
def test_multiple_attributes_and_reassign(self):
g0 = Group.rect(0, 0, 100, 100)\
.add_geom_attribute("a", "aval")\
.add_geom_attribute("b", "bval")\
.add_geom_attribute("b", "newbval")
self.assertDictEqual(
{0: {"a": "aval", "b": "newbval"}},
dict(g0.geom_attributes_manager.attributes))
|
nilq/baby-python
|
python
|
#! /Users/bin/env Python
# Modified version of get_disease.py from ClinGen/LoadData. Creates JSON file
# with all Orphanet data for (initial) load into the server. Run this script
# before using this one:
# obtain_external_data_files.py -s orphanet
import json
from uuid import uuid4
from xml.etree import ElementTree as et
# uuid mapping for previously existing entries to avoid validation errors
uuidMapping = {
"15": "78867c7a-16a6-11e5-8007-60f81dc5b05a",
"654": "788ae1de-16a6-11e5-b341-60f81dc5b05a",
"183660": "788aee73-16a6-11e5-8505-60f81dc5b05a",
"777": "788c3bb0-16a6-11e5-8618-60f81dc5b05a",
"370968": "788cd05e-16a6-11e5-97c0-60f81dc5b05a",
"284984": "788d04b5-16a6-11e5-bc96-60f81dc5b05a",
"891": "788d45ab-16a6-11e5-9042-60f81dc5b05a",
"64742": "788d967d-16a6-11e5-acfb-60f81dc5b05a",
"79452": "788e024f-16a6-11e5-a0b5-60f81dc5b05a"
}
tree = et.parse('rawData/disease.xml')
disorders = tree.findall('.//Disorder')
allData = []
omimNum = 0
omimMulti = 0
synonymNum = 0
synonymMulti = 0
for dis in disorders:
synonym = []
omim = []
omimFound = False
synFound = False
# uuid check
if dis.find('OrphaNumber').text in uuidMapping:
uuid = uuidMapping[dis.find('OrphaNumber').text]
else:
uuid = str(uuid4())
for child in dis.getchildren():
syns = child.findall('.//Synonym')
for syn in syns:
synonym.append(syn.text)
refs = child.findall('.//ExternalReference')
for ref in refs:
if ref.find('Source').text == 'OMIM':
omim.append(ref.find('Reference').text)
newData = {
"orphaNumber": dis.find('OrphaNumber').text,
"term": dis.find('Name').text,
"type": dis.find('DisorderType/Name').text,
"omimIds": omim,
"synonyms": synonym,
"active": True,
"uuid": uuid
}
allData.append(newData)
if len(omim) >0: omimNum += 1
if len(omim) > 1: omimMulti += 1
if len(synonym) > 0: synonymNum +=1
if len(synonym) > 1: synonymMulti += 1
fo = open('orphaPhenotype.json', 'w')
fo.write(json.dumps(allData))
print len(disorders)
print omimNum
print synonymNum
print omimMulti
print synonymMulti
|
nilq/baby-python
|
python
|
# coding=utf8
# Copyright 2018 JDCLOUD.COM
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# NOTE: This class is auto generated by the jdcloud code generator program.
class InternalEndpoint(object):
def __init__(self, esHttpEndpoint=None, esTcpEndpoint=None, kibanaEndpoint=None):
"""
:param esHttpEndpoint: (Optional) es http endpoint
:param esTcpEndpoint: (Optional) es tcp endpoint
:param kibanaEndpoint: (Optional) kibana endpoint
"""
self.esHttpEndpoint = esHttpEndpoint
self.esTcpEndpoint = esTcpEndpoint
self.kibanaEndpoint = kibanaEndpoint
|
nilq/baby-python
|
python
|
# !/usr/bin/env python
# -*- coding: utf-8 -*-
"""Bunch of fixtures to be used across the tests."""
import pytest
@pytest.fixture(scope="function")
def hello_world(request):
"""Create a test fixture."""
hw = "Hello World!"
def tear_down():
# clean up here
pass
request.addfinalizer(tear_down)
return hw
|
nilq/baby-python
|
python
|
from __future__ import absolute_import
from datetime import timedelta
from celery.schedules import crontab
from .celery import app
from django.conf import settings
RESULT_BACKEND = 'django-db'
# Mitigate deprecation error:
# The 'BROKER_URL' setting is deprecated and scheduled for removal in
# version 6.0.0. Use the broker_url instead
#BROKER_URL = 'redis://127.0.0.1:6379'
broker_url = 'redis://127.0.0.1:6379'
TASK_SERIALIZER = 'json'
ACCEPT_CONTENT = ['json']
BEAT_SCHEDULER = "django_celery_beat.schedulers:DatabaseScheduler"
#app.conf.timezone = 'UTC'
TIMEZONE = 'UTC'
app.conf.broker_url = 'redis://127.0.0.1:6379'
# Discover tasks in applications.
app.autodiscover_tasks(
lambda: settings.TASK_MODULES
)
|
nilq/baby-python
|
python
|
'''
Author : @amitrajitbose
Problem : Codechef IPCTRAIN
Approach : Greedy
'''
t=int(input())
for _ in range(t):
finalAnswer=0
n,day=[int(x) for x in input().strip().split()]
valf=[int(i) for i in range(day+1)]
dt=[]
si=[]
for i in range(n):
d,t,s=[int(x) for x in input().strip().split()]
dt.append((d-1,t)) #day of arrival and lecture-plans
si.append((s,i)) #sadnesses
si=sorted(si) #sorting ascending, wrt day arrived
for i in range(n-1,-1,-1):
remaining=dt[si[i][1]][0]
tmp=remaining
j=0
while(j<=day):
if(tmp > valf[tmp]):
j+=1
tmp = valf[tmp]
else:
j=day+1
j=0
while(j<=day):
if(tmp != valf[tmp]):
j+=1
tmp = valf[tmp]
else:
j=day+1
training=dt[si[i][1]][1]
while(day>tmp):
training -= 1
valf[tmp] = remaining
tmp += 1
if(training <= 0):
break
j=0
while(j<=day):
if(tmp > valf[tmp]):
tmp=valf[tmp]
j+=1
else:
j=day+1
j=0
while(j<=day):
if(tmp != valf[tmp]):
j+=1
tmp = valf[tmp]
else:
j=day+1
valf[remaining] = tmp
finalAnswer += (training*si[i][0])
print(finalAnswer)
|
nilq/baby-python
|
python
|
import numpy as np
from numpy.core.defchararray import isupper
def printMatrix(mat):
out = ""
for idxi, i in enumerate(mat):
for idxj, j in enumerate(i):
out += f"{mat[idxi][idxj]} "
out += "\n"
print(out)
def printCoordMatrix(mat):
mat = np.flip(mat, 1)
out = ""
for idxi, i in enumerate(mat):
for idxj, j in enumerate(i):
out += f"{mat[idxj][idxi]} "
out += "\n"
print(out)
class Piece:
pieceSteps = {
'p' : "special", # come back to later
'r' : [[1, 0], [0, 1], [-1, 0], [0, -1]],
'n' : [[1, 2], [2, 1], [2, -1], [1, -2], [-1,-2],[-2, -1], [-2, 1], [-1, 2]],
'b' : [[1, 1], [1, -1], [-1, 1], [-1, -1]],
'q' : [[1, 0], [0, 1], [-1, 0], [0, -1], [1, 1], [1, -1], [-1, 1], [-1, -1]],
'k' : [[1, 0], [0, 1], [-1, 0], [0, -1], [1, 1], [1, -1], [-1, 1], [-1, -1]]
}
pieceMax = {
'p' : "special", # come back to later
'k' : 1
}
board = np.full((8, 8), '.')
def __init__(self, type): #sets up all the piece types
self.type = type
self.steps = self.__class__.pieceSteps.get(self.type.lower())
self.stepMax = self.__class__.pieceMax.get(self.type.lower(), 7)
@classmethod
def setup(cls):
cls.initialize_pieces()
# White Pieces
cls.board[0][0] = 'R'
cls.board[7][0] = 'R'
cls.board[1][0] = 'N'
cls.board[6][0] = 'N'
cls.board[2][0] = 'B'
cls.board[5][0] = 'B'
cls.board[3][0] = 'Q'
cls.board[4][0] = 'K'
cls.board[0][1] = 'P'
cls.board[1][1] = 'P'
cls.board[2][1] = 'P'
cls.board[3][1] = 'P'
cls.board[4][1] = 'P'
cls.board[5][1] = 'P'
cls.board[6][1] = 'P'
cls.board[7][1] = 'P'
cls.board[0][7] = 'r'
cls.board[7][7] = 'r'
cls.board[1][7] = 'n'
cls.board[6][7] = 'n'
cls.board[2][7] = 'b'
cls.board[5][7] = 'b'
cls.board[3][7] = 'q'
cls.board[4][7] = 'k'
cls.board[0][6] = 'p'
cls.board[1][6] = 'p'
cls.board[2][6] = 'p'
cls.board[3][6] = 'p'
cls.board[4][6] = 'p'
cls.board[5][6] = 'p'
cls.board[6][6] = 'p'
cls.board[7][6] = 'p'
@classmethod
def custom_setup(cls):
cls.initialize_pieces()
cls.board[0][0] = 'R'
cls.board[0][7] = 'r'
@classmethod
def initialize_pieces(cls):
cls.P = Piece('P')
cls.R = Piece('R')
cls.N = Piece('N')
cls.B = Piece('B')
cls.Q = Piece('Q')
cls.K = Piece('K')
cls.p = Piece('p')
cls.r = Piece('r')
cls.n = Piece('n')
cls.b = Piece('b')
cls.q = Piece('q')
cls.k = Piece('k')
def find_move(self, xCoord, yCoord): # needs to be able to intake disambiguating info
possibilities = []
for step in self.steps:
xStepPos = xCoord
yStepPos = yCoord
for n in range(self.stepMax):
xStepPos -= step[0]
yStepPos -= step[1]
if xStepPos < 0 or yStepPos < 0:
break
if xStepPos > 7 or yStepPos > 7:
break
if self.__class__.board[xStepPos][yStepPos] != '.':
if self.__class__.board[xStepPos][yStepPos] == self.type:
# need to add ability to specify original coords
possibilities.append([xStepPos, yStepPos])
break
return possibilities
def move(self, xCoord, yCoord):
possibilities = self.find_move(xCoord, yCoord)
if len(possibilities) > 1:
print(possibilities)
raise ValueError("move is ambiguous")
elif len(possibilities) < 1:
print(possibilities)
raise ValueError("move is invalid")
fromX = possibilities[0][0]
fromY = possibilities[0][1]
self.__class__.board[fromX][fromY] = '.'
self.__class__.board[xCoord][yCoord] = self.type
Piece.custom_setup()
# P = Piece('P')
# R = Piece('R')
# N = Piece('N')
# B = Piece('B')
# Q = Piece('Q')
# K = Piece('K')
# p = Piece('p')
# r = Piece('r')
# n = Piece('n')
# b = Piece('b')
# q = Piece('q')
# k = Piece('k')
printCoordMatrix(Piece.board)
Piece.R.move(0, 5)
printCoordMatrix(Piece.board)
|
nilq/baby-python
|
python
|
"""This module will contain class Sort and its related methods."""
class Sort(object):
"""
"""
def __init__(self, iterable=None):
if iterable is None:
iterable = []
if type(iterable) is not list:
raise TypeError('Input is not a list.')
self.len = len(iterable)
self.lst = iterable
def __repr__(self):
output = f'<Input list: { self.lst }>'
return output
def __str__(self):
output = f'Input list length is { self.len }'
return output
def selection(self):
"""
"""
for i in self.lst:
if isinstance(i, str):
raise TypeError('Items must be integers.')
for i in range(len(self.lst)):
smallest_idx = i
for a in range(i+1, len(self.lst)):
if self.lst[smallest_idx] > self.lst[a]:
smallest_idx = a
self.lst[i], self.lst[smallest_idx] = self.lst[smallest_idx], self.lst[i]
# print(self.lst)
return(self.lst)
# inpu = Sort([1, 2, 11, 4, 5, -11])
# inpu.selection()
|
nilq/baby-python
|
python
|
while True:
try:
age = int(input("Enter your age: "))
except ValueError:
print("Invalid value, enter an integer")
continue
except:
print("Something went wrong")
continue
if age < 0 or age > 499:
print("Age not within valid range")
continue
else:
break
|
nilq/baby-python
|
python
|
from itertools import product
import epimargin.plots as plt
import numpy as np
import pandas as pd
import seaborn as sns
from epimargin.estimators import analytical_MPVS
from epimargin.models import SIR
from epimargin.policy import PrioritizedAssignment, RandomVaccineAssignment, VaccinationPolicy
from studies.age_structure.commons import *
from studies.age_structure.palette import *
sns.set(style = "whitegrid")
num_sims = 10
def save_results(model, data, dVx_adm, dVx_eff, dVx_imm, tag):
print(":::: serializing results")
np.savetxt(data/f"hack/dT_{tag}.csv", model.dT, delimiter = ",")
np.savetxt(data/f"hack/dD_{tag}.csv", model.dD, delimiter = ",")
# Dead
np.savetxt(data/f"hack/Dx_{tag}.csv", (fD * [_.mean() for _ in model.D]), delimiter = ",")
np.savetxt(data/f"hack/YLLt_{tag}.csv", np.array([(fD * _) * YLLs[:, None] for _ in model.dD]).reshape(-1, 70), delimiter = ",")
# def save_results(data: Path, policy: VaccinationPolicy, tag: str):
# print(":::: serializing results")
# folder = data/"100_sims_all/"
# folder.mkdir(exist_ok = True)
# outputs = {
# "S_vm": policy.S_vm,
# "S_vn": policy.S_vn,
# "I_vn": policy.I_vn,
# "D_vn": policy.D_vn,
# "R_vn": policy.R_vn,
# "R_vm": policy.R_vm,
# "S" : policy.S,
# "I" : policy.I,
# "R" : policy.R,
# "D" : policy.D,
# "N_v" : policy.N_v,
# "N_nv": policy.N_nv,
# "pi" : policy.pi,
# "q_1" : policy.q_1,
# "q_0" : policy.q_0,
# }
# for (label, timeseries) in outputs.items():
# np.savetxt(folder/f"{label}_{tag}.csv", timeseries, delimiter = ",")
# scaling
# dT_conf = df[state].loc[:, "delta", "confirmed"]
# dT_conf_smooth = pd.Series(smooth(dT_conf), index = dT_conf.index)
# T_conf_smooth = dT_conf_smooth.cumsum().astype(int)
# T = T_conf_smooth[date]
# T_sero = (N * seropos)
# T_ratio = T_sero/T
print(":: running simulations")
# coefplot metrics
evaluated_deaths = {}
evaluated_YLLs = {}
evaluated_YLLs_t = {}
ran_models = {}
novax_districts = set()
for (district, seroprevalence, N_district, _, IFR_sero, _) in district_IFR.filter(items = sorted(set(district_codes.keys()) - set(["Perambalur"])), axis = 0).itertuples():
# for (district, seroprevalence, N_district, _, IFR_sero, _) in district_IFR.filter(items = ["Chennai"], axis = 0).itertuples():
# grab timeseries
D, R = ts.loc[district][["dD", "dR"]].sum()
dT_conf_district = ts.loc[district].dT
dT_conf_district = dT_conf_district.reindex(pd.date_range(dT_conf_district.index.min(), dT_conf_district.index.max()), fill_value = 0)
dT_conf_district_smooth = pd.Series(smooth(dT_conf_district), index = dT_conf_district.index).clip(0).astype(int)
T_conf_smooth = dT_conf_smooth.cumsum().astype(int)
T = T_conf_smooth[date]
T_sero = (N_district * seroprevalence)
T_ratio = T_sero/T
T_scaled = dT_conf_district_smooth.cumsum()[simulation_start] * T_ratio
S = N_district - T_scaled
# run Rt estimation on scaled timeseries
(Rt_dates, Rt_est, *_) = analytical_MPVS(T_ratio * dT_conf_district_smooth, CI = CI, smoothing = lambda _:_, totals = False)
Rt = dict(zip(Rt_dates, Rt_est))
geo_tag = f"{state}_{district}_"
dD0 = ts.loc[district].dD.loc[simulation_start]
I0 = max(0, (T_scaled - R - D))
for (vax_pct_annual_goal, vax_effectiveness) in product(
(0, 0.25, 0.5),
# (0.5,),
(0.7,)
):
daily_rate = vax_pct_annual_goal/365
daily_vax_doses = int(daily_rate * N_district)
daily_net_doses = int(vax_effectiveness * daily_rate * N_district)
policies = [
RandomVaccineAssignment(daily_vax_doses, vax_effectiveness, split_by_age(S), IN_age_ratios),
PrioritizedAssignment( daily_vax_doses, vax_effectiveness, split_by_age(S), [6, 5, 4, 3, 2, 1, 0], "mortality"),
PrioritizedAssignment( daily_vax_doses, vax_effectiveness, split_by_age(S), [1, 2, 3, 4, 0, 5, 6], "contactrate")
# RandomVaccineAssignment(
# daily_vax_doses,
# vax_effectiveness,
# split_by_age(S),
# fI[:, 0] * I0,
# fR[:, 0] * R,
# fD[:, 0] * D,
# split_by_age(N_district),
# IN_age_ratios),
# PrioritizedAssignment(
# daily_vax_doses,
# vax_effectiveness,
# split_by_age(S),
# fI[:, 0] * I0,
# fR[:, 0] * R,
# fD[:, 0] * D,
# split_by_age(N_district),
# IN_age_ratios, [6, 5, 4, 3, 2, 1, 0], "mortality"),
# PrioritizedAssignment(
# daily_vax_doses,
# vax_effectiveness,
# split_by_age(S),
# fI[:, 0] * I0,
# fR[:, 0] * R,
# fD[:, 0] * D,
# split_by_age(N_district),
# IN_age_ratios, [1, 2, 3, 4, 0, 5, 6], "contactrate")
]
vaccination_policy: VaccinationPolicy
for vaccination_policy in policies:
print(district, vax_pct_annual_goal, vax_effectiveness, vaccination_policy.name())
if vax_pct_annual_goal == 0:
param_tag = "novaccination"
if district in novax_districts:
break
else:
novax_districts.add(district)
else:
param_tag = "_".join([
vaccination_policy.name(),
f"ve{int(100*vax_effectiveness)}",
f"annualgoal{int(100 * vax_pct_annual_goal)}",
f"Rt_threshold{Rt_threshold}"
])
tag = geo_tag + param_tag
model = SIR(
name = district,
population = N_district,
dT0 = np.ones(num_sims) * (dT_conf_district_smooth[simulation_start] * T_ratio).astype(int),
Rt0 = Rt[simulation_start],
I0 = np.ones(num_sims) * I0,
R0 = np.ones(num_sims) * R,
D0 = np.ones(num_sims) * D,
mortality = (ts.loc[district].dD.cumsum()[simulation_start]/T_scaled if I0 == 0 else dD0/(gamma * I0)),
random_seed = 0
)
model.dD[0] = np.ones(num_sims) * dD0
t = 0
for t in range(5 * 365):
# vaccination_policy.distribute_doses(model, fS, fI, fR, fD, num_sims = num_sims)
# model.m = vaccination_policy.get_mortality(list(TN_IFRs.values()))
adm, eff, imm = vaccination_policy.distribute_doses(model, num_sims = num_sims)
model.m = vaccination_policy.get_mortality(list(TN_IFRs.values()))
# save_results(data, vaccination_policy, tag)
save_results(model, data, [], [], [], tag)
policy_deaths = model.D[-1] # np.sum(vaccination_policy.dD_bins, axis = 0)
if param_tag in evaluated_deaths:
evaluated_deaths[param_tag] += policy_deaths
else:
evaluated_deaths[param_tag] = policy_deaths
# policy_YLL = np.sum(vaccination_policy.dD_bins, axis = 0) @ YLLs
policy_YLL = (fD * np.sum(model.dD, axis = 0)).T @ YLLs[:, None]
if param_tag in evaluated_YLLs:
evaluated_YLLs[param_tag] += policy_YLL
else:
evaluated_YLLs[param_tag] = policy_YLL
evaluated_death_percentiles = {k: np.percentile(v, [5, 50, 95]) for (k, v) in evaluated_deaths.items() if "ve70" in k or "novaccination" in k}
contact_percentiles = {k: v for (k, v) in evaluated_death_percentiles.items() if "contact" in k}
random_percentiles = {k: v for (k, v) in evaluated_death_percentiles.items() if "random" in k}
mortality_percentiles = {k: v for (k, v) in evaluated_death_percentiles.items() if "mortality" in k}
novax_percentiles = {k: v for (k, v) in evaluated_death_percentiles.items() if "novacc" in k}
fig = plt.figure()
*_, bars = plt.errorbar(
x = [-1],
y = novax_percentiles["novaccination"][1],
yerr = [novax_percentiles["novaccination"][1] - [novax_percentiles["novaccination"][0]],[novax_percentiles["novaccination"][2] - novax_percentiles["novaccination"][1]]],
fmt = "o",
color = no_vax_color,
label = "no vaccination",
figure = fig,
ms = 12, elinewidth = 5
)
[_.set_alpha(0.5) for _ in bars]
for (dx, (metrics, clr)) in enumerate(zip(
[contact_percentiles, random_percentiles, mortality_percentiles],
[contactrate_vax_color, random_vax_color, mortality_vax_color]
)):
for (i, (key, (lo, md, hi))) in enumerate(metrics.items()):
*_, bars = plt.errorbar(
x = [i + 0.2*(dx - 1)], y = [md], yerr = [[md - lo], [hi - md]],
figure = fig, fmt = "o", color = clr, label = None if i > 0 else ["contact rate prioritized", "random assignment", "mortality prioritized"][dx],
ms = 12, elinewidth = 5
)
[_.set_alpha(0.5) for _ in bars]
plt.xticks(list(range(-1, len(metrics))), [f"$\phi = {phi}$%" for phi in [0, 25, 50, 75, 100, 200, 400]], fontsize = "20")
plt.yticks(fontsize = "20")
plt.PlotDevice().ylabel("\ndeaths")
plt.legend(fontsize = "20", ncol = 4, loc = "lower center", bbox_to_anchor = (0.5, 1))
plt.show()
evaluated_YLL_percentiles = {k: np.percentile(v, [5, 50, 95]) for (k, v) in evaluated_YLLs.items() if "ve70" in k or "novaccination" in k}
contact_percentiles = {k: v for (k, v) in evaluated_YLL_percentiles.items() if "contact" in k}
random_percentiles = {k: v for (k, v) in evaluated_YLL_percentiles.items() if "random" in k}
mortality_percentiles = {k: v for (k, v) in evaluated_YLL_percentiles.items() if "mortality" in k}
novax_percentiles = {k: v for (k, v) in evaluated_YLL_percentiles.items() if "novacc" in k}
fig = plt.figure()
*_, bars = plt.errorbar(
x = [-1],
y = novax_percentiles["novaccination"][1],
yerr = [novax_percentiles["novaccination"][1] - [novax_percentiles["novaccination"][0]],[novax_percentiles["novaccination"][2] - novax_percentiles["novaccination"][1]]],
fmt = "o",
color = no_vax_color,
label = "no vaccination",
figure = fig,
ms = 12, elinewidth = 5
)
[_.set_alpha(0.5) for _ in bars]
for (dx, (metrics, clr)) in enumerate(zip(
[contact_percentiles, random_percentiles, mortality_percentiles],
[contactrate_vax_color, random_vax_color, mortality_vax_color]
)):
for (i, (key, (lo, md, hi))) in enumerate(metrics.items()):
*_, bars = plt.errorbar(
x = [i + 0.2*(dx - 1)], y = [md], yerr = [[md - lo], [hi - md]],
figure = fig, fmt = "o", color = clr, label = None if i > 0 else ["contact rate prioritized", "random assignment", "mortality prioritized"][dx],
ms = 12, elinewidth = 5
)
[_.set_alpha(0.5) for _ in bars]
plt.xticks(list(range(-1, len(metrics))), [f"$\phi = {phi}$%" for phi in [0, 25, 50, 75, 100, 200, 400]], fontsize = "20")
plt.yticks(fontsize = "20")
plt.PlotDevice().ylabel("YLLs\n")
# plt.ylim(200, 450)
plt.legend(fontsize = "20", ncol = 4, loc = "lower center", bbox_to_anchor = (0.5, 1))
plt.show()
|
nilq/baby-python
|
python
|
# coding=utf-8
import camera_app
import logging
logger = logging.getLogger(__name__)
logging.getLogger().setLevel(logging.INFO)
if __name__ == '__main__':
camera_app.start()
|
nilq/baby-python
|
python
|
from flask import Blueprint, session, render_template, request, jsonify, Response, abort, current_app, flash, Flask, send_from_directory
from jinja2 import TemplateNotFound
from functools import wraps
from sqlalchemy import or_, and_
from sqlalchemy.orm.exc import NoResultFound
from psiturk.psiturk_config import PsiturkConfig
from psiturk.experiment_errors import ExperimentError
from psiturk.user_utils import PsiTurkAuthorization, nocache
import numpy as np
# # Database setup
from psiturk.db import db_session, init_db
from psiturk.models import Participant
import datetime
import socketio
import uuid
import json
import sys
import traceback
import random
#our stuff
from custom_models import User, Task, Session, Emission
from util import exception
import pattern
#psiturk looks for this blueprint to register endpoints
custom_code = Blueprint('custom_code', __name__, template_folder='templates', static_folder='static')
# modified psiturk looks for this attribute to inject as WSGI middleware into the flask app
sio = socketio.Server(logger=True)
# load the configuration options
config = PsiturkConfig()
config.load_config()
myauth = PsiTurkAuthorization(config) # if you want to add a password protect route use this
#root = Root(host='localhost')
connections = {} # map: socket-id -> user-id
games = {} # map: user-id -> task object (both user-ids)
queue = [] # list of unmatched user-ids
### SETUP/TEARDOWN ###
@custom_code.record
@exception
def record(state):
pass # fires on blueprint registration
@custom_code.teardown_request
@exception
def shutdown_session(exception=None):
db_session.remove()
### HTTP API ###
@custom_code.route('/TemplateData/<path:path>')
@exception
def send_Build(path):
return send_from_directory('static/TemplateData', path)
@custom_code.route('/Build/<path:path>')
@exception
def send_template(path):
return send_from_directory('templates/Build', path)
@custom_code.route('/js/<path:path>', methods=['GET', 'POST'])
@exception
def get_siojs(path):
with open("static/js/" + path) as fin:
data = fin.read()
return data, 200, {'Content-Type': 'application/javascript; charset=utf-8'}
### STANDARD WEBSOCKET API ###
@sio.on('connect')
@exception
def connected(sid, environ):
pass
@sio.on('disconnect')
@exception
def disconnect(sid):
pass
@sio.on('join')
@exception
def join(sid, data):
# assign socket id to psiturk
print("join request from " + str(data))
room = data.get('id', 'none')
sio.enter_room(sid, room)
#sio.emit("doNotWaitForAction", room=room)
sio.emit("unlockChatBox", room=room)
#room=self.student)
#sio.emit('unlock', room=room)
source = data.get('source', None)
# user is reconnecting
busy = False
if room in list(connections.values()):
if room in games:
if not games[room].finished[room]:
if source == 'html' or source == 'stage':
arg = {"role" : games[room].role_string(room), "pattern" : games[room].__class__.__name__}
sio.emit("instructions", arg, room=room)
if source == 'unity' or source == None:
games[room].reconnect(room)
busy = True
# user is new
if not busy:
if config.getboolean("Task Parameters", "single_player"):
testing_user(room)
else:
register_user(room)
connections[sid] = room
@sio.on("sleep_callback")
@exception
def sleep_callback(sid, data):
uid = connections.get(sid, None)
game = games.get(uid, None)
if game is not None:
game.sleep_callback(uid, seconds_remaining=data)
@sio.on("ready")
@exception
def ready(sid, data):
uid = connections.get(sid, None)
game = games.get(uid, None)
if game is not None and game.idle:
game.new_task()
@sio.on("gameStateRevert")
@exception
def revert(sid, data):
uid = connections.get(sid, None)
game = games.get(uid, None)
if game is not None:
game.revert(sid, data)
# UNITY WEBSOCKET API ENDPOINTS
@sio.on('action')
@exception
def action(sid, data):
"""action(action_info-> as json)
The unity game sends this function each time it performs an action, which
could be setting a waypoint, or clicking any of the two to four action
buttons (go, clear waypoints, pickup object, put down object) Feed this
JSON back into action() (sent from flask to unity) to make the unity game
perform this action. You can also feed just the prior state into load() to
reset the scene back to how it was before the action was taken.
"""
data['arguments']['alreadyPlayed'] = True if data['arguments']['alreadyPlayed'] == 'True' else False
uid = connections.get(sid, None)
game = games.get(uid, None)
if game is not None:
#game.current_state = data['prior state']
#game.prev_state = data['prior state']
game.event(uid, event_type='action', event_data=data)
@sio.on('initialState')
@exception
def initialState(sid, data):
#stprint("initialState: " + str(data))
"""
initialState(serialized_state-> as json)
The initial state of the unity game. Called when the unity game first
connects and each time it reconnects after it resets from the reset button.
Gives the game state that can be fed into load() to make the game state be
how it is initially
"""
uid = connections.get(sid, None)
game = games.get(uid, None)
if game is not None:
game.initial_state = data
#game.set_initial_state(uid, data)
#game.event(uid, event_type='initial_state', event_data=data)
@sio.on('gameState')
@exception
def gameState(sid, data):
uid = connections.get(sid, None)
game = games.get(uid, None)
if game is not None:
if game.synchronize_flag:
#x, y = float(data.get('player', {}).get('xPos', 0)), float(data.get('arguments', {}).get('yPos', 0))
#game.last_location[uid][] = np.array([x, y])
#game.last_location[game.partner(uid)][] = np.array([x, y])
game.emit("load", data, room=uid)
game.emit("load", data, room=game.partner(uid))
game.synchronize_flag=False
game.final_state(data)
@sio.on('player_location')
@exception
def playerLocation(sid, data):
uid = connections.get(sid, None)
game = games.get(uid, None)
if game is not None:
if type(game) == pattern.HtmlUnityDemonstrate:
lead = game.teacher
else:
lead = game.student
game.synchronize_state(uid, data, lead=lead)
@sio.on('endedAction')
@exception
def endedAction(sid):
"""
initialState(serialized_state-> as json)
The initial state of the unity game. Called when the unity game first connects and each time
it reconnects after it resets from the reset button. Gives the game state that can be fed into load()
to make the game state be how it is initially
"""
uid = connections.get(sid, None)
game = games.get(uid, None)
if game is not None:
if game.student == uid:
game.ended_action(uid)
### HTML API ENDPOINTS ###
@sio.on('getChatMessage')
@exception
def getChatMessage(sid, data):
"""
getChatMessage({'message': "-",'id': "-"})
Sends a message typed into the chat box to the server. It is called when the user presses the
send button next to the chat box. The text is in message, and the id is the id of the user gotten
from the psiturk id (the same id used in join as shown below)
"""
uid = connections.get(sid, None)
game = games.get(uid, None)
new_game_commands = {"demonstrate": pattern.HtmlUnityDemonstrate,
"apprentice": pattern.HtmlUnityApprentice,
"reward": pattern.HtmlUnityReward }
if data['message'] in new_game_commands.keys():
if game is not None:
new_game = new_game_commands[data['message']](game.sio, game.teacher, game.student)
games[game.teacher] = new_game
games[game.student] = new_game
return
if game is not None:
game.event(uid, event_type='chat', event_data=data['message'])
@sio.on('onTrainingButtonPress')
@exception
def onTrainingButtonPress(sid, data):
"""
onTrainingButtonPress(({'identifier': "-",'id': "-"})
The html interface calls this function when the user clicks any of the buttons that the html interface
was sent with the function getTrainingButtons(). The identifier is the identifier that was sent with
the button and the id is the id of the user gotten from the psiturk id (the same id used in join as shown below)
"""
uid = connections.get(sid, None)
game = games.get(uid, None)
if game is not None:
game.event(uid, event_type='button', event_data=data['identifier'])
def testing_user(uid):
new_game = pattern.HtmlUnityTest(sio=sio, user=uid, num_teaching_tasks=5, num_testing_tasks=5)
new_game.training_levels = []
new_game.testing_levels = []
#new_game.training_levels = []
sio.emit("sendTrainingMessage", "* Entering sandbox mode.", room=uid)
games[uid] = new_game
arg = {"role" : games[uid].role_string(uid), "pattern" : new_game.__class__.__name__}
sio.emit("instructions", arg, room=uid)
new_game.new_task()
### MODALITY LOGIC ###
def register_user(uid):
#todo: validate user (how?)
#queue = queue
if uid not in queue:
queue.append(uid)
if len(queue) > 1 and uid not in games:
a = queue.pop(0)
b = queue.pop(0)
# randomly assign role
if random.random() > .5:
a, b = b, a
pattern_config = config.get("Task Parameters", "patterns").split(',')
pattern_map = {
"Demonstrate" : pattern.HtmlUnityDemonstrate,
"Reward" : pattern.HtmlUnityReward,
"Apprentice": pattern.HtmlUnityApprentice,
"Test": pattern.HtmlUnityTest
}
#todo: weight pattern selection sample by quanity of type in database, if needed
pattern_types = [pattern_map[name.strip()] for name in pattern_config]
n_teach = int(config.get("Task Parameters", "num_teaching_tasks"))
n_test = int(config.get("Task Parameters", "num_testing_tasks"))
new_game = random.choice(pattern_types)(sio=sio, teacher=a, student=b, num_teaching_tasks=n_teach, num_testing_tasks=n_test)
print("created new game of type " + str(new_game.__class__.__name__))
for user in [a, b]:
games[user] = new_game
arg = {"role" : games[user].role_string(user), "pattern" : new_game.__class__.__name__}
#sio.emit("sendTrainingMessage", "* You've been matched as "+ games[user].role_string(user) + ".", room=user)
sio.emit("instructions", arg, room=user)
#initial task
#new_game.new_task()
db_session.commit()
else:
sio.emit("sendTrainingMessage", "* Waiting for a partner.", room=uid)
#queue = queue
if __name__=="__main__":
# app = Flask(__name__)
# app.register_blueprint(custom_code)
# app.wsgi_app = socketio.Middleware(sio, app.wsgi_app)
# app.run(host='localhost', port=5000)
import os, sqlalchemy
if not os.path.exists("participants.db"):
init_db()
|
nilq/baby-python
|
python
|
import pandas as pd
import torch
class DataManager:
def __init__(self, data, labels, folds):
self.raw_data = data
self.data = self.chunks(data, folds)
self.labels = self.chunks(labels, folds)
self.folds = folds
self.index = 0
def chunks(self, seq, n):
avg = len(seq) / float(n)
out = []
last = 0.0
while last < len(seq):
out.append(seq[int(last):int(last + avg)])
last += avg
return out
def getNext(self):
data_copy = self.data.copy()
labels_copy = self.labels.copy()
data_test, labels_test = data_copy.pop(self.index), labels_copy.pop(self.index)
test = self.pre_process(data_test, labels_test)
temp_train = list()
temp_labels = list()
for l in data_copy:
temp_train += l
for s in labels_copy:
temp_labels += s
train = self.pre_process(temp_train, temp_labels)
self.index += 1
return train, test
def pre_process(self, data):
raise NotImplementedError
return None
|
nilq/baby-python
|
python
|
from datetime import datetime, timedelta
import requests
import collectd
class BorgBaseService:
def __init__(self):
self.endpoint = "https://api.borgbase.com/graphql"
self.api_key = None
self.next_request_time = None
self.cached_response = None
def dispatch(self, repo, value, data_type="bytes"):
cld_dispatch = collectd.Values(
plugin='borgbase',
type=data_type,
type_instance=repo
)
cld_dispatch.dispatch(values=[value])
collectd.debug('borgbase: Repo: ' + repo + ' Usage: ' + str(value))
def config(self, config):
api_key_set = False
for node in config.children:
key = node.key.lower()
val = node.values[0]
if key == 'apikey':
self.api_key = val
api_key_set = True
else:
collectd.info('borgbase: Unknown config key "%s"' % key)
if not api_key_set:
collectd.error('borgbase: API Key not set. Exiting')
raise ValueError
def read(self):
query = "query{repoList{id,name,currentUsage}}"
header = {"Authorization": "Bearer " + self.api_key}
collectd.debug('borgbase: Getting data from API')
if self.cached_response is None or self.next_request_time < datetime.now():
self.cached_response = requests.post(self.endpoint,
json={'query': query},
headers=header)
self.next_request_time = datetime.now() + timedelta(minutes=15)
collectd.debug('borgbase: Data requested. Next Request at: ' + self.next_request_time.strftime('%c'))
else:
collectd.debug('borgbase: Got Data from Cache.')
# Get JSON Object from request
r = self.cached_response.json()
total_usage = 0
for repo in r['data']['repoList']:
# Convert MB into bytes
usage = int(repo['currentUsage'] * 1000000)
# Calculate total Usage
total_usage += usage
# Dispatch Usage of the Repo
self.dispatch(repo=repo['name'], value=usage)
# Dispatch Total Usage of all Repos
self.dispatch(repo="total", value=total_usage)
bbs = BorgBaseService()
collectd.register_config(bbs.config)
collectd.register_read(bbs.read)
|
nilq/baby-python
|
python
|
import logging
import os
from telegram.ext import Updater
from db_wrapper import DBWrapper
from handlers.admins import AdminsHandler
from handlers.all import AllHandler
TOKEN = os.environ.get("TOKEN")
LOG_LEVEL = os.environ.get("LOG_LEVEL")
DB_FILE = os.environ.get("DB_FILE")
logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=LOG_LEVEL if LOG_LEVEL else logging.INFO)
dbw = DBWrapper(DB_FILE)
updater = Updater(TOKEN, use_context=True)
dispatcher = updater.dispatcher
COMMANDS = [AdminsHandler(dbw, updater), AllHandler(dbw, updater)]
for command in COMMANDS:
dispatcher.add_handler(command)
updater.start_polling()
|
nilq/baby-python
|
python
|
from flask_wtf import FlaskForm
from wtforms import StringField,TextAreaField,FileField,SubmitField
from wtforms.validators import Required
class CommentForm(FlaskForm):
title = StringField('Comment title',validators= [Required()])
comment = TextAreaField('Comment review')
submit = SubmitField('submit')
class BlogForm(FlaskForm):
title = StringField('Blog title',validators= [Required()])
message = TextAreaField('Blog Message',validators=[Required()])
submit = SubmitField('Submit')
class UpdateProfile(FlaskForm):
bio = TextAreaField('Tell us about yourself',validators=[Required()])
submit = SubmitField('submit')
|
nilq/baby-python
|
python
|
# Implement the Linear Reciprocal Maximization problem
import gurobipy as gp
import numpy as np
from gurobipy import *
id = 903515184
# Invoke Gurobi to solve the SOCP
def solve_socp(id, m=400, n=50):
gm = gp.Model("reciprocal")
A, b = get_data(id, m, n)
# print(A.shape, b.shape) # (400, 50) (400,)
x = gm.addVars(n, lb=-GRB.INFINITY, ub=GRB.INFINITY)
y = gm.addVars(m, lb=0, ub=GRB.INFINITY)
Ax = gm.addVars(m, lb=-GRB.INFINITY)
z1 = gm.addVars(m, lb=-GRB.INFINITY)
z2 = gm.addVars(m, lb=0)
gm.setObjective(sum([y[mi] for mi in range(m)]), GRB.MINIMIZE)
gm.addConstrs(Ax[mi] == sum([A[mi, ni] * x[ni] for ni in range(n)]) for mi in range(m))
gm.addConstrs((Ax[mi] - b[mi]) >= 0 for mi in range(m)) # Ax-b > 0
gm.addConstrs(z1[mi] == y[mi] - Ax[mi] + b[mi] for mi in range(m))
gm.addConstrs(z2[mi] == y[mi] + Ax[mi] - b[mi] for mi in range(m))
gm.addConstrs(4 + z1[mi]*z1[mi] <= z2[mi]*z2[mi] for mi in range(m))
# Solve the model
gm.update()
gm.optimize()
return(gm)
# Generate the data (DO NOT MODIFY)
def get_data(id, m, n):
np.random.seed(id)
bm = 1 + 9 * np.random.rand(m)
Am_base = 2 * (np.random.rand(m, n) - 0.5)
Am_row_norm = np.sum(np.sqrt(Am_base ** 2), 1)
scaling_factor = bm / Am_row_norm
Am = np.multiply(Am_base.transpose(), scaling_factor).transpose()
A = -Am
b = -bm
return(A, b)
solve_socp(id=id)
|
nilq/baby-python
|
python
|
from ..api_base import ApiBase
class CorporateCreditCardExpenses(ApiBase):
"""Class for BankTransactions APIs."""
GET_CORPORATE_CREDIT_CARD_EXPENSES = '/api/tpa/v1/corporate_credit_card_expenses'
GET_CORPORATE_CREDIT_CARD_EXPENSES_COUNT = '/api/tpa/v1/corporate_credit_card_expenses/count'
def get(self, limit=None, offset=None, updated_at=None, spent_at=None, exported=None, personal=None, state=None,
transaction_type=None, settlement_id=None, reimbursement_state=None):
"""Get a list of all Corporate Credit Card Expenses.
Parameters:
offset (int): A cursor for use in pagination, offset is an object ID that defines your place in the list.
(optional)
limit (int): A limit on the number of objects to be returned, between 1 and 1000. (optional)
updated_at (str): Date string in yyyy-MM-ddTHH:mm:ss.SSSZ format along with operator in RHS colon pattern.
(optional)
spent_at(str): Date string in yyyy-MM-ddTHH:mm:ss.SSSZ format along with operator in RHS colon pattern.
(optional)
state(str): A parameter to filter expenses by the state that they're in. (optional)
reimbursement_state(str): A parameter to filter expenses by the state of reimbursement that they're in.
(optional)
personal(bool): A parameter to filter personal or company. (optional)
transaction_type(str): A parameter to filter expenses by transaction type DEBIT/CREDIT. (optional)
settlement_id(str): List of settlement ids.
exported (bool): If set to true, all expenses that are exported alone will be returned. (optional)
Returns:
List with dicts in Corporate Credit Card Expenses schema.
"""
return self._get_request({
'limit': limit,
'offset': offset,
'updated_at': updated_at,
'spent_at': spent_at,
'exported': exported,
'personal': personal,
'state': state,
'transaction_type': transaction_type,
'settlement_id': settlement_id,
'reimbursement_state': reimbursement_state
}, CorporateCreditCardExpenses.GET_CORPORATE_CREDIT_CARD_EXPENSES)
def count(self, updated_at=None, spent_at=None, exported=None, personal=None, state=None, transaction_type=None,
settlement_id=None, reimbursement_state=None):
"""Get a count of all Corporate Credit Card Expenses.
Parameters:
updated_at (str): Date string in yyyy-MM-ddTHH:mm:ss.SSSZ format along with operator in RHS colon pattern.
(optional)
spent_at(str): Date string in yyyy-MM-ddTHH:mm:ss.SSSZ format along with operator in RHS colon pattern.
(optional)
state(str): A parameter to filter expenses by the state that they're in. (optional)
reimbursement_state(str): A parameter to filter expenses by the state of reimbursement that they're in.
(optional)
personal(bool): A parameter to filter personal or company. (optional)
transaction_type(str): A parameter to filter expenses by transaction type DEBIT/CREDIT. (optional)
settlement_id(str): List of settlement ids.
exported (bool): If set to true, all expenses that are exported alone will be returned. (optional)
Returns:
Integer with count.
"""
return self._get_request({
'updated_at': updated_at,
'spent_at': spent_at,
'exported': exported,
'personal': personal,
'state': state,
'transaction_type': transaction_type,
'settlement_id': settlement_id,
'reimbursement_state': reimbursement_state
}, CorporateCreditCardExpenses.GET_CORPORATE_CREDIT_CARD_EXPENSES_COUNT)
def get_all(self, updated_at=None, spent_at=None, exported=None, personal=None, state=None, transaction_type=None,
settlement_id=None, reimbursement_state=None):
"""
Get all the corporate credit card expenses based on paginated call
Parameters:
updated_at (str): Date string in yyyy-MM-ddTHH:mm:ss.SSSZ format along with operator in RHS colon pattern.
(optional)
spent_at(str): Date string in yyyy-MM-ddTHH:mm:ss.SSSZ format along with operator in RHS colon pattern.
(optional)
state(str): A parameter to filter expenses by the state that they're in. (optional)
reimbursement_state(str): A parameter to filter expenses by the state of reimbursement that they're in.
(optional)
personal(bool): A parameter to filter personal or company. (optional)
transaction_type(str): A parameter to filter expenses by transaction type DEBIT/CREDIT. (optional)
settlement_id(str): List of settlement ids.
exported (bool): If set to true, all expenses that are exported alone will be returned. (optional)
Returns:
List with dicts in Corporate Credit Card Expenses schema.
"""
ccc_expenses = []
if settlement_id and len(settlement_id) > 40:
pages = range(0, len(settlement_id), 40)
chunks = []
for i in range(0, len(pages)-1):
chunks.append(settlement_id[pages[i]:pages[i+1]])
chunks.append(settlement_id[pages[len(pages)-1]:])
for chunk in chunks:
count = self.count(settlement_id=chunk, updated_at=updated_at, spent_at=spent_at,
exported=exported, personal=personal, transaction_type=transaction_type,
state=state, reimbursement_state=reimbursement_state)['count']
page_size = 200
for i in range(0, count, page_size):
segment = self.get(
offset=i, limit=page_size, settlement_id=chunk, updated_at=updated_at, spent_at=spent_at,
exported=exported, personal=personal, transaction_type=transaction_type, state=state,
reimbursement_state=reimbursement_state
)
ccc_expenses = ccc_expenses + segment['data']
return ccc_expenses
count = self.count(settlement_id=settlement_id, updated_at=updated_at, spent_at=spent_at,
exported=exported, personal=personal, transaction_type=transaction_type,
state=state, reimbursement_state=reimbursement_state)['count']
page_size = 200
for i in range(0, count, page_size):
segment = self.get(
offset=i, limit=page_size, settlement_id=settlement_id, updated_at=updated_at, spent_at=spent_at,
exported=exported, personal=personal, transaction_type=transaction_type, state=state,
reimbursement_state=reimbursement_state
)
ccc_expenses = ccc_expenses + segment['data']
return ccc_expenses
|
nilq/baby-python
|
python
|
import prata
import time
import timeit
import numpy as np
import sys
import random
import string
B = 1
KB = 1000
MB = 1000000
END = []
def getString(s):
#''.join(random.choice(string.ascii_letters) for x in range(int(real)))
real = 1 if (s-49) < 1 else s-49
return "1"*real
TIMES = 5
SLEEP = 2
NUMBER = 1
def printStats(stats, title, size, u = True):
f = open("pythonThrouput.txt","a")
stats = [round((x)/NUMBER,5) for x in stats]
kilo = size#/1000
bytes = "B"
if u:
if kilo > 1000:
kilo /= 1000
bytes = "KB"
if kilo > 1000:
kilo /= 1000
bytes = "MB"
mbs = [round(kilo/(i),5) for i in stats]
f.write(title + '\n')
f.write("###################\n")
f.write("Min: {}s\n".format(stats[0]))
f.write("Min {}/s: {}\n".format(bytes,mbs[0]))
f.write("Median: {}s\n".format(stats[1]))
f.write("Median {}/s: {}\n".format(bytes,mbs[1]))
f.write("Max: {}s\n".format(stats[2]))
f.write("Max {}/s: {}\n".format(bytes,mbs[2]))
f.write("Average: {}s\n".format(stats[3]))
f.write("Average {}/s: {}\n".format(bytes,mbs[3]))
f.write("###################\n\n")
else:
END.append([kilo,stats[3]])
f.close()
def getStats(times):
return [np.min(times), np.median(times), np.max(times), np.average(times)]
f = open("pythonThrouput.txt","w")
f.close()
m = prata.connect("127.0.0.1",25565)
m.host()
m.createChannel(25566, "test", "FIFO", 500)
SIZE = (1*B)
testListen='''
p.publish("test",STRING)
t = s.listen("test")
'''
obj = getString(SIZE)
setupTestListen = """
STRING = \""""+obj+"""\"
import prata
m = prata.connect(\"127.0.0.1\",25565)
s = m.subscriber()
p = m.publisher()
s.connect(\"test\")
p.connect(\"test\")
"""
printStats(getStats(timeit.Timer(stmt=testListen,setup=setupTestListen).repeat(number=NUMBER,repeat=TIMES)),"Round Trip 50 bytes", sys.getsizeof(obj))
SIZE = (1*KB)
testListen='''
p.publish("test",STRING)
t = s.listen("test")
'''
obj = getString(SIZE)
setupTestListen = """
STRING = \""""+obj+"""\"
import prata
m = prata.connect(\"127.0.0.1\",25565)
s = m.subscriber()
p = m.publisher()
s.connect(\"test\")
p.connect(\"test\")
"""
printStats(getStats(timeit.Timer(stmt=testListen,setup=setupTestListen).repeat(number=NUMBER,repeat=TIMES)),"Round Trip 1 KiloByte", sys.getsizeof(obj))
SIZE = (1*MB)
testListen='''
p.publish("test",STRING)
t = s.listen("test")
'''
obj = getString(SIZE)
setupTestListen = """
STRING = \""""+obj+"""\"
import prata
m = prata.connect(\"127.0.0.1\",25565)
s = m.subscriber()
p = m.publisher()
s.connect(\"test\")
p.connect(\"test\")
"""
printStats(getStats(timeit.Timer(stmt=testListen,setup=setupTestListen).repeat(number=NUMBER,repeat=TIMES)),"Round Trip 1 MegaByte", sys.getsizeof(obj))
SIZE = (35*MB)
testListen='''
p.publish("test",STRING)
t = s.listen("test")
'''
obj = getString(SIZE)
setupTestListen = """
STRING = \""""+obj+"""\"
import prata
m = prata.connect(\"127.0.0.1\",25565)
s = m.subscriber()
p = m.publisher()
s.connect(\"test\")
p.connect(\"test\")
"""
printStats(getStats(timeit.Timer(stmt=testListen,setup=setupTestListen).repeat(number=NUMBER,repeat=TIMES)),"Round Trip 35 MegaBytes", sys.getsizeof(obj))
def largegroup():
for i in range(1,10001):
SIZE = i*100
testListen='''
p.publish("test",STRING)
t = s.listen("test")
'''
obj = getString(SIZE)
setupTestListen = """
STRING = \""""+obj+"""\"
import prata
m = prata.connect(\"127.0.0.1\",25565)
s = m.subscriber()
p = m.publisher()
s.connect(\"test\")
p.connect(\"test\")
"""
printStats(getStats(timeit.Timer(stmt=testListen,setup=setupTestListen).repeat(number=1,repeat=2)),"Round Trip {} Bytes".format(SIZE), sys.getsizeof(obj),False)
time.sleep(.1)
def manyGroup():
for i in range(1,1001):
R = random.randint(1,10)
SIZE = i*100
testListen='''
for i in range('''+str(R)+'''):
p.publish("test",STRING)
for i in range('''+str(R)+'''):
t = s.listen("test")
'''
obj = getString(SIZE)
setupTestListen = """
STRING = \""""+obj+"""\"
import prata
m = prata.connect(\"127.0.0.1\",25565)
s = m.subscriber()
p = m.publisher()
s.connect(\"test\")
p.connect(\"test\")
"""
printStats(getStats(timeit.Timer(stmt=testListen,setup=setupTestListen).repeat(number=1,repeat=2)),"".format(SIZE), sys.getsizeof(obj),False)
END[-1].append(R)
time.sleep(.1)
manyGroup()
f = open("many.csv","w")
f.write("Bytes,Time(s),Iterations,Total Throughput, Singular Throughput\n")
for e in END:
f.write(str(e[0]))
f.write(", ")
f.write(str(e[1]))
f.write(", ")
f.write(str(e[2]))
f.write(", ")
f.write(str(e[0]/e[1]))
f.write(", ")
f.write(str((e[0]/e[1])*e[2]))
f.write("\n")
f.close()
m.terminate()
|
nilq/baby-python
|
python
|
# -*- coding: utf-8 -*-
"""
This file is used for indexing FedWeb2013.
@author: Shuo Zhang
"""
import os
import tarfile
from bs4 import BeautifulSoup
from Elastic import Elastic
def fedweb13_index(index_name,output_file):
elastic = Elastic(index_name)
mappings = {
# "id": Elastic.notanalyzed_field(),
"title": Elastic.analyzed_field(),
"content": Elastic.analyzed_field()
}
elastic.create_index(mappings=mappings, force=True)
maindir = "/data/collections/fedwebgh/search_data/fedweb13/FW13-sample-search"
num_doc = 0
f_feb = open(output_file,"w")
for d in os.listdir(maindir):
if d.startswith("md"):#ignore md5.txt
continue
inpath = os.path.join(maindir, d)
tar = tarfile.open(inpath,"r")
tar.extractall()
docs = {}
for member_info in tar.getmembers():
if len(member_info.name)>23:#get file instead of folder
f = open(member_info.name)
soup = BeautifulSoup(f,"lxml")
for snippets in soup.find_all("snippet"):
doc_dict = {}
doc_id = snippets.get("id").lower()
f_feb.write(doc_id+" "+"FW13-"+doc_id[5:9]+"\n")# write output file
try:
title = snippets.title.text
except:
title = ""
try:
content = snippets.description.text
except:
content = snippets
doc_dict["title"] = title
doc_dict["content"] = content
docs[doc_id] = doc_dict
num_doc += 1
"continous update docs and add into index"
elastic.add_docs_bulk(docs)
print ("finish parse and index for file: ",inpath)
print(num_doc," indexed")
if __name__ == "__main__":
index_name = "fedweb13"
fedweb13_index(index_name,"assoc_fed13.txt")
|
nilq/baby-python
|
python
|
import ast
import re
import shutil
import sys
import urllib.parse
import urllib.request
from pathlib import Path
def download_build(branch_url: str, build: str, reg_exr: re, directory: Path):
build_url = branch_url + build + "/"
build_api_url = build_url + "api/python"
artifacts = ast.literal_eval(urllib.request.urlopen(build_api_url).read().decode("utf-8"))["artifacts"]
artifacts = filter(lambda it: reg_exr.match(it["fileName"]), artifacts)
if not artifacts:
print("No artifact matched in build " + build)
return
print("Task for build %s start" % build)
directory.mkdir(parents=True, exist_ok=True)
try:
for artifact in artifacts:
artifact_url = build_url + "artifact/" + artifact["relativePath"]
file_name = artifact["fileName"]
file_path = directory / file_name
print("Downloading " + artifact_url)
urllib.request.urlretrieve(artifact_url, str(file_path))
except BaseException:
shutil.rmtree(directory)
raise
print("Finish task for build " + build)
def main():
if len(sys.argv) != 4:
sys.exit("Usage:\npython downloader.py {branchUrl} {matchExr} {outputDir}")
# parse args
input_branch_url, input_match_exr, output_dir = sys.argv[1:]
# parse url
parsed_input_branch_url = urllib.parse.urlparse(input_branch_url)
if not parsed_input_branch_url.scheme or not parsed_input_branch_url.netloc or not parsed_input_branch_url.path:
raise Exception("Invalid url")
if not parsed_input_branch_url.path.endswith("/"):
# noinspection PyProtectedMember
parsed_input_branch_url = parsed_input_branch_url._replace(path=parsed_input_branch_url.path + "/")
branch_url = urllib.parse.urlunparse(parsed_input_branch_url)
# parse regExr
reg_exr = re.compile(input_match_exr)
# ensure outputDir exists
output_path = Path(output_dir)
output_path.mkdir(parents=True, exist_ok=True)
# fetch builds list
branch_api_url = branch_url + "api/python"
builds = ast.literal_eval(urllib.request.urlopen(branch_api_url).read().decode("utf-8"))["builds"]
builds = map(lambda it: str(it["number"]), builds)
non_exist_builds = filter(lambda it: not (output_path / it).exists(), builds)
non_exist_builds = list(non_exist_builds) # for multi times iterate
if not non_exist_builds:
sys.exit("Everything up-to-date")
print("Missing builds: " + ", ".join(str(it) for it in non_exist_builds))
# download builds
for build in non_exist_builds:
download_build(branch_url, build, reg_exr, output_path / build)
if __name__ == '__main__':
main()
|
nilq/baby-python
|
python
|
from tests.test_helper import *
from braintree.test.credit_card_numbers import CreditCardNumbers
from datetime import datetime
from datetime import date
from braintree.authorization_adjustment import AuthorizationAdjustment
from unittest.mock import MagicMock
class TestTransaction(unittest.TestCase):
@raises_with_regexp(KeyError, "'Invalid keys: bad_key'")
def test_clone_transaction_raises_exception_with_bad_keys(self):
Transaction.clone_transaction("an id", {"bad_key": "value"})
@raises_with_regexp(KeyError, "'Invalid keys: bad_key'")
def test_sale_raises_exception_with_bad_keys(self):
Transaction.sale({"bad_key": "value"})
@raises_with_regexp(KeyError, "'Invalid keys: credit_card\[bad_key\]'")
def test_sale_raises_exception_with_nested_bad_keys(self):
Transaction.sale({"credit_card": {"bad_key": "value"}})
@raises(NotFoundError)
def test_finding_empty_id_raises_not_found_exception(self):
Transaction.find(" ")
@raises(NotFoundError)
def test_finding_none_raises_not_found_exception(self):
Transaction.find(None)
def test_constructor_includes_disbursement_information(self):
attributes = {
'amount': '27.00',
'tax_amount': '1.00',
'customer_id': '4096',
'merchant_account_id': '8192',
'order_id': '106601',
'channel': '101',
'payment_method_token': 'sometoken',
'purchase_order_number': '20202',
'recurring': 'False',
'disbursement_details': {
'settlement_amount': '27.00',
'settlement_currency_iso_code': 'USD',
'settlement_currency_exchange_rate': '1',
'disbursement_date': date(2013, 4, 10),
'funds_held': False
}
}
transaction = Transaction(None, attributes)
self.assertEqual(transaction.disbursement_details.settlement_amount, Decimal('27.00'))
self.assertEqual(transaction.disbursement_details.settlement_currency_iso_code, 'USD')
self.assertEqual(transaction.disbursement_details.settlement_currency_exchange_rate, Decimal('1'))
self.assertEqual(transaction.disbursement_details.disbursement_date, date(2013, 4, 10))
self.assertEqual(transaction.disbursement_details.funds_held, False)
self.assertEqual(transaction.is_disbursed, True)
def test_transaction_handles_nil_risk_data(self):
attributes = {
'amount': '27.00',
'tax_amount': '1.00',
'customer_id': '4096',
'merchant_account_id': '8192',
'order_id': '106601',
'channel': '101',
'payment_method_token': 'sometoken',
'purchase_order_number': '20202',
'recurring': 'False',
}
transaction = Transaction(None, attributes)
self.assertEqual(transaction.risk_data, None)
def test_is_disbursed_false(self):
attributes = {
'amount': '27.00',
'tax_amount': '1.00',
'customer_id': '4096',
'merchant_account_id': '8192',
'order_id': '106601',
'channel': '101',
'payment_method_token': 'sometoken',
'purchase_order_number': '20202',
'recurring': 'False',
'disbursement_details': {
'settlement_amount': None,
'settlement_currency_iso_code': None,
'settlement_currency_exchange_rate': None,
'disbursement_date': None,
'funds_held': None,
}
}
transaction = Transaction(None, attributes)
self.assertEqual(transaction.is_disbursed, False)
def test_sale_with_skip_advanced_fraud_checking_value_as_true(self):
attributes = {
"amount": TransactionAmounts.Authorize,
"credit_card": {
"number": CreditCardNumbers.Visa,
"expiration_date": "05/2009"
},
"options": {
"skip_advanced_fraud_checking": True
}
}
transaction_gateway = self.setup_transaction_gateway_and_mock_post()
transaction_gateway.sale(attributes)
transaction_param = transaction_gateway._post.call_args[0][1]
self.assertTrue(transaction_param['transaction']['options']['skip_advanced_fraud_checking'])
def test_sale_with_skip_advanced_fraud_checking_value_as_false(self):
attributes = {
"amount": TransactionAmounts.Authorize,
"credit_card": {
"number": CreditCardNumbers.Visa,
"expiration_date": "05/2009"
},
"options": {
"skip_advanced_fraud_checking": False
}
}
transaction_gateway = self.setup_transaction_gateway_and_mock_post()
transaction_gateway.sale(attributes)
transaction_param = transaction_gateway._post.call_args[0][1]
self.assertFalse(transaction_param['transaction']['options']['skip_advanced_fraud_checking'])
def test_sale_without_skip_advanced_fraud_checking_value_option(self):
attributes = {
"amount": TransactionAmounts.Authorize,
"credit_card": {
"number": CreditCardNumbers.Visa,
"expiration_date": "05/2009"
},
"options": {
"submit_for_settlement": True
}
}
transaction_gateway = self.setup_transaction_gateway_and_mock_post()
transaction_gateway.sale(attributes)
transaction_param = transaction_gateway._post.call_args[0][1]
self.assertTrue('skip_advanced_fraud_checking' not in transaction_param['transaction']['options'])
def setup_transaction_gateway_and_mock_post(self):
transaction_gateway = TransactionGateway(BraintreeGateway(None))
transaction_gateway._post = MagicMock(name='config.http.post')
return transaction_gateway
def test_constructor_doesnt_includes_auth_adjustments(self):
attributes = {
'amount': '27.00',
'customer_id': '4096',
'merchant_account_id': '8192',
'payment_method_token': 'sometoken',
'purchase_order_number': '20202',
'recurring': 'False',
'tax_amount': '1.00',
}
transaction = Transaction(None, attributes)
self.assertFalse(hasattr(transaction, 'authorization_adjustments'))
def test_constructor_includes_auth_adjustments(self):
attributes = {
'amount': '27.00',
'customer_id': '4096',
'merchant_account_id': '8192',
'payment_method_token': 'sometoken',
'purchase_order_number': '20202',
'recurring': 'False',
'tax_amount': '1.00',
'authorization_adjustments': [{
"amount": "20.00",
"timestamp": datetime(2017, 7, 12, 1, 2, 3),
"success": True,
"processor_response_code": "1000",
"processor_response_text": "Approved",
}],
}
transaction = Transaction(None, attributes)
transaction_adjustment = transaction.authorization_adjustments[0]
self.assertEqual(transaction_adjustment.amount, Decimal("20.00"))
self.assertEqual(transaction_adjustment.timestamp, datetime(2017, 7, 12, 1, 2, 3))
self.assertEqual(transaction_adjustment.success, True)
self.assertEqual(transaction_adjustment.processor_response_code, "1000")
self.assertEqual(transaction_adjustment.processor_response_text, "Approved")
def test_constructor_includes_network_transaction_id_and_response_code_and_response_text(self):
attributes = {
'amount': '27.00',
'tax_amount': '1.00',
'network_transaction_id': '123456789012345',
'network_response_code': '00',
'network_response_text': 'Successful approval/completion or V.I.P. PIN verification is successful'
}
transaction = Transaction(None, attributes)
self.assertEqual(transaction.network_transaction_id, "123456789012345")
self.assertEqual(transaction.network_response_code, "00")
self.assertEqual(transaction.network_response_text, "Successful approval/completion or V.I.P. PIN verification is successful")
def test_constructor_includes_installment_count(self):
attributes = {
'amount': '27.00',
'tax_amount': '1.00',
'installments': {
'count': 4
}
}
transaction = Transaction(None, attributes)
self.assertEqual(transaction.installments["count"], 4)
|
nilq/baby-python
|
python
|
from django.contrib import admin
from django.contrib.auth.admin import UserAdmin
from .models import Promise
from .models import Family
from .models import User
admin.site.register(Promise)
admin.site.register(Family)
admin.site.register(User, UserAdmin)
|
nilq/baby-python
|
python
|
"""
Pylot
model.py
You may place your models here.
"""
from active_sqlalchemy import SQLAlchemy
import pylot.component.model
from . import get_config
config = get_config()
db = SQLAlchemy(config.DATABASE_URI)
# User Struct.
UserStruct = pylot.component.model.user_struct(db)
# Post Struct
PostStruct = pylot.component.model.post_struct(db, UserStruct)
# A simple Note table
class MyNote(db.Model):
user_id = db.Column(db.Integer, db.ForeignKey(UserStruct.User.id))
title = db.Column(db.String(250))
content = db.Column(db.Text)
user = db.relationship(UserStruct.User, backref="notes")
|
nilq/baby-python
|
python
|
from typing import List, Tuple
import logging
from .track import Track
from vcap import DetectionNode
from vcap_utils import iou_cost_matrix, linear_assignment
MATCH_FUNC_OUTPUT = Tuple[
List[Tuple[DetectionNode, Track]],
List[Track],
List[DetectionNode]]
class Tracker:
def __init__(self, min_iou, max_misses, n_hits_to_init):
self.tracks: List[Track] = []
self.min_iou_for_iou_match = min_iou
"""Minimum IOU in order for an 'iou only' match to occur"""
self.max_misses = max_misses
"""How many frames in a row a detection can go before being
deleted"""
self.n_hits_to_init = n_hits_to_init
def predict(self):
"""Propogate track state distributions 1 time step forward."""
def update(self, detections: List[DetectionNode]):
matches, unmatched_tracks, unmatched_dets = self._match(
new_dets=detections,
tracks=self.tracks)
for det, track in matches:
track.update(det)
for track in unmatched_tracks:
track.mark_missed()
for det in unmatched_dets:
self.start_track(det)
# Clean out dead tracks
self.tracks = [t for t in self.tracks if not t.is_deleted]
def start_track(self, det: DetectionNode):
track = Track(det, self.max_misses, self.n_hits_to_init)
self.tracks.append(track)
return track
def _match(self, new_dets: List[DetectionNode], tracks: List[Track]) \
-> MATCH_FUNC_OUTPUT:
matches: List[Tuple[DetectionNode, Track]] = []
confirmed_tracks = [t for t in tracks if t.is_confirmed]
unconfirmed_tracks = [t for t in tracks if not t.is_confirmed]
# Try to match dets with confirmed tracks
matched_c, unmatched_c_tracks, unmatched_c_dets = \
self._try_iou_matching(new_dets, confirmed_tracks)
# Try to match dets with unconfirmed tracks
matched_u, unmatched_u_tracks, unmatched_u_dets = \
self._try_iou_matching(unmatched_c_dets, unconfirmed_tracks)
return (matched_c + matched_u,
unmatched_u_tracks + unmatched_c_tracks,
unmatched_u_dets)
def _try_iou_matching(self, dets: List[DetectionNode],
tracks: List[Track]) -> MATCH_FUNC_OUTPUT:
# Match confirmed tracks with detections where possible, IOU based
tracks_latest_dets = [t.latest_det for t in tracks]
if len(tracks_latest_dets) == 0:
return [], tracks, dets
iou_cost = iou_cost_matrix(dets, tracks_latest_dets)
iou_cost[iou_cost > (1 - self.min_iou_for_iou_match)] = 1
indices = linear_assignment(iou_cost)
matches: List[Tuple[DetectionNode, Track]] = []
unmatched_tracks = tracks.copy()
unmatched_dets = dets.copy()
for det_index, conf_track_index in indices:
det = dets[det_index]
track = tracks[conf_track_index]
cost_iou = iou_cost[det_index][conf_track_index]
if cost_iou == 1:
continue
matches.append((det, track))
unmatched_tracks.remove(track)
unmatched_dets.remove(det)
return matches, unmatched_tracks, unmatched_dets
|
nilq/baby-python
|
python
|
def reverseArray(arr, start, end):
while start < end:
if arr[start] != arr[end]:
arr[start], arr[end] = arr[end], arr[start]
start += 1
end -= 1
return arr
def reverseArrayInRecursive(arr, start, end):
if start >= end:
return arr
arr[start], arr[end] = arr[end], arr[start]
return reverseArrayInRecursive(arr, start + 1, end - 1)
print(reverseArrayInRecursive([1, 2, 3, 4, 5], 0, 4))
|
nilq/baby-python
|
python
|
# Copyright 1999-2020 Alibaba Group Holding Ltd.
#
# 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 numpy as np
from sklearn.base import TransformerMixin
from sklearn.utils.validation import check_is_fitted, FLOAT_DTYPES
from ... import tensor as mt
from ...tensor.core import TENSOR_TYPE
from ..base import BaseEstimator
from ..utils.validation import check_array
def _handle_zeros_in_scale(scale, copy=True):
"""Makes sure that whenever scale is zero, we handle it correctly.
This happens in most scalers when we have constant features.
"""
# if we are fitting on 1D arrays, scale might be a scalar
if np.isscalar(scale): # pragma: no cover
if scale == .0:
scale = 1.
return scale
elif hasattr(scale, 'ndim') and scale.ndim == 0: # pragma: no cover
# scalar that is tensor
return mt.where(scale == .0, 1., scale)
elif isinstance(scale, (np.ndarray, TENSOR_TYPE)):
if copy:
# New array to avoid side-effects
scale = scale.copy()
scale[scale == 0.0] = 1.0
return scale
class MinMaxScaler(TransformerMixin, BaseEstimator):
"""Transform features by scaling each feature to a given range.
This estimator scales and translates each feature individually such
that it is in the given range on the training set, e.g. between
zero and one.
The transformation is given by::
X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))
X_scaled = X_std * (max - min) + min
where min, max = feature_range.
This transformation is often used as an alternative to zero mean,
unit variance scaling.
Read more in the :ref:`User Guide <preprocessing_scaler>`.
Parameters
----------
feature_range : tuple (min, max), default=(0, 1)
Desired range of transformed data.
copy : bool, default=True
Set to False to perform inplace row normalization and avoid a
copy (if the input is already a numpy array).
clip: bool, default=False
Set to True to clip transformed values of held-out data to
provided `feature range`.
Attributes
----------
min_ : Tensor of shape (n_features,)
Per feature adjustment for minimum. Equivalent to
``min - X.min(axis=0) * self.scale_``
scale_ : Tensor of shape (n_features,)
Per feature relative scaling of the data. Equivalent to
``(max - min) / (X.max(axis=0) - X.min(axis=0))``
data_min_ : ndarray of shape (n_features,)
Per feature minimum seen in the data
data_max_ : ndarray of shape (n_features,)
Per feature maximum seen in the data
data_range_ : ndarray of shape (n_features,)
Per feature range ``(data_max_ - data_min_)`` seen in the data
n_samples_seen_ : int
The number of samples processed by the estimator.
It will be reset on new calls to fit, but increments across
``partial_fit`` calls.
Examples
--------
>>> from mars.learn.preprocessing import MinMaxScaler
>>> data = [[-1, 2], [-0.5, 6], [0, 10], [1, 18]]
>>> scaler = MinMaxScaler()
>>> print(scaler.fit(data))
MinMaxScaler()
>>> print(scaler.data_max_)
[ 1. 18.]
>>> print(scaler.transform(data))
[[0. 0. ]
[0.25 0.25]
[0.5 0.5 ]
[1. 1. ]]
>>> print(scaler.transform([[2, 2]]))
[[1.5 0. ]]
See Also
--------
minmax_scale : Equivalent function without the estimator API.
Notes
-----
NaNs are treated as missing values: disregarded in fit, and maintained in
transform.
For a comparison of the different scalers, transformers, and normalizers,
see :ref:`examples/preprocessing/plot_all_scaling.py
<sphx_glr_auto_examples_preprocessing_plot_all_scaling.py>`.
"""
def __init__(self, feature_range=(0, 1), copy=True, clip=False):
self.feature_range = feature_range
self.copy = copy
self.clip = clip
def _reset(self): # pragma: no cover
"""Reset internal data-dependent state of the scaler, if necessary.
__init__ parameters are not touched.
"""
# Checking one attribute is enough, becase they are all set together
# in partial_fit
if hasattr(self, 'scale_'):
del self.scale_
del self.min_
del self.n_samples_seen_
del self.data_min_
del self.data_max_
del self.data_range_
def fit(self, X, y=None, session=None, run_kwargs=None):
"""Compute the minimum and maximum to be used for later scaling.
Parameters
----------
X : array-like of shape (n_samples, n_features)
The data used to compute the per-feature minimum and maximum
used for later scaling along the features axis.
y : None
Ignored.
Returns
-------
self : object
Fitted scaler.
"""
# Reset internal state before fitting
self._reset()
return self.partial_fit(X, y, session=session, run_kwargs=run_kwargs)
def partial_fit(self, X, y=None, session=None, run_kwargs=None):
"""Online computation of min and max on X for later scaling.
All of X is processed as a single batch. This is intended for cases
when :meth:`fit` is not feasible due to very large number of
`n_samples` or because X is read from a continuous stream.
Parameters
----------
X : array-like of shape (n_samples, n_features)
The data used to compute the mean and standard deviation
used for later scaling along the features axis.
y : None
Ignored.
Returns
-------
self : object
Fitted scaler.
"""
feature_range = self.feature_range
if feature_range[0] >= feature_range[1]:
raise ValueError("Minimum of desired feature range must be smaller"
" than maximum. Got %s." % str(feature_range))
if mt.tensor(X).issparse(): # pragma: no cover
raise TypeError("MinMaxScaler does not support sparse input. "
"Consider using MaxAbsScaler instead.")
first_pass = not hasattr(self, 'n_samples_seen_')
X = self._validate_data(X, reset=first_pass,
estimator=self, dtype=FLOAT_DTYPES,
force_all_finite="allow-nan")
if np.isnan(X.shape[0]): # pragma: no cover
X.execute(session=session, **(run_kwargs or dict()))
data_min = mt.nanmin(X, axis=0)
data_max = mt.nanmax(X, axis=0)
if first_pass:
self.n_samples_seen_ = X.shape[0]
else:
data_min = mt.minimum(self.data_min_, data_min) # pylint: disable=access-member-before-definition
data_max = mt.maximum(self.data_max_, data_max) # pylint: disable=access-member-before-definition
self.n_samples_seen_ += X.shape[0]
data_range = data_max - data_min
self.scale_ = ((feature_range[1] - feature_range[0]) /
_handle_zeros_in_scale(data_range))
self.min_ = feature_range[0] - data_min * self.scale_
self.data_min_ = data_min
self.data_max_ = data_max
self.data_range_ = data_range
mt.ExecutableTuple([self.scale_, self.min_, self.data_min_,
self.data_max_, self.data_range_]).execute(
session=session, **(run_kwargs or dict()))
return self
def transform(self, X, session=None, run_kwargs=None):
"""Scale features of X according to feature_range.
Parameters
----------
X : array-like of shape (n_samples, n_features)
Input data that will be transformed.
Returns
-------
Xt : ndarray of shape (n_samples, n_features)
Transformed data.
"""
check_is_fitted(self)
X = self._validate_data(X, copy=self.copy, dtype=FLOAT_DTYPES,
force_all_finite="allow-nan", reset=False)
X *= self.scale_
X += self.min_
if self.clip:
X = mt.clip(X, self.feature_range[0], self.feature_range[1])
return X.execute(session=session, **(run_kwargs or dict()))
def inverse_transform(self, X, session=None, run_kwargs=None):
"""Undo the scaling of X according to feature_range.
Parameters
----------
X : array-like of shape (n_samples, n_features)
Input data that will be transformed. It cannot be sparse.
Returns
-------
Xt : ndarray of shape (n_samples, n_features)
Transformed data.
"""
check_is_fitted(self)
X = check_array(X, copy=self.copy, dtype=FLOAT_DTYPES,
force_all_finite="allow-nan")
X -= self.min_
X /= self.scale_
return X.execute(session=session, **(run_kwargs or dict()))
def _more_tags(self): # pylint: disable=no-self-use
return {'allow_nan': True}
def minmax_scale(X, feature_range=(0, 1), *, axis=0, copy=True,
session=None, run_kwargs=None):
"""Transform features by scaling each feature to a given range.
This estimator scales and translates each feature individually such
that it is in the given range on the training set, i.e. between
zero and one.
The transformation is given by (when ``axis=0``)::
X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))
X_scaled = X_std * (max - min) + min
where min, max = feature_range.
The transformation is calculated as (when ``axis=0``)::
X_scaled = scale * X + min - X.min(axis=0) * scale
where scale = (max - min) / (X.max(axis=0) - X.min(axis=0))
This transformation is often used as an alternative to zero mean,
unit variance scaling.
Read more in the :ref:`User Guide <preprocessing_scaler>`.
.. versionadded:: 0.17
*minmax_scale* function interface
to :class:`~sklearn.preprocessing.MinMaxScaler`.
Parameters
----------
X : array-like of shape (n_samples, n_features)
The data.
feature_range : tuple (min, max), default=(0, 1)
Desired range of transformed data.
axis : int, default=0
Axis used to scale along. If 0, independently scale each feature,
otherwise (if 1) scale each sample.
copy : bool, default=True
Set to False to perform inplace scaling and avoid a copy (if the input
is already a numpy array).
Returns
-------
X_tr : ndarray of shape (n_samples, n_features)
The transformed data.
.. warning:: Risk of data leak
Do not use :func:`~sklearn.preprocessing.minmax_scale` unless you know
what you are doing. A common mistake is to apply it to the entire data
*before* splitting into training and test sets. This will bias the
model evaluation because information would have leaked from the test
set to the training set.
In general, we recommend using
:class:`~sklearn.preprocessing.MinMaxScaler` within a
:ref:`Pipeline <pipeline>` in order to prevent most risks of data
leaking: `pipe = make_pipeline(MinMaxScaler(), LogisticRegression())`.
See Also
--------
MinMaxScaler : Performs scaling to a given range using the Transformer
API (e.g. as part of a preprocessing
:class:`~sklearn.pipeline.Pipeline`).
Notes
-----
For a comparison of the different scalers, transformers, and normalizers,
see :ref:`examples/preprocessing/plot_all_scaling.py
<sphx_glr_auto_examples_preprocessing_plot_all_scaling.py>`.
""" # noqa
# Unlike the scaler object, this function allows 1d input.
# If copy is required, it will be done inside the scaler object.
X = check_array(X, copy=False, ensure_2d=False,
dtype=FLOAT_DTYPES, force_all_finite='allow-nan')
original_ndim = X.ndim
if original_ndim == 1:
X = X.reshape(X.shape[0], 1)
s = MinMaxScaler(feature_range=feature_range, copy=copy)
if axis == 0:
X = s.fit_transform(X)
else:
X = s.fit_transform(X.T).T
if original_ndim == 1:
X = X.ravel()
return X.execute(session=session, **(run_kwargs or dict()))
|
nilq/baby-python
|
python
|
import pytest
from mock import patch
from uds.can.consecutive_frame import CanConsecutiveFrameHandler, \
InconsistentArgumentsError, CanDlcHandler, DEFAULT_FILLER_BYTE
from uds.can import CanAddressingFormat
class TestCanConsecutiveFrameHandler:
"""Unit tests for `CanConsecutiveFrameHandler` class."""
SCRIPT_LOCATION = "uds.can.consecutive_frame"
def setup(self):
self._patcher_validate_nibble = patch(f"{self.SCRIPT_LOCATION}.validate_nibble")
self.mock_validate_nibble = self._patcher_validate_nibble.start()
self._patcher_validate_raw_byte = patch(f"{self.SCRIPT_LOCATION}.validate_raw_byte")
self.mock_validate_raw_byte = self._patcher_validate_raw_byte.start()
self._patcher_validate_raw_bytes = patch(f"{self.SCRIPT_LOCATION}.validate_raw_bytes")
self.mock_validate_raw_bytes = self._patcher_validate_raw_bytes.start()
self._patcher_encode_dlc = patch(f"{self.SCRIPT_LOCATION}.CanDlcHandler.encode_dlc")
self.mock_encode_dlc = self._patcher_encode_dlc.start()
self._patcher_decode_dlc = patch(f"{self.SCRIPT_LOCATION}.CanDlcHandler.decode_dlc")
self.mock_decode_dlc = self._patcher_decode_dlc.start()
self._patcher_get_min_dlc = patch(f"{self.SCRIPT_LOCATION}.CanDlcHandler.get_min_dlc")
self.mock_get_min_dlc = self._patcher_get_min_dlc.start()
self._patcher_encode_ai_data_bytes = \
patch(f"{self.SCRIPT_LOCATION}.CanAddressingInformationHandler.encode_ai_data_bytes")
self.mock_encode_ai_data_bytes = self._patcher_encode_ai_data_bytes.start()
self._patcher_get_ai_data_bytes_number = \
patch(f"{self.SCRIPT_LOCATION}.CanAddressingInformationHandler.get_ai_data_bytes_number")
self.mock_get_ai_data_bytes_number = self._patcher_get_ai_data_bytes_number.start()
def teardown(self):
self._patcher_validate_nibble.stop()
self._patcher_validate_raw_byte.stop()
self._patcher_validate_raw_bytes.stop()
self._patcher_encode_dlc.stop()
self._patcher_decode_dlc.stop()
self._patcher_get_min_dlc.stop()
self._patcher_encode_ai_data_bytes.stop()
self._patcher_get_ai_data_bytes_number.stop()
# create_valid_frame_data
@pytest.mark.parametrize("addressing_format, target_address, address_extension", [
("some format", "TA", "SA"),
("another format", None, None),
])
@pytest.mark.parametrize("dlc, filler_byte, sequence_number", [
(CanDlcHandler.MIN_BASE_UDS_DLC, 0x66, "some sequence number"),
(CanDlcHandler.MIN_BASE_UDS_DLC + 2, 0x99, 0xF),
])
@pytest.mark.parametrize("payload, data_bytes_number, ai_data_bytes, sn_data_bytes", [
([0x54], 2, [], [0xFA]),
(range(50, 110), 64, [0x98], [0x12, 0x34]),
])
@patch(f"{SCRIPT_LOCATION}.CanConsecutiveFrameHandler._CanConsecutiveFrameHandler__encode_sn")
def test_create_valid_frame_data__valid_with_dlc(self, mock_encode_sn,
addressing_format, target_address, address_extension,
payload, sequence_number, dlc, filler_byte,
data_bytes_number, ai_data_bytes, sn_data_bytes):
self.mock_decode_dlc.return_value = data_bytes_number
self.mock_encode_ai_data_bytes.return_value = ai_data_bytes
mock_encode_sn.return_value = sn_data_bytes
cf_frame_data = CanConsecutiveFrameHandler.create_valid_frame_data(addressing_format=addressing_format,
target_address=target_address,
address_extension=address_extension,
payload=payload,
sequence_number=sequence_number,
dlc=dlc,
filler_byte=filler_byte)
self.mock_validate_raw_byte.assert_called_once_with(filler_byte)
self.mock_validate_raw_bytes.assert_called_once_with(payload, allow_empty=False)
self.mock_decode_dlc.assert_called_once_with(dlc)
self.mock_encode_ai_data_bytes.assert_called_once_with(addressing_format=addressing_format,
target_address=target_address,
address_extension=address_extension)
mock_encode_sn.assert_called_once_with(sequence_number=sequence_number)
assert isinstance(cf_frame_data, list)
assert len(cf_frame_data) == data_bytes_number
@pytest.mark.parametrize("addressing_format, target_address, address_extension", [
("some format", "TA", "SA"),
("another format", None, None),
])
@pytest.mark.parametrize("dlc, filler_byte, sequence_number", [
(CanDlcHandler.MIN_BASE_UDS_DLC, 0x66, "some sequence number"),
(CanDlcHandler.MIN_BASE_UDS_DLC + 2, 0x99, 0xF),
])
@pytest.mark.parametrize("payload, data_bytes_number, ai_data_bytes, sn_data_bytes", [
([0x54], 2, [], [0xFA]),
(range(50, 110), 64, [0x98], [0x12, 0x34]),
])
@patch(f"{SCRIPT_LOCATION}.CanConsecutiveFrameHandler.get_min_dlc")
@patch(f"{SCRIPT_LOCATION}.CanConsecutiveFrameHandler._CanConsecutiveFrameHandler__encode_sn")
def test_create_valid_frame_data__valid_without_dlc(self, mock_encode_sn, mock_get_min_dlc,
addressing_format, target_address, address_extension,
payload, sequence_number, dlc, filler_byte,
data_bytes_number, ai_data_bytes, sn_data_bytes):
mock_get_min_dlc.return_value = dlc
self.mock_decode_dlc.return_value = data_bytes_number
self.mock_encode_ai_data_bytes.return_value = ai_data_bytes
mock_encode_sn.return_value = sn_data_bytes
cf_frame_data = CanConsecutiveFrameHandler.create_valid_frame_data(addressing_format=addressing_format,
target_address=target_address,
address_extension=address_extension,
payload=payload,
sequence_number=sequence_number,
dlc=None,
filler_byte=filler_byte)
self.mock_validate_raw_byte.assert_called_once_with(filler_byte)
self.mock_validate_raw_bytes.assert_called_once_with(payload, allow_empty=False)
mock_get_min_dlc.assert_called_once_with(addressing_format=addressing_format,
payload_length=len(payload))
self.mock_decode_dlc.assert_called_once_with(dlc)
self.mock_encode_ai_data_bytes.assert_called_once_with(addressing_format=addressing_format,
target_address=target_address,
address_extension=address_extension)
mock_encode_sn.assert_called_once_with(sequence_number=sequence_number)
assert isinstance(cf_frame_data, list)
assert len(cf_frame_data) == data_bytes_number
@pytest.mark.parametrize("addressing_format, target_address, address_extension", [
("some format", "TA", "SA"),
("another format", None, None),
])
@pytest.mark.parametrize("filler_byte, sequence_number", [
(0x66, "some sequence number"),
(0x99, 0xF),
])
@pytest.mark.parametrize("dlc, payload, data_bytes_number, ai_data_bytes, sn_data_bytes", [
(CanDlcHandler.MIN_BASE_UDS_DLC - 1, range(60), 100, [0xFF], [0x00, 0xFA]),
(CanDlcHandler.MIN_BASE_UDS_DLC - 2, [0x3E], 7, [], [0x01]),
(CanDlcHandler.MIN_BASE_UDS_DLC + 1, [0x20, 0x30, 0x44], 4, [0xAA], [0x03]),
])
@patch(f"{SCRIPT_LOCATION}.CanConsecutiveFrameHandler._CanConsecutiveFrameHandler__encode_sn")
def test_create_valid_frame_data__inconsistent_args(self, mock_encode_sn,
addressing_format, target_address, address_extension,
payload, sequence_number, dlc, filler_byte,
data_bytes_number, ai_data_bytes, sn_data_bytes):
self.mock_decode_dlc.return_value = data_bytes_number
self.mock_encode_ai_data_bytes.return_value = ai_data_bytes
mock_encode_sn.return_value = sn_data_bytes
with pytest.raises(InconsistentArgumentsError):
CanConsecutiveFrameHandler.create_valid_frame_data(addressing_format=addressing_format,
target_address=target_address,
address_extension=address_extension,
payload=payload,
sequence_number=sequence_number,
dlc=dlc,
filler_byte=filler_byte)
self.mock_validate_raw_byte.assert_called_once_with(filler_byte)
self.mock_validate_raw_bytes.assert_called_once_with(payload, allow_empty=False)
self.mock_decode_dlc.assert_called_once_with(dlc)
self.mock_encode_ai_data_bytes.assert_called_once_with(addressing_format=addressing_format,
target_address=target_address,
address_extension=address_extension)
mock_encode_sn.assert_called_once_with(sequence_number=sequence_number)
# create_any_frame_data
@pytest.mark.parametrize("addressing_format, target_address, address_extension", [
("some format", "TA", "SA"),
("another format", None, None),
])
@pytest.mark.parametrize("dlc, filler_byte, sequence_number", [
(CanDlcHandler.MIN_BASE_UDS_DLC - 2, 0x66, "some sequence number"),
(CanDlcHandler.MIN_BASE_UDS_DLC + 2, 0x99, 0xF),
])
@pytest.mark.parametrize("payload, data_bytes_number, ai_data_bytes, sn_data_bytes", [
([], 8, [], [0x0C]),
(range(50, 110), 64, [0x98], [0x12, 0x34]),
])
@patch(f"{SCRIPT_LOCATION}.CanConsecutiveFrameHandler._CanConsecutiveFrameHandler__encode_sn")
def test_create_any_frame_data__valid(self, mock_encode_sn,
addressing_format, target_address, address_extension,
payload, sequence_number, dlc, filler_byte,
data_bytes_number, ai_data_bytes, sn_data_bytes):
self.mock_decode_dlc.return_value = data_bytes_number
self.mock_encode_ai_data_bytes.return_value = ai_data_bytes
mock_encode_sn.return_value = sn_data_bytes
cf_frame_data = CanConsecutiveFrameHandler.create_any_frame_data(addressing_format=addressing_format,
target_address=target_address,
address_extension=address_extension,
payload=payload,
sequence_number=sequence_number,
dlc=dlc,
filler_byte=filler_byte)
self.mock_validate_raw_byte.assert_called_once_with(filler_byte)
self.mock_validate_raw_bytes.assert_called_once_with(payload, allow_empty=True)
self.mock_decode_dlc.assert_called_once_with(dlc)
self.mock_encode_ai_data_bytes.assert_called_once_with(addressing_format=addressing_format,
target_address=target_address,
address_extension=address_extension)
mock_encode_sn.assert_called_once_with(sequence_number=sequence_number)
assert isinstance(cf_frame_data, list)
assert len(cf_frame_data) == data_bytes_number
@pytest.mark.parametrize("addressing_format, target_address, address_extension", [
("some format", "TA", "SA"),
("another format", None, None),
])
@pytest.mark.parametrize("filler_byte, sequence_number", [
(0x66, "some sequence number"),
(0x99, 0xF),
])
@pytest.mark.parametrize("dlc, payload, data_bytes_number, ai_data_bytes, sn_data_bytes", [
(CanDlcHandler.MIN_BASE_UDS_DLC - 1, range(60), 62, [0xFF], [0x00, 0xFA]),
(CanDlcHandler.MIN_BASE_UDS_DLC, [0x20, 0x30, 0x44], 3, [], [0x03]),
])
@patch(f"{SCRIPT_LOCATION}.CanConsecutiveFrameHandler._CanConsecutiveFrameHandler__encode_sn")
def test_create_any_frame_data__inconsistent_args(self, mock_encode_sn,
addressing_format, target_address, address_extension,
payload, sequence_number, dlc, filler_byte,
data_bytes_number, ai_data_bytes, sn_data_bytes):
self.mock_decode_dlc.return_value = data_bytes_number
self.mock_encode_ai_data_bytes.return_value = ai_data_bytes
mock_encode_sn.return_value = sn_data_bytes
with pytest.raises(InconsistentArgumentsError):
CanConsecutiveFrameHandler.create_any_frame_data(addressing_format=addressing_format,
target_address=target_address,
address_extension=address_extension,
payload=payload,
sequence_number=sequence_number,
dlc=dlc,
filler_byte=filler_byte)
self.mock_validate_raw_byte.assert_called_once_with(filler_byte)
self.mock_validate_raw_bytes.assert_called_once_with(payload, allow_empty=True)
self.mock_decode_dlc.assert_called_once_with(dlc)
self.mock_encode_ai_data_bytes.assert_called_once_with(addressing_format=addressing_format,
target_address=target_address,
address_extension=address_extension)
mock_encode_sn.assert_called_once_with(sequence_number=sequence_number)
# is_consecutive_frame
@pytest.mark.parametrize("addressing_format", ["some addressing format", "another format"])
@pytest.mark.parametrize("ai_bytes_number, raw_frame_data", [
(0, (0x2F, 0xFE, 0xDC, 0xBA, 0x98, 0x76)),
(1, [0x01, 0x20] + list(range(46))),
])
def test_is_consecutive_frame__true(self, addressing_format, raw_frame_data,
ai_bytes_number):
self.mock_get_ai_data_bytes_number.return_value = ai_bytes_number
assert CanConsecutiveFrameHandler.is_consecutive_frame(addressing_format=addressing_format,
raw_frame_data=raw_frame_data) is True
self.mock_get_ai_data_bytes_number.assert_called_once_with(addressing_format)
@pytest.mark.parametrize("addressing_format", ["some addressing format", "another format"])
@pytest.mark.parametrize("ai_bytes_number, raw_frame_data", [
(0, (0x0F, 0xFE, 0xDC, 0xBA, 0x98, 0x76)),
(1, [0x01, 0x10] + list(range(46))),
(0, [0x35] + list(range(47))),
(1, (0x13, 0xFE, 0x21)),
])
def test_is_consecutive_frame__false(self, addressing_format, raw_frame_data, ai_bytes_number):
self.mock_get_ai_data_bytes_number.return_value = ai_bytes_number
assert CanConsecutiveFrameHandler.is_consecutive_frame(addressing_format=addressing_format,
raw_frame_data=raw_frame_data) is False
self.mock_get_ai_data_bytes_number.assert_called_once_with(addressing_format)
# decode_payload
@pytest.mark.parametrize("addressing_format", ["some addressing format", "another format"])
@pytest.mark.parametrize("ai_bytes_number, raw_frame_data", [
(0, [0x25] + list(range(47))),
(1, (0x13, 0x2E, 0x21)),
])
@patch(f"{SCRIPT_LOCATION}.CanConsecutiveFrameHandler.is_consecutive_frame")
def test_decode_payload(self, mock_is_consecutive_frame,
addressing_format, raw_frame_data, ai_bytes_number):
mock_is_consecutive_frame.return_value = True
self.mock_get_ai_data_bytes_number.return_value = ai_bytes_number
payload = CanConsecutiveFrameHandler.decode_payload(addressing_format=addressing_format,
raw_frame_data=raw_frame_data)
assert isinstance(payload, list)
assert payload == list(raw_frame_data)[ai_bytes_number + CanConsecutiveFrameHandler.SN_BYTES_USED:]
mock_is_consecutive_frame.assert_called_once_with(addressing_format=addressing_format,
raw_frame_data=raw_frame_data)
self.mock_get_ai_data_bytes_number.assert_called_once_with(addressing_format)
@pytest.mark.parametrize("addressing_format", ["some addressing format", "another format"])
@pytest.mark.parametrize("raw_frame_data", [
(0x2F, 0xFE, 0xDC, 0xBA, 0x98, 0x76),
[0x01, 0x20] + list(range(46)),
])
@patch(f"{SCRIPT_LOCATION}.CanConsecutiveFrameHandler.is_consecutive_frame")
def test_decode_payload__value_error(self, mock_is_consecutive_frame,
addressing_format, raw_frame_data):
mock_is_consecutive_frame.return_value = False
with pytest.raises(ValueError):
CanConsecutiveFrameHandler.decode_payload(addressing_format=addressing_format,
raw_frame_data=raw_frame_data)
mock_is_consecutive_frame.assert_called_once_with(addressing_format=addressing_format,
raw_frame_data=raw_frame_data)
self.mock_get_ai_data_bytes_number.assert_not_called()
# decode_sequence_number
@pytest.mark.parametrize("addressing_format", ["some addressing format", "another format"])
@pytest.mark.parametrize("ai_bytes_number, raw_frame_data", [
(0, [0x25] + list(range(47))),
(1, (0x13, 0x2E, 0x21)),
])
@patch(f"{SCRIPT_LOCATION}.CanConsecutiveFrameHandler.is_consecutive_frame")
def test_decode_sequence_number(self, mock_is_consecutive_frame,
addressing_format, raw_frame_data, ai_bytes_number):
mock_is_consecutive_frame.return_value = True
self.mock_get_ai_data_bytes_number.return_value = ai_bytes_number
sequence_number = CanConsecutiveFrameHandler.decode_sequence_number(addressing_format=addressing_format,
raw_frame_data=raw_frame_data)
assert isinstance(sequence_number, int)
assert sequence_number == raw_frame_data[ai_bytes_number] & 0xF
mock_is_consecutive_frame.assert_called_once_with(addressing_format=addressing_format,
raw_frame_data=raw_frame_data)
self.mock_get_ai_data_bytes_number.assert_called_once_with(addressing_format)
@pytest.mark.parametrize("addressing_format", ["some addressing format", "another format"])
@pytest.mark.parametrize("raw_frame_data", [
(0x2F, 0xFE, 0xDC, 0xBA, 0x98, 0x76),
[0x01, 0x20] + list(range(46)),
])
@patch(f"{SCRIPT_LOCATION}.CanConsecutiveFrameHandler.is_consecutive_frame")
def test_decode_sequence_number__value_error(self, mock_is_consecutive_frame,
addressing_format, raw_frame_data):
mock_is_consecutive_frame.return_value = False
with pytest.raises(ValueError):
CanConsecutiveFrameHandler.decode_sequence_number(addressing_format=addressing_format,
raw_frame_data=raw_frame_data)
mock_is_consecutive_frame.assert_called_once_with(addressing_format=addressing_format,
raw_frame_data=raw_frame_data)
self.mock_get_ai_data_bytes_number.assert_not_called()
# get_min_dlc
@pytest.mark.parametrize("addressing_format", ["some addressing format", "something else"])
@pytest.mark.parametrize("ai_data_bytes, payload_length", [
(0, 1),
(0, 62),
])
@pytest.mark.parametrize("decoded_dlc", [8, 0xF])
def test_get_min_dlc(self, addressing_format, payload_length, ai_data_bytes, decoded_dlc):
self.mock_get_ai_data_bytes_number.return_value = ai_data_bytes
self.mock_get_min_dlc.return_value = decoded_dlc
assert CanConsecutiveFrameHandler.get_min_dlc(
addressing_format=addressing_format, payload_length=payload_length) == self.mock_get_min_dlc.return_value
self.mock_get_ai_data_bytes_number.assert_called_once_with(addressing_format)
data_bytes_number = payload_length + CanConsecutiveFrameHandler.SN_BYTES_USED + ai_data_bytes
self.mock_get_min_dlc.assert_called_once_with(data_bytes_number)
@pytest.mark.parametrize("addressing_format", ["some addressing format", "something else"])
@pytest.mark.parametrize("payload_length", [None, "not a payload", 5.])
def test_get_min_dlc__type_error(self, addressing_format, payload_length):
with pytest.raises(TypeError):
CanConsecutiveFrameHandler.get_min_dlc(addressing_format=addressing_format, payload_length=payload_length)
@pytest.mark.parametrize("addressing_format", ["some addressing format", "something else"])
@pytest.mark.parametrize("payload_length", [0, 64])
def test_get_min_dlc__value_error(self, addressing_format, payload_length):
with pytest.raises(ValueError):
CanConsecutiveFrameHandler.get_min_dlc(addressing_format=addressing_format, payload_length=payload_length)
@pytest.mark.parametrize("addressing_format", ["some addressing format", "something else"])
@pytest.mark.parametrize("ai_data_bytes, payload_length", [
(1, 63),
(2, 62),
])
def test_get_min_dlc__inconsistent_args(self, addressing_format, payload_length, ai_data_bytes):
self.mock_get_ai_data_bytes_number.return_value = ai_data_bytes
with pytest.raises(InconsistentArgumentsError):
CanConsecutiveFrameHandler.get_min_dlc(addressing_format=addressing_format, payload_length=payload_length)
self.mock_get_ai_data_bytes_number.assert_called_once_with(addressing_format)
# get_max_payload_size
@pytest.mark.parametrize("addressing_format", ["some addressing format", "something else"])
@pytest.mark.parametrize("dlc", ["some DLC", 8])
@pytest.mark.parametrize("frame_data_bytes_number, ai_data_bytes_number", [
(10, 1),
(64, 1),
])
def test_get_max_payload_size__with_addressing_dlc(self, addressing_format, dlc,
frame_data_bytes_number, ai_data_bytes_number):
self.mock_decode_dlc.return_value = frame_data_bytes_number
self.mock_get_ai_data_bytes_number.return_value = ai_data_bytes_number
max_value = CanConsecutiveFrameHandler.get_max_payload_size(addressing_format=addressing_format, dlc=dlc)
self.mock_decode_dlc.assert_called_once_with(dlc)
self.mock_get_ai_data_bytes_number.assert_called_once_with(addressing_format)
assert isinstance(max_value, int)
assert max_value == frame_data_bytes_number - ai_data_bytes_number - CanConsecutiveFrameHandler.SN_BYTES_USED
@pytest.mark.parametrize("addressing_format", ["some addressing format", "something else"])
@pytest.mark.parametrize("dlc", ["some DLC", 8])
@pytest.mark.parametrize("frame_data_bytes_number, ai_data_bytes_number", [
(1, 1),
(0, 0),
])
def test_get_max_payload_size__too_short(self, addressing_format, dlc,
frame_data_bytes_number, ai_data_bytes_number):
self.mock_decode_dlc.return_value = frame_data_bytes_number
self.mock_get_ai_data_bytes_number.return_value = ai_data_bytes_number
with pytest.raises(InconsistentArgumentsError):
CanConsecutiveFrameHandler.get_max_payload_size(addressing_format=addressing_format, dlc=dlc)
self.mock_decode_dlc.assert_called_once_with(dlc)
self.mock_get_ai_data_bytes_number.assert_called_once_with(addressing_format)
def test_get_max_payload_size__without_args(self):
max_value = CanConsecutiveFrameHandler.get_max_payload_size()
self.mock_decode_dlc.assert_not_called()
self.mock_get_ai_data_bytes_number.assert_not_called()
assert isinstance(max_value, int)
assert max_value == CanDlcHandler.MAX_DATA_BYTES_NUMBER - CanConsecutiveFrameHandler.SN_BYTES_USED
# validate_frame_data
@pytest.mark.parametrize("addressing_format, raw_frame_data", [
("some addressing format", "some raw frame data"),
("another format", range(5)),
])
@pytest.mark.parametrize("min_dlc, decoded_dlc", [
(8, 8),
(13, 15),
])
@patch(f"{SCRIPT_LOCATION}.CanConsecutiveFrameHandler.is_consecutive_frame")
@patch(f"{SCRIPT_LOCATION}.CanConsecutiveFrameHandler.get_min_dlc")
def test_validate_frame_data__valid(self, mock_get_min_dlc, mock_is_consecutive_frame,
addressing_format, raw_frame_data,
decoded_dlc, min_dlc):
mock_is_consecutive_frame.return_value = True
mock_get_min_dlc.return_value = min_dlc
self.mock_encode_dlc.return_value = decoded_dlc
CanConsecutiveFrameHandler.validate_frame_data(addressing_format=addressing_format,
raw_frame_data=raw_frame_data)
self.mock_validate_raw_bytes.assert_called_once_with(raw_frame_data)
mock_is_consecutive_frame.assert_called_once_with(addressing_format=addressing_format,
raw_frame_data=raw_frame_data)
mock_get_min_dlc.assert_called_once_with(addressing_format=addressing_format)
@pytest.mark.parametrize("addressing_format, raw_frame_data", [
("some addressing format", "some raw frame data"),
("another format", range(5)),
])
@patch(f"{SCRIPT_LOCATION}.CanConsecutiveFrameHandler.is_consecutive_frame")
def test_validate_frame_data__value_error(self, mock_is_consecutive_frame,
addressing_format, raw_frame_data):
mock_is_consecutive_frame.return_value = False
with pytest.raises(ValueError):
CanConsecutiveFrameHandler.validate_frame_data(addressing_format=addressing_format,
raw_frame_data=raw_frame_data)
mock_is_consecutive_frame.assert_called_once_with(addressing_format=addressing_format,
raw_frame_data=raw_frame_data)
@pytest.mark.parametrize("addressing_format, raw_frame_data", [
("some addressing format", "some raw frame data"),
("another format", range(5)),
])
@pytest.mark.parametrize("min_dlc, decoded_dlc", [
(1, 0),
(15, 8),
])
@patch(f"{SCRIPT_LOCATION}.CanConsecutiveFrameHandler.is_consecutive_frame")
@patch(f"{SCRIPT_LOCATION}.CanConsecutiveFrameHandler.get_min_dlc")
def test_validate_frame_data__inconsistent_error(self, mock_get_min_dlc, mock_is_consecutive_frame,
addressing_format, raw_frame_data,
decoded_dlc, min_dlc):
mock_is_consecutive_frame.return_value = True
mock_get_min_dlc.return_value = min_dlc
self.mock_encode_dlc.return_value = decoded_dlc
with pytest.raises(InconsistentArgumentsError):
CanConsecutiveFrameHandler.validate_frame_data(addressing_format=addressing_format,
raw_frame_data=raw_frame_data)
self.mock_validate_raw_bytes.assert_called_once_with(raw_frame_data)
mock_is_consecutive_frame.assert_called_once_with(addressing_format=addressing_format,
raw_frame_data=raw_frame_data)
mock_get_min_dlc.assert_called_once_with(addressing_format=addressing_format)
# __encode_sn
@pytest.mark.parametrize("sequence_number", [0, 0xF])
def test_encode_sn(self, sequence_number):
assert CanConsecutiveFrameHandler._CanConsecutiveFrameHandler__encode_sn(sequence_number=sequence_number) \
== [(CanConsecutiveFrameHandler.CONSECUTIVE_FRAME_N_PCI << 4) + sequence_number]
self.mock_validate_nibble.assert_called_once_with(sequence_number)
@pytest.mark.integration
class TestCanSingleFrameHandlerIntegration:
"""Integration tests for `CanSingleFrameHandler` class."""
# create_valid_frame_data
@pytest.mark.parametrize("kwargs, expected_raw_frame_data", [
({"addressing_format": CanAddressingFormat.NORMAL_11BIT_ADDRESSING,
"payload": [0x9A],
"sequence_number": 0}, [0x20, 0x9A]),
({"addressing_format": CanAddressingFormat.NORMAL_FIXED_ADDRESSING,
"payload": tuple(range(48)),
"sequence_number": 0xF}, [0x2F] + list(range(48)) + (15 * [DEFAULT_FILLER_BYTE])),
({"addressing_format": CanAddressingFormat.EXTENDED_ADDRESSING,
"target_address": 0xF1,
"dlc": 8,
"payload": (0x92, 0xB8),
"sequence_number": 0x5,
"filler_byte": 0xD9}, [0xF1, 0x25, 0x92, 0xB8, 0xD9, 0xD9, 0xD9, 0xD9]),
({"addressing_format": CanAddressingFormat.MIXED_11BIT_ADDRESSING,
"address_extension": 0xE8,
"dlc": 9,
"payload": list(range(10, 20)),
"sequence_number": 0xB,
"filler_byte": 0x99}, [0xE8, 0x2B] + list(range(10, 20))),
({"addressing_format": CanAddressingFormat.MIXED_29BIT_ADDRESSING,
"target_address": 0xFE,
"address_extension": 0xDC,
"payload": tuple(range(50, 96)),
"sequence_number": 0x1,
"filler_byte": 0xD9}, [0xDC, 0x21] + list(range(50, 96))),
])
def test_create_valid_frame_data__valid(self, kwargs, expected_raw_frame_data):
assert CanConsecutiveFrameHandler.create_valid_frame_data(**kwargs) == expected_raw_frame_data
@pytest.mark.parametrize("kwargs", [
{"addressing_format": CanAddressingFormat.NORMAL_11BIT_ADDRESSING,
"payload": [0x9A],
"dlc": 1,
"sequence_number": 0},
{"addressing_format": CanAddressingFormat.NORMAL_FIXED_ADDRESSING,
"payload": [],
"sequence_number": 0xF},
{"addressing_format": CanAddressingFormat.EXTENDED_ADDRESSING,
"target_address": 0xF1,
"payload": [0x9A],
"dlc": 8,
"sequence_number": 0x10},
{"addressing_format": CanAddressingFormat.MIXED_11BIT_ADDRESSING,
"address_extension": 0xE8,
"payload": list(range(7)),
"dlc": 8,
"sequence_number": 0x10},
{"addressing_format": CanAddressingFormat.MIXED_29BIT_ADDRESSING,
"target_address": 0xFE,
"address_extension": 0xE8,
"payload": tuple(range(50, 96)),
"sequence_number": -1,
"filler_byte": 0xD9}
])
def test_create_valid_frame_data__invalid(self, kwargs):
with pytest.raises(ValueError):
CanConsecutiveFrameHandler.create_valid_frame_data(**kwargs)
# create_any_frame_data
@pytest.mark.parametrize("kwargs, expected_raw_frame_data", [
({"addressing_format": CanAddressingFormat.NORMAL_11BIT_ADDRESSING,
"payload": [],
"dlc": 1,
"sequence_number": 0}, [0x20]),
({"addressing_format": CanAddressingFormat.NORMAL_FIXED_ADDRESSING,
"payload": (0xFE, 0xDC),
"dlc": 5,
"sequence_number": 0xF}, [0x2F, 0xFE, 0xDC, DEFAULT_FILLER_BYTE, DEFAULT_FILLER_BYTE]),
({"addressing_format": CanAddressingFormat.EXTENDED_ADDRESSING,
"target_address": 0xF1,
"payload": [],
"dlc": 2,
"sequence_number": 0xE,
"filler_byte": 0xD9}, [0xF1, 0x2E]),
({"addressing_format": CanAddressingFormat.MIXED_29BIT_ADDRESSING,
"address_extension": 0xE8,
"payload": [],
"dlc": 2,
"sequence_number": 0x1}, [0xE8, 0x21]),
])
def test_create_any_frame_data__valid(self, kwargs, expected_raw_frame_data):
assert CanConsecutiveFrameHandler.create_any_frame_data(**kwargs) == expected_raw_frame_data
@pytest.mark.parametrize("kwargs", [
{"addressing_format": CanAddressingFormat.NORMAL_11BIT_ADDRESSING,
"payload": [0x9A],
"dlc": 1,
"sequence_number": 0},
{"addressing_format": CanAddressingFormat.NORMAL_FIXED_ADDRESSING,
"payload": [],
"dlc": 8,
"sequence_number": -1},
{"addressing_format": CanAddressingFormat.EXTENDED_ADDRESSING,
"target_address": 0xF1,
"payload": [0x9A],
"dlc": 8,
"sequence_number": 0x10},
{"addressing_format": CanAddressingFormat.MIXED_11BIT_ADDRESSING,
"address_extension": 0xE8,
"payload": list(range(7)),
"dlc": 8,
"sequence_number": 0xE},
])
def test_create_any_frame_data__invalid(self, kwargs):
with pytest.raises(ValueError):
CanConsecutiveFrameHandler.create_any_frame_data(**kwargs)
# validate_frame_data
@pytest.mark.parametrize("addressing_format, raw_frame_data", [
(CanAddressingFormat.NORMAL_11BIT_ADDRESSING, (0x20, 0x12, 0x34, 0x45, 0x67, 0x89, 0x9A, 0xBC)),
(CanAddressingFormat.NORMAL_FIXED_ADDRESSING, (0x2F, 0x2F)),
(CanAddressingFormat.EXTENDED_ADDRESSING, (0xF0, 0x26, 0x00)),
(CanAddressingFormat.MIXED_11BIT_ADDRESSING, [0x30, 0x21] + (46 * [0xFF])),
(CanAddressingFormat.MIXED_29BIT_ADDRESSING, (0x8B, 0x2E, 0x9B)),
])
def test_validate_frame_data__valid(self, addressing_format, raw_frame_data):
assert CanConsecutiveFrameHandler.validate_frame_data(addressing_format=addressing_format,
raw_frame_data=raw_frame_data) is None
@pytest.mark.parametrize("addressing_format, raw_frame_data", [
(CanAddressingFormat.NORMAL_11BIT_ADDRESSING, [0x20]),
(CanAddressingFormat.NORMAL_FIXED_ADDRESSING, tuple([0x2F] + ([0xFF] * 64))),
(CanAddressingFormat.EXTENDED_ADDRESSING, [0x2F, 0x2F]),
(CanAddressingFormat.MIXED_29BIT_ADDRESSING, (0x8B, 0x2E)),
])
def test_validate_frame_data__invalid(self, addressing_format, raw_frame_data):
with pytest.raises(ValueError):
CanConsecutiveFrameHandler.validate_frame_data(addressing_format=addressing_format,
raw_frame_data=raw_frame_data)
|
nilq/baby-python
|
python
|
foo = input("Treat? ")
if foo == "Pastry":
print("Buttery flaky goodness")
elif foo == "Cake":
print("A light and fluffy classic")
elif foo == "Cookie":
print("Warm and crispy on the edges")
else:
print("We do not sell that. It sounds yum!")
foo = int(input("Wind speed? "))
if foo < 10:
print("No flying today.")
elif foo > 40:
print("Dangerous wind conditions!")
else:
print("Perfect kite weather!")
foo = input("Sentence? ")
bar = foo.replace("Voldemort", "You Know Who")
print(bar)
foo = input("Message? ")
bar = foo.replace("mandrake", "TOP SECRET")
if bar == foo:
print("No words are top secret")
else:
print(bar)
foo = input("Book title? ")
print(foo)
for i in foo:
print(i)
foo = input("Guard word? ")
bar = foo.replace("s" , "b")
for i in bar:
print(i)
print(bar)
from turtle import *
length = int(input("Length? "))
pencolor("pink")
pensize(5)
for i in range(6):
forward(length)
left(60)
backward(length/2)
from turtle import *
length = int(input("How many pancakes? "))
pencolor("wheat")
pensize(6)
penup()
backward(50)
for i in range(length):
pendown()
forward(100)
penup()
right(90)
forward(10)
right(90)
forward(100)
left(180)
|
nilq/baby-python
|
python
|
from .sender import *
from .receiver import *
|
nilq/baby-python
|
python
|
import pytest
from pre_commit.main import main as pre_commit
from versort import get_sorter
def test_style():
"""Just run pre-commit and see what happens."""
pre_commit(("run", "--all-files", "--show-diff-on-failure", "--color=always"))
def test_unknown_sorter():
"""See there's a valid error when a sorter is unknown."""
with pytest.raises(ValueError):
get_sorter("missing")
|
nilq/baby-python
|
python
|
# -*- coding: utf-8 -*-
# (Deprecated) The old version of similarity calculation. Will be removed in upcoming update.
from func.utils import Database
from func.model import Model
from pyspark.sql.functions import column
import pickle
import time
def prefilter(db, test):
app_query = 'SELECT * FROM app WHERE (category = \'{}\')'.format(test['category'])
ui_query = 'SELECT * FROM ui WHERE (appname IN (SELECT appname FROM app WHERE (category = \'{}\')))'.format(test['category'])
app_df = db.query(app_query)
ui_df = db.query(ui_query)
return app_df, ui_df
def load_from_db(db, test_input, is_prefilter = True):
# load from metadata db. You can choose the whether to do prefiltering.
if is_prefilter:
app_df, ui_df = prefilter(db, test_input)
else:
app_df = db.load(table='app')
ui_df = db.load(table='ui')
return app_df, ui_df
if __name__ == '__main__':
db = Database()
# load in a test sample
file = open('localdata/test_ui', 'rb')
test_ui = pickle.load(file)
file.close()
# prefiltering by category
time_start=time.time()
app_df, ui_df = load_from_db(db, test_ui, is_prefilter = True)
ui_targets = ui_df.select(column('uiid'),column('appname')).collect()
time_end=time.time()
print('Read from sql time cost',time_end-time_start,'s')
# use the ML/DL models
time_start=time.time()
model_demo = Model(test_ui, ui_targets)
sim_df_pd = model_demo.cos_similarity()
sim_app_df = ui_df.select(column('uiid'),column('appname')).where(ui_df.uiid.isin(sim_df_pd.uiid.iloc[0:6].tolist()))
sim_app = sim_app_df.collect()
result_df = app_df.where(app_df.appname.isin([row.appname for row in sim_app]))
outputs = result_df.join(sim_app_df,"appname","left").collect()
time_end=time.time()
print('Model time cost',time_end-time_start,'s')
file = open('localdata/result_demo', 'wb')
pickle.dump(outputs, file)
file.close()
|
nilq/baby-python
|
python
|
from django.conf import settings
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.permissions import AllowAny
from rest_framework.exceptions import NotFound
from allauth.account.models import EmailAddress
from users.models import User
from organizations_ext.models import Organization
from teams.models import Team
from projects.models import Project
from glitchtip.uptime.models import Monitor
class SeedDataAPIView(APIView):
"""
Delete existing data and seed data used in end to end testing
Very destructive. Never enable on production.
"""
permission_classes = [AllowAny]
def post(self, request):
if settings.ENABLE_TEST_API is not True:
raise NotFound("Enable Test API is not enabled")
user_email = "cypresstest@example.com"
other_user_email = "cypresstest-other@example.com"
user_password = "hunter22" # nosec
organization_name = "Business Company, Inc."
team_slug = "cypresstestteam"
project_name = "NicheScrip"
User.objects.filter(email=user_email).delete()
user = User.objects.create_user(email=user_email, password=user_password)
User.objects.filter(email=other_user_email).delete()
other_user = User.objects.create_user(
email=other_user_email, password=user_password
)
EmailAddress.objects.create(
user=user, email=user_email, primary=True, verified=False
)
EmailAddress.objects.create(
user=other_user, email=other_user_email, primary=True, verified=False
)
Organization.objects.filter(name=organization_name).delete()
organization = Organization.objects.create(name=organization_name)
orgUser = organization.add_user(user=user)
Team.objects.filter(slug=team_slug).delete()
team = Team.objects.create(slug=team_slug, organization=organization)
Project.objects.filter(name=project_name).delete()
project = Project.objects.create(name=project_name, organization=organization)
Monitor.objects.filter(name="cytestmonitor").delete()
Monitor.objects.create(
name = "cytestmonitor",
organization=organization,
project=project,
url="https://www.google.com",
monitor_type="Ping",
interval="00:01:00"
)
if (request.query_params.get("extras")):
project_name = "SwitchGrip"
project2 = Project.objects.create(name=project_name, organization=organization)
project_name = "PitchFlip"
project3 = Project.objects.create(name=project_name, organization=organization, platform="JavaScript")
team.projects.add(project)
team.projects.add(project2)
team.projects.add(project3)
team.members.add(orgUser)
return Response()
|
nilq/baby-python
|
python
|
from doodledashboard.component import NotificationCreator
from doodledashboard.notifications.notification import Notification
from doodledashboard.notifications.outputs import TextNotificationOutput
class TextInMessage(Notification):
"""Creates a notification containing the text of the last message"""
def create_output(self, messages):
return TextNotificationOutput(messages[-1].text) if messages else None
def get_output_types(self):
return [TextNotificationOutput]
def __str__(self):
return "Text In Message (name=%s)" % self.name
class TextInMessageCreator(NotificationCreator):
@staticmethod
def get_id():
return "text-from-message"
def create(self, options, secret_store):
return TextInMessage()
|
nilq/baby-python
|
python
|
from .util import generate_evenly_spaced_data_set
def pagie_func1(x, y):
return 1.0 / x ** (-4) + 1.0 / y ** (-4)
def generate_pagie1():
train = generate_evenly_spaced_data_set(pagie_func1, 0.4, (-5, 5))
test = generate_evenly_spaced_data_set(pagie_func1, 0.4, (-5, 5))
return train, test
all_problems = {"pagie1": generate_pagie1}
|
nilq/baby-python
|
python
|
# mc_bot.py
# Source: https://github.com/DrGFreeman/mc-to-discord
#
# MIT License
#
# Copyright (c) 2018 Julien de la Bruere-Terreault <drgfreeman@tuta.io>
#
# 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.
# A simple script that monitors the logs of a Minecraft server and posts user
# activity (joining & leaving server) to Discord via webhook.
import datetime
import time
import requests
# Path to minecraft server main directory
MINECRAFT_PATH = '<insert path here>'
# Discord webhook URL ('https://discordapp.com/api/webhooks/{webhook.id}/{webhook.token}')
# See https://discordapp.com/developers/docs/resources/webhook
# and https://support.discordapp.com/hc/en-us/articles/228383668-Intro-to-Webhooks
WEBHOOK_URL = '<insert webhook URL here>'
# Message templates
MSG_LAUNCH = 'Hello, I keep you informed of user activity on the Minecraft server.'
MSG_SERVER_STOPPED = 'The server is stopped. See you next time.'
MSG_PLAYER_JOINED = '[{0:%H:%M}] {player_name} joined the server.'
MSG_PLAYER_LEFT = '[{0:%H:%M}] {player_name} left the server.'
# Path to log file
LOG_FILE = MINECRAFT_PATH + 'logs/latest.log'
# Dictionaries storing players name (key) and status (value)
players_current = dict()
players_previous = dict()
# Function to post content string to discord
def post_discord(content):
r = requests.post(WEBHOOK_URL, json={'content': content})
print(content)
# Main program
if __name__ == '__main__':
active = True
try:
post_discord(MSG_LAUNCH)
while active:
# Parse log file
with open(LOG_FILE, 'r') as log_file:
for line in log_file:
tokens = line.split()
if len(tokens) > 4:
if tokens[4] == 'Stopping':
post_discord(MSG_SERVER_STOPPED)
active = False
break
if tokens[4] == 'joined':
players_current[tokens[3]] = 'in'
elif tokens[4] == 'left':
players_current[tokens[3]] = 'out'
# Compare current player status with previous and post changes to discord
now = datetime.datetime.now()
for player, status in players_current.items():
if player in players_previous.keys():
if players_previous[player] != status:
if status == 'in':
post_discord(MSG_PLAYER_JOINED.format(now, player_name=player))
else:
post_discord(MSG_PLAYER_LEFT.format(now, player_name=player))
elif status == 'in':
post_discord(MSG_PLAYER_JOINED.format(now, player_name=player))
players_previous = players_current.copy()
time.sleep(5)
except KeyboardInterrupt:
pass
|
nilq/baby-python
|
python
|
"""Setup module for NI Veristand."""
from os.path import dirname
from os.path import join
from setuptools import find_packages
from setuptools import setup
pypi_name = 'niveristand'
def get_version(name):
"""Calculate a version number."""
import os
version = None
script_dir = os.path.dirname(os.path.realpath(__file__))
script_dir = os.path.join(script_dir, name)
if not os.path.exists(os.path.join(script_dir, 'VERSION')):
version = '0.9.3'
else:
with open(os.path.join(script_dir, 'VERSION'), 'r') as version_file:
version = version_file.read().rstrip()
return version
def read_contents(file_to_read):
"""Read a file in this folder."""
with open(join(dirname(__file__), file_to_read), 'r') as f:
return f.read()
setup(
name=pypi_name,
version=get_version(pypi_name),
description='NI VeriStand Python API',
long_description=read_contents('README.rst'),
author='National Instruments',
maintainer="Marcelo Izaguirre",
maintainer_email="marcelo.izaguirre@ni.com",
url="https://github.com/ni/niveristand-python",
keywords=['niveristand', 'veristand'],
license='MIT',
packages=find_packages('src'),
package_dir={'': 'src'},
include_package_data=True,
install_requires=['pythonnet', 'PyYAML', 'enum34'],
tests_require=['pytest', 'numpy'],
classifiers=[
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"Intended Audience :: Science/Research",
"License :: OSI Approved :: MIT License",
"Operating System :: Microsoft :: Windows",
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.3",
"Programming Language :: Python :: 3.4",
"Programming Language :: Python :: 3.5",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: Implementation :: CPython",
"Programming Language :: Python :: Implementation :: PyPy",
"Topic :: Software Development :: Testing"
],
package_data={pypi_name: ['VERSION']},
)
|
nilq/baby-python
|
python
|
# -*- coding: utf-8 -*-
from brewtils.models import Operation
from beer_garden.api.http.base_handler import BaseHandler
class NamespaceListAPI(BaseHandler):
async def get(self):
"""
---
summary: Get a list of all namespaces known to this garden
responses:
200:
description: List of Namespaces
50x:
$ref: '#/definitions/50xError'
tags:
- Namespace
"""
response = await self.client(Operation(operation_type="NAMESPACE_READ_ALL"))
self.set_header("Content-Type", "application/json; charset=UTF-8")
self.write(response)
|
nilq/baby-python
|
python
|
from PIL import Image
import numpy
from .base import Base
from .loss_func import psnr_np, mse_np
from utils import Loader, Keeper
class BaseInterpolation(Base):
_scale_type = None
_scale_factor = 4
def model(self):
return None
def serialize(self):
pass
def unserialize(self):
pass
def history(self):
pass
def train(
self,
bundle,
bundle_size=32,
steps_per_epoch=128,
epochs=8,
verbose=True,
):
pass
def score(
self,
bundle,
bundle_size=32,
verbose=True,
):
loader = Loader(bundle)
data = loader.data_test(bundle_size)
averages_mse = 0.0
averages_psnr = 0.0
for i in range(0, len(data[0])):
image = numpy.array(data[0][i])
image *= 255
image = Image.fromarray(numpy.uint8(image))
image = image.convert('RGB')
image = image.resize((
int(image.size[0] * self._scale_factor),
int(image.size[1] * self._scale_factor),
), self._scale_type)
image = numpy.array(image)
image = image.astype('float32')
image /= 255
averages_mse += mse_np(data[1][i], image)
averages_psnr += psnr_np(data[1][i], image)
return [
averages_mse / len(data[0]),
averages_psnr / len(data[0]),
]
def test(
self,
bundle,
bundle_size=32,
verbose=True,
):
loader = Loader(bundle)
data = loader.data_test(bundle_size)
result = []
for image in data[0]:
image = numpy.array(image)
image *= 255
image = Image.fromarray(numpy.uint8(image))
image = image.convert('RGB')
image = image.resize((
int(image.size[0] * self._scale_factor),
int(image.size[1] * self._scale_factor),
), self._scale_type)
image = numpy.array(image)
image = image.astype('float32')
image /= 255
result.append(image)
keeper = Keeper(bundle, self.name())
for i in range(0, len(data[0])):
keeper.save(f'{bundle}-{i+1}', data[1][i], data[0][i], result[i])
|
nilq/baby-python
|
python
|
#Archivo para rutas USER
#Este modulo permite definir subrutas o rutas por separado, response es para respuestas HTTP
from fastapi import APIRouter, Response, status
#Esto solo me dice a donde conectarme, no hay un schema
from config.db import conn
#Aquí traemos el schema
from models.order_details import order_details
#Llamada al schema usuario para crear uno
from schemas.order_detail import Order_detail, Order_detail_in, Order_detail_outs, Order_detail_outs, Order_detail_update
#Modulo para generar una función de cifrado
from cryptography.fernet import Fernet
#Ahora para scar los codigos HTTP
from starlette.status import HTTP_204_NO_CONTENT
order_detail = APIRouter()
"""
Endpoint para obtener todos los order_details
@return: lista de order_details
"""
#Obtiene todos los order_details
@order_detail.get("/order_details", response_model=list[Order_detail_outs], tags=["order_details"])
def get_order_details():
return conn.execute(order_details.select()).fetchall()
"""
Endpoint para obtener un order_detail a través de un ID
@param: id_order_detail: id del order_detail
"""
#Obtiene un order_detail por id
@order_detail.get("/order_details/{id}", response_model=Order_detail_outs, tags=["order_details"])
def get_order_detail(id: str):
return conn.execute(order_details.select().where(order_details.c.id == id)).first()
"""
Endpoint para crear un order_detail
@param: order_detail: información del order_detail
@return: un order_detail
"""
#Creación de un order_detail
@order_detail.post("/order_details", response_model=Order_detail_outs, tags=["order_details"])
def create_order_detail(order_detail: Order_detail_in):
new_order_detail = {
"user_id": order_detail.user_id,
"payment_id": order_detail.payment_id,
"total": order_detail.total,
#"created_at": order_detail.created_at,
}
result = conn.execute(order_details.insert().values(new_order_detail))
return conn.execute(order_details.select().where(order_details.c.id == result.lastrowid)).first()
"""
Endpoint para borrar un order_detail
@param: id_order_detail: id del order_detail
return: HTTP_204_NO_CONTENT
"""
#Eliminación de un order_detail
@order_detail.delete("/order_details/{id}", status_code = status.HTTP_204_NO_CONTENT, tags = ["order_details"])
def delete_order_detail(id: str):
conn.execute(order_details.delete().where(order_details.c.id == id))
return Response(status_code = HTTP_204_NO_CONTENT)
"""
Endpoint para actualizar un order_detail
@param: id_order_detail: id del order_detail
@param: order_detail: información del order_detail a actualizar
return: un order_detail actualizado
"""
#Actualización de un order_detail
@order_detail.put("/order_details/{id}", response_model=Order_detail_outs, tags = ["order_details"])
def update_order_detail(id: str, order_detail: Order_detail_update):
conn.execute(order_details.update().values(
user_id = order_detail.user_id,
payment_id = order_detail.payment_id,
total = order_detail.total,
#created_at = order_detail.created_at,
).where(order_details.c.id == id))
return conn.execute(order_details.select().where(order_details.c.id == id)).first()
|
nilq/baby-python
|
python
|
"""
Definitions of various hard coded constants.
Pyro - Python Remote Objects. Copyright by Irmen de Jong (irmen@razorvine.net).
"""
# Pyro version
VERSION = "4.30"
# standard object name for the Daemon object
DAEMON_NAME = "Pyro.Daemon"
# standard name for the Name server itself
NAMESERVER_NAME = "Pyro.NameServer"
# standard name for Flame server
FLAME_NAME = "Pyro.Flame"
# wire protocol version. Note that if this gets updated, Pyrolite might need an update too.
PROTOCOL_VERSION = 47
|
nilq/baby-python
|
python
|
import logging
import bson
import hashlib
import base58
def doc2CID (inp):
try:
# JSON OBJ to BSON encode
bson_ = bson.dumps(inp)
# SHA-256 Double Hashing
hash_ = hashlib.sha256(bson_)
hash_ = hashlib.sha256(hash_.digest())
# Convert to Base-58 string
b58c_ = base58.b58encode(hash_.digest())
return b58c_.decode('utf-8')
except Exception as e:
logging.debug(e)
return None
def doc2bson (inp):
try:
# JSON OBJ to BSON encode
bson_ = bson.dumps(inp)
return bson_
except Exception as e:
logging.debug(e)
return None
def bson2doc (inp):
try:
# BSON to JSON OBJ
json_ = bson.loads(inp)
return json_
except Exception as e:
logging.debug(e)
return None
|
nilq/baby-python
|
python
|
# Supported clients
from .supported_search_clients import SupportedSearchClients
# Utility function
from .download_images import download_image, download_all_images
# Search API Clients
from .search_api_client import SearchAPIClient
from .google_cse_client import GoogleCustomSearchEngineClient
from .bing_image_search_client import BingImageSearchClient
# Google image scraper
from .google_image_scraper import GoogleImageScraper
|
nilq/baby-python
|
python
|
from quantumdl.models.quantummodel import *
from quantumdl.core.engine import *
|
nilq/baby-python
|
python
|
import datetime
from django.utils.timezone import utc
from rest_framework.authentication import TokenAuthentication
from rest_framework import exceptions
from django.utils.six import text_type
import base64
import binascii
from django.contrib.auth import get_user_model
from django.middleware.csrf import CsrfViewMiddleware
from django.utils.translation import ugettext_lazy as _
from django.utils.timezone import utc
from rest_framework import HTTP_HEADER_ENCODING, exceptions
from rest_framework.compat import authenticate
from rest_framework.exceptions import AuthenticationFailed
from django.conf import settings
import pytz
def get_the_authorization_header(request):
"""
Return request's 'Authorization:' header, as a bytestring.
Hide some test client ickyness where the header can be unicode.
"""
auth = request.META.get('HTTP_AUTHORIZATION', b'')
if isinstance(auth, text_type):
# Work around django test client oddness
auth = auth.encode(HTTP_HEADER_ENCODING)
return auth
class ExpiringTokenAuthentication(TokenAuthentication):
def get_model(self):
if self.model is not None:
return self.model
from rest_framework.authtoken.models import Token
return Token
def authenticate(self, request):
auth = get_the_authorization_header(request).split()
if not auth or auth[0].lower() != self.keyword.lower().encode():
return None
if len(auth) == 1:
msg = _('Invalid token header. No credentials provided.')
raise exceptions.AuthenticationFailed(msg)
elif len(auth) > 2:
msg = _('Invalid token header. Token string should not contain spaces.')
raise exceptions.AuthenticationFailed(msg)
try:
token = auth[1].decode()
except UnicodeError:
msg = _('Invalid token header. Token string should not contain invalid characters.')
raise exceptions.AuthenticationFailed(msg)
return self.authenticate_credentials(token)
def authenticate_credentials(self, key):
model = self.get_model()
try:
token = model.objects.select_related('user').get(key=key)
except model.DoesNotExist:
raise exceptions.AuthenticationFailed('Invalid token.')
if not token.user.is_active:
raise exceptions.AuthenticationFailed('User inactive or deleted.')
utc_now = datetime.datetime.utcnow()
utc_now = utc_now.replace(tzinfo=pytz.utc)
if token.created < utc_now - datetime.timedelta(days=30):
raise exceptions.AuthenticationFailed('Token has expired')
return (token.user, token)
def authenticate_header(self, request):
return self.keyword
class AuthenticatedOrAnonymousAuthentication(ExpiringTokenAuthentication):
def authenticate(self, request):
try:
return super(AuthenticatedOrAnonymousAuthentication, self).authenticate(request)
except:
return None
|
nilq/baby-python
|
python
|
from __future__ import annotations
from unittest import TestCase
from tests.classes.simple_order import SimpleOrder
from tests.classes.simple_project import SimpleProject
from tests.classes.simple_chart import SimpleChart
from tests.classes.simple_setting import SimpleSetting
from tests.classes.author import Author
from tests.classes.nested_object import NestedDict, NestedList
class TestIsModified(TestCase):
def test_jsonclass_object_is_not_modified_by_default(self):
order = SimpleOrder(quantity=5)
order._mark_not_new()
self.assertEqual(order.is_modified, False)
def test_jsonclass_object_is_modified_is_readonly(self):
order = SimpleOrder(quantity=5)
with self.assertRaises(AttributeError) as context:
order.is_modified = True
self.assertEqual(str(context.exception), "can't set attribute")
def test_jsonclass_object_is_modified_if_any_field_is_modified(self):
order = SimpleOrder(quantity=5)
order._mark_not_new()
order.quantity = 2
self.assertEqual(order.modified_fields, ('quantity',))
self.assertEqual(order.is_modified, True)
def test_jsonclass_object_is_modified_if_list_value_is_mutated(self):
project = SimpleProject(name='OK', attendees=['Butai', 'Buti'])
project._mark_not_new()
project.attendees.append('Liittiengesai')
self.assertEqual(project.modified_fields, ('attendees',))
self.assertEqual(project.is_modified, True)
def test_jsonclass_object_is_modified_if_dict_value_is_mutated(self):
chart = SimpleChart(name='B', partitions={'thenha': 0.5, 'guaê': 0.3})
chart._mark_not_new()
chart.partitions['lanê'] = 0.8
self.assertEqual(chart.modified_fields, ('partitions',))
self.assertEqual(chart.is_modified, True)
def test_jsonclass_object_is_modified_if_shape_value_is_mutated(self):
setting = SimpleSetting(user='B',
email={'auto_send': False,
'receive_promotion': False})
setting._mark_not_new()
setting.email['receive_promotion'] = True
self.assertEqual(setting.modified_fields, ('email',))
self.assertEqual(setting.is_modified, True)
def test_jsonclass_object_is_not_modified_if_nested_is_mutated(self):
author = Author(name='Kia',
articles=[{'title': 'Long',
'content': 'Khng Ti Ua E Sim Lai'}])
author._mark_not_new()
author.articles[0]._mark_not_new()
author.articles[0].title = 'M Guan Kong Tsai Huê'
self.assertEqual(author.is_modified, False)
self.assertEqual(author.modified_fields, ())
self.assertEqual(author.articles[0].is_modified, True)
self.assertEqual(author.articles[0].modified_fields, ('title',))
def test_jsonclass_object_is_modified_if_nested_list_is_modified(self):
nlst = NestedList(id='1', value={'a': ['1', '2'], 'b': ['1', '2']})
nlst._mark_not_new()
nlst.value['b'].append('3')
self.assertEqual(nlst.is_modified, True)
self.assertEqual(nlst.modified_fields, ('value.b',))
def test_jsonclass_object_is_modified_if_nested_dict_is_modified(self):
ndct = NestedDict(id='1', value=[{'a': '1'}, {'b': '1'}])
ndct._mark_not_new()
ndct.value[1]['c'] = '2'
self.assertEqual(ndct.is_modified, True)
self.assertEqual(ndct.modified_fields, ('value.1',))
|
nilq/baby-python
|
python
|
# -*- coding: utf-8 -*-
from flask import render_template, request, redirect, url_for, abort
from fcsite import check_forced_registration_blueprint
from fcsite.models import bbs
from fcsite.auth import requires_login
from fcsite.utils import pagination, logi
mod = check_forced_registration_blueprint('bbs', __name__, url_prefix='/bbs')
@mod.route('/')
@mod.route('/<int:page>')
@requires_login
def index(page=1):
modelpage = max(0, page - 1)
posts = bbs.find_posts_on_page(modelpage)
pages = bbs.count_pages()
if page > pages:
abort(404)
begin, end = pagination(page, pages)
return render_template('bbs.html', page=page, pages=pages, posts=posts,
begin=begin, end=end)
@mod.route('/post', methods=['POST'])
@requires_login
def post():
logi('bbs post')
body = request.form['body']
bbs.post(body)
return redirect(url_for('bbs.index'))
|
nilq/baby-python
|
python
|
# Copyright 2014: Mirantis 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.
import time
from rally.common import broker
from rally.common import logging
from rally.common.plugin import discover
from rally.common.plugin import plugin
from rally.common import utils as rutils
from xrally_docker.common.cleanup import resources
from xrally_docker import service
LOG = logging.getLogger(__name__)
class SeekAndDestroy(object):
def __init__(self, manager_cls, client, resource_classes=None,
owner_id=None):
"""Resource deletion class.
This class contains method exterminate() that finds and deletes
all resources created by Rally.
:param manager_cls: subclass of base.ResourceManager
:param client: a docker client instance
:param resource_classes: Resource classes to match resource names
against
:param owner_id: The UUID of an owner to match resource names against
"""
self.manager_cls = manager_cls
self.client = client
self.resource_classes = resource_classes or [
rutils.RandomNameGeneratorMixin]
self.owner_id = owner_id
def _delete_single_resource(self, resource):
"""Safe resource deletion with retries and timeouts.
Send request to delete resource, in case of failures repeat it few
times. After that pull status of resource until it's deleted.
Writes in LOG warning with UUID of resource that wasn't deleted
:param resource: instance of resource manager initiated with resource
that should be deleted.
"""
msg_kw = {
"uuid": resource.id(),
"name": "; ".join(resource.name()),
"resource": resource._name
}
LOG.debug(
"Deleting docker.%(resource)s object %(name)s (%(uuid)s)"
% msg_kw)
try:
rutils.retry(resource._max_attempts, resource.delete)
except Exception as e:
msg = ("Resource deletion failed, max retries exceeded for "
"docker.%(resource)s: %(uuid)s.") % msg_kw
if logging.is_debug():
LOG.exception(msg)
else:
LOG.warning("%(msg)s Reason: %(e)s" % {"msg": msg, "e": e})
else:
started = time.time()
failures_count = 0
while time.time() - started < resource._timeout:
try:
if resource.is_deleted():
return
except Exception as e:
LOG.exception(
"Seems like %s.%s.is_deleted(self) method is broken "
"It shouldn't raise any exceptions."
% (resource.__module__, type(resource).__name__))
# NOTE(boris-42): Avoid LOG spamming in case of bad
# is_deleted() method
failures_count += 1
if failures_count > resource._max_attempts:
break
finally:
rutils.interruptable_sleep(resource._interval)
LOG.warning("Resource deletion failed, timeout occurred for "
"docker.%(resource)s: %(uuid)s." % msg_kw)
def _publisher(self, queue):
"""Publisher for deletion jobs.
This method lists all resources (using manager_cls) and puts jobs for
deletion.
"""
try:
for raw_resource in rutils.retry(
3, self.manager_cls.list, self.client):
queue.append(raw_resource)
except Exception:
LOG.exception(
"Seems like %s.%s.list(self) method is broken. "
"It shouldn't raise any exceptions."
% (self.manager_cls.__module__, self.manager_cls.__name__))
def _consumer(self, cache, raw_resource):
"""Method that consumes single deletion job."""
names = raw_resource.name()
if not isinstance(names, list):
names = [names]
for name in names:
if rutils.name_matches_object(
name, *self.resource_classes,
task_id=self.owner_id, exact=False):
self._delete_single_resource(raw_resource)
break
def exterminate(self):
"""Delete all resources for passed resource_mgr."""
broker.run(self._publisher, self._consumer,
consumers_count=self.manager_cls._threads)
def find_resource_managers(names=None):
"""Returns resource managers.
:param names: List of names that is used for filtering resource manager
classes
"""
names = set(names or [])
resource_managers = []
for manager in discover.itersubclasses(resources.ResourceManager):
if manager._name in names:
resource_managers.append(manager)
resource_managers.sort(key=lambda x: x._order)
found_names = set()
for mgr in resource_managers:
found_names.add(mgr._name)
missing = names - found_names
if missing:
LOG.warning("Missing resource managers: %s" % ", ".join(missing))
return resource_managers
def cleanup(spec, names=None, superclass=plugin.Plugin, owner_id=None):
"""Generic cleaner.
This method goes through all plugins. Filter those and left only plugins
with _service from services or _resource from resources.
:param spec: a spec for Docker client
:param names: Use only resource managers that have names in this list.
:param superclass: The plugin superclass to perform cleanup
for. E.g., this could be
``rally.task.scenario.Scenario`` to cleanup all
Scenario resources.
:param owner_id: The UUID of an owner of resource. If it was created at
workload level, it should be workload UUID. If it was created at
subtask level, it should be subtask UUID.
"""
resource_classes = [cls for cls in discover.itersubclasses(superclass)
if issubclass(cls, rutils.RandomNameGeneratorMixin)]
if not resource_classes and issubclass(superclass,
rutils.RandomNameGeneratorMixin):
resource_classes.append(superclass)
docker = service.Docker(spec)
for manager in find_resource_managers(names):
LOG.debug("Cleaning up docker %s objects" % manager._name)
SeekAndDestroy(manager, docker,
resource_classes=resource_classes,
owner_id=owner_id).exterminate()
|
nilq/baby-python
|
python
|
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.10
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
def swig_import_helper():
import importlib
pkg = __name__.rpartition('.')[0]
mname = '.'.join((pkg, '_libvncxx')).lstrip('.')
try:
return importlib.import_module(mname)
except ImportError:
return importlib.import_module('_libvncxx')
_libvncxx = swig_import_helper()
del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
def swig_import_helper():
from os.path import dirname
import imp
fp = None
try:
fp, pathname, description = imp.find_module('_libvncxx', [dirname(__file__)])
except ImportError:
import _libvncxx
return _libvncxx
if fp is not None:
try:
_mod = imp.load_module('_libvncxx', fp, pathname, description)
finally:
fp.close()
return _mod
_libvncxx = swig_import_helper()
del swig_import_helper
else:
import _libvncxx
del _swig_python_version_info
try:
_swig_property = property
except NameError:
pass # Python < 2.2 doesn't have 'property'.
try:
import builtins as __builtin__
except ImportError:
import __builtin__
def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
if (name == "thisown"):
return self.this.own(value)
if (name == "this"):
if type(value).__name__ == 'SwigPyObject':
self.__dict__[name] = value
return
method = class_type.__swig_setmethods__.get(name, None)
if method:
return method(self, value)
if (not static):
if _newclass:
object.__setattr__(self, name, value)
else:
self.__dict__[name] = value
else:
raise AttributeError("You cannot add attributes to %s" % self)
def _swig_setattr(self, class_type, name, value):
return _swig_setattr_nondynamic(self, class_type, name, value, 0)
def _swig_getattr(self, class_type, name):
if (name == "thisown"):
return self.this.own()
method = class_type.__swig_getmethods__.get(name, None)
if method:
return method(self)
raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))
def _swig_repr(self):
try:
strthis = "proxy of " + self.this.__repr__()
except __builtin__.Exception:
strthis = ""
return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
try:
_object = object
_newclass = 1
except __builtin__.Exception:
class _object:
pass
_newclass = 0
class vec3f(_object):
"""Proxy of C++ vn::math::vec<(3,float)> class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, vec3f, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, vec3f, name)
def __init__(self, *args):
"""
__init__(vn::math::vec<(3,float)> self) -> vec3f
__init__(vn::math::vec<(3,float)> self, float val) -> vec3f
__init__(vn::math::vec<(3,float)> self, float const & x_val, float const & y_val, float const & z_val) -> vec3f
"""
this = _libvncxx.new_vec3f(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
def zero():
"""zero() -> vec3f"""
return _libvncxx.vec3f_zero()
zero = staticmethod(zero)
def one():
"""one() -> vec3f"""
return _libvncxx.vec3f_one()
one = staticmethod(one)
def unitX():
"""unitX() -> vec3f"""
return _libvncxx.vec3f_unitX()
unitX = staticmethod(unitX)
def unitY():
"""unitY() -> vec3f"""
return _libvncxx.vec3f_unitY()
unitY = staticmethod(unitY)
def unitZ():
"""unitZ() -> vec3f"""
return _libvncxx.vec3f_unitZ()
unitZ = staticmethod(unitZ)
def __neg__(self):
"""__neg__(vec3f self) -> vec3f"""
return _libvncxx.vec3f___neg__(self)
def __iadd__(self, rhs):
"""__iadd__(vec3f self, vec3f rhs) -> vec3f"""
return _libvncxx.vec3f___iadd__(self, rhs)
def __isub__(self, rhs):
"""__isub__(vec3f self, vec3f rhs) -> vec3f"""
return _libvncxx.vec3f___isub__(self, rhs)
def __imul__(self, rhs):
"""__imul__(vec3f self, float const & rhs) -> vec3f"""
return _libvncxx.vec3f___imul__(self, rhs)
def __idiv__(self, rhs):
"""__idiv__(vec3f self, float const & rhs) -> vec3f"""
return _libvncxx.vec3f___idiv__(self, rhs)
def dim(self):
"""dim(vec3f self) -> size_t"""
return _libvncxx.vec3f_dim(self)
def neg(self):
"""neg(vec3f self) -> vec3f"""
return _libvncxx.vec3f_neg(self)
def mag(self):
"""mag(vec3f self) -> float"""
return _libvncxx.vec3f_mag(self)
def add(self, toAdd):
"""add(vec3f self, vec3f toAdd) -> vec3f"""
return _libvncxx.vec3f_add(self, toAdd)
def sub(self, to_sub):
"""sub(vec3f self, vec3f to_sub) -> vec3f"""
return _libvncxx.vec3f_sub(self, to_sub)
def mult(self, scalar):
"""mult(vec3f self, double const & scalar) -> vec3f"""
return _libvncxx.vec3f_mult(self, scalar)
def div(self, scalar):
"""div(vec3f self, double const & scalar) -> vec3f"""
return _libvncxx.vec3f_div(self, scalar)
def norm(self):
"""norm(vec3f self) -> vec3f"""
return _libvncxx.vec3f_norm(self)
def dot(self, rhs):
"""dot(vec3f self, vec3f rhs) -> float"""
return _libvncxx.vec3f_dot(self, rhs)
def cross(self, rhs):
"""cross(vec3f self, vec3f rhs) -> vec3f"""
return _libvncxx.vec3f_cross(self, rhs)
def __getX(self):
"""__getX(vec3f self) -> float"""
return _libvncxx.vec3f___getX(self)
def __setX(self, v):
"""__setX(vec3f self, float v)"""
return _libvncxx.vec3f___setX(self, v)
def __getY(self):
"""__getY(vec3f self) -> float"""
return _libvncxx.vec3f___getY(self)
def __setY(self, v):
"""__setY(vec3f self, float v)"""
return _libvncxx.vec3f___setY(self, v)
def __getZ(self):
"""__getZ(vec3f self) -> float"""
return _libvncxx.vec3f___getZ(self)
def __setZ(self, v):
"""__setZ(vec3f self, float v)"""
return _libvncxx.vec3f___setZ(self, v)
x = property(__getX, __setX)
y = property(__getY, __setY)
z = property(__getZ, __setZ)
def __iter__(self):
for v in [ self.x, self.y, self.z ]:
yield v
def __repr__(self):
"""__repr__(vec3f self) -> char *"""
return _libvncxx.vec3f___repr__(self)
def __str__(self):
"""__str__(vec3f self) -> char *"""
return _libvncxx.vec3f___str__(self)
__swig_destroy__ = _libvncxx.delete_vec3f
__del__ = lambda self: None
vec3f_swigregister = _libvncxx.vec3f_swigregister
vec3f_swigregister(vec3f)
def vec3f_zero():
"""vec3f_zero() -> vec3f"""
return _libvncxx.vec3f_zero()
def vec3f_one():
"""vec3f_one() -> vec3f"""
return _libvncxx.vec3f_one()
def vec3f_unitX():
"""vec3f_unitX() -> vec3f"""
return _libvncxx.vec3f_unitX()
def vec3f_unitY():
"""vec3f_unitY() -> vec3f"""
return _libvncxx.vec3f_unitY()
def vec3f_unitZ():
"""vec3f_unitZ() -> vec3f"""
return _libvncxx.vec3f_unitZ()
class vec3d(_object):
"""Proxy of C++ vn::math::vec<(3,double)> class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, vec3d, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, vec3d, name)
def __init__(self, *args):
"""
__init__(vn::math::vec<(3,double)> self) -> vec3d
__init__(vn::math::vec<(3,double)> self, double val) -> vec3d
__init__(vn::math::vec<(3,double)> self, double const & x_val, double const & y_val, double const & z_val) -> vec3d
"""
this = _libvncxx.new_vec3d(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
def zero():
"""zero() -> vec3d"""
return _libvncxx.vec3d_zero()
zero = staticmethod(zero)
def one():
"""one() -> vec3d"""
return _libvncxx.vec3d_one()
one = staticmethod(one)
def unitX():
"""unitX() -> vec3d"""
return _libvncxx.vec3d_unitX()
unitX = staticmethod(unitX)
def unitY():
"""unitY() -> vec3d"""
return _libvncxx.vec3d_unitY()
unitY = staticmethod(unitY)
def unitZ():
"""unitZ() -> vec3d"""
return _libvncxx.vec3d_unitZ()
unitZ = staticmethod(unitZ)
def __neg__(self):
"""__neg__(vec3d self) -> vec3d"""
return _libvncxx.vec3d___neg__(self)
def __iadd__(self, rhs):
"""__iadd__(vec3d self, vec3d rhs) -> vec3d"""
return _libvncxx.vec3d___iadd__(self, rhs)
def __isub__(self, rhs):
"""__isub__(vec3d self, vec3d rhs) -> vec3d"""
return _libvncxx.vec3d___isub__(self, rhs)
def __imul__(self, rhs):
"""__imul__(vec3d self, double const & rhs) -> vec3d"""
return _libvncxx.vec3d___imul__(self, rhs)
def __idiv__(self, rhs):
"""__idiv__(vec3d self, double const & rhs) -> vec3d"""
return _libvncxx.vec3d___idiv__(self, rhs)
def dim(self):
"""dim(vec3d self) -> size_t"""
return _libvncxx.vec3d_dim(self)
def neg(self):
"""neg(vec3d self) -> vec3d"""
return _libvncxx.vec3d_neg(self)
def mag(self):
"""mag(vec3d self) -> double"""
return _libvncxx.vec3d_mag(self)
def add(self, toAdd):
"""add(vec3d self, vec3d toAdd) -> vec3d"""
return _libvncxx.vec3d_add(self, toAdd)
def sub(self, to_sub):
"""sub(vec3d self, vec3d to_sub) -> vec3d"""
return _libvncxx.vec3d_sub(self, to_sub)
def mult(self, scalar):
"""mult(vec3d self, double const & scalar) -> vec3d"""
return _libvncxx.vec3d_mult(self, scalar)
def div(self, scalar):
"""div(vec3d self, double const & scalar) -> vec3d"""
return _libvncxx.vec3d_div(self, scalar)
def norm(self):
"""norm(vec3d self) -> vec3d"""
return _libvncxx.vec3d_norm(self)
def dot(self, rhs):
"""dot(vec3d self, vec3d rhs) -> double"""
return _libvncxx.vec3d_dot(self, rhs)
def cross(self, rhs):
"""cross(vec3d self, vec3d rhs) -> vec3d"""
return _libvncxx.vec3d_cross(self, rhs)
def __getX(self):
"""__getX(vec3d self) -> float"""
return _libvncxx.vec3d___getX(self)
def __setX(self, v):
"""__setX(vec3d self, double v)"""
return _libvncxx.vec3d___setX(self, v)
def __getY(self):
"""__getY(vec3d self) -> float"""
return _libvncxx.vec3d___getY(self)
def __setY(self, v):
"""__setY(vec3d self, double v)"""
return _libvncxx.vec3d___setY(self, v)
def __getZ(self):
"""__getZ(vec3d self) -> float"""
return _libvncxx.vec3d___getZ(self)
def __setZ(self, v):
"""__setZ(vec3d self, double v)"""
return _libvncxx.vec3d___setZ(self, v)
x = property(__getX, __setX)
y = property(__getY, __setY)
z = property(__getZ, __setZ)
def __iter__(self):
for v in [ self.x, self.y, self.z ]:
yield v
def __repr__(self):
"""__repr__(vec3d self) -> char *"""
return _libvncxx.vec3d___repr__(self)
def __str__(self):
"""__str__(vec3d self) -> char *"""
return _libvncxx.vec3d___str__(self)
__swig_destroy__ = _libvncxx.delete_vec3d
__del__ = lambda self: None
vec3d_swigregister = _libvncxx.vec3d_swigregister
vec3d_swigregister(vec3d)
def vec3d_zero():
"""vec3d_zero() -> vec3d"""
return _libvncxx.vec3d_zero()
def vec3d_one():
"""vec3d_one() -> vec3d"""
return _libvncxx.vec3d_one()
def vec3d_unitX():
"""vec3d_unitX() -> vec3d"""
return _libvncxx.vec3d_unitX()
def vec3d_unitY():
"""vec3d_unitY() -> vec3d"""
return _libvncxx.vec3d_unitY()
def vec3d_unitZ():
"""vec3d_unitZ() -> vec3d"""
return _libvncxx.vec3d_unitZ()
class vec4f(_object):
"""Proxy of C++ vn::math::vec<(4,float)> class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, vec4f, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, vec4f, name)
def __init__(self, *args):
"""
__init__(vn::math::vec<(4,float)> self) -> vec4f
__init__(vn::math::vec<(4,float)> self, float val) -> vec4f
__init__(vn::math::vec<(4,float)> self, float x_val, float y_val, float z_val, float w_val) -> vec4f
"""
this = _libvncxx.new_vec4f(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
def zero():
"""zero() -> vec4f"""
return _libvncxx.vec4f_zero()
zero = staticmethod(zero)
def one():
"""one() -> vec4f"""
return _libvncxx.vec4f_one()
one = staticmethod(one)
def unitX():
"""unitX() -> vec4f"""
return _libvncxx.vec4f_unitX()
unitX = staticmethod(unitX)
def unitY():
"""unitY() -> vec4f"""
return _libvncxx.vec4f_unitY()
unitY = staticmethod(unitY)
def unitZ():
"""unitZ() -> vec4f"""
return _libvncxx.vec4f_unitZ()
unitZ = staticmethod(unitZ)
def unitW():
"""unitW() -> vec4f"""
return _libvncxx.vec4f_unitW()
unitW = staticmethod(unitW)
def __neg__(self):
"""__neg__(vec4f self) -> vec4f"""
return _libvncxx.vec4f___neg__(self)
def __iadd__(self, rhs):
"""__iadd__(vec4f self, vec4f rhs) -> vec4f"""
return _libvncxx.vec4f___iadd__(self, rhs)
def __isub__(self, rhs):
"""__isub__(vec4f self, vec4f rhs) -> vec4f"""
return _libvncxx.vec4f___isub__(self, rhs)
def __imul__(self, rhs):
"""__imul__(vec4f self, float const & rhs) -> vec4f"""
return _libvncxx.vec4f___imul__(self, rhs)
def __idiv__(self, rhs):
"""__idiv__(vec4f self, float const & rhs) -> vec4f"""
return _libvncxx.vec4f___idiv__(self, rhs)
def dim(self):
"""dim(vec4f self) -> size_t"""
return _libvncxx.vec4f_dim(self)
def neg(self):
"""neg(vec4f self) -> vec4f"""
return _libvncxx.vec4f_neg(self)
def mag(self):
"""mag(vec4f self) -> float"""
return _libvncxx.vec4f_mag(self)
def add(self, toAdd):
"""add(vec4f self, vec4f toAdd) -> vec4f"""
return _libvncxx.vec4f_add(self, toAdd)
def sub(self, to_sub):
"""sub(vec4f self, vec4f to_sub) -> vec4f"""
return _libvncxx.vec4f_sub(self, to_sub)
def mult(self, scalar):
"""mult(vec4f self, double const & scalar) -> vec4f"""
return _libvncxx.vec4f_mult(self, scalar)
def div(self, scalar):
"""div(vec4f self, double const & scalar) -> vec4f"""
return _libvncxx.vec4f_div(self, scalar)
def norm(self):
"""norm(vec4f self) -> vec4f"""
return _libvncxx.vec4f_norm(self)
def dot(self, rhs):
"""dot(vec4f self, vec4f rhs) -> float"""
return _libvncxx.vec4f_dot(self, rhs)
def __getX(self):
"""__getX(vec4f self) -> float"""
return _libvncxx.vec4f___getX(self)
def __setX(self, v):
"""__setX(vec4f self, float v)"""
return _libvncxx.vec4f___setX(self, v)
def __getY(self):
"""__getY(vec4f self) -> float"""
return _libvncxx.vec4f___getY(self)
def __setY(self, v):
"""__setY(vec4f self, float v)"""
return _libvncxx.vec4f___setY(self, v)
def __getZ(self):
"""__getZ(vec4f self) -> float"""
return _libvncxx.vec4f___getZ(self)
def __setZ(self, v):
"""__setZ(vec4f self, float v)"""
return _libvncxx.vec4f___setZ(self, v)
def __getW(self):
"""__getW(vec4f self) -> float"""
return _libvncxx.vec4f___getW(self)
def __setW(self, v):
"""__setW(vec4f self, float v)"""
return _libvncxx.vec4f___setW(self, v)
x = property(__getX, __setX)
y = property(__getY, __setY)
z = property(__getZ, __setZ)
w = property(__getW, __setW)
def __iter__(self):
for v in [ self.x, self.y, self.z, self.w ]:
yield v
#def __repr__(self):
# return "<vnpy.vec4f>"
def __repr__(self):
"""__repr__(vec4f self) -> char *"""
return _libvncxx.vec4f___repr__(self)
def __str__(self):
"""__str__(vec4f self) -> char *"""
return _libvncxx.vec4f___str__(self)
__swig_destroy__ = _libvncxx.delete_vec4f
__del__ = lambda self: None
vec4f_swigregister = _libvncxx.vec4f_swigregister
vec4f_swigregister(vec4f)
def vec4f_zero():
"""vec4f_zero() -> vec4f"""
return _libvncxx.vec4f_zero()
def vec4f_one():
"""vec4f_one() -> vec4f"""
return _libvncxx.vec4f_one()
def vec4f_unitX():
"""vec4f_unitX() -> vec4f"""
return _libvncxx.vec4f_unitX()
def vec4f_unitY():
"""vec4f_unitY() -> vec4f"""
return _libvncxx.vec4f_unitY()
def vec4f_unitZ():
"""vec4f_unitZ() -> vec4f"""
return _libvncxx.vec4f_unitZ()
def vec4f_unitW():
"""vec4f_unitW() -> vec4f"""
return _libvncxx.vec4f_unitW()
class mat3f(_object):
"""Proxy of C++ vn::math::mat<(3,3,float)> class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, mat3f, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, mat3f, name)
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(vn::math::mat<(3,3,float)> self) -> mat3f
__init__(vn::math::mat<(3,3,float)> self, float val) -> mat3f
__init__(vn::math::mat<(3,3,float)> self, float e00v, float e01v, float e02v, float e10v, float e11v, float e12v, float e20v, float e21v, float e22v) -> mat3f
__init__(vn::math::mat<(3,3,float)> self, vec3f col0, vec3f col1, vec3f col2) -> mat3f
"""
this = _libvncxx.new_mat3f(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
def zero():
"""zero() -> mat3f"""
return _libvncxx.mat3f_zero()
zero = staticmethod(zero)
def one():
"""one() -> mat3f"""
return _libvncxx.mat3f_one()
one = staticmethod(one)
def identity():
"""identity() -> mat3f"""
return _libvncxx.mat3f_identity()
identity = staticmethod(identity)
def __call__(self, *args):
"""
__call__(mat3f self, size_t row, size_t col) -> float
__call__(mat3f self, size_t row, size_t col) -> float const &
"""
return _libvncxx.mat3f___call__(self, *args)
def __neg__(self):
"""__neg__(mat3f self) -> mat3f"""
return _libvncxx.mat3f___neg__(self)
def dimRow(self):
"""dimRow(mat3f self) -> size_t"""
return _libvncxx.mat3f_dimRow(self)
def dimCol(self):
"""dimCol(mat3f self) -> size_t"""
return _libvncxx.mat3f_dimCol(self)
def dimCols(self):
"""dimCols(mat3f self) -> size_t"""
return _libvncxx.mat3f_dimCols(self)
def neg(self):
"""neg(mat3f self) -> mat3f"""
return _libvncxx.mat3f_neg(self)
def mult(self, scalar):
"""mult(mat3f self, double const & scalar) -> mat3f"""
return _libvncxx.mat3f_mult(self, scalar)
def div(self, scalar):
"""div(mat3f self, double const & scalar) -> mat3f"""
return _libvncxx.mat3f_div(self, scalar)
def add(self, toAdd):
"""add(mat3f self, mat3f toAdd) -> mat3f"""
return _libvncxx.mat3f_add(self, toAdd)
def sub(self, toSub):
"""sub(mat3f self, mat3f toSub) -> mat3f"""
return _libvncxx.mat3f_sub(self, toSub)
def transpose(self):
"""transpose(mat3f self) -> mat3f"""
return _libvncxx.mat3f_transpose(self)
def __getE00(self):
"""__getE00(mat3f self) -> float"""
return _libvncxx.mat3f___getE00(self)
def __setE00(self, v):
"""__setE00(mat3f self, float v)"""
return _libvncxx.mat3f___setE00(self, v)
def __getE01(self):
"""__getE01(mat3f self) -> float"""
return _libvncxx.mat3f___getE01(self)
def __setE01(self, v):
"""__setE01(mat3f self, float v)"""
return _libvncxx.mat3f___setE01(self, v)
def __getE02(self):
"""__getE02(mat3f self) -> float"""
return _libvncxx.mat3f___getE02(self)
def __setE02(self, v):
"""__setE02(mat3f self, float v)"""
return _libvncxx.mat3f___setE02(self, v)
def __getE10(self):
"""__getE10(mat3f self) -> float"""
return _libvncxx.mat3f___getE10(self)
def __setE10(self, v):
"""__setE10(mat3f self, float v)"""
return _libvncxx.mat3f___setE10(self, v)
def __getE11(self):
"""__getE11(mat3f self) -> float"""
return _libvncxx.mat3f___getE11(self)
def __setE11(self, v):
"""__setE11(mat3f self, float v)"""
return _libvncxx.mat3f___setE11(self, v)
def __getE12(self):
"""__getE12(mat3f self) -> float"""
return _libvncxx.mat3f___getE12(self)
def __setE12(self, v):
"""__setE12(mat3f self, float v)"""
return _libvncxx.mat3f___setE12(self, v)
def __getE20(self):
"""__getE20(mat3f self) -> float"""
return _libvncxx.mat3f___getE20(self)
def __setE20(self, v):
"""__setE20(mat3f self, float v)"""
return _libvncxx.mat3f___setE20(self, v)
def __getE21(self):
"""__getE21(mat3f self) -> float"""
return _libvncxx.mat3f___getE21(self)
def __setE21(self, v):
"""__setE21(mat3f self, float v)"""
return _libvncxx.mat3f___setE21(self, v)
def __getE22(self):
"""__getE22(mat3f self) -> float"""
return _libvncxx.mat3f___getE22(self)
def __setE22(self, v):
"""__setE22(mat3f self, float v)"""
return _libvncxx.mat3f___setE22(self, v)
e00 = property(__getE00, __setE00)
e01 = property(__getE01, __setE01)
e02 = property(__getE02, __setE02)
e10 = property(__getE10, __setE10)
e11 = property(__getE11, __setE11)
e12 = property(__getE12, __setE12)
e20 = property(__getE20, __setE20)
e21 = property(__getE21, __setE21)
e22 = property(__getE22, __setE22)
# TODO: Not sure how to return considering row- vs. column-ordering.
#def __iter__(self):
# for v in [ self.e00, self.e01, self.e02, self.e10, self.e11, self.e12, self.e20, self.e21, self.e22 ]:
# yield v
#def __repr__(self):
# return "<vnpy.mat3f>"
__swig_destroy__ = _libvncxx.delete_mat3f
__del__ = lambda self: None
mat3f_swigregister = _libvncxx.mat3f_swigregister
mat3f_swigregister(mat3f)
def mat3f_zero():
"""mat3f_zero() -> mat3f"""
return _libvncxx.mat3f_zero()
def mat3f_one():
"""mat3f_one() -> mat3f"""
return _libvncxx.mat3f_one()
def mat3f_identity():
"""mat3f_identity() -> mat3f"""
return _libvncxx.mat3f_identity()
class Attitude(_object):
"""Proxy of C++ vn::math::AttitudeF class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Attitude, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Attitude, name)
__repr__ = _swig_repr
def no_rotation():
"""no_rotation() -> Attitude"""
return _libvncxx.Attitude_no_rotation()
no_rotation = staticmethod(no_rotation)
def from_quat(quat):
"""from_quat(vec4f quat) -> Attitude"""
return _libvncxx.Attitude_from_quat(quat)
from_quat = staticmethod(from_quat)
def from_ypr_degs(yprInDegs):
"""from_ypr_degs(vec3f yprInDegs) -> Attitude"""
return _libvncxx.Attitude_from_ypr_degs(yprInDegs)
from_ypr_degs = staticmethod(from_ypr_degs)
def from_ypr_rads(yprInRads):
"""from_ypr_rads(vec3f yprInRads) -> Attitude"""
return _libvncxx.Attitude_from_ypr_rads(yprInRads)
from_ypr_rads = staticmethod(from_ypr_rads)
def from_dcm(dcm):
"""from_dcm(mat3f dcm) -> Attitude"""
return _libvncxx.Attitude_from_dcm(dcm)
from_dcm = staticmethod(from_dcm)
def __init__(self):
"""__init__(vn::math::AttitudeF self) -> Attitude"""
this = _libvncxx.new_Attitude()
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
def __yprInDegs(self):
"""__yprInDegs(Attitude self) -> vec3f"""
return _libvncxx.Attitude___yprInDegs(self)
def __yprInRads(self):
"""__yprInRads(Attitude self) -> vec3f"""
return _libvncxx.Attitude___yprInRads(self)
def __quat(self):
"""__quat(Attitude self) -> vec4f"""
return _libvncxx.Attitude___quat(self)
def __dcm(self):
"""__dcm(Attitude self) -> mat3f"""
return _libvncxx.Attitude___dcm(self)
ypr_degs = property(__yprInDegs)
ypr_rads = property(__yprInRads)
quat = property(__quat)
dcm = property(__dcm)
def __repr__(self):
return "<vnpy.Attitude>"
__swig_destroy__ = _libvncxx.delete_Attitude
__del__ = lambda self: None
Attitude_swigregister = _libvncxx.Attitude_swigregister
Attitude_swigregister(Attitude)
def Attitude_no_rotation():
"""Attitude_no_rotation() -> Attitude"""
return _libvncxx.Attitude_no_rotation()
def Attitude_from_quat(quat):
"""Attitude_from_quat(vec4f quat) -> Attitude"""
return _libvncxx.Attitude_from_quat(quat)
def Attitude_from_ypr_degs(yprInDegs):
"""Attitude_from_ypr_degs(vec3f yprInDegs) -> Attitude"""
return _libvncxx.Attitude_from_ypr_degs(yprInDegs)
def Attitude_from_ypr_rads(yprInRads):
"""Attitude_from_ypr_rads(vec3f yprInRads) -> Attitude"""
return _libvncxx.Attitude_from_ypr_rads(yprInRads)
def Attitude_from_dcm(dcm):
"""Attitude_from_dcm(mat3f dcm) -> Attitude"""
return _libvncxx.Attitude_from_dcm(dcm)
class Position(_object):
"""Proxy of C++ vn::math::PositionD class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Position, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Position, name)
__repr__ = _swig_repr
def __init__(self):
"""__init__(vn::math::PositionD self) -> Position"""
this = _libvncxx.new_Position()
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
def from_lla(lla):
"""from_lla(vec3d lla) -> Position"""
return _libvncxx.Position_from_lla(lla)
from_lla = staticmethod(from_lla)
def from_ecef(ecef):
"""from_ecef(vec3d ecef) -> Position"""
return _libvncxx.Position_from_ecef(ecef)
from_ecef = staticmethod(from_ecef)
def __repr__(self):
return "<vnpy.Position>"
__swig_destroy__ = _libvncxx.delete_Position
__del__ = lambda self: None
Position_swigregister = _libvncxx.Position_swigregister
Position_swigregister(Position)
def Position_from_lla(lla):
"""Position_from_lla(vec3d lla) -> Position"""
return _libvncxx.Position_from_lla(lla)
def Position_from_ecef(ecef):
"""Position_from_ecef(vec3d ecef) -> Position"""
return _libvncxx.Position_from_ecef(ecef)
def __rad2deg_f(angleInRads):
"""__rad2deg_f(float angleInRads) -> float"""
return _libvncxx.__rad2deg_f(angleInRads)
def __rad2deg_d(angleInRads):
"""__rad2deg_d(double angleInRads) -> double"""
return _libvncxx.__rad2deg_d(angleInRads)
def __deg2rad_f(angleInDegs):
"""__deg2rad_f(float angleInDegs) -> float"""
return _libvncxx.__deg2rad_f(angleInDegs)
def __deg2rad_d(angleInDegs):
"""__deg2rad_d(double angleInDegs) -> double"""
return _libvncxx.__deg2rad_d(angleInDegs)
def celsius2fahren(*args):
"""
celsius2fahren(float tempInCelsius) -> float
celsius2fahren(double tempInCelsius) -> double
"""
return _libvncxx.celsius2fahren(*args)
def fahren2celsius(*args):
"""
fahren2celsius(float tempInFahren) -> float
fahren2celsius(double tempInFahren) -> double
"""
return _libvncxx.fahren2celsius(*args)
def celsius2kelvin(*args):
"""
celsius2kelvin(float tempInCelsius) -> float
celsius2kelvin(double tempInCelsius) -> double
"""
return _libvncxx.celsius2kelvin(*args)
def kelvin2celsius(*args):
"""
kelvin2celsius(float tempInKelvin) -> float
kelvin2celsius(double tempInKelvin) -> double
"""
return _libvncxx.kelvin2celsius(*args)
def fahren2kelvin(*args):
"""
fahren2kelvin(float tempInFahren) -> float
fahren2kelvin(double tempInFahren) -> double
"""
return _libvncxx.fahren2kelvin(*args)
def kelvin2fahren(*args):
"""
kelvin2fahren(float tempInKelvin) -> float
kelvin2fahren(double tempInKelvin) -> double
"""
return _libvncxx.kelvin2fahren(*args)
def ypr_degs2quat(yprInDegs):
"""ypr_degs2quat(vec3f yprInDegs) -> vec4f"""
return _libvncxx.ypr_degs2quat(yprInDegs)
def ypr_rads2quat(yprInRads):
"""ypr_rads2quat(vec3f yprInRads) -> vec4f"""
return _libvncxx.ypr_rads2quat(yprInRads)
def ypr_degs2dcm(yprInDegs):
"""ypr_degs2dcm(vec3f yprInDegs) -> mat3f"""
return _libvncxx.ypr_degs2dcm(yprInDegs)
def ypr_rads2dcm(yprInRads):
"""ypr_rads2dcm(vec3f yprInRads) -> mat3f"""
return _libvncxx.ypr_rads2dcm(yprInRads)
def quat2ypr_degs(quat):
"""quat2ypr_degs(vec4f quat) -> vec3f"""
return _libvncxx.quat2ypr_degs(quat)
def quat2ypr_rads(quat):
"""quat2ypr_rads(vec4f quat) -> vec3f"""
return _libvncxx.quat2ypr_rads(quat)
def quat2dcm(quat):
"""quat2dcm(vec4f quat) -> mat3f"""
return _libvncxx.quat2dcm(quat)
def dcm2ypr_degs(dcm):
"""dcm2ypr_degs(mat3f dcm) -> vec3f"""
return _libvncxx.dcm2ypr_degs(dcm)
def dcm2ypr_rads(dcm):
"""dcm2ypr_rads(mat3f dcm) -> vec3f"""
return _libvncxx.dcm2ypr_rads(dcm)
def dcm2quat(dcm):
"""dcm2quat(mat3f dcm) -> vec4f"""
return _libvncxx.dcm2quat(dcm)
def velocity_ned_xy2course_over_ground(velNedX, velNedY):
"""velocity_ned_xy2course_over_ground(float velNedX, float velNedY) -> float"""
return _libvncxx.velocity_ned_xy2course_over_ground(velNedX, velNedY)
def velocity_ned2course_over_ground(velNed):
"""velocity_ned2course_over_ground(vec3f velNed) -> float"""
return _libvncxx.velocity_ned2course_over_ground(velNed)
def velocity_ned_xy2speed_over_ground(velNedX, velNedY):
"""velocity_ned_xy2speed_over_ground(float velNedX, float velNedY) -> float"""
return _libvncxx.velocity_ned_xy2speed_over_ground(velNedX, velNedY)
def velocity_ned2speed_over_ground(velNed):
"""velocity_ned2speed_over_ground(vec3f velNed) -> float"""
return _libvncxx.velocity_ned2speed_over_ground(velNed)
def quat2omega_phi_kappa_rads(quat):
"""quat2omega_phi_kappa_rads(vec4f quat) -> vec3f"""
return _libvncxx.quat2omega_phi_kappa_rads(quat)
def dcm2omega_phi_kappa_rads(dcm):
"""dcm2omega_phi_kappa_rads(mat3f dcm) -> vec3f"""
return _libvncxx.dcm2omega_phi_kappa_rads(dcm)
def ypr_degs2omega_phi_kappa_rads(yprDegs):
"""ypr_degs2omega_phi_kappa_rads(vec3f yprDegs) -> vec3f"""
return _libvncxx.ypr_degs2omega_phi_kappa_rads(yprDegs)
def ypr_rads2omega_phi_kappa_rads(yprRads):
"""ypr_rads2omega_phi_kappa_rads(vec3f yprRads) -> vec3f"""
return _libvncxx.ypr_rads2omega_phi_kappa_rads(yprRads)
def __rad2deg_v3f(anglesInRads):
"""__rad2deg_v3f(vec3f anglesInRads) -> vec3f"""
return _libvncxx.__rad2deg_v3f(anglesInRads)
def __rad2deg_v3d(anglesInRads):
"""__rad2deg_v3d(vec3f anglesInRads) -> vec3f"""
return _libvncxx.__rad2deg_v3d(anglesInRads)
def __deg2rad_v3f(anglesInDegs):
"""__deg2rad_v3f(vec3f anglesInDegs) -> vec3f"""
return _libvncxx.__deg2rad_v3f(anglesInDegs)
def __deg2rad_v3d(anglesInDegs):
"""__deg2rad_v3d(vec3f anglesInDegs) -> vec3f"""
return _libvncxx.__deg2rad_v3d(anglesInDegs)
ERRORDETECTIONMODE_NONE = _libvncxx.ERRORDETECTIONMODE_NONE
ERRORDETECTIONMODE_CHECKSUM = _libvncxx.ERRORDETECTIONMODE_CHECKSUM
ERRORDETECTIONMODE_CRC = _libvncxx.ERRORDETECTIONMODE_CRC
VNOFF = _libvncxx.VNOFF
VNYPR = _libvncxx.VNYPR
VNQTN = _libvncxx.VNQTN
VNQMR = _libvncxx.VNQMR
VNMAG = _libvncxx.VNMAG
VNACC = _libvncxx.VNACC
VNGYR = _libvncxx.VNGYR
VNMAR = _libvncxx.VNMAR
VNYMR = _libvncxx.VNYMR
VNYBA = _libvncxx.VNYBA
VNYIA = _libvncxx.VNYIA
VNIMU = _libvncxx.VNIMU
VNGPS = _libvncxx.VNGPS
VNGPE = _libvncxx.VNGPE
VNINS = _libvncxx.VNINS
VNINE = _libvncxx.VNINE
VNISL = _libvncxx.VNISL
VNISE = _libvncxx.VNISE
VNDTV = _libvncxx.VNDTV
SYNCINMODE_COUNT = _libvncxx.SYNCINMODE_COUNT
SYNCINMODE_IMU = _libvncxx.SYNCINMODE_IMU
SYNCINMODE_ASYNC = _libvncxx.SYNCINMODE_ASYNC
SYNCINEDGE_RISING = _libvncxx.SYNCINEDGE_RISING
SYNCINEDGE_FALLING = _libvncxx.SYNCINEDGE_FALLING
SYNCOUTMODE_NONE = _libvncxx.SYNCOUTMODE_NONE
SYNCOUTMODE_ITEMSTART = _libvncxx.SYNCOUTMODE_ITEMSTART
SYNCOUTMODE_IMUREADY = _libvncxx.SYNCOUTMODE_IMUREADY
SYNCOUTMODE_INS = _libvncxx.SYNCOUTMODE_INS
SYNCOUTMODE_GPSPPS = _libvncxx.SYNCOUTMODE_GPSPPS
SYNCOUTPOLARITY_NEGATIVE = _libvncxx.SYNCOUTPOLARITY_NEGATIVE
SYNCOUTPOLARITY_POSITIVE = _libvncxx.SYNCOUTPOLARITY_POSITIVE
COUNTMODE_NONE = _libvncxx.COUNTMODE_NONE
COUNTMODE_SYNCINCOUNT = _libvncxx.COUNTMODE_SYNCINCOUNT
COUNTMODE_SYNCINTIME = _libvncxx.COUNTMODE_SYNCINTIME
COUNTMODE_SYNCOUTCOUNTER = _libvncxx.COUNTMODE_SYNCOUTCOUNTER
COUNTMODE_GPSPPS = _libvncxx.COUNTMODE_GPSPPS
STATUSMODE_OFF = _libvncxx.STATUSMODE_OFF
STATUSMODE_VPESTATUS = _libvncxx.STATUSMODE_VPESTATUS
STATUSMODE_INSSTATUS = _libvncxx.STATUSMODE_INSSTATUS
CHECKSUMMODE_OFF = _libvncxx.CHECKSUMMODE_OFF
CHECKSUMMODE_CHECKSUM = _libvncxx.CHECKSUMMODE_CHECKSUM
CHECKSUMMODE_CRC = _libvncxx.CHECKSUMMODE_CRC
ERRORMODE_IGNORE = _libvncxx.ERRORMODE_IGNORE
ERRORMODE_SEND = _libvncxx.ERRORMODE_SEND
ERRORMODE_SENDANDOFF = _libvncxx.ERRORMODE_SENDANDOFF
FILTERMODE_NOFILTERING = _libvncxx.FILTERMODE_NOFILTERING
FILTERMODE_ONLYRAW = _libvncxx.FILTERMODE_ONLYRAW
FILTERMODE_ONLYCOMPENSATED = _libvncxx.FILTERMODE_ONLYCOMPENSATED
FILTERMODE_BOTH = _libvncxx.FILTERMODE_BOTH
INTEGRATIONFRAME_BODY = _libvncxx.INTEGRATIONFRAME_BODY
INTEGRATIONFRAME_NED = _libvncxx.INTEGRATIONFRAME_NED
COMPENSATIONMODE_NONE = _libvncxx.COMPENSATIONMODE_NONE
COMPENSATIONMODE_BIAS = _libvncxx.COMPENSATIONMODE_BIAS
GPSFIX_NOFIX = _libvncxx.GPSFIX_NOFIX
GPSFIX_TIMEONLY = _libvncxx.GPSFIX_TIMEONLY
GPSFIX_2D = _libvncxx.GPSFIX_2D
GPSFIX_3D = _libvncxx.GPSFIX_3D
GPSMODE_ONBOARDGPS = _libvncxx.GPSMODE_ONBOARDGPS
GPSMODE_EXTERNALGPS = _libvncxx.GPSMODE_EXTERNALGPS
GPSMODE_EXTERNALVN200GPS = _libvncxx.GPSMODE_EXTERNALVN200GPS
PPSSOURCE_GPSPPSRISING = _libvncxx.PPSSOURCE_GPSPPSRISING
PPSSOURCE_GPSPPSFALLING = _libvncxx.PPSSOURCE_GPSPPSFALLING
PPSSOURCE_SYNCINRISING = _libvncxx.PPSSOURCE_SYNCINRISING
PPSSOURCE_SYNCINFALLING = _libvncxx.PPSSOURCE_SYNCINFALLING
VPEENABLE_DISABLE = _libvncxx.VPEENABLE_DISABLE
VPEENABLE_ENABLE = _libvncxx.VPEENABLE_ENABLE
HEADINGMODE_ABSOLUTE = _libvncxx.HEADINGMODE_ABSOLUTE
HEADINGMODE_RELATIVE = _libvncxx.HEADINGMODE_RELATIVE
HEADINGMODE_INDOOR = _libvncxx.HEADINGMODE_INDOOR
VPEMODE_OFF = _libvncxx.VPEMODE_OFF
VPEMODE_MODE1 = _libvncxx.VPEMODE_MODE1
SCENARIO_AHRS = _libvncxx.SCENARIO_AHRS
SCENARIO_INSWITHPRESSURE = _libvncxx.SCENARIO_INSWITHPRESSURE
SCENARIO_INSWITHOUTPRESSURE = _libvncxx.SCENARIO_INSWITHOUTPRESSURE
SCENARIO_GPSMOVINGBASELINEDYNAMIC = _libvncxx.SCENARIO_GPSMOVINGBASELINEDYNAMIC
SCENARIO_GPSMOVINGBASELINESTATIC = _libvncxx.SCENARIO_GPSMOVINGBASELINESTATIC
HSIMODE_OFF = _libvncxx.HSIMODE_OFF
HSIMODE_RUN = _libvncxx.HSIMODE_RUN
HSIMODE_RESET = _libvncxx.HSIMODE_RESET
HSIOUTPUT_NOONBOARD = _libvncxx.HSIOUTPUT_NOONBOARD
HSIOUTPUT_USEONBOARD = _libvncxx.HSIOUTPUT_USEONBOARD
VELOCITYCOMPENSATIONMODE_DISABLED = _libvncxx.VELOCITYCOMPENSATIONMODE_DISABLED
VELOCITYCOMPENSATIONMODE_BODYMEASUREMENT = _libvncxx.VELOCITYCOMPENSATIONMODE_BODYMEASUREMENT
MAGNETICMODE_2D = _libvncxx.MAGNETICMODE_2D
MAGNETICMODE_3D = _libvncxx.MAGNETICMODE_3D
EXTERNALSENSORMODE_INTERNAL = _libvncxx.EXTERNALSENSORMODE_INTERNAL
EXTERNALSENSORMODE_EXTERNAL200HZ = _libvncxx.EXTERNALSENSORMODE_EXTERNAL200HZ
EXTERNALSENSORMODE_EXTERNALONUPDATE = _libvncxx.EXTERNALSENSORMODE_EXTERNALONUPDATE
FOAMINIT_NOFOAMINIT = _libvncxx.FOAMINIT_NOFOAMINIT
FOAMINIT_FOAMINITPITCHROLL = _libvncxx.FOAMINIT_FOAMINITPITCHROLL
FOAMINIT_FOAMINITHEADINGPITCHROLL = _libvncxx.FOAMINIT_FOAMINITHEADINGPITCHROLL
FOAMINIT_FOAMINITPITCHROLLCOVARIANCE = _libvncxx.FOAMINIT_FOAMINITPITCHROLLCOVARIANCE
FOAMINIT_FOAMINITHEADINGPITCHROLLCOVARIANCE = _libvncxx.FOAMINIT_FOAMINITHEADINGPITCHROLLCOVARIANCE
SENSSAT_MAGX = _libvncxx.SENSSAT_MAGX
SENSSAT_MAGY = _libvncxx.SENSSAT_MAGY
SENSSAT_MAGZ = _libvncxx.SENSSAT_MAGZ
SENSSAT_ACCX = _libvncxx.SENSSAT_ACCX
SENSSAT_ACCY = _libvncxx.SENSSAT_ACCY
SENSSAT_ACCZ = _libvncxx.SENSSAT_ACCZ
SENSSAT_GYROX = _libvncxx.SENSSAT_GYROX
SENSSAT_GYROY = _libvncxx.SENSSAT_GYROY
SENSSAT_GYROZ = _libvncxx.SENSSAT_GYROZ
SENSSAT_PRES = _libvncxx.SENSSAT_PRES
class VpeStatus(_object):
"""Proxy of C++ vn::protocol::uart::VpeStatus class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, VpeStatus, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, VpeStatus, name)
__repr__ = _swig_repr
__swig_setmethods__["attitudeQuality"] = _libvncxx.VpeStatus_attitudeQuality_set
__swig_getmethods__["attitudeQuality"] = _libvncxx.VpeStatus_attitudeQuality_get
if _newclass:
attitudeQuality = _swig_property(_libvncxx.VpeStatus_attitudeQuality_get, _libvncxx.VpeStatus_attitudeQuality_set)
__swig_setmethods__["gyroSaturation"] = _libvncxx.VpeStatus_gyroSaturation_set
__swig_getmethods__["gyroSaturation"] = _libvncxx.VpeStatus_gyroSaturation_get
if _newclass:
gyroSaturation = _swig_property(_libvncxx.VpeStatus_gyroSaturation_get, _libvncxx.VpeStatus_gyroSaturation_set)
__swig_setmethods__["gyroSaturationRecovery"] = _libvncxx.VpeStatus_gyroSaturationRecovery_set
__swig_getmethods__["gyroSaturationRecovery"] = _libvncxx.VpeStatus_gyroSaturationRecovery_get
if _newclass:
gyroSaturationRecovery = _swig_property(_libvncxx.VpeStatus_gyroSaturationRecovery_get, _libvncxx.VpeStatus_gyroSaturationRecovery_set)
__swig_setmethods__["magDisturbance"] = _libvncxx.VpeStatus_magDisturbance_set
__swig_getmethods__["magDisturbance"] = _libvncxx.VpeStatus_magDisturbance_get
if _newclass:
magDisturbance = _swig_property(_libvncxx.VpeStatus_magDisturbance_get, _libvncxx.VpeStatus_magDisturbance_set)
__swig_setmethods__["magSaturation"] = _libvncxx.VpeStatus_magSaturation_set
__swig_getmethods__["magSaturation"] = _libvncxx.VpeStatus_magSaturation_get
if _newclass:
magSaturation = _swig_property(_libvncxx.VpeStatus_magSaturation_get, _libvncxx.VpeStatus_magSaturation_set)
__swig_setmethods__["accDisturbance"] = _libvncxx.VpeStatus_accDisturbance_set
__swig_getmethods__["accDisturbance"] = _libvncxx.VpeStatus_accDisturbance_get
if _newclass:
accDisturbance = _swig_property(_libvncxx.VpeStatus_accDisturbance_get, _libvncxx.VpeStatus_accDisturbance_set)
__swig_setmethods__["accSaturation"] = _libvncxx.VpeStatus_accSaturation_set
__swig_getmethods__["accSaturation"] = _libvncxx.VpeStatus_accSaturation_get
if _newclass:
accSaturation = _swig_property(_libvncxx.VpeStatus_accSaturation_get, _libvncxx.VpeStatus_accSaturation_set)
__swig_setmethods__["knownMagDisturbance"] = _libvncxx.VpeStatus_knownMagDisturbance_set
__swig_getmethods__["knownMagDisturbance"] = _libvncxx.VpeStatus_knownMagDisturbance_get
if _newclass:
knownMagDisturbance = _swig_property(_libvncxx.VpeStatus_knownMagDisturbance_get, _libvncxx.VpeStatus_knownMagDisturbance_set)
__swig_setmethods__["knownAccelDisturbance"] = _libvncxx.VpeStatus_knownAccelDisturbance_set
__swig_getmethods__["knownAccelDisturbance"] = _libvncxx.VpeStatus_knownAccelDisturbance_get
if _newclass:
knownAccelDisturbance = _swig_property(_libvncxx.VpeStatus_knownAccelDisturbance_get, _libvncxx.VpeStatus_knownAccelDisturbance_set)
def __init__(self, *args):
"""
__init__(vn::protocol::uart::VpeStatus self) -> VpeStatus
__init__(vn::protocol::uart::VpeStatus self, uint16_t raw) -> VpeStatus
"""
this = _libvncxx.new_VpeStatus(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_VpeStatus
__del__ = lambda self: None
VpeStatus_swigregister = _libvncxx.VpeStatus_swigregister
VpeStatus_swigregister(VpeStatus)
INSSTATUS_NOT_TRACKING = _libvncxx.INSSTATUS_NOT_TRACKING
INSSTATUS_SUFFICIENT_DYNAMIC_MOTION = _libvncxx.INSSTATUS_SUFFICIENT_DYNAMIC_MOTION
INSSTATUS_TRACKING = _libvncxx.INSSTATUS_TRACKING
INSSTATUS_GPS_FIX = _libvncxx.INSSTATUS_GPS_FIX
INSSTATUS_TIME_ERROR = _libvncxx.INSSTATUS_TIME_ERROR
INSSTATUS_IMU_ERROR = _libvncxx.INSSTATUS_IMU_ERROR
INSSTATUS_MAG_PRES_ERROR = _libvncxx.INSSTATUS_MAG_PRES_ERROR
INSSTATUS_GPS_ERROR = _libvncxx.INSSTATUS_GPS_ERROR
class TimeUtc(_object):
"""Proxy of C++ vn::protocol::uart::TimeUtc class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, TimeUtc, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, TimeUtc, name)
__repr__ = _swig_repr
__swig_setmethods__["year"] = _libvncxx.TimeUtc_year_set
__swig_getmethods__["year"] = _libvncxx.TimeUtc_year_get
if _newclass:
year = _swig_property(_libvncxx.TimeUtc_year_get, _libvncxx.TimeUtc_year_set)
__swig_setmethods__["month"] = _libvncxx.TimeUtc_month_set
__swig_getmethods__["month"] = _libvncxx.TimeUtc_month_get
if _newclass:
month = _swig_property(_libvncxx.TimeUtc_month_get, _libvncxx.TimeUtc_month_set)
__swig_setmethods__["day"] = _libvncxx.TimeUtc_day_set
__swig_getmethods__["day"] = _libvncxx.TimeUtc_day_get
if _newclass:
day = _swig_property(_libvncxx.TimeUtc_day_get, _libvncxx.TimeUtc_day_set)
__swig_setmethods__["hour"] = _libvncxx.TimeUtc_hour_set
__swig_getmethods__["hour"] = _libvncxx.TimeUtc_hour_get
if _newclass:
hour = _swig_property(_libvncxx.TimeUtc_hour_get, _libvncxx.TimeUtc_hour_set)
__swig_setmethods__["min"] = _libvncxx.TimeUtc_min_set
__swig_getmethods__["min"] = _libvncxx.TimeUtc_min_get
if _newclass:
min = _swig_property(_libvncxx.TimeUtc_min_get, _libvncxx.TimeUtc_min_set)
__swig_setmethods__["sec"] = _libvncxx.TimeUtc_sec_set
__swig_getmethods__["sec"] = _libvncxx.TimeUtc_sec_get
if _newclass:
sec = _swig_property(_libvncxx.TimeUtc_sec_get, _libvncxx.TimeUtc_sec_set)
__swig_setmethods__["ms"] = _libvncxx.TimeUtc_ms_set
__swig_getmethods__["ms"] = _libvncxx.TimeUtc_ms_get
if _newclass:
ms = _swig_property(_libvncxx.TimeUtc_ms_get, _libvncxx.TimeUtc_ms_set)
def __init__(self):
"""__init__(vn::protocol::uart::TimeUtc self) -> TimeUtc"""
this = _libvncxx.new_TimeUtc()
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_TimeUtc
__del__ = lambda self: None
TimeUtc_swigregister = _libvncxx.TimeUtc_swigregister
TimeUtc_swigregister(TimeUtc)
def __or__(*args):
"""
__or__(COMMONGROUP lhs, COMMONGROUP rhs) -> COMMONGROUP
__or__(TIMEGROUP lhs, TIMEGROUP rhs) -> TIMEGROUP
__or__(IMUGROUP lhs, IMUGROUP rhs) -> IMUGROUP
__or__(GPSGROUP lhs, GPSGROUP rhs) -> GPSGROUP
__or__(ATTITUDEGROUP lhs, ATTITUDEGROUP rhs) -> ATTITUDEGROUP
__or__(INSGROUP lhs, INSGROUP rhs) -> INSGROUP
"""
return _libvncxx.__or__(*args)
def to_string(*args):
"""
to_string(ASYNCMODE val) -> std::string
to_string(COMMONGROUP val) -> std::string
to_string(TIMEGROUP val) -> std::string
to_string(IMUGROUP val) -> std::string
to_string(GPSGROUP val) -> std::string
to_string(ATTITUDEGROUP val) -> std::string
to_string(INSGROUP val) -> std::string
"""
return _libvncxx.to_string(*args)
def __lshift__(*args):
"""
__lshift__(std::ostream & out, ASYNCMODE e) -> std::ostream
__lshift__(std::ostream & out, COMMONGROUP e) -> std::ostream
__lshift__(std::ostream & out, TIMEGROUP e) -> std::ostream
__lshift__(std::ostream & out, IMUGROUP e) -> std::ostream
__lshift__(std::ostream & out, GPSGROUP e) -> std::ostream
__lshift__(std::ostream & out, ATTITUDEGROUP e) -> std::ostream
__lshift__(std::ostream & out, INSGROUP e) -> std::ostream &
"""
return _libvncxx.__lshift__(*args)
class Packet(_object):
"""Proxy of C++ vn::protocol::uart::Packet class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, Packet, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, Packet, name)
__repr__ = _swig_repr
__swig_getmethods__["BinaryGroupLengths"] = _libvncxx.Packet_BinaryGroupLengths_get
if _newclass:
BinaryGroupLengths = _swig_property(_libvncxx.Packet_BinaryGroupLengths_get)
TYPE_UNKNOWN = _libvncxx.Packet_TYPE_UNKNOWN
TYPE_BINARY = _libvncxx.Packet_TYPE_BINARY
TYPE_ASCII = _libvncxx.Packet_TYPE_ASCII
def __init__(self, *args):
"""
__init__(vn::protocol::uart::Packet self) -> Packet
__init__(vn::protocol::uart::Packet self, char const * packet, size_t length) -> Packet
__init__(vn::protocol::uart::Packet self, std::string packet) -> Packet
__init__(vn::protocol::uart::Packet self, Packet toCopy) -> Packet
"""
this = _libvncxx.new_Packet(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_Packet
__del__ = lambda self: None
def __datastr(self):
"""__datastr(Packet self) -> std::string"""
return _libvncxx.Packet___datastr(self)
def __type(self):
"""__type(Packet self) -> vn::protocol::uart::Packet::Type"""
return _libvncxx.Packet___type(self)
def __isValid(self):
"""__isValid(Packet self) -> bool"""
return _libvncxx.Packet___isValid(self)
def __isError(self):
"""__isError(Packet self) -> bool"""
return _libvncxx.Packet___isError(self)
def __isResponse(self):
"""__isResponse(Packet self) -> bool"""
return _libvncxx.Packet___isResponse(self)
def __isAsciiAsync(self):
"""__isAsciiAsync(Packet self) -> bool"""
return _libvncxx.Packet___isAsciiAsync(self)
def determine_ascii_async_type(self):
"""determine_ascii_async_type(Packet self) -> vn::protocol::uart::AsciiAsync"""
return _libvncxx.Packet_determine_ascii_async_type(self)
def isCompatible(self, commonGroup, timeGroup, imuGroup, gpsGroup, attitudeGroup, insGroup):
"""isCompatible(Packet self, COMMONGROUP commonGroup, TIMEGROUP timeGroup, IMUGROUP imuGroup, GPSGROUP gpsGroup, ATTITUDEGROUP attitudeGroup, INSGROUP insGroup) -> bool"""
return _libvncxx.Packet_isCompatible(self, commonGroup, timeGroup, imuGroup, gpsGroup, attitudeGroup, insGroup)
def computeBinaryPacketLength(startOfPossibleBinaryPacket):
"""computeBinaryPacketLength(char const * startOfPossibleBinaryPacket) -> size_t"""
return _libvncxx.Packet_computeBinaryPacketLength(startOfPossibleBinaryPacket)
computeBinaryPacketLength = staticmethod(computeBinaryPacketLength)
def computeNumOfBytesForBinaryGroupPayload(group, groupField):
"""computeNumOfBytesForBinaryGroupPayload(BINARYGROUP group, uint16_t groupField) -> size_t"""
return _libvncxx.Packet_computeNumOfBytesForBinaryGroupPayload(group, groupField)
computeNumOfBytesForBinaryGroupPayload = staticmethod(computeNumOfBytesForBinaryGroupPayload)
def parse_error(self):
"""parse_error(Packet self) -> SENSORERROR"""
return _libvncxx.Packet_parse_error(self)
def groups(self):
"""groups(Packet self) -> uint8_t"""
return _libvncxx.Packet_groups(self)
def groupField(self, index):
"""groupField(Packet self, size_t index) -> uint16_t"""
return _libvncxx.Packet_groupField(self, index)
def extractUint8(self):
"""extractUint8(Packet self) -> uint8_t"""
return _libvncxx.Packet_extractUint8(self)
def extractInt8(self):
"""extractInt8(Packet self) -> int8_t"""
return _libvncxx.Packet_extractInt8(self)
def extractUint16(self):
"""extractUint16(Packet self) -> uint16_t"""
return _libvncxx.Packet_extractUint16(self)
def extractUint32(self):
"""extractUint32(Packet self) -> uint32_t"""
return _libvncxx.Packet_extractUint32(self)
def extractUint64(self):
"""extractUint64(Packet self) -> uint64_t"""
return _libvncxx.Packet_extractUint64(self)
def extractFloat(self):
"""extractFloat(Packet self) -> float"""
return _libvncxx.Packet_extractFloat(self)
def extractVec3f(self):
"""extractVec3f(Packet self) -> vec3f"""
return _libvncxx.Packet_extractVec3f(self)
def extractVec3d(self):
"""extractVec3d(Packet self) -> vec3d"""
return _libvncxx.Packet_extractVec3d(self)
def extractVec4f(self):
"""extractVec4f(Packet self) -> vec4f"""
return _libvncxx.Packet_extractVec4f(self)
def extractMat3f(self):
"""extractMat3f(Packet self) -> mat3f"""
return _libvncxx.Packet_extractMat3f(self)
def finalizeCommand(errorDetectionMode, packet, length):
"""finalizeCommand(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * packet, size_t length) -> size_t"""
return _libvncxx.Packet_finalizeCommand(errorDetectionMode, packet, length)
finalizeCommand = staticmethod(finalizeCommand)
def genReadBinaryOutput1(errorDetectionMode, buffer, size):
"""genReadBinaryOutput1(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadBinaryOutput1(errorDetectionMode, buffer, size)
genReadBinaryOutput1 = staticmethod(genReadBinaryOutput1)
def genReadBinaryOutput2(errorDetectionMode, buffer, size):
"""genReadBinaryOutput2(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadBinaryOutput2(errorDetectionMode, buffer, size)
genReadBinaryOutput2 = staticmethod(genReadBinaryOutput2)
def genReadBinaryOutput3(errorDetectionMode, buffer, size):
"""genReadBinaryOutput3(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadBinaryOutput3(errorDetectionMode, buffer, size)
genReadBinaryOutput3 = staticmethod(genReadBinaryOutput3)
def genWriteBinaryOutput1(errorDetectionMode, buffer, size, asyncMode, rateDivisor, commonField, timeField, imuField, gpsField, attitudeField, insField):
"""genWriteBinaryOutput1(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint16_t asyncMode, uint16_t rateDivisor, uint16_t commonField, uint16_t timeField, uint16_t imuField, uint16_t gpsField, uint16_t attitudeField, uint16_t insField) -> size_t"""
return _libvncxx.Packet_genWriteBinaryOutput1(errorDetectionMode, buffer, size, asyncMode, rateDivisor, commonField, timeField, imuField, gpsField, attitudeField, insField)
genWriteBinaryOutput1 = staticmethod(genWriteBinaryOutput1)
def genWriteBinaryOutput2(errorDetectionMode, buffer, size, asyncMode, rateDivisor, commonField, timeField, imuField, gpsField, attitudeField, insField):
"""genWriteBinaryOutput2(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint16_t asyncMode, uint16_t rateDivisor, uint16_t commonField, uint16_t timeField, uint16_t imuField, uint16_t gpsField, uint16_t attitudeField, uint16_t insField) -> size_t"""
return _libvncxx.Packet_genWriteBinaryOutput2(errorDetectionMode, buffer, size, asyncMode, rateDivisor, commonField, timeField, imuField, gpsField, attitudeField, insField)
genWriteBinaryOutput2 = staticmethod(genWriteBinaryOutput2)
def genWriteBinaryOutput3(errorDetectionMode, buffer, size, asyncMode, rateDivisor, commonField, timeField, imuField, gpsField, attitudeField, insField):
"""genWriteBinaryOutput3(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint16_t asyncMode, uint16_t rateDivisor, uint16_t commonField, uint16_t timeField, uint16_t imuField, uint16_t gpsField, uint16_t attitudeField, uint16_t insField) -> size_t"""
return _libvncxx.Packet_genWriteBinaryOutput3(errorDetectionMode, buffer, size, asyncMode, rateDivisor, commonField, timeField, imuField, gpsField, attitudeField, insField)
genWriteBinaryOutput3 = staticmethod(genWriteBinaryOutput3)
def genWriteSettings(errorDetectionMode, buffer, size):
"""genWriteSettings(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genWriteSettings(errorDetectionMode, buffer, size)
genWriteSettings = staticmethod(genWriteSettings)
def genTare(errorDetectionMode, buffer, size):
"""genTare(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genTare(errorDetectionMode, buffer, size)
genTare = staticmethod(genTare)
def genKnownMagneticDisturbance(errorDetectionMode, buffer, size, isMagneticDisturbancePresent):
"""genKnownMagneticDisturbance(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, bool isMagneticDisturbancePresent) -> size_t"""
return _libvncxx.Packet_genKnownMagneticDisturbance(errorDetectionMode, buffer, size, isMagneticDisturbancePresent)
genKnownMagneticDisturbance = staticmethod(genKnownMagneticDisturbance)
def genKnownAccelerationDisturbance(errorDetectionMode, buffer, size, isAccelerationDisturbancePresent):
"""genKnownAccelerationDisturbance(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, bool isAccelerationDisturbancePresent) -> size_t"""
return _libvncxx.Packet_genKnownAccelerationDisturbance(errorDetectionMode, buffer, size, isAccelerationDisturbancePresent)
genKnownAccelerationDisturbance = staticmethod(genKnownAccelerationDisturbance)
def genSetGyroBias(errorDetectionMode, buffer, size):
"""genSetGyroBias(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genSetGyroBias(errorDetectionMode, buffer, size)
genSetGyroBias = staticmethod(genSetGyroBias)
def genRestoreFactorySettings(errorDetectionMode, buffer, size):
"""genRestoreFactorySettings(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genRestoreFactorySettings(errorDetectionMode, buffer, size)
genRestoreFactorySettings = staticmethod(genRestoreFactorySettings)
def genReset(errorDetectionMode, buffer, size):
"""genReset(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReset(errorDetectionMode, buffer, size)
genReset = staticmethod(genReset)
def genReadUserTag(errorDetectionMode, buffer, size):
"""genReadUserTag(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadUserTag(errorDetectionMode, buffer, size)
genReadUserTag = staticmethod(genReadUserTag)
def genWriteUserTag(errorDetectionMode, buffer, size, tag):
"""genWriteUserTag(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, std::string tag) -> size_t"""
return _libvncxx.Packet_genWriteUserTag(errorDetectionMode, buffer, size, tag)
genWriteUserTag = staticmethod(genWriteUserTag)
def genReadModelNumber(errorDetectionMode, buffer, size):
"""genReadModelNumber(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadModelNumber(errorDetectionMode, buffer, size)
genReadModelNumber = staticmethod(genReadModelNumber)
def genReadHardwareRevision(errorDetectionMode, buffer, size):
"""genReadHardwareRevision(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadHardwareRevision(errorDetectionMode, buffer, size)
genReadHardwareRevision = staticmethod(genReadHardwareRevision)
def genReadSerialNumber(errorDetectionMode, buffer, size):
"""genReadSerialNumber(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadSerialNumber(errorDetectionMode, buffer, size)
genReadSerialNumber = staticmethod(genReadSerialNumber)
def genReadFirmwareVersion(errorDetectionMode, buffer, size):
"""genReadFirmwareVersion(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadFirmwareVersion(errorDetectionMode, buffer, size)
genReadFirmwareVersion = staticmethod(genReadFirmwareVersion)
def genReadSerialBaudRate(*args):
"""
genReadSerialBaudRate(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t port) -> size_t
genReadSerialBaudRate(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t
"""
return _libvncxx.Packet_genReadSerialBaudRate(*args)
genReadSerialBaudRate = staticmethod(genReadSerialBaudRate)
def genWriteSerialBaudRate(*args):
"""
genWriteSerialBaudRate(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint32_t baudrate, uint8_t port) -> size_t
genWriteSerialBaudRate(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint32_t baudrate) -> size_t
"""
return _libvncxx.Packet_genWriteSerialBaudRate(*args)
genWriteSerialBaudRate = staticmethod(genWriteSerialBaudRate)
def genReadAsyncDataOutputType(*args):
"""
genReadAsyncDataOutputType(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t port) -> size_t
genReadAsyncDataOutputType(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t
"""
return _libvncxx.Packet_genReadAsyncDataOutputType(*args)
genReadAsyncDataOutputType = staticmethod(genReadAsyncDataOutputType)
def genWriteAsyncDataOutputType(*args):
"""
genWriteAsyncDataOutputType(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint32_t ador, uint8_t port) -> size_t
genWriteAsyncDataOutputType(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint32_t ador) -> size_t
"""
return _libvncxx.Packet_genWriteAsyncDataOutputType(*args)
genWriteAsyncDataOutputType = staticmethod(genWriteAsyncDataOutputType)
def genReadAsyncDataOutputFrequency(*args):
"""
genReadAsyncDataOutputFrequency(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t port) -> size_t
genReadAsyncDataOutputFrequency(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t
"""
return _libvncxx.Packet_genReadAsyncDataOutputFrequency(*args)
genReadAsyncDataOutputFrequency = staticmethod(genReadAsyncDataOutputFrequency)
def genWriteAsyncDataOutputFrequency(*args):
"""
genWriteAsyncDataOutputFrequency(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint32_t adof, uint8_t port) -> size_t
genWriteAsyncDataOutputFrequency(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint32_t adof) -> size_t
"""
return _libvncxx.Packet_genWriteAsyncDataOutputFrequency(*args)
genWriteAsyncDataOutputFrequency = staticmethod(genWriteAsyncDataOutputFrequency)
def genReadYawPitchRoll(errorDetectionMode, buffer, size):
"""genReadYawPitchRoll(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadYawPitchRoll(errorDetectionMode, buffer, size)
genReadYawPitchRoll = staticmethod(genReadYawPitchRoll)
def genReadAttitudeQuaternion(errorDetectionMode, buffer, size):
"""genReadAttitudeQuaternion(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadAttitudeQuaternion(errorDetectionMode, buffer, size)
genReadAttitudeQuaternion = staticmethod(genReadAttitudeQuaternion)
def genReadQuaternionMagneticAccelerationAndAngularRates(errorDetectionMode, buffer, size):
"""genReadQuaternionMagneticAccelerationAndAngularRates(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadQuaternionMagneticAccelerationAndAngularRates(errorDetectionMode, buffer, size)
genReadQuaternionMagneticAccelerationAndAngularRates = staticmethod(genReadQuaternionMagneticAccelerationAndAngularRates)
def genReadMagneticMeasurements(errorDetectionMode, buffer, size):
"""genReadMagneticMeasurements(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadMagneticMeasurements(errorDetectionMode, buffer, size)
genReadMagneticMeasurements = staticmethod(genReadMagneticMeasurements)
def genReadAccelerationMeasurements(errorDetectionMode, buffer, size):
"""genReadAccelerationMeasurements(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadAccelerationMeasurements(errorDetectionMode, buffer, size)
genReadAccelerationMeasurements = staticmethod(genReadAccelerationMeasurements)
def genReadAngularRateMeasurements(errorDetectionMode, buffer, size):
"""genReadAngularRateMeasurements(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadAngularRateMeasurements(errorDetectionMode, buffer, size)
genReadAngularRateMeasurements = staticmethod(genReadAngularRateMeasurements)
def genReadMagneticAccelerationAndAngularRates(errorDetectionMode, buffer, size):
"""genReadMagneticAccelerationAndAngularRates(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadMagneticAccelerationAndAngularRates(errorDetectionMode, buffer, size)
genReadMagneticAccelerationAndAngularRates = staticmethod(genReadMagneticAccelerationAndAngularRates)
def genReadMagneticAndGravityReferenceVectors(errorDetectionMode, buffer, size):
"""genReadMagneticAndGravityReferenceVectors(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadMagneticAndGravityReferenceVectors(errorDetectionMode, buffer, size)
genReadMagneticAndGravityReferenceVectors = staticmethod(genReadMagneticAndGravityReferenceVectors)
def genWriteMagneticAndGravityReferenceVectors(errorDetectionMode, buffer, size, magRef, accRef):
"""genWriteMagneticAndGravityReferenceVectors(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, vec3f magRef, vec3f accRef) -> size_t"""
return _libvncxx.Packet_genWriteMagneticAndGravityReferenceVectors(errorDetectionMode, buffer, size, magRef, accRef)
genWriteMagneticAndGravityReferenceVectors = staticmethod(genWriteMagneticAndGravityReferenceVectors)
def genReadFilterMeasurementsVarianceParameters(errorDetectionMode, buffer, size):
"""genReadFilterMeasurementsVarianceParameters(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadFilterMeasurementsVarianceParameters(errorDetectionMode, buffer, size)
genReadFilterMeasurementsVarianceParameters = staticmethod(genReadFilterMeasurementsVarianceParameters)
def genWriteFilterMeasurementsVarianceParameters(errorDetectionMode, buffer, size, angularWalkVariance, angularRateVariance, magneticVariance, accelerationVariance):
"""genWriteFilterMeasurementsVarianceParameters(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, float angularWalkVariance, vec3f angularRateVariance, vec3f magneticVariance, vec3f accelerationVariance) -> size_t"""
return _libvncxx.Packet_genWriteFilterMeasurementsVarianceParameters(errorDetectionMode, buffer, size, angularWalkVariance, angularRateVariance, magneticVariance, accelerationVariance)
genWriteFilterMeasurementsVarianceParameters = staticmethod(genWriteFilterMeasurementsVarianceParameters)
def genReadMagnetometerCompensation(errorDetectionMode, buffer, size):
"""genReadMagnetometerCompensation(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadMagnetometerCompensation(errorDetectionMode, buffer, size)
genReadMagnetometerCompensation = staticmethod(genReadMagnetometerCompensation)
def genWriteMagnetometerCompensation(errorDetectionMode, buffer, size, c, b):
"""genWriteMagnetometerCompensation(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, mat3f c, vec3f b) -> size_t"""
return _libvncxx.Packet_genWriteMagnetometerCompensation(errorDetectionMode, buffer, size, c, b)
genWriteMagnetometerCompensation = staticmethod(genWriteMagnetometerCompensation)
def genReadFilterActiveTuningParameters(errorDetectionMode, buffer, size):
"""genReadFilterActiveTuningParameters(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadFilterActiveTuningParameters(errorDetectionMode, buffer, size)
genReadFilterActiveTuningParameters = staticmethod(genReadFilterActiveTuningParameters)
def genWriteFilterActiveTuningParameters(errorDetectionMode, buffer, size, magneticDisturbanceGain, accelerationDisturbanceGain, magneticDisturbanceMemory, accelerationDisturbanceMemory):
"""genWriteFilterActiveTuningParameters(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, float magneticDisturbanceGain, float accelerationDisturbanceGain, float magneticDisturbanceMemory, float accelerationDisturbanceMemory) -> size_t"""
return _libvncxx.Packet_genWriteFilterActiveTuningParameters(errorDetectionMode, buffer, size, magneticDisturbanceGain, accelerationDisturbanceGain, magneticDisturbanceMemory, accelerationDisturbanceMemory)
genWriteFilterActiveTuningParameters = staticmethod(genWriteFilterActiveTuningParameters)
def genReadAccelerationCompensation(errorDetectionMode, buffer, size):
"""genReadAccelerationCompensation(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadAccelerationCompensation(errorDetectionMode, buffer, size)
genReadAccelerationCompensation = staticmethod(genReadAccelerationCompensation)
def genWriteAccelerationCompensation(errorDetectionMode, buffer, size, c, b):
"""genWriteAccelerationCompensation(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, mat3f c, vec3f b) -> size_t"""
return _libvncxx.Packet_genWriteAccelerationCompensation(errorDetectionMode, buffer, size, c, b)
genWriteAccelerationCompensation = staticmethod(genWriteAccelerationCompensation)
def genReadReferenceFrameRotation(errorDetectionMode, buffer, size):
"""genReadReferenceFrameRotation(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadReferenceFrameRotation(errorDetectionMode, buffer, size)
genReadReferenceFrameRotation = staticmethod(genReadReferenceFrameRotation)
def genWriteReferenceFrameRotation(errorDetectionMode, buffer, size, c):
"""genWriteReferenceFrameRotation(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, mat3f c) -> size_t"""
return _libvncxx.Packet_genWriteReferenceFrameRotation(errorDetectionMode, buffer, size, c)
genWriteReferenceFrameRotation = staticmethod(genWriteReferenceFrameRotation)
def genReadYawPitchRollMagneticAccelerationAndAngularRates(errorDetectionMode, buffer, size):
"""genReadYawPitchRollMagneticAccelerationAndAngularRates(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadYawPitchRollMagneticAccelerationAndAngularRates(errorDetectionMode, buffer, size)
genReadYawPitchRollMagneticAccelerationAndAngularRates = staticmethod(genReadYawPitchRollMagneticAccelerationAndAngularRates)
def genReadCommunicationProtocolControl(errorDetectionMode, buffer, size):
"""genReadCommunicationProtocolControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadCommunicationProtocolControl(errorDetectionMode, buffer, size)
genReadCommunicationProtocolControl = staticmethod(genReadCommunicationProtocolControl)
def genWriteCommunicationProtocolControl(errorDetectionMode, buffer, size, serialCount, serialStatus, spiCount, spiStatus, serialChecksum, spiChecksum, errorMode):
"""genWriteCommunicationProtocolControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t serialCount, uint8_t serialStatus, uint8_t spiCount, uint8_t spiStatus, uint8_t serialChecksum, uint8_t spiChecksum, uint8_t errorMode) -> size_t"""
return _libvncxx.Packet_genWriteCommunicationProtocolControl(errorDetectionMode, buffer, size, serialCount, serialStatus, spiCount, spiStatus, serialChecksum, spiChecksum, errorMode)
genWriteCommunicationProtocolControl = staticmethod(genWriteCommunicationProtocolControl)
def genReadSynchronizationControl(errorDetectionMode, buffer, size):
"""genReadSynchronizationControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadSynchronizationControl(errorDetectionMode, buffer, size)
genReadSynchronizationControl = staticmethod(genReadSynchronizationControl)
def genWriteSynchronizationControl(errorDetectionMode, buffer, size, syncInMode, syncInEdge, syncInSkipFactor, syncOutMode, syncOutPolarity, syncOutSkipFactor, syncOutPulseWidth):
"""genWriteSynchronizationControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t syncInMode, uint8_t syncInEdge, uint16_t syncInSkipFactor, uint8_t syncOutMode, uint8_t syncOutPolarity, uint16_t syncOutSkipFactor, uint32_t syncOutPulseWidth) -> size_t"""
return _libvncxx.Packet_genWriteSynchronizationControl(errorDetectionMode, buffer, size, syncInMode, syncInEdge, syncInSkipFactor, syncOutMode, syncOutPolarity, syncOutSkipFactor, syncOutPulseWidth)
genWriteSynchronizationControl = staticmethod(genWriteSynchronizationControl)
def genReadSynchronizationStatus(errorDetectionMode, buffer, size):
"""genReadSynchronizationStatus(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadSynchronizationStatus(errorDetectionMode, buffer, size)
genReadSynchronizationStatus = staticmethod(genReadSynchronizationStatus)
def genWriteSynchronizationStatus(errorDetectionMode, buffer, size, syncInCount, syncInTime, syncOutCount):
"""genWriteSynchronizationStatus(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint32_t syncInCount, uint32_t syncInTime, uint32_t syncOutCount) -> size_t"""
return _libvncxx.Packet_genWriteSynchronizationStatus(errorDetectionMode, buffer, size, syncInCount, syncInTime, syncOutCount)
genWriteSynchronizationStatus = staticmethod(genWriteSynchronizationStatus)
def genReadFilterBasicControl(errorDetectionMode, buffer, size):
"""genReadFilterBasicControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadFilterBasicControl(errorDetectionMode, buffer, size)
genReadFilterBasicControl = staticmethod(genReadFilterBasicControl)
def genWriteFilterBasicControl(errorDetectionMode, buffer, size, magMode, extMagMode, extAccMode, extGyroMode, gyroLimit):
"""genWriteFilterBasicControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t magMode, uint8_t extMagMode, uint8_t extAccMode, uint8_t extGyroMode, vec3f gyroLimit) -> size_t"""
return _libvncxx.Packet_genWriteFilterBasicControl(errorDetectionMode, buffer, size, magMode, extMagMode, extAccMode, extGyroMode, gyroLimit)
genWriteFilterBasicControl = staticmethod(genWriteFilterBasicControl)
def genReadVpeBasicControl(errorDetectionMode, buffer, size):
"""genReadVpeBasicControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadVpeBasicControl(errorDetectionMode, buffer, size)
genReadVpeBasicControl = staticmethod(genReadVpeBasicControl)
def genWriteVpeBasicControl(errorDetectionMode, buffer, size, enable, headingMode, filteringMode, tuningMode):
"""genWriteVpeBasicControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t enable, uint8_t headingMode, uint8_t filteringMode, uint8_t tuningMode) -> size_t"""
return _libvncxx.Packet_genWriteVpeBasicControl(errorDetectionMode, buffer, size, enable, headingMode, filteringMode, tuningMode)
genWriteVpeBasicControl = staticmethod(genWriteVpeBasicControl)
def genReadVpeMagnetometerBasicTuning(errorDetectionMode, buffer, size):
"""genReadVpeMagnetometerBasicTuning(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadVpeMagnetometerBasicTuning(errorDetectionMode, buffer, size)
genReadVpeMagnetometerBasicTuning = staticmethod(genReadVpeMagnetometerBasicTuning)
def genWriteVpeMagnetometerBasicTuning(errorDetectionMode, buffer, size, baseTuning, adaptiveTuning, adaptiveFiltering):
"""genWriteVpeMagnetometerBasicTuning(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, vec3f baseTuning, vec3f adaptiveTuning, vec3f adaptiveFiltering) -> size_t"""
return _libvncxx.Packet_genWriteVpeMagnetometerBasicTuning(errorDetectionMode, buffer, size, baseTuning, adaptiveTuning, adaptiveFiltering)
genWriteVpeMagnetometerBasicTuning = staticmethod(genWriteVpeMagnetometerBasicTuning)
def genReadVpeMagnetometerAdvancedTuning(errorDetectionMode, buffer, size):
"""genReadVpeMagnetometerAdvancedTuning(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadVpeMagnetometerAdvancedTuning(errorDetectionMode, buffer, size)
genReadVpeMagnetometerAdvancedTuning = staticmethod(genReadVpeMagnetometerAdvancedTuning)
def genWriteVpeMagnetometerAdvancedTuning(errorDetectionMode, buffer, size, minFiltering, maxFiltering, maxAdaptRate, disturbanceWindow, maxTuning):
"""genWriteVpeMagnetometerAdvancedTuning(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, vec3f minFiltering, vec3f maxFiltering, float maxAdaptRate, float disturbanceWindow, float maxTuning) -> size_t"""
return _libvncxx.Packet_genWriteVpeMagnetometerAdvancedTuning(errorDetectionMode, buffer, size, minFiltering, maxFiltering, maxAdaptRate, disturbanceWindow, maxTuning)
genWriteVpeMagnetometerAdvancedTuning = staticmethod(genWriteVpeMagnetometerAdvancedTuning)
def genReadVpeAccelerometerBasicTuning(errorDetectionMode, buffer, size):
"""genReadVpeAccelerometerBasicTuning(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadVpeAccelerometerBasicTuning(errorDetectionMode, buffer, size)
genReadVpeAccelerometerBasicTuning = staticmethod(genReadVpeAccelerometerBasicTuning)
def genWriteVpeAccelerometerBasicTuning(errorDetectionMode, buffer, size, baseTuning, adaptiveTuning, adaptiveFiltering):
"""genWriteVpeAccelerometerBasicTuning(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, vec3f baseTuning, vec3f adaptiveTuning, vec3f adaptiveFiltering) -> size_t"""
return _libvncxx.Packet_genWriteVpeAccelerometerBasicTuning(errorDetectionMode, buffer, size, baseTuning, adaptiveTuning, adaptiveFiltering)
genWriteVpeAccelerometerBasicTuning = staticmethod(genWriteVpeAccelerometerBasicTuning)
def genReadVpeAccelerometerAdvancedTuning(errorDetectionMode, buffer, size):
"""genReadVpeAccelerometerAdvancedTuning(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadVpeAccelerometerAdvancedTuning(errorDetectionMode, buffer, size)
genReadVpeAccelerometerAdvancedTuning = staticmethod(genReadVpeAccelerometerAdvancedTuning)
def genWriteVpeAccelerometerAdvancedTuning(errorDetectionMode, buffer, size, minFiltering, maxFiltering, maxAdaptRate, disturbanceWindow, maxTuning):
"""genWriteVpeAccelerometerAdvancedTuning(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, vec3f minFiltering, vec3f maxFiltering, float maxAdaptRate, float disturbanceWindow, float maxTuning) -> size_t"""
return _libvncxx.Packet_genWriteVpeAccelerometerAdvancedTuning(errorDetectionMode, buffer, size, minFiltering, maxFiltering, maxAdaptRate, disturbanceWindow, maxTuning)
genWriteVpeAccelerometerAdvancedTuning = staticmethod(genWriteVpeAccelerometerAdvancedTuning)
def genReadVpeGyroBasicTuning(errorDetectionMode, buffer, size):
"""genReadVpeGyroBasicTuning(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadVpeGyroBasicTuning(errorDetectionMode, buffer, size)
genReadVpeGyroBasicTuning = staticmethod(genReadVpeGyroBasicTuning)
def genWriteVpeGyroBasicTuning(errorDetectionMode, buffer, size, angularWalkVariance, baseTuning, adaptiveTuning):
"""genWriteVpeGyroBasicTuning(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, vec3f angularWalkVariance, vec3f baseTuning, vec3f adaptiveTuning) -> size_t"""
return _libvncxx.Packet_genWriteVpeGyroBasicTuning(errorDetectionMode, buffer, size, angularWalkVariance, baseTuning, adaptiveTuning)
genWriteVpeGyroBasicTuning = staticmethod(genWriteVpeGyroBasicTuning)
def genReadFilterStartupGyroBias(errorDetectionMode, buffer, size):
"""genReadFilterStartupGyroBias(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadFilterStartupGyroBias(errorDetectionMode, buffer, size)
genReadFilterStartupGyroBias = staticmethod(genReadFilterStartupGyroBias)
def genWriteFilterStartupGyroBias(errorDetectionMode, buffer, size, bias):
"""genWriteFilterStartupGyroBias(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, vec3f bias) -> size_t"""
return _libvncxx.Packet_genWriteFilterStartupGyroBias(errorDetectionMode, buffer, size, bias)
genWriteFilterStartupGyroBias = staticmethod(genWriteFilterStartupGyroBias)
def genReadMagnetometerCalibrationControl(errorDetectionMode, buffer, size):
"""genReadMagnetometerCalibrationControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadMagnetometerCalibrationControl(errorDetectionMode, buffer, size)
genReadMagnetometerCalibrationControl = staticmethod(genReadMagnetometerCalibrationControl)
def genWriteMagnetometerCalibrationControl(errorDetectionMode, buffer, size, hsiMode, hsiOutput, convergeRate):
"""genWriteMagnetometerCalibrationControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t hsiMode, uint8_t hsiOutput, uint8_t convergeRate) -> size_t"""
return _libvncxx.Packet_genWriteMagnetometerCalibrationControl(errorDetectionMode, buffer, size, hsiMode, hsiOutput, convergeRate)
genWriteMagnetometerCalibrationControl = staticmethod(genWriteMagnetometerCalibrationControl)
def genReadCalculatedMagnetometerCalibration(errorDetectionMode, buffer, size):
"""genReadCalculatedMagnetometerCalibration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadCalculatedMagnetometerCalibration(errorDetectionMode, buffer, size)
genReadCalculatedMagnetometerCalibration = staticmethod(genReadCalculatedMagnetometerCalibration)
def genReadIndoorHeadingModeControl(errorDetectionMode, buffer, size):
"""genReadIndoorHeadingModeControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadIndoorHeadingModeControl(errorDetectionMode, buffer, size)
genReadIndoorHeadingModeControl = staticmethod(genReadIndoorHeadingModeControl)
def genWriteIndoorHeadingModeControl(errorDetectionMode, buffer, size, maxRateError):
"""genWriteIndoorHeadingModeControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, float maxRateError) -> size_t"""
return _libvncxx.Packet_genWriteIndoorHeadingModeControl(errorDetectionMode, buffer, size, maxRateError)
genWriteIndoorHeadingModeControl = staticmethod(genWriteIndoorHeadingModeControl)
def genReadVelocityCompensationMeasurement(errorDetectionMode, buffer, size):
"""genReadVelocityCompensationMeasurement(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadVelocityCompensationMeasurement(errorDetectionMode, buffer, size)
genReadVelocityCompensationMeasurement = staticmethod(genReadVelocityCompensationMeasurement)
def genWriteVelocityCompensationMeasurement(errorDetectionMode, buffer, size, velocity):
"""genWriteVelocityCompensationMeasurement(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, vec3f velocity) -> size_t"""
return _libvncxx.Packet_genWriteVelocityCompensationMeasurement(errorDetectionMode, buffer, size, velocity)
genWriteVelocityCompensationMeasurement = staticmethod(genWriteVelocityCompensationMeasurement)
def genReadVelocityCompensationControl(errorDetectionMode, buffer, size):
"""genReadVelocityCompensationControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadVelocityCompensationControl(errorDetectionMode, buffer, size)
genReadVelocityCompensationControl = staticmethod(genReadVelocityCompensationControl)
def genWriteVelocityCompensationControl(errorDetectionMode, buffer, size, mode, velocityTuning, rateTuning):
"""genWriteVelocityCompensationControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t mode, float velocityTuning, float rateTuning) -> size_t"""
return _libvncxx.Packet_genWriteVelocityCompensationControl(errorDetectionMode, buffer, size, mode, velocityTuning, rateTuning)
genWriteVelocityCompensationControl = staticmethod(genWriteVelocityCompensationControl)
def genReadVelocityCompensationStatus(errorDetectionMode, buffer, size):
"""genReadVelocityCompensationStatus(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadVelocityCompensationStatus(errorDetectionMode, buffer, size)
genReadVelocityCompensationStatus = staticmethod(genReadVelocityCompensationStatus)
def genReadImuMeasurements(errorDetectionMode, buffer, size):
"""genReadImuMeasurements(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadImuMeasurements(errorDetectionMode, buffer, size)
genReadImuMeasurements = staticmethod(genReadImuMeasurements)
def genReadGpsConfiguration(errorDetectionMode, buffer, size):
"""genReadGpsConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadGpsConfiguration(errorDetectionMode, buffer, size)
genReadGpsConfiguration = staticmethod(genReadGpsConfiguration)
def genWriteGpsConfiguration(errorDetectionMode, buffer, size, mode, ppsSource):
"""genWriteGpsConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t mode, uint8_t ppsSource) -> size_t"""
return _libvncxx.Packet_genWriteGpsConfiguration(errorDetectionMode, buffer, size, mode, ppsSource)
genWriteGpsConfiguration = staticmethod(genWriteGpsConfiguration)
def genReadGpsAntennaOffset(errorDetectionMode, buffer, size):
"""genReadGpsAntennaOffset(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadGpsAntennaOffset(errorDetectionMode, buffer, size)
genReadGpsAntennaOffset = staticmethod(genReadGpsAntennaOffset)
def genWriteGpsAntennaOffset(errorDetectionMode, buffer, size, position):
"""genWriteGpsAntennaOffset(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, vec3f position) -> size_t"""
return _libvncxx.Packet_genWriteGpsAntennaOffset(errorDetectionMode, buffer, size, position)
genWriteGpsAntennaOffset = staticmethod(genWriteGpsAntennaOffset)
def genReadGpsSolutionLla(errorDetectionMode, buffer, size):
"""genReadGpsSolutionLla(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadGpsSolutionLla(errorDetectionMode, buffer, size)
genReadGpsSolutionLla = staticmethod(genReadGpsSolutionLla)
def genReadGpsSolutionEcef(errorDetectionMode, buffer, size):
"""genReadGpsSolutionEcef(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadGpsSolutionEcef(errorDetectionMode, buffer, size)
genReadGpsSolutionEcef = staticmethod(genReadGpsSolutionEcef)
def genReadInsSolutionLla(errorDetectionMode, buffer, size):
"""genReadInsSolutionLla(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadInsSolutionLla(errorDetectionMode, buffer, size)
genReadInsSolutionLla = staticmethod(genReadInsSolutionLla)
def genReadInsSolutionEcef(errorDetectionMode, buffer, size):
"""genReadInsSolutionEcef(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadInsSolutionEcef(errorDetectionMode, buffer, size)
genReadInsSolutionEcef = staticmethod(genReadInsSolutionEcef)
def genReadInsBasicConfiguration(errorDetectionMode, buffer, size):
"""genReadInsBasicConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadInsBasicConfiguration(errorDetectionMode, buffer, size)
genReadInsBasicConfiguration = staticmethod(genReadInsBasicConfiguration)
def genWriteInsBasicConfiguration(errorDetectionMode, buffer, size, scenario, ahrsAiding, estBaseline):
"""genWriteInsBasicConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t scenario, uint8_t ahrsAiding, uint8_t estBaseline) -> size_t"""
return _libvncxx.Packet_genWriteInsBasicConfiguration(errorDetectionMode, buffer, size, scenario, ahrsAiding, estBaseline)
genWriteInsBasicConfiguration = staticmethod(genWriteInsBasicConfiguration)
def genReadInsAdvancedConfiguration(errorDetectionMode, buffer, size):
"""genReadInsAdvancedConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadInsAdvancedConfiguration(errorDetectionMode, buffer, size)
genReadInsAdvancedConfiguration = staticmethod(genReadInsAdvancedConfiguration)
def genWriteInsAdvancedConfiguration(errorDetectionMode, buffer, size, useMag, usePres, posAtt, velAtt, velBias, useFoam, gpsCovType, velCount, velInit, moveOrigin, gpsTimeout, deltaLimitPos, deltaLimitVel, minPosUncertainty, minVelUncertainty):
"""genWriteInsAdvancedConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t useMag, uint8_t usePres, uint8_t posAtt, uint8_t velAtt, uint8_t velBias, uint8_t useFoam, uint8_t gpsCovType, uint8_t velCount, float velInit, float moveOrigin, float gpsTimeout, float deltaLimitPos, float deltaLimitVel, float minPosUncertainty, float minVelUncertainty) -> size_t"""
return _libvncxx.Packet_genWriteInsAdvancedConfiguration(errorDetectionMode, buffer, size, useMag, usePres, posAtt, velAtt, velBias, useFoam, gpsCovType, velCount, velInit, moveOrigin, gpsTimeout, deltaLimitPos, deltaLimitVel, minPosUncertainty, minVelUncertainty)
genWriteInsAdvancedConfiguration = staticmethod(genWriteInsAdvancedConfiguration)
def genReadInsStateLla(errorDetectionMode, buffer, size):
"""genReadInsStateLla(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadInsStateLla(errorDetectionMode, buffer, size)
genReadInsStateLla = staticmethod(genReadInsStateLla)
def genReadInsStateEcef(errorDetectionMode, buffer, size):
"""genReadInsStateEcef(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadInsStateEcef(errorDetectionMode, buffer, size)
genReadInsStateEcef = staticmethod(genReadInsStateEcef)
def genReadStartupFilterBiasEstimate(errorDetectionMode, buffer, size):
"""genReadStartupFilterBiasEstimate(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadStartupFilterBiasEstimate(errorDetectionMode, buffer, size)
genReadStartupFilterBiasEstimate = staticmethod(genReadStartupFilterBiasEstimate)
def genWriteStartupFilterBiasEstimate(errorDetectionMode, buffer, size, gyroBias, accelBias, pressureBias):
"""genWriteStartupFilterBiasEstimate(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, vec3f gyroBias, vec3f accelBias, float pressureBias) -> size_t"""
return _libvncxx.Packet_genWriteStartupFilterBiasEstimate(errorDetectionMode, buffer, size, gyroBias, accelBias, pressureBias)
genWriteStartupFilterBiasEstimate = staticmethod(genWriteStartupFilterBiasEstimate)
def genReadDeltaThetaAndDeltaVelocity(errorDetectionMode, buffer, size):
"""genReadDeltaThetaAndDeltaVelocity(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadDeltaThetaAndDeltaVelocity(errorDetectionMode, buffer, size)
genReadDeltaThetaAndDeltaVelocity = staticmethod(genReadDeltaThetaAndDeltaVelocity)
def genReadDeltaThetaAndDeltaVelocityConfiguration(errorDetectionMode, buffer, size):
"""genReadDeltaThetaAndDeltaVelocityConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadDeltaThetaAndDeltaVelocityConfiguration(errorDetectionMode, buffer, size)
genReadDeltaThetaAndDeltaVelocityConfiguration = staticmethod(genReadDeltaThetaAndDeltaVelocityConfiguration)
def genWriteDeltaThetaAndDeltaVelocityConfiguration(errorDetectionMode, buffer, size, integrationFrame, gyroCompensation, accelCompensation):
"""genWriteDeltaThetaAndDeltaVelocityConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t integrationFrame, uint8_t gyroCompensation, uint8_t accelCompensation) -> size_t"""
return _libvncxx.Packet_genWriteDeltaThetaAndDeltaVelocityConfiguration(errorDetectionMode, buffer, size, integrationFrame, gyroCompensation, accelCompensation)
genWriteDeltaThetaAndDeltaVelocityConfiguration = staticmethod(genWriteDeltaThetaAndDeltaVelocityConfiguration)
def genReadReferenceVectorConfiguration(errorDetectionMode, buffer, size):
"""genReadReferenceVectorConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadReferenceVectorConfiguration(errorDetectionMode, buffer, size)
genReadReferenceVectorConfiguration = staticmethod(genReadReferenceVectorConfiguration)
def genWriteReferenceVectorConfiguration(errorDetectionMode, buffer, size, useMagModel, useGravityModel, recalcThreshold, year, position):
"""genWriteReferenceVectorConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t useMagModel, uint8_t useGravityModel, uint32_t recalcThreshold, float year, vec3d position) -> size_t"""
return _libvncxx.Packet_genWriteReferenceVectorConfiguration(errorDetectionMode, buffer, size, useMagModel, useGravityModel, recalcThreshold, year, position)
genWriteReferenceVectorConfiguration = staticmethod(genWriteReferenceVectorConfiguration)
def genReadGyroCompensation(errorDetectionMode, buffer, size):
"""genReadGyroCompensation(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadGyroCompensation(errorDetectionMode, buffer, size)
genReadGyroCompensation = staticmethod(genReadGyroCompensation)
def genWriteGyroCompensation(errorDetectionMode, buffer, size, c, b):
"""genWriteGyroCompensation(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, mat3f c, vec3f b) -> size_t"""
return _libvncxx.Packet_genWriteGyroCompensation(errorDetectionMode, buffer, size, c, b)
genWriteGyroCompensation = staticmethod(genWriteGyroCompensation)
def genReadImuFilteringConfiguration(errorDetectionMode, buffer, size):
"""genReadImuFilteringConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadImuFilteringConfiguration(errorDetectionMode, buffer, size)
genReadImuFilteringConfiguration = staticmethod(genReadImuFilteringConfiguration)
def genWriteImuFilteringConfiguration(errorDetectionMode, buffer, size, magWindowSize, accelWindowSize, gyroWindowSize, tempWindowSize, presWindowSize, magFilterMode, accelFilterMode, gyroFilterMode, tempFilterMode, presFilterMode):
"""genWriteImuFilteringConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint16_t magWindowSize, uint16_t accelWindowSize, uint16_t gyroWindowSize, uint16_t tempWindowSize, uint16_t presWindowSize, uint8_t magFilterMode, uint8_t accelFilterMode, uint8_t gyroFilterMode, uint8_t tempFilterMode, uint8_t presFilterMode) -> size_t"""
return _libvncxx.Packet_genWriteImuFilteringConfiguration(errorDetectionMode, buffer, size, magWindowSize, accelWindowSize, gyroWindowSize, tempWindowSize, presWindowSize, magFilterMode, accelFilterMode, gyroFilterMode, tempFilterMode, presFilterMode)
genWriteImuFilteringConfiguration = staticmethod(genWriteImuFilteringConfiguration)
def genReadGpsCompassBaseline(errorDetectionMode, buffer, size):
"""genReadGpsCompassBaseline(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadGpsCompassBaseline(errorDetectionMode, buffer, size)
genReadGpsCompassBaseline = staticmethod(genReadGpsCompassBaseline)
def genWriteGpsCompassBaseline(errorDetectionMode, buffer, size, position, uncertainty):
"""genWriteGpsCompassBaseline(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, vec3f position, vec3f uncertainty) -> size_t"""
return _libvncxx.Packet_genWriteGpsCompassBaseline(errorDetectionMode, buffer, size, position, uncertainty)
genWriteGpsCompassBaseline = staticmethod(genWriteGpsCompassBaseline)
def genReadGpsCompassEstimatedBaseline(errorDetectionMode, buffer, size):
"""genReadGpsCompassEstimatedBaseline(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadGpsCompassEstimatedBaseline(errorDetectionMode, buffer, size)
genReadGpsCompassEstimatedBaseline = staticmethod(genReadGpsCompassEstimatedBaseline)
def genReadImuRateConfiguration(errorDetectionMode, buffer, size):
"""genReadImuRateConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadImuRateConfiguration(errorDetectionMode, buffer, size)
genReadImuRateConfiguration = staticmethod(genReadImuRateConfiguration)
def genWriteImuRateConfiguration(errorDetectionMode, buffer, size, imuRate, navDivisor, filterTargetRate, filterMinRate):
"""genWriteImuRateConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint16_t imuRate, uint16_t navDivisor, float filterTargetRate, float filterMinRate) -> size_t"""
return _libvncxx.Packet_genWriteImuRateConfiguration(errorDetectionMode, buffer, size, imuRate, navDivisor, filterTargetRate, filterMinRate)
genWriteImuRateConfiguration = staticmethod(genWriteImuRateConfiguration)
def genReadYawPitchRollTrueBodyAccelerationAndAngularRates(errorDetectionMode, buffer, size):
"""genReadYawPitchRollTrueBodyAccelerationAndAngularRates(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadYawPitchRollTrueBodyAccelerationAndAngularRates(errorDetectionMode, buffer, size)
genReadYawPitchRollTrueBodyAccelerationAndAngularRates = staticmethod(genReadYawPitchRollTrueBodyAccelerationAndAngularRates)
def genReadYawPitchRollTrueInertialAccelerationAndAngularRates(errorDetectionMode, buffer, size):
"""genReadYawPitchRollTrueInertialAccelerationAndAngularRates(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadYawPitchRollTrueInertialAccelerationAndAngularRates(errorDetectionMode, buffer, size)
genReadYawPitchRollTrueInertialAccelerationAndAngularRates = staticmethod(genReadYawPitchRollTrueInertialAccelerationAndAngularRates)
def parseVNYPR(self, yawPitchRoll):
"""parseVNYPR(Packet self, vec3f yawPitchRoll)"""
return _libvncxx.Packet_parseVNYPR(self, yawPitchRoll)
def parseVNQTN(self, quaternion):
"""parseVNQTN(Packet self, vec4f quaternion)"""
return _libvncxx.Packet_parseVNQTN(self, quaternion)
def parseVNQMR(self, quaternion, magnetic, acceleration, angularRate):
"""parseVNQMR(Packet self, vec4f quaternion, vec3f magnetic, vec3f acceleration, vec3f angularRate)"""
return _libvncxx.Packet_parseVNQMR(self, quaternion, magnetic, acceleration, angularRate)
def parseVNMAG(self, magnetic):
"""parseVNMAG(Packet self, vec3f magnetic)"""
return _libvncxx.Packet_parseVNMAG(self, magnetic)
def parseVNACC(self, acceleration):
"""parseVNACC(Packet self, vec3f acceleration)"""
return _libvncxx.Packet_parseVNACC(self, acceleration)
def parseVNGYR(self, angularRate):
"""parseVNGYR(Packet self, vec3f angularRate)"""
return _libvncxx.Packet_parseVNGYR(self, angularRate)
def parseVNMAR(self, magnetic, acceleration, angularRate):
"""parseVNMAR(Packet self, vec3f magnetic, vec3f acceleration, vec3f angularRate)"""
return _libvncxx.Packet_parseVNMAR(self, magnetic, acceleration, angularRate)
def parseVNYMR(self, yawPitchRoll, magnetic, acceleration, angularRate):
"""parseVNYMR(Packet self, vec3f yawPitchRoll, vec3f magnetic, vec3f acceleration, vec3f angularRate)"""
return _libvncxx.Packet_parseVNYMR(self, yawPitchRoll, magnetic, acceleration, angularRate)
def parseVNYBA(self, yawPitchRoll, accelerationBody, angularRate):
"""parseVNYBA(Packet self, vec3f yawPitchRoll, vec3f accelerationBody, vec3f angularRate)"""
return _libvncxx.Packet_parseVNYBA(self, yawPitchRoll, accelerationBody, angularRate)
def parseVNYIA(self, yawPitchRoll, accelerationInertial, angularRate):
"""parseVNYIA(Packet self, vec3f yawPitchRoll, vec3f accelerationInertial, vec3f angularRate)"""
return _libvncxx.Packet_parseVNYIA(self, yawPitchRoll, accelerationInertial, angularRate)
def parseVNIMU(self, magneticUncompensated, accelerationUncompensated, angularRateUncompensated, temperature, pressure):
"""parseVNIMU(Packet self, vec3f magneticUncompensated, vec3f accelerationUncompensated, vec3f angularRateUncompensated, float * temperature, float * pressure)"""
return _libvncxx.Packet_parseVNIMU(self, magneticUncompensated, accelerationUncompensated, angularRateUncompensated, temperature, pressure)
def parseVNGPS(self, time, week, gpsFix, numSats, lla, nedVel, nedAcc, speedAcc, timeAcc):
"""parseVNGPS(Packet self, double * time, uint16_t * week, uint8_t * gpsFix, uint8_t * numSats, vec3d lla, vec3f nedVel, vec3f nedAcc, float * speedAcc, float * timeAcc)"""
return _libvncxx.Packet_parseVNGPS(self, time, week, gpsFix, numSats, lla, nedVel, nedAcc, speedAcc, timeAcc)
def parseVNINS(self, time, week, status, yawPitchRoll, lla, nedVel, attUncertainty, posUncertainty, velUncertainty):
"""parseVNINS(Packet self, double * time, uint16_t * week, uint16_t * status, vec3f yawPitchRoll, vec3d lla, vec3f nedVel, float * attUncertainty, float * posUncertainty, float * velUncertainty)"""
return _libvncxx.Packet_parseVNINS(self, time, week, status, yawPitchRoll, lla, nedVel, attUncertainty, posUncertainty, velUncertainty)
def parseVNINE(self, time, week, status, ypr, position, velocity, attUncertainty, posUncertainty, velUncertainty):
"""parseVNINE(Packet self, double * time, uint16_t * week, uint16_t * status, vec3f ypr, vec3d position, vec3f velocity, float * attUncertainty, float * posUncertainty, float * velUncertainty)"""
return _libvncxx.Packet_parseVNINE(self, time, week, status, ypr, position, velocity, attUncertainty, posUncertainty, velUncertainty)
def parseVNISL(self, ypr, lla, velocity, acceleration, angularRate):
"""parseVNISL(Packet self, vec3f ypr, vec3d lla, vec3f velocity, vec3f acceleration, vec3f angularRate)"""
return _libvncxx.Packet_parseVNISL(self, ypr, lla, velocity, acceleration, angularRate)
def parseVNISE(self, ypr, position, velocity, acceleration, angularRate):
"""parseVNISE(Packet self, vec3f ypr, vec3d position, vec3f velocity, vec3f acceleration, vec3f angularRate)"""
return _libvncxx.Packet_parseVNISE(self, ypr, position, velocity, acceleration, angularRate)
def parseVNGPE(self, tow, week, gpsFix, numSats, position, velocity, posAcc, speedAcc, timeAcc):
"""parseVNGPE(Packet self, double * tow, uint16_t * week, uint8_t * gpsFix, uint8_t * numSats, vec3d position, vec3f velocity, vec3f posAcc, float * speedAcc, float * timeAcc)"""
return _libvncxx.Packet_parseVNGPE(self, tow, week, gpsFix, numSats, position, velocity, posAcc, speedAcc, timeAcc)
def parseVNDTV(self, deltaTime, deltaTheta, deltaVelocity):
"""parseVNDTV(Packet self, float * deltaTime, vec3f deltaTheta, vec3f deltaVelocity)"""
return _libvncxx.Packet_parseVNDTV(self, deltaTime, deltaTheta, deltaVelocity)
def parseBinaryOutput(self, asyncMode, rateDivisor, outputGroup, commonField, timeField, imuField, gpsField, attitudeField, insField):
"""parseBinaryOutput(Packet self, uint16_t * asyncMode, uint16_t * rateDivisor, uint16_t * outputGroup, uint16_t * commonField, uint16_t * timeField, uint16_t * imuField, uint16_t * gpsField, uint16_t * attitudeField, uint16_t * insField)"""
return _libvncxx.Packet_parseBinaryOutput(self, asyncMode, rateDivisor, outputGroup, commonField, timeField, imuField, gpsField, attitudeField, insField)
def parseUserTag(self, tag):
"""parseUserTag(Packet self, char * tag)"""
return _libvncxx.Packet_parseUserTag(self, tag)
def parseModelNumber(self, productName):
"""parseModelNumber(Packet self, char * productName)"""
return _libvncxx.Packet_parseModelNumber(self, productName)
def parseHardwareRevision(self, revision):
"""parseHardwareRevision(Packet self, uint32_t * revision)"""
return _libvncxx.Packet_parseHardwareRevision(self, revision)
def parseSerialNumber(self, serialNum):
"""parseSerialNumber(Packet self, uint32_t * serialNum)"""
return _libvncxx.Packet_parseSerialNumber(self, serialNum)
def parseFirmwareVersion(self, firmwareVersion):
"""parseFirmwareVersion(Packet self, char * firmwareVersion)"""
return _libvncxx.Packet_parseFirmwareVersion(self, firmwareVersion)
def parseSerialBaudRate(self, baudrate):
"""parseSerialBaudRate(Packet self, uint32_t * baudrate)"""
return _libvncxx.Packet_parseSerialBaudRate(self, baudrate)
def parseAsyncDataOutputType(self, ador):
"""parseAsyncDataOutputType(Packet self, uint32_t * ador)"""
return _libvncxx.Packet_parseAsyncDataOutputType(self, ador)
def parseAsyncDataOutputFrequency(self, adof):
"""parseAsyncDataOutputFrequency(Packet self, uint32_t * adof)"""
return _libvncxx.Packet_parseAsyncDataOutputFrequency(self, adof)
def parseYawPitchRoll(self, yawPitchRoll):
"""parseYawPitchRoll(Packet self, vec3f yawPitchRoll)"""
return _libvncxx.Packet_parseYawPitchRoll(self, yawPitchRoll)
def parseAttitudeQuaternion(self, quat):
"""parseAttitudeQuaternion(Packet self, vec4f quat)"""
return _libvncxx.Packet_parseAttitudeQuaternion(self, quat)
def parseQuaternionMagneticAccelerationAndAngularRates(self, quat, mag, accel, gyro):
"""parseQuaternionMagneticAccelerationAndAngularRates(Packet self, vec4f quat, vec3f mag, vec3f accel, vec3f gyro)"""
return _libvncxx.Packet_parseQuaternionMagneticAccelerationAndAngularRates(self, quat, mag, accel, gyro)
def parseMagneticMeasurements(self, mag):
"""parseMagneticMeasurements(Packet self, vec3f mag)"""
return _libvncxx.Packet_parseMagneticMeasurements(self, mag)
def parseAccelerationMeasurements(self, accel):
"""parseAccelerationMeasurements(Packet self, vec3f accel)"""
return _libvncxx.Packet_parseAccelerationMeasurements(self, accel)
def parseAngularRateMeasurements(self, gyro):
"""parseAngularRateMeasurements(Packet self, vec3f gyro)"""
return _libvncxx.Packet_parseAngularRateMeasurements(self, gyro)
def parseMagneticAccelerationAndAngularRates(self, mag, accel, gyro):
"""parseMagneticAccelerationAndAngularRates(Packet self, vec3f mag, vec3f accel, vec3f gyro)"""
return _libvncxx.Packet_parseMagneticAccelerationAndAngularRates(self, mag, accel, gyro)
def parseMagneticAndGravityReferenceVectors(self, magRef, accRef):
"""parseMagneticAndGravityReferenceVectors(Packet self, vec3f magRef, vec3f accRef)"""
return _libvncxx.Packet_parseMagneticAndGravityReferenceVectors(self, magRef, accRef)
def parseFilterMeasurementsVarianceParameters(self, angularWalkVariance, angularRateVariance, magneticVariance, accelerationVariance):
"""parseFilterMeasurementsVarianceParameters(Packet self, float * angularWalkVariance, vec3f angularRateVariance, vec3f magneticVariance, vec3f accelerationVariance)"""
return _libvncxx.Packet_parseFilterMeasurementsVarianceParameters(self, angularWalkVariance, angularRateVariance, magneticVariance, accelerationVariance)
def parseMagnetometerCompensation(self, c, b):
"""parseMagnetometerCompensation(Packet self, mat3f c, vec3f b)"""
return _libvncxx.Packet_parseMagnetometerCompensation(self, c, b)
def parseFilterActiveTuningParameters(self, magneticDisturbanceGain, accelerationDisturbanceGain, magneticDisturbanceMemory, accelerationDisturbanceMemory):
"""parseFilterActiveTuningParameters(Packet self, float * magneticDisturbanceGain, float * accelerationDisturbanceGain, float * magneticDisturbanceMemory, float * accelerationDisturbanceMemory)"""
return _libvncxx.Packet_parseFilterActiveTuningParameters(self, magneticDisturbanceGain, accelerationDisturbanceGain, magneticDisturbanceMemory, accelerationDisturbanceMemory)
def parseAccelerationCompensation(self, c, b):
"""parseAccelerationCompensation(Packet self, mat3f c, vec3f b)"""
return _libvncxx.Packet_parseAccelerationCompensation(self, c, b)
def parseReferenceFrameRotation(self, c):
"""parseReferenceFrameRotation(Packet self, mat3f c)"""
return _libvncxx.Packet_parseReferenceFrameRotation(self, c)
def parseYawPitchRollMagneticAccelerationAndAngularRates(self, yawPitchRoll, mag, accel, gyro):
"""parseYawPitchRollMagneticAccelerationAndAngularRates(Packet self, vec3f yawPitchRoll, vec3f mag, vec3f accel, vec3f gyro)"""
return _libvncxx.Packet_parseYawPitchRollMagneticAccelerationAndAngularRates(self, yawPitchRoll, mag, accel, gyro)
def parseCommunicationProtocolControl(self, serialCount, serialStatus, spiCount, spiStatus, serialChecksum, spiChecksum, errorMode):
"""parseCommunicationProtocolControl(Packet self, uint8_t * serialCount, uint8_t * serialStatus, uint8_t * spiCount, uint8_t * spiStatus, uint8_t * serialChecksum, uint8_t * spiChecksum, uint8_t * errorMode)"""
return _libvncxx.Packet_parseCommunicationProtocolControl(self, serialCount, serialStatus, spiCount, spiStatus, serialChecksum, spiChecksum, errorMode)
def parseSynchronizationControl(self, syncInMode, syncInEdge, syncInSkipFactor, syncOutMode, syncOutPolarity, syncOutSkipFactor, syncOutPulseWidth):
"""parseSynchronizationControl(Packet self, uint8_t * syncInMode, uint8_t * syncInEdge, uint16_t * syncInSkipFactor, uint8_t * syncOutMode, uint8_t * syncOutPolarity, uint16_t * syncOutSkipFactor, uint32_t * syncOutPulseWidth)"""
return _libvncxx.Packet_parseSynchronizationControl(self, syncInMode, syncInEdge, syncInSkipFactor, syncOutMode, syncOutPolarity, syncOutSkipFactor, syncOutPulseWidth)
def parseSynchronizationStatus(self, syncInCount, syncInTime, syncOutCount):
"""parseSynchronizationStatus(Packet self, uint32_t * syncInCount, uint32_t * syncInTime, uint32_t * syncOutCount)"""
return _libvncxx.Packet_parseSynchronizationStatus(self, syncInCount, syncInTime, syncOutCount)
def parseFilterBasicControl(self, magMode, extMagMode, extAccMode, extGyroMode, gyroLimit):
"""parseFilterBasicControl(Packet self, uint8_t * magMode, uint8_t * extMagMode, uint8_t * extAccMode, uint8_t * extGyroMode, vec3f gyroLimit)"""
return _libvncxx.Packet_parseFilterBasicControl(self, magMode, extMagMode, extAccMode, extGyroMode, gyroLimit)
def parseVpeBasicControl(self, enable, headingMode, filteringMode, tuningMode):
"""parseVpeBasicControl(Packet self, uint8_t * enable, uint8_t * headingMode, uint8_t * filteringMode, uint8_t * tuningMode)"""
return _libvncxx.Packet_parseVpeBasicControl(self, enable, headingMode, filteringMode, tuningMode)
def parseVpeMagnetometerBasicTuning(self, baseTuning, adaptiveTuning, adaptiveFiltering):
"""parseVpeMagnetometerBasicTuning(Packet self, vec3f baseTuning, vec3f adaptiveTuning, vec3f adaptiveFiltering)"""
return _libvncxx.Packet_parseVpeMagnetometerBasicTuning(self, baseTuning, adaptiveTuning, adaptiveFiltering)
def parseVpeMagnetometerAdvancedTuning(self, minFiltering, maxFiltering, maxAdaptRate, disturbanceWindow, maxTuning):
"""parseVpeMagnetometerAdvancedTuning(Packet self, vec3f minFiltering, vec3f maxFiltering, float * maxAdaptRate, float * disturbanceWindow, float * maxTuning)"""
return _libvncxx.Packet_parseVpeMagnetometerAdvancedTuning(self, minFiltering, maxFiltering, maxAdaptRate, disturbanceWindow, maxTuning)
def parseVpeAccelerometerBasicTuning(self, baseTuning, adaptiveTuning, adaptiveFiltering):
"""parseVpeAccelerometerBasicTuning(Packet self, vec3f baseTuning, vec3f adaptiveTuning, vec3f adaptiveFiltering)"""
return _libvncxx.Packet_parseVpeAccelerometerBasicTuning(self, baseTuning, adaptiveTuning, adaptiveFiltering)
def parseVpeAccelerometerAdvancedTuning(self, minFiltering, maxFiltering, maxAdaptRate, disturbanceWindow, maxTuning):
"""parseVpeAccelerometerAdvancedTuning(Packet self, vec3f minFiltering, vec3f maxFiltering, float * maxAdaptRate, float * disturbanceWindow, float * maxTuning)"""
return _libvncxx.Packet_parseVpeAccelerometerAdvancedTuning(self, minFiltering, maxFiltering, maxAdaptRate, disturbanceWindow, maxTuning)
def parseVpeGyroBasicTuning(self, angularWalkVariance, baseTuning, adaptiveTuning):
"""parseVpeGyroBasicTuning(Packet self, vec3f angularWalkVariance, vec3f baseTuning, vec3f adaptiveTuning)"""
return _libvncxx.Packet_parseVpeGyroBasicTuning(self, angularWalkVariance, baseTuning, adaptiveTuning)
def parseFilterStartupGyroBias(self, bias):
"""parseFilterStartupGyroBias(Packet self, vec3f bias)"""
return _libvncxx.Packet_parseFilterStartupGyroBias(self, bias)
def parseMagnetometerCalibrationControl(self, hsiMode, hsiOutput, convergeRate):
"""parseMagnetometerCalibrationControl(Packet self, uint8_t * hsiMode, uint8_t * hsiOutput, uint8_t * convergeRate)"""
return _libvncxx.Packet_parseMagnetometerCalibrationControl(self, hsiMode, hsiOutput, convergeRate)
def parseCalculatedMagnetometerCalibration(self, c, b):
"""parseCalculatedMagnetometerCalibration(Packet self, mat3f c, vec3f b)"""
return _libvncxx.Packet_parseCalculatedMagnetometerCalibration(self, c, b)
def parseIndoorHeadingModeControl(self, maxRateError):
"""parseIndoorHeadingModeControl(Packet self, float * maxRateError)"""
return _libvncxx.Packet_parseIndoorHeadingModeControl(self, maxRateError)
def parseVelocityCompensationMeasurement(self, velocity):
"""parseVelocityCompensationMeasurement(Packet self, vec3f velocity)"""
return _libvncxx.Packet_parseVelocityCompensationMeasurement(self, velocity)
def parseVelocityCompensationControl(self, mode, velocityTuning, rateTuning):
"""parseVelocityCompensationControl(Packet self, uint8_t * mode, float * velocityTuning, float * rateTuning)"""
return _libvncxx.Packet_parseVelocityCompensationControl(self, mode, velocityTuning, rateTuning)
def parseVelocityCompensationStatus(self, x, xDot, accelOffset, omega):
"""parseVelocityCompensationStatus(Packet self, float * x, float * xDot, vec3f accelOffset, vec3f omega)"""
return _libvncxx.Packet_parseVelocityCompensationStatus(self, x, xDot, accelOffset, omega)
def parseImuMeasurements(self, mag, accel, gyro, temp, pressure):
"""parseImuMeasurements(Packet self, vec3f mag, vec3f accel, vec3f gyro, float * temp, float * pressure)"""
return _libvncxx.Packet_parseImuMeasurements(self, mag, accel, gyro, temp, pressure)
def parseGpsConfiguration(self, mode, ppsSource):
"""parseGpsConfiguration(Packet self, uint8_t * mode, uint8_t * ppsSource)"""
return _libvncxx.Packet_parseGpsConfiguration(self, mode, ppsSource)
def parseGpsAntennaOffset(self, position):
"""parseGpsAntennaOffset(Packet self, vec3f position)"""
return _libvncxx.Packet_parseGpsAntennaOffset(self, position)
def parseGpsSolutionLla(self, time, week, gpsFix, numSats, lla, nedVel, nedAcc, speedAcc, timeAcc):
"""parseGpsSolutionLla(Packet self, double * time, uint16_t * week, uint8_t * gpsFix, uint8_t * numSats, vec3d lla, vec3f nedVel, vec3f nedAcc, float * speedAcc, float * timeAcc)"""
return _libvncxx.Packet_parseGpsSolutionLla(self, time, week, gpsFix, numSats, lla, nedVel, nedAcc, speedAcc, timeAcc)
def parseGpsSolutionEcef(self, tow, week, gpsFix, numSats, position, velocity, posAcc, speedAcc, timeAcc):
"""parseGpsSolutionEcef(Packet self, double * tow, uint16_t * week, uint8_t * gpsFix, uint8_t * numSats, vec3d position, vec3f velocity, vec3f posAcc, float * speedAcc, float * timeAcc)"""
return _libvncxx.Packet_parseGpsSolutionEcef(self, tow, week, gpsFix, numSats, position, velocity, posAcc, speedAcc, timeAcc)
def parseInsSolutionLla(self, time, week, status, yawPitchRoll, position, nedVel, attUncertainty, posUncertainty, velUncertainty):
"""parseInsSolutionLla(Packet self, double * time, uint16_t * week, uint16_t * status, vec3f yawPitchRoll, vec3d position, vec3f nedVel, float * attUncertainty, float * posUncertainty, float * velUncertainty)"""
return _libvncxx.Packet_parseInsSolutionLla(self, time, week, status, yawPitchRoll, position, nedVel, attUncertainty, posUncertainty, velUncertainty)
def parseInsSolutionEcef(self, time, week, status, yawPitchRoll, position, velocity, attUncertainty, posUncertainty, velUncertainty):
"""parseInsSolutionEcef(Packet self, double * time, uint16_t * week, uint16_t * status, vec3f yawPitchRoll, vec3d position, vec3f velocity, float * attUncertainty, float * posUncertainty, float * velUncertainty)"""
return _libvncxx.Packet_parseInsSolutionEcef(self, time, week, status, yawPitchRoll, position, velocity, attUncertainty, posUncertainty, velUncertainty)
def parseInsBasicConfiguration(self, *args):
"""
parseInsBasicConfiguration(Packet self, uint8_t * scenario, uint8_t * ahrsAiding)
parseInsBasicConfiguration(Packet self, uint8_t * scenario, uint8_t * ahrsAiding, uint8_t * estBaseline)
"""
return _libvncxx.Packet_parseInsBasicConfiguration(self, *args)
def parseInsAdvancedConfiguration(self, useMag, usePres, posAtt, velAtt, velBias, useFoam, gpsCovType, velCount, velInit, moveOrigin, gpsTimeout, deltaLimitPos, deltaLimitVel, minPosUncertainty, minVelUncertainty):
"""parseInsAdvancedConfiguration(Packet self, uint8_t * useMag, uint8_t * usePres, uint8_t * posAtt, uint8_t * velAtt, uint8_t * velBias, uint8_t * useFoam, uint8_t * gpsCovType, uint8_t * velCount, float * velInit, float * moveOrigin, float * gpsTimeout, float * deltaLimitPos, float * deltaLimitVel, float * minPosUncertainty, float * minVelUncertainty)"""
return _libvncxx.Packet_parseInsAdvancedConfiguration(self, useMag, usePres, posAtt, velAtt, velBias, useFoam, gpsCovType, velCount, velInit, moveOrigin, gpsTimeout, deltaLimitPos, deltaLimitVel, minPosUncertainty, minVelUncertainty)
def parseInsStateLla(self, yawPitchRoll, position, velocity, accel, angularRate):
"""parseInsStateLla(Packet self, vec3f yawPitchRoll, vec3d position, vec3f velocity, vec3f accel, vec3f angularRate)"""
return _libvncxx.Packet_parseInsStateLla(self, yawPitchRoll, position, velocity, accel, angularRate)
def parseInsStateEcef(self, yawPitchRoll, position, velocity, accel, angularRate):
"""parseInsStateEcef(Packet self, vec3f yawPitchRoll, vec3d position, vec3f velocity, vec3f accel, vec3f angularRate)"""
return _libvncxx.Packet_parseInsStateEcef(self, yawPitchRoll, position, velocity, accel, angularRate)
def parseStartupFilterBiasEstimate(self, gyroBias, accelBias, pressureBias):
"""parseStartupFilterBiasEstimate(Packet self, vec3f gyroBias, vec3f accelBias, float * pressureBias)"""
return _libvncxx.Packet_parseStartupFilterBiasEstimate(self, gyroBias, accelBias, pressureBias)
def parseDeltaThetaAndDeltaVelocity(self, deltaTime, deltaTheta, deltaVelocity):
"""parseDeltaThetaAndDeltaVelocity(Packet self, float * deltaTime, vec3f deltaTheta, vec3f deltaVelocity)"""
return _libvncxx.Packet_parseDeltaThetaAndDeltaVelocity(self, deltaTime, deltaTheta, deltaVelocity)
def parseDeltaThetaAndDeltaVelocityConfiguration(self, integrationFrame, gyroCompensation, accelCompensation):
"""parseDeltaThetaAndDeltaVelocityConfiguration(Packet self, uint8_t * integrationFrame, uint8_t * gyroCompensation, uint8_t * accelCompensation)"""
return _libvncxx.Packet_parseDeltaThetaAndDeltaVelocityConfiguration(self, integrationFrame, gyroCompensation, accelCompensation)
def parseReferenceVectorConfiguration(self, useMagModel, useGravityModel, recalcThreshold, year, position):
"""parseReferenceVectorConfiguration(Packet self, uint8_t * useMagModel, uint8_t * useGravityModel, uint32_t * recalcThreshold, float * year, vec3d position)"""
return _libvncxx.Packet_parseReferenceVectorConfiguration(self, useMagModel, useGravityModel, recalcThreshold, year, position)
def parseGyroCompensation(self, c, b):
"""parseGyroCompensation(Packet self, mat3f c, vec3f b)"""
return _libvncxx.Packet_parseGyroCompensation(self, c, b)
def parseImuFilteringConfiguration(self, magWindowSize, accelWindowSize, gyroWindowSize, tempWindowSize, presWindowSize, magFilterMode, accelFilterMode, gyroFilterMode, tempFilterMode, presFilterMode):
"""parseImuFilteringConfiguration(Packet self, uint16_t * magWindowSize, uint16_t * accelWindowSize, uint16_t * gyroWindowSize, uint16_t * tempWindowSize, uint16_t * presWindowSize, uint8_t * magFilterMode, uint8_t * accelFilterMode, uint8_t * gyroFilterMode, uint8_t * tempFilterMode, uint8_t * presFilterMode)"""
return _libvncxx.Packet_parseImuFilteringConfiguration(self, magWindowSize, accelWindowSize, gyroWindowSize, tempWindowSize, presWindowSize, magFilterMode, accelFilterMode, gyroFilterMode, tempFilterMode, presFilterMode)
def parseGpsCompassBaseline(self, position, uncertainty):
"""parseGpsCompassBaseline(Packet self, vec3f position, vec3f uncertainty)"""
return _libvncxx.Packet_parseGpsCompassBaseline(self, position, uncertainty)
def parseGpsCompassEstimatedBaseline(self, estBaselineUsed, numMeas, position, uncertainty):
"""parseGpsCompassEstimatedBaseline(Packet self, uint8_t * estBaselineUsed, uint16_t * numMeas, vec3f position, vec3f uncertainty)"""
return _libvncxx.Packet_parseGpsCompassEstimatedBaseline(self, estBaselineUsed, numMeas, position, uncertainty)
def parseImuRateConfiguration(self, imuRate, navDivisor, filterTargetRate, filterMinRate):
"""parseImuRateConfiguration(Packet self, uint16_t * imuRate, uint16_t * navDivisor, float * filterTargetRate, float * filterMinRate)"""
return _libvncxx.Packet_parseImuRateConfiguration(self, imuRate, navDivisor, filterTargetRate, filterMinRate)
def parseYawPitchRollTrueBodyAccelerationAndAngularRates(self, yawPitchRoll, bodyAccel, gyro):
"""parseYawPitchRollTrueBodyAccelerationAndAngularRates(Packet self, vec3f yawPitchRoll, vec3f bodyAccel, vec3f gyro)"""
return _libvncxx.Packet_parseYawPitchRollTrueBodyAccelerationAndAngularRates(self, yawPitchRoll, bodyAccel, gyro)
def parseYawPitchRollTrueInertialAccelerationAndAngularRates(self, yawPitchRoll, inertialAccel, gyro):
"""parseYawPitchRollTrueInertialAccelerationAndAngularRates(Packet self, vec3f yawPitchRoll, vec3f inertialAccel, vec3f gyro)"""
return _libvncxx.Packet_parseYawPitchRollTrueInertialAccelerationAndAngularRates(self, yawPitchRoll, inertialAccel, gyro)
is_valid = property(__isValid)
type = property(__type)
datastr = property(__datastr)
is_error = property(__isError)
is_response = property(__isResponse)
is_ascii_async = property(__isAsciiAsync)
def __repr__(self):
return "<vnpy.Packet>"
Packet_swigregister = _libvncxx.Packet_swigregister
Packet_swigregister(Packet)
cvar = _libvncxx.cvar
def Packet_computeBinaryPacketLength(startOfPossibleBinaryPacket):
"""Packet_computeBinaryPacketLength(char const * startOfPossibleBinaryPacket) -> size_t"""
return _libvncxx.Packet_computeBinaryPacketLength(startOfPossibleBinaryPacket)
def Packet_computeNumOfBytesForBinaryGroupPayload(group, groupField):
"""Packet_computeNumOfBytesForBinaryGroupPayload(BINARYGROUP group, uint16_t groupField) -> size_t"""
return _libvncxx.Packet_computeNumOfBytesForBinaryGroupPayload(group, groupField)
def Packet_finalizeCommand(errorDetectionMode, packet, length):
"""Packet_finalizeCommand(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * packet, size_t length) -> size_t"""
return _libvncxx.Packet_finalizeCommand(errorDetectionMode, packet, length)
def Packet_genReadBinaryOutput1(errorDetectionMode, buffer, size):
"""Packet_genReadBinaryOutput1(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadBinaryOutput1(errorDetectionMode, buffer, size)
def Packet_genReadBinaryOutput2(errorDetectionMode, buffer, size):
"""Packet_genReadBinaryOutput2(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadBinaryOutput2(errorDetectionMode, buffer, size)
def Packet_genReadBinaryOutput3(errorDetectionMode, buffer, size):
"""Packet_genReadBinaryOutput3(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadBinaryOutput3(errorDetectionMode, buffer, size)
def Packet_genWriteBinaryOutput1(errorDetectionMode, buffer, size, asyncMode, rateDivisor, commonField, timeField, imuField, gpsField, attitudeField, insField):
"""Packet_genWriteBinaryOutput1(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint16_t asyncMode, uint16_t rateDivisor, uint16_t commonField, uint16_t timeField, uint16_t imuField, uint16_t gpsField, uint16_t attitudeField, uint16_t insField) -> size_t"""
return _libvncxx.Packet_genWriteBinaryOutput1(errorDetectionMode, buffer, size, asyncMode, rateDivisor, commonField, timeField, imuField, gpsField, attitudeField, insField)
def Packet_genWriteBinaryOutput2(errorDetectionMode, buffer, size, asyncMode, rateDivisor, commonField, timeField, imuField, gpsField, attitudeField, insField):
"""Packet_genWriteBinaryOutput2(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint16_t asyncMode, uint16_t rateDivisor, uint16_t commonField, uint16_t timeField, uint16_t imuField, uint16_t gpsField, uint16_t attitudeField, uint16_t insField) -> size_t"""
return _libvncxx.Packet_genWriteBinaryOutput2(errorDetectionMode, buffer, size, asyncMode, rateDivisor, commonField, timeField, imuField, gpsField, attitudeField, insField)
def Packet_genWriteBinaryOutput3(errorDetectionMode, buffer, size, asyncMode, rateDivisor, commonField, timeField, imuField, gpsField, attitudeField, insField):
"""Packet_genWriteBinaryOutput3(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint16_t asyncMode, uint16_t rateDivisor, uint16_t commonField, uint16_t timeField, uint16_t imuField, uint16_t gpsField, uint16_t attitudeField, uint16_t insField) -> size_t"""
return _libvncxx.Packet_genWriteBinaryOutput3(errorDetectionMode, buffer, size, asyncMode, rateDivisor, commonField, timeField, imuField, gpsField, attitudeField, insField)
def Packet_genWriteSettings(errorDetectionMode, buffer, size):
"""Packet_genWriteSettings(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genWriteSettings(errorDetectionMode, buffer, size)
def Packet_genTare(errorDetectionMode, buffer, size):
"""Packet_genTare(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genTare(errorDetectionMode, buffer, size)
def Packet_genKnownMagneticDisturbance(errorDetectionMode, buffer, size, isMagneticDisturbancePresent):
"""Packet_genKnownMagneticDisturbance(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, bool isMagneticDisturbancePresent) -> size_t"""
return _libvncxx.Packet_genKnownMagneticDisturbance(errorDetectionMode, buffer, size, isMagneticDisturbancePresent)
def Packet_genKnownAccelerationDisturbance(errorDetectionMode, buffer, size, isAccelerationDisturbancePresent):
"""Packet_genKnownAccelerationDisturbance(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, bool isAccelerationDisturbancePresent) -> size_t"""
return _libvncxx.Packet_genKnownAccelerationDisturbance(errorDetectionMode, buffer, size, isAccelerationDisturbancePresent)
def Packet_genSetGyroBias(errorDetectionMode, buffer, size):
"""Packet_genSetGyroBias(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genSetGyroBias(errorDetectionMode, buffer, size)
def Packet_genRestoreFactorySettings(errorDetectionMode, buffer, size):
"""Packet_genRestoreFactorySettings(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genRestoreFactorySettings(errorDetectionMode, buffer, size)
def Packet_genReset(errorDetectionMode, buffer, size):
"""Packet_genReset(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReset(errorDetectionMode, buffer, size)
def Packet_genReadUserTag(errorDetectionMode, buffer, size):
"""Packet_genReadUserTag(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadUserTag(errorDetectionMode, buffer, size)
def Packet_genWriteUserTag(errorDetectionMode, buffer, size, tag):
"""Packet_genWriteUserTag(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, std::string tag) -> size_t"""
return _libvncxx.Packet_genWriteUserTag(errorDetectionMode, buffer, size, tag)
def Packet_genReadModelNumber(errorDetectionMode, buffer, size):
"""Packet_genReadModelNumber(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadModelNumber(errorDetectionMode, buffer, size)
def Packet_genReadHardwareRevision(errorDetectionMode, buffer, size):
"""Packet_genReadHardwareRevision(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadHardwareRevision(errorDetectionMode, buffer, size)
def Packet_genReadSerialNumber(errorDetectionMode, buffer, size):
"""Packet_genReadSerialNumber(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadSerialNumber(errorDetectionMode, buffer, size)
def Packet_genReadFirmwareVersion(errorDetectionMode, buffer, size):
"""Packet_genReadFirmwareVersion(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadFirmwareVersion(errorDetectionMode, buffer, size)
def Packet_genReadSerialBaudRate(*args):
"""
genReadSerialBaudRate(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t port) -> size_t
Packet_genReadSerialBaudRate(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t
"""
return _libvncxx.Packet_genReadSerialBaudRate(*args)
def Packet_genWriteSerialBaudRate(*args):
"""
genWriteSerialBaudRate(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint32_t baudrate, uint8_t port) -> size_t
Packet_genWriteSerialBaudRate(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint32_t baudrate) -> size_t
"""
return _libvncxx.Packet_genWriteSerialBaudRate(*args)
def Packet_genReadAsyncDataOutputType(*args):
"""
genReadAsyncDataOutputType(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t port) -> size_t
Packet_genReadAsyncDataOutputType(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t
"""
return _libvncxx.Packet_genReadAsyncDataOutputType(*args)
def Packet_genWriteAsyncDataOutputType(*args):
"""
genWriteAsyncDataOutputType(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint32_t ador, uint8_t port) -> size_t
Packet_genWriteAsyncDataOutputType(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint32_t ador) -> size_t
"""
return _libvncxx.Packet_genWriteAsyncDataOutputType(*args)
def Packet_genReadAsyncDataOutputFrequency(*args):
"""
genReadAsyncDataOutputFrequency(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t port) -> size_t
Packet_genReadAsyncDataOutputFrequency(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t
"""
return _libvncxx.Packet_genReadAsyncDataOutputFrequency(*args)
def Packet_genWriteAsyncDataOutputFrequency(*args):
"""
genWriteAsyncDataOutputFrequency(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint32_t adof, uint8_t port) -> size_t
Packet_genWriteAsyncDataOutputFrequency(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint32_t adof) -> size_t
"""
return _libvncxx.Packet_genWriteAsyncDataOutputFrequency(*args)
def Packet_genReadYawPitchRoll(errorDetectionMode, buffer, size):
"""Packet_genReadYawPitchRoll(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadYawPitchRoll(errorDetectionMode, buffer, size)
def Packet_genReadAttitudeQuaternion(errorDetectionMode, buffer, size):
"""Packet_genReadAttitudeQuaternion(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadAttitudeQuaternion(errorDetectionMode, buffer, size)
def Packet_genReadQuaternionMagneticAccelerationAndAngularRates(errorDetectionMode, buffer, size):
"""Packet_genReadQuaternionMagneticAccelerationAndAngularRates(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadQuaternionMagneticAccelerationAndAngularRates(errorDetectionMode, buffer, size)
def Packet_genReadMagneticMeasurements(errorDetectionMode, buffer, size):
"""Packet_genReadMagneticMeasurements(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadMagneticMeasurements(errorDetectionMode, buffer, size)
def Packet_genReadAccelerationMeasurements(errorDetectionMode, buffer, size):
"""Packet_genReadAccelerationMeasurements(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadAccelerationMeasurements(errorDetectionMode, buffer, size)
def Packet_genReadAngularRateMeasurements(errorDetectionMode, buffer, size):
"""Packet_genReadAngularRateMeasurements(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadAngularRateMeasurements(errorDetectionMode, buffer, size)
def Packet_genReadMagneticAccelerationAndAngularRates(errorDetectionMode, buffer, size):
"""Packet_genReadMagneticAccelerationAndAngularRates(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadMagneticAccelerationAndAngularRates(errorDetectionMode, buffer, size)
def Packet_genReadMagneticAndGravityReferenceVectors(errorDetectionMode, buffer, size):
"""Packet_genReadMagneticAndGravityReferenceVectors(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadMagneticAndGravityReferenceVectors(errorDetectionMode, buffer, size)
def Packet_genWriteMagneticAndGravityReferenceVectors(errorDetectionMode, buffer, size, magRef, accRef):
"""Packet_genWriteMagneticAndGravityReferenceVectors(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, vec3f magRef, vec3f accRef) -> size_t"""
return _libvncxx.Packet_genWriteMagneticAndGravityReferenceVectors(errorDetectionMode, buffer, size, magRef, accRef)
def Packet_genReadFilterMeasurementsVarianceParameters(errorDetectionMode, buffer, size):
"""Packet_genReadFilterMeasurementsVarianceParameters(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadFilterMeasurementsVarianceParameters(errorDetectionMode, buffer, size)
def Packet_genWriteFilterMeasurementsVarianceParameters(errorDetectionMode, buffer, size, angularWalkVariance, angularRateVariance, magneticVariance, accelerationVariance):
"""Packet_genWriteFilterMeasurementsVarianceParameters(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, float angularWalkVariance, vec3f angularRateVariance, vec3f magneticVariance, vec3f accelerationVariance) -> size_t"""
return _libvncxx.Packet_genWriteFilterMeasurementsVarianceParameters(errorDetectionMode, buffer, size, angularWalkVariance, angularRateVariance, magneticVariance, accelerationVariance)
def Packet_genReadMagnetometerCompensation(errorDetectionMode, buffer, size):
"""Packet_genReadMagnetometerCompensation(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadMagnetometerCompensation(errorDetectionMode, buffer, size)
def Packet_genWriteMagnetometerCompensation(errorDetectionMode, buffer, size, c, b):
"""Packet_genWriteMagnetometerCompensation(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, mat3f c, vec3f b) -> size_t"""
return _libvncxx.Packet_genWriteMagnetometerCompensation(errorDetectionMode, buffer, size, c, b)
def Packet_genReadFilterActiveTuningParameters(errorDetectionMode, buffer, size):
"""Packet_genReadFilterActiveTuningParameters(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadFilterActiveTuningParameters(errorDetectionMode, buffer, size)
def Packet_genWriteFilterActiveTuningParameters(errorDetectionMode, buffer, size, magneticDisturbanceGain, accelerationDisturbanceGain, magneticDisturbanceMemory, accelerationDisturbanceMemory):
"""Packet_genWriteFilterActiveTuningParameters(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, float magneticDisturbanceGain, float accelerationDisturbanceGain, float magneticDisturbanceMemory, float accelerationDisturbanceMemory) -> size_t"""
return _libvncxx.Packet_genWriteFilterActiveTuningParameters(errorDetectionMode, buffer, size, magneticDisturbanceGain, accelerationDisturbanceGain, magneticDisturbanceMemory, accelerationDisturbanceMemory)
def Packet_genReadAccelerationCompensation(errorDetectionMode, buffer, size):
"""Packet_genReadAccelerationCompensation(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadAccelerationCompensation(errorDetectionMode, buffer, size)
def Packet_genWriteAccelerationCompensation(errorDetectionMode, buffer, size, c, b):
"""Packet_genWriteAccelerationCompensation(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, mat3f c, vec3f b) -> size_t"""
return _libvncxx.Packet_genWriteAccelerationCompensation(errorDetectionMode, buffer, size, c, b)
def Packet_genReadReferenceFrameRotation(errorDetectionMode, buffer, size):
"""Packet_genReadReferenceFrameRotation(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadReferenceFrameRotation(errorDetectionMode, buffer, size)
def Packet_genWriteReferenceFrameRotation(errorDetectionMode, buffer, size, c):
"""Packet_genWriteReferenceFrameRotation(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, mat3f c) -> size_t"""
return _libvncxx.Packet_genWriteReferenceFrameRotation(errorDetectionMode, buffer, size, c)
def Packet_genReadYawPitchRollMagneticAccelerationAndAngularRates(errorDetectionMode, buffer, size):
"""Packet_genReadYawPitchRollMagneticAccelerationAndAngularRates(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadYawPitchRollMagneticAccelerationAndAngularRates(errorDetectionMode, buffer, size)
def Packet_genReadCommunicationProtocolControl(errorDetectionMode, buffer, size):
"""Packet_genReadCommunicationProtocolControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadCommunicationProtocolControl(errorDetectionMode, buffer, size)
def Packet_genWriteCommunicationProtocolControl(errorDetectionMode, buffer, size, serialCount, serialStatus, spiCount, spiStatus, serialChecksum, spiChecksum, errorMode):
"""Packet_genWriteCommunicationProtocolControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t serialCount, uint8_t serialStatus, uint8_t spiCount, uint8_t spiStatus, uint8_t serialChecksum, uint8_t spiChecksum, uint8_t errorMode) -> size_t"""
return _libvncxx.Packet_genWriteCommunicationProtocolControl(errorDetectionMode, buffer, size, serialCount, serialStatus, spiCount, spiStatus, serialChecksum, spiChecksum, errorMode)
def Packet_genReadSynchronizationControl(errorDetectionMode, buffer, size):
"""Packet_genReadSynchronizationControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadSynchronizationControl(errorDetectionMode, buffer, size)
def Packet_genWriteSynchronizationControl(errorDetectionMode, buffer, size, syncInMode, syncInEdge, syncInSkipFactor, syncOutMode, syncOutPolarity, syncOutSkipFactor, syncOutPulseWidth):
"""Packet_genWriteSynchronizationControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t syncInMode, uint8_t syncInEdge, uint16_t syncInSkipFactor, uint8_t syncOutMode, uint8_t syncOutPolarity, uint16_t syncOutSkipFactor, uint32_t syncOutPulseWidth) -> size_t"""
return _libvncxx.Packet_genWriteSynchronizationControl(errorDetectionMode, buffer, size, syncInMode, syncInEdge, syncInSkipFactor, syncOutMode, syncOutPolarity, syncOutSkipFactor, syncOutPulseWidth)
def Packet_genReadSynchronizationStatus(errorDetectionMode, buffer, size):
"""Packet_genReadSynchronizationStatus(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadSynchronizationStatus(errorDetectionMode, buffer, size)
def Packet_genWriteSynchronizationStatus(errorDetectionMode, buffer, size, syncInCount, syncInTime, syncOutCount):
"""Packet_genWriteSynchronizationStatus(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint32_t syncInCount, uint32_t syncInTime, uint32_t syncOutCount) -> size_t"""
return _libvncxx.Packet_genWriteSynchronizationStatus(errorDetectionMode, buffer, size, syncInCount, syncInTime, syncOutCount)
def Packet_genReadFilterBasicControl(errorDetectionMode, buffer, size):
"""Packet_genReadFilterBasicControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadFilterBasicControl(errorDetectionMode, buffer, size)
def Packet_genWriteFilterBasicControl(errorDetectionMode, buffer, size, magMode, extMagMode, extAccMode, extGyroMode, gyroLimit):
"""Packet_genWriteFilterBasicControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t magMode, uint8_t extMagMode, uint8_t extAccMode, uint8_t extGyroMode, vec3f gyroLimit) -> size_t"""
return _libvncxx.Packet_genWriteFilterBasicControl(errorDetectionMode, buffer, size, magMode, extMagMode, extAccMode, extGyroMode, gyroLimit)
def Packet_genReadVpeBasicControl(errorDetectionMode, buffer, size):
"""Packet_genReadVpeBasicControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadVpeBasicControl(errorDetectionMode, buffer, size)
def Packet_genWriteVpeBasicControl(errorDetectionMode, buffer, size, enable, headingMode, filteringMode, tuningMode):
"""Packet_genWriteVpeBasicControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t enable, uint8_t headingMode, uint8_t filteringMode, uint8_t tuningMode) -> size_t"""
return _libvncxx.Packet_genWriteVpeBasicControl(errorDetectionMode, buffer, size, enable, headingMode, filteringMode, tuningMode)
def Packet_genReadVpeMagnetometerBasicTuning(errorDetectionMode, buffer, size):
"""Packet_genReadVpeMagnetometerBasicTuning(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadVpeMagnetometerBasicTuning(errorDetectionMode, buffer, size)
def Packet_genWriteVpeMagnetometerBasicTuning(errorDetectionMode, buffer, size, baseTuning, adaptiveTuning, adaptiveFiltering):
"""Packet_genWriteVpeMagnetometerBasicTuning(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, vec3f baseTuning, vec3f adaptiveTuning, vec3f adaptiveFiltering) -> size_t"""
return _libvncxx.Packet_genWriteVpeMagnetometerBasicTuning(errorDetectionMode, buffer, size, baseTuning, adaptiveTuning, adaptiveFiltering)
def Packet_genReadVpeMagnetometerAdvancedTuning(errorDetectionMode, buffer, size):
"""Packet_genReadVpeMagnetometerAdvancedTuning(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadVpeMagnetometerAdvancedTuning(errorDetectionMode, buffer, size)
def Packet_genWriteVpeMagnetometerAdvancedTuning(errorDetectionMode, buffer, size, minFiltering, maxFiltering, maxAdaptRate, disturbanceWindow, maxTuning):
"""Packet_genWriteVpeMagnetometerAdvancedTuning(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, vec3f minFiltering, vec3f maxFiltering, float maxAdaptRate, float disturbanceWindow, float maxTuning) -> size_t"""
return _libvncxx.Packet_genWriteVpeMagnetometerAdvancedTuning(errorDetectionMode, buffer, size, minFiltering, maxFiltering, maxAdaptRate, disturbanceWindow, maxTuning)
def Packet_genReadVpeAccelerometerBasicTuning(errorDetectionMode, buffer, size):
"""Packet_genReadVpeAccelerometerBasicTuning(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadVpeAccelerometerBasicTuning(errorDetectionMode, buffer, size)
def Packet_genWriteVpeAccelerometerBasicTuning(errorDetectionMode, buffer, size, baseTuning, adaptiveTuning, adaptiveFiltering):
"""Packet_genWriteVpeAccelerometerBasicTuning(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, vec3f baseTuning, vec3f adaptiveTuning, vec3f adaptiveFiltering) -> size_t"""
return _libvncxx.Packet_genWriteVpeAccelerometerBasicTuning(errorDetectionMode, buffer, size, baseTuning, adaptiveTuning, adaptiveFiltering)
def Packet_genReadVpeAccelerometerAdvancedTuning(errorDetectionMode, buffer, size):
"""Packet_genReadVpeAccelerometerAdvancedTuning(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadVpeAccelerometerAdvancedTuning(errorDetectionMode, buffer, size)
def Packet_genWriteVpeAccelerometerAdvancedTuning(errorDetectionMode, buffer, size, minFiltering, maxFiltering, maxAdaptRate, disturbanceWindow, maxTuning):
"""Packet_genWriteVpeAccelerometerAdvancedTuning(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, vec3f minFiltering, vec3f maxFiltering, float maxAdaptRate, float disturbanceWindow, float maxTuning) -> size_t"""
return _libvncxx.Packet_genWriteVpeAccelerometerAdvancedTuning(errorDetectionMode, buffer, size, minFiltering, maxFiltering, maxAdaptRate, disturbanceWindow, maxTuning)
def Packet_genReadVpeGyroBasicTuning(errorDetectionMode, buffer, size):
"""Packet_genReadVpeGyroBasicTuning(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadVpeGyroBasicTuning(errorDetectionMode, buffer, size)
def Packet_genWriteVpeGyroBasicTuning(errorDetectionMode, buffer, size, angularWalkVariance, baseTuning, adaptiveTuning):
"""Packet_genWriteVpeGyroBasicTuning(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, vec3f angularWalkVariance, vec3f baseTuning, vec3f adaptiveTuning) -> size_t"""
return _libvncxx.Packet_genWriteVpeGyroBasicTuning(errorDetectionMode, buffer, size, angularWalkVariance, baseTuning, adaptiveTuning)
def Packet_genReadFilterStartupGyroBias(errorDetectionMode, buffer, size):
"""Packet_genReadFilterStartupGyroBias(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadFilterStartupGyroBias(errorDetectionMode, buffer, size)
def Packet_genWriteFilterStartupGyroBias(errorDetectionMode, buffer, size, bias):
"""Packet_genWriteFilterStartupGyroBias(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, vec3f bias) -> size_t"""
return _libvncxx.Packet_genWriteFilterStartupGyroBias(errorDetectionMode, buffer, size, bias)
def Packet_genReadMagnetometerCalibrationControl(errorDetectionMode, buffer, size):
"""Packet_genReadMagnetometerCalibrationControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadMagnetometerCalibrationControl(errorDetectionMode, buffer, size)
def Packet_genWriteMagnetometerCalibrationControl(errorDetectionMode, buffer, size, hsiMode, hsiOutput, convergeRate):
"""Packet_genWriteMagnetometerCalibrationControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t hsiMode, uint8_t hsiOutput, uint8_t convergeRate) -> size_t"""
return _libvncxx.Packet_genWriteMagnetometerCalibrationControl(errorDetectionMode, buffer, size, hsiMode, hsiOutput, convergeRate)
def Packet_genReadCalculatedMagnetometerCalibration(errorDetectionMode, buffer, size):
"""Packet_genReadCalculatedMagnetometerCalibration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadCalculatedMagnetometerCalibration(errorDetectionMode, buffer, size)
def Packet_genReadIndoorHeadingModeControl(errorDetectionMode, buffer, size):
"""Packet_genReadIndoorHeadingModeControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadIndoorHeadingModeControl(errorDetectionMode, buffer, size)
def Packet_genWriteIndoorHeadingModeControl(errorDetectionMode, buffer, size, maxRateError):
"""Packet_genWriteIndoorHeadingModeControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, float maxRateError) -> size_t"""
return _libvncxx.Packet_genWriteIndoorHeadingModeControl(errorDetectionMode, buffer, size, maxRateError)
def Packet_genReadVelocityCompensationMeasurement(errorDetectionMode, buffer, size):
"""Packet_genReadVelocityCompensationMeasurement(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadVelocityCompensationMeasurement(errorDetectionMode, buffer, size)
def Packet_genWriteVelocityCompensationMeasurement(errorDetectionMode, buffer, size, velocity):
"""Packet_genWriteVelocityCompensationMeasurement(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, vec3f velocity) -> size_t"""
return _libvncxx.Packet_genWriteVelocityCompensationMeasurement(errorDetectionMode, buffer, size, velocity)
def Packet_genReadVelocityCompensationControl(errorDetectionMode, buffer, size):
"""Packet_genReadVelocityCompensationControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadVelocityCompensationControl(errorDetectionMode, buffer, size)
def Packet_genWriteVelocityCompensationControl(errorDetectionMode, buffer, size, mode, velocityTuning, rateTuning):
"""Packet_genWriteVelocityCompensationControl(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t mode, float velocityTuning, float rateTuning) -> size_t"""
return _libvncxx.Packet_genWriteVelocityCompensationControl(errorDetectionMode, buffer, size, mode, velocityTuning, rateTuning)
def Packet_genReadVelocityCompensationStatus(errorDetectionMode, buffer, size):
"""Packet_genReadVelocityCompensationStatus(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadVelocityCompensationStatus(errorDetectionMode, buffer, size)
def Packet_genReadImuMeasurements(errorDetectionMode, buffer, size):
"""Packet_genReadImuMeasurements(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadImuMeasurements(errorDetectionMode, buffer, size)
def Packet_genReadGpsConfiguration(errorDetectionMode, buffer, size):
"""Packet_genReadGpsConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadGpsConfiguration(errorDetectionMode, buffer, size)
def Packet_genWriteGpsConfiguration(errorDetectionMode, buffer, size, mode, ppsSource):
"""Packet_genWriteGpsConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t mode, uint8_t ppsSource) -> size_t"""
return _libvncxx.Packet_genWriteGpsConfiguration(errorDetectionMode, buffer, size, mode, ppsSource)
def Packet_genReadGpsAntennaOffset(errorDetectionMode, buffer, size):
"""Packet_genReadGpsAntennaOffset(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadGpsAntennaOffset(errorDetectionMode, buffer, size)
def Packet_genWriteGpsAntennaOffset(errorDetectionMode, buffer, size, position):
"""Packet_genWriteGpsAntennaOffset(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, vec3f position) -> size_t"""
return _libvncxx.Packet_genWriteGpsAntennaOffset(errorDetectionMode, buffer, size, position)
def Packet_genReadGpsSolutionLla(errorDetectionMode, buffer, size):
"""Packet_genReadGpsSolutionLla(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadGpsSolutionLla(errorDetectionMode, buffer, size)
def Packet_genReadGpsSolutionEcef(errorDetectionMode, buffer, size):
"""Packet_genReadGpsSolutionEcef(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadGpsSolutionEcef(errorDetectionMode, buffer, size)
def Packet_genReadInsSolutionLla(errorDetectionMode, buffer, size):
"""Packet_genReadInsSolutionLla(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadInsSolutionLla(errorDetectionMode, buffer, size)
def Packet_genReadInsSolutionEcef(errorDetectionMode, buffer, size):
"""Packet_genReadInsSolutionEcef(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadInsSolutionEcef(errorDetectionMode, buffer, size)
def Packet_genReadInsBasicConfiguration(errorDetectionMode, buffer, size):
"""Packet_genReadInsBasicConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadInsBasicConfiguration(errorDetectionMode, buffer, size)
def Packet_genWriteInsBasicConfiguration(errorDetectionMode, buffer, size, scenario, ahrsAiding, estBaseline):
"""Packet_genWriteInsBasicConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t scenario, uint8_t ahrsAiding, uint8_t estBaseline) -> size_t"""
return _libvncxx.Packet_genWriteInsBasicConfiguration(errorDetectionMode, buffer, size, scenario, ahrsAiding, estBaseline)
def Packet_genReadInsAdvancedConfiguration(errorDetectionMode, buffer, size):
"""Packet_genReadInsAdvancedConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadInsAdvancedConfiguration(errorDetectionMode, buffer, size)
def Packet_genWriteInsAdvancedConfiguration(errorDetectionMode, buffer, size, useMag, usePres, posAtt, velAtt, velBias, useFoam, gpsCovType, velCount, velInit, moveOrigin, gpsTimeout, deltaLimitPos, deltaLimitVel, minPosUncertainty, minVelUncertainty):
"""Packet_genWriteInsAdvancedConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t useMag, uint8_t usePres, uint8_t posAtt, uint8_t velAtt, uint8_t velBias, uint8_t useFoam, uint8_t gpsCovType, uint8_t velCount, float velInit, float moveOrigin, float gpsTimeout, float deltaLimitPos, float deltaLimitVel, float minPosUncertainty, float minVelUncertainty) -> size_t"""
return _libvncxx.Packet_genWriteInsAdvancedConfiguration(errorDetectionMode, buffer, size, useMag, usePres, posAtt, velAtt, velBias, useFoam, gpsCovType, velCount, velInit, moveOrigin, gpsTimeout, deltaLimitPos, deltaLimitVel, minPosUncertainty, minVelUncertainty)
def Packet_genReadInsStateLla(errorDetectionMode, buffer, size):
"""Packet_genReadInsStateLla(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadInsStateLla(errorDetectionMode, buffer, size)
def Packet_genReadInsStateEcef(errorDetectionMode, buffer, size):
"""Packet_genReadInsStateEcef(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadInsStateEcef(errorDetectionMode, buffer, size)
def Packet_genReadStartupFilterBiasEstimate(errorDetectionMode, buffer, size):
"""Packet_genReadStartupFilterBiasEstimate(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadStartupFilterBiasEstimate(errorDetectionMode, buffer, size)
def Packet_genWriteStartupFilterBiasEstimate(errorDetectionMode, buffer, size, gyroBias, accelBias, pressureBias):
"""Packet_genWriteStartupFilterBiasEstimate(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, vec3f gyroBias, vec3f accelBias, float pressureBias) -> size_t"""
return _libvncxx.Packet_genWriteStartupFilterBiasEstimate(errorDetectionMode, buffer, size, gyroBias, accelBias, pressureBias)
def Packet_genReadDeltaThetaAndDeltaVelocity(errorDetectionMode, buffer, size):
"""Packet_genReadDeltaThetaAndDeltaVelocity(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadDeltaThetaAndDeltaVelocity(errorDetectionMode, buffer, size)
def Packet_genReadDeltaThetaAndDeltaVelocityConfiguration(errorDetectionMode, buffer, size):
"""Packet_genReadDeltaThetaAndDeltaVelocityConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadDeltaThetaAndDeltaVelocityConfiguration(errorDetectionMode, buffer, size)
def Packet_genWriteDeltaThetaAndDeltaVelocityConfiguration(errorDetectionMode, buffer, size, integrationFrame, gyroCompensation, accelCompensation):
"""Packet_genWriteDeltaThetaAndDeltaVelocityConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t integrationFrame, uint8_t gyroCompensation, uint8_t accelCompensation) -> size_t"""
return _libvncxx.Packet_genWriteDeltaThetaAndDeltaVelocityConfiguration(errorDetectionMode, buffer, size, integrationFrame, gyroCompensation, accelCompensation)
def Packet_genReadReferenceVectorConfiguration(errorDetectionMode, buffer, size):
"""Packet_genReadReferenceVectorConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadReferenceVectorConfiguration(errorDetectionMode, buffer, size)
def Packet_genWriteReferenceVectorConfiguration(errorDetectionMode, buffer, size, useMagModel, useGravityModel, recalcThreshold, year, position):
"""Packet_genWriteReferenceVectorConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint8_t useMagModel, uint8_t useGravityModel, uint32_t recalcThreshold, float year, vec3d position) -> size_t"""
return _libvncxx.Packet_genWriteReferenceVectorConfiguration(errorDetectionMode, buffer, size, useMagModel, useGravityModel, recalcThreshold, year, position)
def Packet_genReadGyroCompensation(errorDetectionMode, buffer, size):
"""Packet_genReadGyroCompensation(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadGyroCompensation(errorDetectionMode, buffer, size)
def Packet_genWriteGyroCompensation(errorDetectionMode, buffer, size, c, b):
"""Packet_genWriteGyroCompensation(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, mat3f c, vec3f b) -> size_t"""
return _libvncxx.Packet_genWriteGyroCompensation(errorDetectionMode, buffer, size, c, b)
def Packet_genReadImuFilteringConfiguration(errorDetectionMode, buffer, size):
"""Packet_genReadImuFilteringConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadImuFilteringConfiguration(errorDetectionMode, buffer, size)
def Packet_genWriteImuFilteringConfiguration(errorDetectionMode, buffer, size, magWindowSize, accelWindowSize, gyroWindowSize, tempWindowSize, presWindowSize, magFilterMode, accelFilterMode, gyroFilterMode, tempFilterMode, presFilterMode):
"""Packet_genWriteImuFilteringConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint16_t magWindowSize, uint16_t accelWindowSize, uint16_t gyroWindowSize, uint16_t tempWindowSize, uint16_t presWindowSize, uint8_t magFilterMode, uint8_t accelFilterMode, uint8_t gyroFilterMode, uint8_t tempFilterMode, uint8_t presFilterMode) -> size_t"""
return _libvncxx.Packet_genWriteImuFilteringConfiguration(errorDetectionMode, buffer, size, magWindowSize, accelWindowSize, gyroWindowSize, tempWindowSize, presWindowSize, magFilterMode, accelFilterMode, gyroFilterMode, tempFilterMode, presFilterMode)
def Packet_genReadGpsCompassBaseline(errorDetectionMode, buffer, size):
"""Packet_genReadGpsCompassBaseline(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadGpsCompassBaseline(errorDetectionMode, buffer, size)
def Packet_genWriteGpsCompassBaseline(errorDetectionMode, buffer, size, position, uncertainty):
"""Packet_genWriteGpsCompassBaseline(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, vec3f position, vec3f uncertainty) -> size_t"""
return _libvncxx.Packet_genWriteGpsCompassBaseline(errorDetectionMode, buffer, size, position, uncertainty)
def Packet_genReadGpsCompassEstimatedBaseline(errorDetectionMode, buffer, size):
"""Packet_genReadGpsCompassEstimatedBaseline(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadGpsCompassEstimatedBaseline(errorDetectionMode, buffer, size)
def Packet_genReadImuRateConfiguration(errorDetectionMode, buffer, size):
"""Packet_genReadImuRateConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadImuRateConfiguration(errorDetectionMode, buffer, size)
def Packet_genWriteImuRateConfiguration(errorDetectionMode, buffer, size, imuRate, navDivisor, filterTargetRate, filterMinRate):
"""Packet_genWriteImuRateConfiguration(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size, uint16_t imuRate, uint16_t navDivisor, float filterTargetRate, float filterMinRate) -> size_t"""
return _libvncxx.Packet_genWriteImuRateConfiguration(errorDetectionMode, buffer, size, imuRate, navDivisor, filterTargetRate, filterMinRate)
def Packet_genReadYawPitchRollTrueBodyAccelerationAndAngularRates(errorDetectionMode, buffer, size):
"""Packet_genReadYawPitchRollTrueBodyAccelerationAndAngularRates(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadYawPitchRollTrueBodyAccelerationAndAngularRates(errorDetectionMode, buffer, size)
def Packet_genReadYawPitchRollTrueInertialAccelerationAndAngularRates(errorDetectionMode, buffer, size):
"""Packet_genReadYawPitchRollTrueInertialAccelerationAndAngularRates(vn::protocol::uart::ErrorDetectionMode errorDetectionMode, char * buffer, size_t size) -> size_t"""
return _libvncxx.Packet_genReadYawPitchRollTrueInertialAccelerationAndAngularRates(errorDetectionMode, buffer, size)
class BinaryOutputRegister(_object):
"""Proxy of C++ vn::sensors::BinaryOutputRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, BinaryOutputRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, BinaryOutputRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["async_mode"] = _libvncxx.BinaryOutputRegister_async_mode_set
__swig_getmethods__["async_mode"] = _libvncxx.BinaryOutputRegister_async_mode_get
if _newclass:
async_mode = _swig_property(_libvncxx.BinaryOutputRegister_async_mode_get, _libvncxx.BinaryOutputRegister_async_mode_set)
__swig_setmethods__["rate_divisor"] = _libvncxx.BinaryOutputRegister_rate_divisor_set
__swig_getmethods__["rate_divisor"] = _libvncxx.BinaryOutputRegister_rate_divisor_get
if _newclass:
rate_divisor = _swig_property(_libvncxx.BinaryOutputRegister_rate_divisor_get, _libvncxx.BinaryOutputRegister_rate_divisor_set)
__swig_setmethods__["common_field"] = _libvncxx.BinaryOutputRegister_common_field_set
__swig_getmethods__["common_field"] = _libvncxx.BinaryOutputRegister_common_field_get
if _newclass:
common_field = _swig_property(_libvncxx.BinaryOutputRegister_common_field_get, _libvncxx.BinaryOutputRegister_common_field_set)
__swig_setmethods__["time_field"] = _libvncxx.BinaryOutputRegister_time_field_set
__swig_getmethods__["time_field"] = _libvncxx.BinaryOutputRegister_time_field_get
if _newclass:
time_field = _swig_property(_libvncxx.BinaryOutputRegister_time_field_get, _libvncxx.BinaryOutputRegister_time_field_set)
__swig_setmethods__["imu_field"] = _libvncxx.BinaryOutputRegister_imu_field_set
__swig_getmethods__["imu_field"] = _libvncxx.BinaryOutputRegister_imu_field_get
if _newclass:
imu_field = _swig_property(_libvncxx.BinaryOutputRegister_imu_field_get, _libvncxx.BinaryOutputRegister_imu_field_set)
__swig_setmethods__["gps_field"] = _libvncxx.BinaryOutputRegister_gps_field_set
__swig_getmethods__["gps_field"] = _libvncxx.BinaryOutputRegister_gps_field_get
if _newclass:
gps_field = _swig_property(_libvncxx.BinaryOutputRegister_gps_field_get, _libvncxx.BinaryOutputRegister_gps_field_set)
__swig_setmethods__["attitude_field"] = _libvncxx.BinaryOutputRegister_attitude_field_set
__swig_getmethods__["attitude_field"] = _libvncxx.BinaryOutputRegister_attitude_field_get
if _newclass:
attitude_field = _swig_property(_libvncxx.BinaryOutputRegister_attitude_field_get, _libvncxx.BinaryOutputRegister_attitude_field_set)
__swig_setmethods__["ins_field"] = _libvncxx.BinaryOutputRegister_ins_field_set
__swig_getmethods__["ins_field"] = _libvncxx.BinaryOutputRegister_ins_field_get
if _newclass:
ins_field = _swig_property(_libvncxx.BinaryOutputRegister_ins_field_get, _libvncxx.BinaryOutputRegister_ins_field_set)
def __init__(self, *args):
"""
__init__(vn::sensors::BinaryOutputRegister self) -> BinaryOutputRegister
__init__(vn::sensors::BinaryOutputRegister self, ASYNCMODE asyncModeIn, uint16_t rateDivisorIn, COMMONGROUP commonFieldIn, TIMEGROUP timeFieldIn, IMUGROUP imuFieldIn, GPSGROUP gpsFieldIn, ATTITUDEGROUP attitudeFieldIn, INSGROUP insFieldIn) -> BinaryOutputRegister
__init__(vn::sensors::BinaryOutputRegister self, uint16_t asyncModeIn, uint16_t rateDivisorIn, uint16_t commonFieldIn, uint16_t timeFieldIn, uint16_t imuFieldIn, uint16_t gpsFieldIn, uint16_t attitudeFieldIn, uint16_t insFieldIn) -> BinaryOutputRegister
"""
this = _libvncxx.new_BinaryOutputRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_BinaryOutputRegister
__del__ = lambda self: None
BinaryOutputRegister_swigregister = _libvncxx.BinaryOutputRegister_swigregister
BinaryOutputRegister_swigregister(BinaryOutputRegister)
class QuaternionMagneticAccelerationAndAngularRatesRegister(_object):
"""Proxy of C++ vn::sensors::QuaternionMagneticAccelerationAndAngularRatesRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, QuaternionMagneticAccelerationAndAngularRatesRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, QuaternionMagneticAccelerationAndAngularRatesRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["quat"] = _libvncxx.QuaternionMagneticAccelerationAndAngularRatesRegister_quat_set
__swig_getmethods__["quat"] = _libvncxx.QuaternionMagneticAccelerationAndAngularRatesRegister_quat_get
if _newclass:
quat = _swig_property(_libvncxx.QuaternionMagneticAccelerationAndAngularRatesRegister_quat_get, _libvncxx.QuaternionMagneticAccelerationAndAngularRatesRegister_quat_set)
__swig_setmethods__["mag"] = _libvncxx.QuaternionMagneticAccelerationAndAngularRatesRegister_mag_set
__swig_getmethods__["mag"] = _libvncxx.QuaternionMagneticAccelerationAndAngularRatesRegister_mag_get
if _newclass:
mag = _swig_property(_libvncxx.QuaternionMagneticAccelerationAndAngularRatesRegister_mag_get, _libvncxx.QuaternionMagneticAccelerationAndAngularRatesRegister_mag_set)
__swig_setmethods__["accel"] = _libvncxx.QuaternionMagneticAccelerationAndAngularRatesRegister_accel_set
__swig_getmethods__["accel"] = _libvncxx.QuaternionMagneticAccelerationAndAngularRatesRegister_accel_get
if _newclass:
accel = _swig_property(_libvncxx.QuaternionMagneticAccelerationAndAngularRatesRegister_accel_get, _libvncxx.QuaternionMagneticAccelerationAndAngularRatesRegister_accel_set)
__swig_setmethods__["gyro"] = _libvncxx.QuaternionMagneticAccelerationAndAngularRatesRegister_gyro_set
__swig_getmethods__["gyro"] = _libvncxx.QuaternionMagneticAccelerationAndAngularRatesRegister_gyro_get
if _newclass:
gyro = _swig_property(_libvncxx.QuaternionMagneticAccelerationAndAngularRatesRegister_gyro_get, _libvncxx.QuaternionMagneticAccelerationAndAngularRatesRegister_gyro_set)
def __init__(self, *args):
"""
__init__(vn::sensors::QuaternionMagneticAccelerationAndAngularRatesRegister self) -> QuaternionMagneticAccelerationAndAngularRatesRegister
__init__(vn::sensors::QuaternionMagneticAccelerationAndAngularRatesRegister self, vec4f quatIn, vec3f magIn, vec3f accelIn, vec3f gyroIn) -> QuaternionMagneticAccelerationAndAngularRatesRegister
"""
this = _libvncxx.new_QuaternionMagneticAccelerationAndAngularRatesRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_QuaternionMagneticAccelerationAndAngularRatesRegister
__del__ = lambda self: None
QuaternionMagneticAccelerationAndAngularRatesRegister_swigregister = _libvncxx.QuaternionMagneticAccelerationAndAngularRatesRegister_swigregister
QuaternionMagneticAccelerationAndAngularRatesRegister_swigregister(QuaternionMagneticAccelerationAndAngularRatesRegister)
class MagneticAccelerationAndAngularRatesRegister(_object):
"""Proxy of C++ vn::sensors::MagneticAccelerationAndAngularRatesRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, MagneticAccelerationAndAngularRatesRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, MagneticAccelerationAndAngularRatesRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["mag"] = _libvncxx.MagneticAccelerationAndAngularRatesRegister_mag_set
__swig_getmethods__["mag"] = _libvncxx.MagneticAccelerationAndAngularRatesRegister_mag_get
if _newclass:
mag = _swig_property(_libvncxx.MagneticAccelerationAndAngularRatesRegister_mag_get, _libvncxx.MagneticAccelerationAndAngularRatesRegister_mag_set)
__swig_setmethods__["accel"] = _libvncxx.MagneticAccelerationAndAngularRatesRegister_accel_set
__swig_getmethods__["accel"] = _libvncxx.MagneticAccelerationAndAngularRatesRegister_accel_get
if _newclass:
accel = _swig_property(_libvncxx.MagneticAccelerationAndAngularRatesRegister_accel_get, _libvncxx.MagneticAccelerationAndAngularRatesRegister_accel_set)
__swig_setmethods__["gyro"] = _libvncxx.MagneticAccelerationAndAngularRatesRegister_gyro_set
__swig_getmethods__["gyro"] = _libvncxx.MagneticAccelerationAndAngularRatesRegister_gyro_get
if _newclass:
gyro = _swig_property(_libvncxx.MagneticAccelerationAndAngularRatesRegister_gyro_get, _libvncxx.MagneticAccelerationAndAngularRatesRegister_gyro_set)
def __init__(self, *args):
"""
__init__(vn::sensors::MagneticAccelerationAndAngularRatesRegister self) -> MagneticAccelerationAndAngularRatesRegister
__init__(vn::sensors::MagneticAccelerationAndAngularRatesRegister self, vec3f magIn, vec3f accelIn, vec3f gyroIn) -> MagneticAccelerationAndAngularRatesRegister
"""
this = _libvncxx.new_MagneticAccelerationAndAngularRatesRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_MagneticAccelerationAndAngularRatesRegister
__del__ = lambda self: None
MagneticAccelerationAndAngularRatesRegister_swigregister = _libvncxx.MagneticAccelerationAndAngularRatesRegister_swigregister
MagneticAccelerationAndAngularRatesRegister_swigregister(MagneticAccelerationAndAngularRatesRegister)
class MagneticAndGravityReferenceVectorsRegister(_object):
"""Proxy of C++ vn::sensors::MagneticAndGravityReferenceVectorsRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, MagneticAndGravityReferenceVectorsRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, MagneticAndGravityReferenceVectorsRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["mag_ref"] = _libvncxx.MagneticAndGravityReferenceVectorsRegister_mag_ref_set
__swig_getmethods__["mag_ref"] = _libvncxx.MagneticAndGravityReferenceVectorsRegister_mag_ref_get
if _newclass:
mag_ref = _swig_property(_libvncxx.MagneticAndGravityReferenceVectorsRegister_mag_ref_get, _libvncxx.MagneticAndGravityReferenceVectorsRegister_mag_ref_set)
__swig_setmethods__["acc_ref"] = _libvncxx.MagneticAndGravityReferenceVectorsRegister_acc_ref_set
__swig_getmethods__["acc_ref"] = _libvncxx.MagneticAndGravityReferenceVectorsRegister_acc_ref_get
if _newclass:
acc_ref = _swig_property(_libvncxx.MagneticAndGravityReferenceVectorsRegister_acc_ref_get, _libvncxx.MagneticAndGravityReferenceVectorsRegister_acc_ref_set)
def __init__(self, *args):
"""
__init__(vn::sensors::MagneticAndGravityReferenceVectorsRegister self) -> MagneticAndGravityReferenceVectorsRegister
__init__(vn::sensors::MagneticAndGravityReferenceVectorsRegister self, vec3f magRefIn, vec3f accRefIn) -> MagneticAndGravityReferenceVectorsRegister
"""
this = _libvncxx.new_MagneticAndGravityReferenceVectorsRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_MagneticAndGravityReferenceVectorsRegister
__del__ = lambda self: None
MagneticAndGravityReferenceVectorsRegister_swigregister = _libvncxx.MagneticAndGravityReferenceVectorsRegister_swigregister
MagneticAndGravityReferenceVectorsRegister_swigregister(MagneticAndGravityReferenceVectorsRegister)
class FilterMeasurementsVarianceParametersRegister(_object):
"""Proxy of C++ vn::sensors::FilterMeasurementsVarianceParametersRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, FilterMeasurementsVarianceParametersRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, FilterMeasurementsVarianceParametersRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["angular_walk_variance"] = _libvncxx.FilterMeasurementsVarianceParametersRegister_angular_walk_variance_set
__swig_getmethods__["angular_walk_variance"] = _libvncxx.FilterMeasurementsVarianceParametersRegister_angular_walk_variance_get
if _newclass:
angular_walk_variance = _swig_property(_libvncxx.FilterMeasurementsVarianceParametersRegister_angular_walk_variance_get, _libvncxx.FilterMeasurementsVarianceParametersRegister_angular_walk_variance_set)
__swig_setmethods__["angular_rate_variance"] = _libvncxx.FilterMeasurementsVarianceParametersRegister_angular_rate_variance_set
__swig_getmethods__["angular_rate_variance"] = _libvncxx.FilterMeasurementsVarianceParametersRegister_angular_rate_variance_get
if _newclass:
angular_rate_variance = _swig_property(_libvncxx.FilterMeasurementsVarianceParametersRegister_angular_rate_variance_get, _libvncxx.FilterMeasurementsVarianceParametersRegister_angular_rate_variance_set)
__swig_setmethods__["magnetic_variance"] = _libvncxx.FilterMeasurementsVarianceParametersRegister_magnetic_variance_set
__swig_getmethods__["magnetic_variance"] = _libvncxx.FilterMeasurementsVarianceParametersRegister_magnetic_variance_get
if _newclass:
magnetic_variance = _swig_property(_libvncxx.FilterMeasurementsVarianceParametersRegister_magnetic_variance_get, _libvncxx.FilterMeasurementsVarianceParametersRegister_magnetic_variance_set)
__swig_setmethods__["acceleration_variance"] = _libvncxx.FilterMeasurementsVarianceParametersRegister_acceleration_variance_set
__swig_getmethods__["acceleration_variance"] = _libvncxx.FilterMeasurementsVarianceParametersRegister_acceleration_variance_get
if _newclass:
acceleration_variance = _swig_property(_libvncxx.FilterMeasurementsVarianceParametersRegister_acceleration_variance_get, _libvncxx.FilterMeasurementsVarianceParametersRegister_acceleration_variance_set)
def __init__(self, *args):
"""
__init__(vn::sensors::FilterMeasurementsVarianceParametersRegister self) -> FilterMeasurementsVarianceParametersRegister
__init__(vn::sensors::FilterMeasurementsVarianceParametersRegister self, float angularWalkVarianceIn, vec3f angularRateVarianceIn, vec3f magneticVarianceIn, vec3f accelerationVarianceIn) -> FilterMeasurementsVarianceParametersRegister
"""
this = _libvncxx.new_FilterMeasurementsVarianceParametersRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_FilterMeasurementsVarianceParametersRegister
__del__ = lambda self: None
FilterMeasurementsVarianceParametersRegister_swigregister = _libvncxx.FilterMeasurementsVarianceParametersRegister_swigregister
FilterMeasurementsVarianceParametersRegister_swigregister(FilterMeasurementsVarianceParametersRegister)
class MagnetometerCompensationRegister(_object):
"""Proxy of C++ vn::sensors::MagnetometerCompensationRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, MagnetometerCompensationRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, MagnetometerCompensationRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["c"] = _libvncxx.MagnetometerCompensationRegister_c_set
__swig_getmethods__["c"] = _libvncxx.MagnetometerCompensationRegister_c_get
if _newclass:
c = _swig_property(_libvncxx.MagnetometerCompensationRegister_c_get, _libvncxx.MagnetometerCompensationRegister_c_set)
__swig_setmethods__["b"] = _libvncxx.MagnetometerCompensationRegister_b_set
__swig_getmethods__["b"] = _libvncxx.MagnetometerCompensationRegister_b_get
if _newclass:
b = _swig_property(_libvncxx.MagnetometerCompensationRegister_b_get, _libvncxx.MagnetometerCompensationRegister_b_set)
def __init__(self, *args):
"""
__init__(vn::sensors::MagnetometerCompensationRegister self) -> MagnetometerCompensationRegister
__init__(vn::sensors::MagnetometerCompensationRegister self, mat3f cIn, vec3f bIn) -> MagnetometerCompensationRegister
"""
this = _libvncxx.new_MagnetometerCompensationRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_MagnetometerCompensationRegister
__del__ = lambda self: None
MagnetometerCompensationRegister_swigregister = _libvncxx.MagnetometerCompensationRegister_swigregister
MagnetometerCompensationRegister_swigregister(MagnetometerCompensationRegister)
class FilterActiveTuningParametersRegister(_object):
"""Proxy of C++ vn::sensors::FilterActiveTuningParametersRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, FilterActiveTuningParametersRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, FilterActiveTuningParametersRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["magnetic_disturbance_gain"] = _libvncxx.FilterActiveTuningParametersRegister_magnetic_disturbance_gain_set
__swig_getmethods__["magnetic_disturbance_gain"] = _libvncxx.FilterActiveTuningParametersRegister_magnetic_disturbance_gain_get
if _newclass:
magnetic_disturbance_gain = _swig_property(_libvncxx.FilterActiveTuningParametersRegister_magnetic_disturbance_gain_get, _libvncxx.FilterActiveTuningParametersRegister_magnetic_disturbance_gain_set)
__swig_setmethods__["acceleration_disturbance_gain"] = _libvncxx.FilterActiveTuningParametersRegister_acceleration_disturbance_gain_set
__swig_getmethods__["acceleration_disturbance_gain"] = _libvncxx.FilterActiveTuningParametersRegister_acceleration_disturbance_gain_get
if _newclass:
acceleration_disturbance_gain = _swig_property(_libvncxx.FilterActiveTuningParametersRegister_acceleration_disturbance_gain_get, _libvncxx.FilterActiveTuningParametersRegister_acceleration_disturbance_gain_set)
__swig_setmethods__["magnetic_disturbance_memory"] = _libvncxx.FilterActiveTuningParametersRegister_magnetic_disturbance_memory_set
__swig_getmethods__["magnetic_disturbance_memory"] = _libvncxx.FilterActiveTuningParametersRegister_magnetic_disturbance_memory_get
if _newclass:
magnetic_disturbance_memory = _swig_property(_libvncxx.FilterActiveTuningParametersRegister_magnetic_disturbance_memory_get, _libvncxx.FilterActiveTuningParametersRegister_magnetic_disturbance_memory_set)
__swig_setmethods__["acceleration_disturbance_memory"] = _libvncxx.FilterActiveTuningParametersRegister_acceleration_disturbance_memory_set
__swig_getmethods__["acceleration_disturbance_memory"] = _libvncxx.FilterActiveTuningParametersRegister_acceleration_disturbance_memory_get
if _newclass:
acceleration_disturbance_memory = _swig_property(_libvncxx.FilterActiveTuningParametersRegister_acceleration_disturbance_memory_get, _libvncxx.FilterActiveTuningParametersRegister_acceleration_disturbance_memory_set)
def __init__(self, *args):
"""
__init__(vn::sensors::FilterActiveTuningParametersRegister self) -> FilterActiveTuningParametersRegister
__init__(vn::sensors::FilterActiveTuningParametersRegister self, float magneticDisturbanceGainIn, float accelerationDisturbanceGainIn, float magneticDisturbanceMemoryIn, float accelerationDisturbanceMemoryIn) -> FilterActiveTuningParametersRegister
"""
this = _libvncxx.new_FilterActiveTuningParametersRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_FilterActiveTuningParametersRegister
__del__ = lambda self: None
FilterActiveTuningParametersRegister_swigregister = _libvncxx.FilterActiveTuningParametersRegister_swigregister
FilterActiveTuningParametersRegister_swigregister(FilterActiveTuningParametersRegister)
class AccelerationCompensationRegister(_object):
"""Proxy of C++ vn::sensors::AccelerationCompensationRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, AccelerationCompensationRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, AccelerationCompensationRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["c"] = _libvncxx.AccelerationCompensationRegister_c_set
__swig_getmethods__["c"] = _libvncxx.AccelerationCompensationRegister_c_get
if _newclass:
c = _swig_property(_libvncxx.AccelerationCompensationRegister_c_get, _libvncxx.AccelerationCompensationRegister_c_set)
__swig_setmethods__["b"] = _libvncxx.AccelerationCompensationRegister_b_set
__swig_getmethods__["b"] = _libvncxx.AccelerationCompensationRegister_b_get
if _newclass:
b = _swig_property(_libvncxx.AccelerationCompensationRegister_b_get, _libvncxx.AccelerationCompensationRegister_b_set)
def __init__(self, *args):
"""
__init__(vn::sensors::AccelerationCompensationRegister self) -> AccelerationCompensationRegister
__init__(vn::sensors::AccelerationCompensationRegister self, mat3f cIn, vec3f bIn) -> AccelerationCompensationRegister
"""
this = _libvncxx.new_AccelerationCompensationRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_AccelerationCompensationRegister
__del__ = lambda self: None
AccelerationCompensationRegister_swigregister = _libvncxx.AccelerationCompensationRegister_swigregister
AccelerationCompensationRegister_swigregister(AccelerationCompensationRegister)
class YawPitchRollMagneticAccelerationAndAngularRatesRegister(_object):
"""Proxy of C++ vn::sensors::YawPitchRollMagneticAccelerationAndAngularRatesRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, YawPitchRollMagneticAccelerationAndAngularRatesRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, YawPitchRollMagneticAccelerationAndAngularRatesRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["yaw_pitch_roll"] = _libvncxx.YawPitchRollMagneticAccelerationAndAngularRatesRegister_yaw_pitch_roll_set
__swig_getmethods__["yaw_pitch_roll"] = _libvncxx.YawPitchRollMagneticAccelerationAndAngularRatesRegister_yaw_pitch_roll_get
if _newclass:
yaw_pitch_roll = _swig_property(_libvncxx.YawPitchRollMagneticAccelerationAndAngularRatesRegister_yaw_pitch_roll_get, _libvncxx.YawPitchRollMagneticAccelerationAndAngularRatesRegister_yaw_pitch_roll_set)
__swig_setmethods__["mag"] = _libvncxx.YawPitchRollMagneticAccelerationAndAngularRatesRegister_mag_set
__swig_getmethods__["mag"] = _libvncxx.YawPitchRollMagneticAccelerationAndAngularRatesRegister_mag_get
if _newclass:
mag = _swig_property(_libvncxx.YawPitchRollMagneticAccelerationAndAngularRatesRegister_mag_get, _libvncxx.YawPitchRollMagneticAccelerationAndAngularRatesRegister_mag_set)
__swig_setmethods__["accel"] = _libvncxx.YawPitchRollMagneticAccelerationAndAngularRatesRegister_accel_set
__swig_getmethods__["accel"] = _libvncxx.YawPitchRollMagneticAccelerationAndAngularRatesRegister_accel_get
if _newclass:
accel = _swig_property(_libvncxx.YawPitchRollMagneticAccelerationAndAngularRatesRegister_accel_get, _libvncxx.YawPitchRollMagneticAccelerationAndAngularRatesRegister_accel_set)
__swig_setmethods__["gyro"] = _libvncxx.YawPitchRollMagneticAccelerationAndAngularRatesRegister_gyro_set
__swig_getmethods__["gyro"] = _libvncxx.YawPitchRollMagneticAccelerationAndAngularRatesRegister_gyro_get
if _newclass:
gyro = _swig_property(_libvncxx.YawPitchRollMagneticAccelerationAndAngularRatesRegister_gyro_get, _libvncxx.YawPitchRollMagneticAccelerationAndAngularRatesRegister_gyro_set)
def __init__(self, *args):
"""
__init__(vn::sensors::YawPitchRollMagneticAccelerationAndAngularRatesRegister self) -> YawPitchRollMagneticAccelerationAndAngularRatesRegister
__init__(vn::sensors::YawPitchRollMagneticAccelerationAndAngularRatesRegister self, vec3f yawPitchRollIn, vec3f magIn, vec3f accelIn, vec3f gyroIn) -> YawPitchRollMagneticAccelerationAndAngularRatesRegister
"""
this = _libvncxx.new_YawPitchRollMagneticAccelerationAndAngularRatesRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_YawPitchRollMagneticAccelerationAndAngularRatesRegister
__del__ = lambda self: None
YawPitchRollMagneticAccelerationAndAngularRatesRegister_swigregister = _libvncxx.YawPitchRollMagneticAccelerationAndAngularRatesRegister_swigregister
YawPitchRollMagneticAccelerationAndAngularRatesRegister_swigregister(YawPitchRollMagneticAccelerationAndAngularRatesRegister)
class CommunicationProtocolControlRegister(_object):
"""Proxy of C++ vn::sensors::CommunicationProtocolControlRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, CommunicationProtocolControlRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, CommunicationProtocolControlRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["serial_status"] = _libvncxx.CommunicationProtocolControlRegister_serial_status_set
__swig_getmethods__["serial_status"] = _libvncxx.CommunicationProtocolControlRegister_serial_status_get
if _newclass:
serial_status = _swig_property(_libvncxx.CommunicationProtocolControlRegister_serial_status_get, _libvncxx.CommunicationProtocolControlRegister_serial_status_set)
__swig_setmethods__["serialStatus"] = _libvncxx.CommunicationProtocolControlRegister_serialStatus_set
__swig_getmethods__["serialStatus"] = _libvncxx.CommunicationProtocolControlRegister_serialStatus_get
if _newclass:
serialStatus = _swig_property(_libvncxx.CommunicationProtocolControlRegister_serialStatus_get, _libvncxx.CommunicationProtocolControlRegister_serialStatus_set)
__swig_setmethods__["spi_count"] = _libvncxx.CommunicationProtocolControlRegister_spi_count_set
__swig_getmethods__["spi_count"] = _libvncxx.CommunicationProtocolControlRegister_spi_count_get
if _newclass:
spi_count = _swig_property(_libvncxx.CommunicationProtocolControlRegister_spi_count_get, _libvncxx.CommunicationProtocolControlRegister_spi_count_set)
__swig_setmethods__["spi_status"] = _libvncxx.CommunicationProtocolControlRegister_spi_status_set
__swig_getmethods__["spi_status"] = _libvncxx.CommunicationProtocolControlRegister_spi_status_get
if _newclass:
spi_status = _swig_property(_libvncxx.CommunicationProtocolControlRegister_spi_status_get, _libvncxx.CommunicationProtocolControlRegister_spi_status_set)
__swig_setmethods__["serial_checksum"] = _libvncxx.CommunicationProtocolControlRegister_serial_checksum_set
__swig_getmethods__["serial_checksum"] = _libvncxx.CommunicationProtocolControlRegister_serial_checksum_get
if _newclass:
serial_checksum = _swig_property(_libvncxx.CommunicationProtocolControlRegister_serial_checksum_get, _libvncxx.CommunicationProtocolControlRegister_serial_checksum_set)
__swig_setmethods__["spi_checksum"] = _libvncxx.CommunicationProtocolControlRegister_spi_checksum_set
__swig_getmethods__["spi_checksum"] = _libvncxx.CommunicationProtocolControlRegister_spi_checksum_get
if _newclass:
spi_checksum = _swig_property(_libvncxx.CommunicationProtocolControlRegister_spi_checksum_get, _libvncxx.CommunicationProtocolControlRegister_spi_checksum_set)
__swig_setmethods__["error_mode"] = _libvncxx.CommunicationProtocolControlRegister_error_mode_set
__swig_getmethods__["error_mode"] = _libvncxx.CommunicationProtocolControlRegister_error_mode_get
if _newclass:
error_mode = _swig_property(_libvncxx.CommunicationProtocolControlRegister_error_mode_get, _libvncxx.CommunicationProtocolControlRegister_error_mode_set)
def __init__(self, *args):
"""
__init__(vn::sensors::CommunicationProtocolControlRegister self) -> CommunicationProtocolControlRegister
__init__(vn::sensors::CommunicationProtocolControlRegister self, vn::protocol::uart::CountMode serialCountIn, vn::protocol::uart::StatusMode serialStatusIn, vn::protocol::uart::CountMode spiCountIn, vn::protocol::uart::StatusMode spiStatusIn, vn::protocol::uart::ChecksumMode serialChecksumIn, vn::protocol::uart::ChecksumMode spiChecksumIn, vn::protocol::uart::ErrorMode errorModeIn) -> CommunicationProtocolControlRegister
"""
this = _libvncxx.new_CommunicationProtocolControlRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_CommunicationProtocolControlRegister
__del__ = lambda self: None
CommunicationProtocolControlRegister_swigregister = _libvncxx.CommunicationProtocolControlRegister_swigregister
CommunicationProtocolControlRegister_swigregister(CommunicationProtocolControlRegister)
class SynchronizationControlRegister(_object):
"""Proxy of C++ vn::sensors::SynchronizationControlRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, SynchronizationControlRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, SynchronizationControlRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["syncInMode"] = _libvncxx.SynchronizationControlRegister_syncInMode_set
__swig_getmethods__["syncInMode"] = _libvncxx.SynchronizationControlRegister_syncInMode_get
if _newclass:
syncInMode = _swig_property(_libvncxx.SynchronizationControlRegister_syncInMode_get, _libvncxx.SynchronizationControlRegister_syncInMode_set)
__swig_setmethods__["syncInEdge"] = _libvncxx.SynchronizationControlRegister_syncInEdge_set
__swig_getmethods__["syncInEdge"] = _libvncxx.SynchronizationControlRegister_syncInEdge_get
if _newclass:
syncInEdge = _swig_property(_libvncxx.SynchronizationControlRegister_syncInEdge_get, _libvncxx.SynchronizationControlRegister_syncInEdge_set)
__swig_setmethods__["syncInSkipFactor"] = _libvncxx.SynchronizationControlRegister_syncInSkipFactor_set
__swig_getmethods__["syncInSkipFactor"] = _libvncxx.SynchronizationControlRegister_syncInSkipFactor_get
if _newclass:
syncInSkipFactor = _swig_property(_libvncxx.SynchronizationControlRegister_syncInSkipFactor_get, _libvncxx.SynchronizationControlRegister_syncInSkipFactor_set)
__swig_setmethods__["syncOutMode"] = _libvncxx.SynchronizationControlRegister_syncOutMode_set
__swig_getmethods__["syncOutMode"] = _libvncxx.SynchronizationControlRegister_syncOutMode_get
if _newclass:
syncOutMode = _swig_property(_libvncxx.SynchronizationControlRegister_syncOutMode_get, _libvncxx.SynchronizationControlRegister_syncOutMode_set)
__swig_setmethods__["syncOutPolarity"] = _libvncxx.SynchronizationControlRegister_syncOutPolarity_set
__swig_getmethods__["syncOutPolarity"] = _libvncxx.SynchronizationControlRegister_syncOutPolarity_get
if _newclass:
syncOutPolarity = _swig_property(_libvncxx.SynchronizationControlRegister_syncOutPolarity_get, _libvncxx.SynchronizationControlRegister_syncOutPolarity_set)
__swig_setmethods__["syncOutSkipFactor"] = _libvncxx.SynchronizationControlRegister_syncOutSkipFactor_set
__swig_getmethods__["syncOutSkipFactor"] = _libvncxx.SynchronizationControlRegister_syncOutSkipFactor_get
if _newclass:
syncOutSkipFactor = _swig_property(_libvncxx.SynchronizationControlRegister_syncOutSkipFactor_get, _libvncxx.SynchronizationControlRegister_syncOutSkipFactor_set)
__swig_setmethods__["syncOutPulseWidth"] = _libvncxx.SynchronizationControlRegister_syncOutPulseWidth_set
__swig_getmethods__["syncOutPulseWidth"] = _libvncxx.SynchronizationControlRegister_syncOutPulseWidth_get
if _newclass:
syncOutPulseWidth = _swig_property(_libvncxx.SynchronizationControlRegister_syncOutPulseWidth_get, _libvncxx.SynchronizationControlRegister_syncOutPulseWidth_set)
def __init__(self, *args):
"""
__init__(vn::sensors::SynchronizationControlRegister self) -> SynchronizationControlRegister
__init__(vn::sensors::SynchronizationControlRegister self, vn::protocol::uart::SyncInMode syncInModeIn, vn::protocol::uart::SyncInEdge syncInEdgeIn, uint16_t syncInSkipFactorIn, vn::protocol::uart::SyncOutMode syncOutModeIn, vn::protocol::uart::SyncOutPolarity syncOutPolarityIn, uint16_t syncOutSkipFactorIn, uint32_t syncOutPulseWidthIn) -> SynchronizationControlRegister
"""
this = _libvncxx.new_SynchronizationControlRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_SynchronizationControlRegister
__del__ = lambda self: None
SynchronizationControlRegister_swigregister = _libvncxx.SynchronizationControlRegister_swigregister
SynchronizationControlRegister_swigregister(SynchronizationControlRegister)
class SynchronizationStatusRegister(_object):
"""Proxy of C++ vn::sensors::SynchronizationStatusRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, SynchronizationStatusRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, SynchronizationStatusRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["sync_in_count"] = _libvncxx.SynchronizationStatusRegister_sync_in_count_set
__swig_getmethods__["sync_in_count"] = _libvncxx.SynchronizationStatusRegister_sync_in_count_get
if _newclass:
sync_in_count = _swig_property(_libvncxx.SynchronizationStatusRegister_sync_in_count_get, _libvncxx.SynchronizationStatusRegister_sync_in_count_set)
__swig_setmethods__["sync_in_time"] = _libvncxx.SynchronizationStatusRegister_sync_in_time_set
__swig_getmethods__["sync_in_time"] = _libvncxx.SynchronizationStatusRegister_sync_in_time_get
if _newclass:
sync_in_time = _swig_property(_libvncxx.SynchronizationStatusRegister_sync_in_time_get, _libvncxx.SynchronizationStatusRegister_sync_in_time_set)
__swig_setmethods__["sync_out_count"] = _libvncxx.SynchronizationStatusRegister_sync_out_count_set
__swig_getmethods__["sync_out_count"] = _libvncxx.SynchronizationStatusRegister_sync_out_count_get
if _newclass:
sync_out_count = _swig_property(_libvncxx.SynchronizationStatusRegister_sync_out_count_get, _libvncxx.SynchronizationStatusRegister_sync_out_count_set)
def __init__(self, *args):
"""
__init__(vn::sensors::SynchronizationStatusRegister self) -> SynchronizationStatusRegister
__init__(vn::sensors::SynchronizationStatusRegister self, uint32_t syncInCountIn, uint32_t syncInTimeIn, uint32_t syncOutCountIn) -> SynchronizationStatusRegister
"""
this = _libvncxx.new_SynchronizationStatusRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_SynchronizationStatusRegister
__del__ = lambda self: None
SynchronizationStatusRegister_swigregister = _libvncxx.SynchronizationStatusRegister_swigregister
SynchronizationStatusRegister_swigregister(SynchronizationStatusRegister)
class FilterBasicControlRegister(_object):
"""Proxy of C++ vn::sensors::FilterBasicControlRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, FilterBasicControlRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, FilterBasicControlRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["mag_mode"] = _libvncxx.FilterBasicControlRegister_mag_mode_set
__swig_getmethods__["mag_mode"] = _libvncxx.FilterBasicControlRegister_mag_mode_get
if _newclass:
mag_mode = _swig_property(_libvncxx.FilterBasicControlRegister_mag_mode_get, _libvncxx.FilterBasicControlRegister_mag_mode_set)
__swig_setmethods__["ext_mag_mode"] = _libvncxx.FilterBasicControlRegister_ext_mag_mode_set
__swig_getmethods__["ext_mag_mode"] = _libvncxx.FilterBasicControlRegister_ext_mag_mode_get
if _newclass:
ext_mag_mode = _swig_property(_libvncxx.FilterBasicControlRegister_ext_mag_mode_get, _libvncxx.FilterBasicControlRegister_ext_mag_mode_set)
__swig_setmethods__["ext_acc_mode"] = _libvncxx.FilterBasicControlRegister_ext_acc_mode_set
__swig_getmethods__["ext_acc_mode"] = _libvncxx.FilterBasicControlRegister_ext_acc_mode_get
if _newclass:
ext_acc_mode = _swig_property(_libvncxx.FilterBasicControlRegister_ext_acc_mode_get, _libvncxx.FilterBasicControlRegister_ext_acc_mode_set)
__swig_setmethods__["ext_gyro_mode"] = _libvncxx.FilterBasicControlRegister_ext_gyro_mode_set
__swig_getmethods__["ext_gyro_mode"] = _libvncxx.FilterBasicControlRegister_ext_gyro_mode_get
if _newclass:
ext_gyro_mode = _swig_property(_libvncxx.FilterBasicControlRegister_ext_gyro_mode_get, _libvncxx.FilterBasicControlRegister_ext_gyro_mode_set)
__swig_setmethods__["gyro_limit"] = _libvncxx.FilterBasicControlRegister_gyro_limit_set
__swig_getmethods__["gyro_limit"] = _libvncxx.FilterBasicControlRegister_gyro_limit_get
if _newclass:
gyro_limit = _swig_property(_libvncxx.FilterBasicControlRegister_gyro_limit_get, _libvncxx.FilterBasicControlRegister_gyro_limit_set)
def __init__(self, *args):
"""
__init__(vn::sensors::FilterBasicControlRegister self) -> FilterBasicControlRegister
__init__(vn::sensors::FilterBasicControlRegister self, vn::protocol::uart::MagneticMode magModeIn, vn::protocol::uart::ExternalSensorMode extMagModeIn, vn::protocol::uart::ExternalSensorMode extAccModeIn, vn::protocol::uart::ExternalSensorMode extGyroModeIn, vec3f gyroLimitIn) -> FilterBasicControlRegister
"""
this = _libvncxx.new_FilterBasicControlRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_FilterBasicControlRegister
__del__ = lambda self: None
FilterBasicControlRegister_swigregister = _libvncxx.FilterBasicControlRegister_swigregister
FilterBasicControlRegister_swigregister(FilterBasicControlRegister)
class VpeBasicControlRegister(_object):
"""Proxy of C++ vn::sensors::VpeBasicControlRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, VpeBasicControlRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, VpeBasicControlRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["enable"] = _libvncxx.VpeBasicControlRegister_enable_set
__swig_getmethods__["enable"] = _libvncxx.VpeBasicControlRegister_enable_get
if _newclass:
enable = _swig_property(_libvncxx.VpeBasicControlRegister_enable_get, _libvncxx.VpeBasicControlRegister_enable_set)
__swig_setmethods__["heading_mode"] = _libvncxx.VpeBasicControlRegister_heading_mode_set
__swig_getmethods__["heading_mode"] = _libvncxx.VpeBasicControlRegister_heading_mode_get
if _newclass:
heading_mode = _swig_property(_libvncxx.VpeBasicControlRegister_heading_mode_get, _libvncxx.VpeBasicControlRegister_heading_mode_set)
__swig_setmethods__["filtering_mode"] = _libvncxx.VpeBasicControlRegister_filtering_mode_set
__swig_getmethods__["filtering_mode"] = _libvncxx.VpeBasicControlRegister_filtering_mode_get
if _newclass:
filtering_mode = _swig_property(_libvncxx.VpeBasicControlRegister_filtering_mode_get, _libvncxx.VpeBasicControlRegister_filtering_mode_set)
__swig_setmethods__["tuning_mode"] = _libvncxx.VpeBasicControlRegister_tuning_mode_set
__swig_getmethods__["tuning_mode"] = _libvncxx.VpeBasicControlRegister_tuning_mode_get
if _newclass:
tuning_mode = _swig_property(_libvncxx.VpeBasicControlRegister_tuning_mode_get, _libvncxx.VpeBasicControlRegister_tuning_mode_set)
def __init__(self, *args):
"""
__init__(vn::sensors::VpeBasicControlRegister self) -> VpeBasicControlRegister
__init__(vn::sensors::VpeBasicControlRegister self, vn::protocol::uart::VpeEnable enableIn, vn::protocol::uart::HeadingMode headingModeIn, vn::protocol::uart::VpeMode filteringModeIn, vn::protocol::uart::VpeMode tuningModeIn) -> VpeBasicControlRegister
"""
this = _libvncxx.new_VpeBasicControlRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_VpeBasicControlRegister
__del__ = lambda self: None
VpeBasicControlRegister_swigregister = _libvncxx.VpeBasicControlRegister_swigregister
VpeBasicControlRegister_swigregister(VpeBasicControlRegister)
class VpeMagnetometerBasicTuningRegister(_object):
"""Proxy of C++ vn::sensors::VpeMagnetometerBasicTuningRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, VpeMagnetometerBasicTuningRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, VpeMagnetometerBasicTuningRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["base_tuning"] = _libvncxx.VpeMagnetometerBasicTuningRegister_base_tuning_set
__swig_getmethods__["base_tuning"] = _libvncxx.VpeMagnetometerBasicTuningRegister_base_tuning_get
if _newclass:
base_tuning = _swig_property(_libvncxx.VpeMagnetometerBasicTuningRegister_base_tuning_get, _libvncxx.VpeMagnetometerBasicTuningRegister_base_tuning_set)
__swig_setmethods__["adaptive_tuning"] = _libvncxx.VpeMagnetometerBasicTuningRegister_adaptive_tuning_set
__swig_getmethods__["adaptive_tuning"] = _libvncxx.VpeMagnetometerBasicTuningRegister_adaptive_tuning_get
if _newclass:
adaptive_tuning = _swig_property(_libvncxx.VpeMagnetometerBasicTuningRegister_adaptive_tuning_get, _libvncxx.VpeMagnetometerBasicTuningRegister_adaptive_tuning_set)
__swig_setmethods__["adaptive_filtering"] = _libvncxx.VpeMagnetometerBasicTuningRegister_adaptive_filtering_set
__swig_getmethods__["adaptive_filtering"] = _libvncxx.VpeMagnetometerBasicTuningRegister_adaptive_filtering_get
if _newclass:
adaptive_filtering = _swig_property(_libvncxx.VpeMagnetometerBasicTuningRegister_adaptive_filtering_get, _libvncxx.VpeMagnetometerBasicTuningRegister_adaptive_filtering_set)
def __init__(self, *args):
"""
__init__(vn::sensors::VpeMagnetometerBasicTuningRegister self) -> VpeMagnetometerBasicTuningRegister
__init__(vn::sensors::VpeMagnetometerBasicTuningRegister self, vec3f baseTuningIn, vec3f adaptiveTuningIn, vec3f adaptiveFilteringIn) -> VpeMagnetometerBasicTuningRegister
"""
this = _libvncxx.new_VpeMagnetometerBasicTuningRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_VpeMagnetometerBasicTuningRegister
__del__ = lambda self: None
VpeMagnetometerBasicTuningRegister_swigregister = _libvncxx.VpeMagnetometerBasicTuningRegister_swigregister
VpeMagnetometerBasicTuningRegister_swigregister(VpeMagnetometerBasicTuningRegister)
class VpeMagnetometerAdvancedTuningRegister(_object):
"""Proxy of C++ vn::sensors::VpeMagnetometerAdvancedTuningRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, VpeMagnetometerAdvancedTuningRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, VpeMagnetometerAdvancedTuningRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["min_filtering"] = _libvncxx.VpeMagnetometerAdvancedTuningRegister_min_filtering_set
__swig_getmethods__["min_filtering"] = _libvncxx.VpeMagnetometerAdvancedTuningRegister_min_filtering_get
if _newclass:
min_filtering = _swig_property(_libvncxx.VpeMagnetometerAdvancedTuningRegister_min_filtering_get, _libvncxx.VpeMagnetometerAdvancedTuningRegister_min_filtering_set)
__swig_setmethods__["max_filtering"] = _libvncxx.VpeMagnetometerAdvancedTuningRegister_max_filtering_set
__swig_getmethods__["max_filtering"] = _libvncxx.VpeMagnetometerAdvancedTuningRegister_max_filtering_get
if _newclass:
max_filtering = _swig_property(_libvncxx.VpeMagnetometerAdvancedTuningRegister_max_filtering_get, _libvncxx.VpeMagnetometerAdvancedTuningRegister_max_filtering_set)
__swig_setmethods__["max_adapt_rate"] = _libvncxx.VpeMagnetometerAdvancedTuningRegister_max_adapt_rate_set
__swig_getmethods__["max_adapt_rate"] = _libvncxx.VpeMagnetometerAdvancedTuningRegister_max_adapt_rate_get
if _newclass:
max_adapt_rate = _swig_property(_libvncxx.VpeMagnetometerAdvancedTuningRegister_max_adapt_rate_get, _libvncxx.VpeMagnetometerAdvancedTuningRegister_max_adapt_rate_set)
__swig_setmethods__["disturbance_window"] = _libvncxx.VpeMagnetometerAdvancedTuningRegister_disturbance_window_set
__swig_getmethods__["disturbance_window"] = _libvncxx.VpeMagnetometerAdvancedTuningRegister_disturbance_window_get
if _newclass:
disturbance_window = _swig_property(_libvncxx.VpeMagnetometerAdvancedTuningRegister_disturbance_window_get, _libvncxx.VpeMagnetometerAdvancedTuningRegister_disturbance_window_set)
__swig_setmethods__["max_tuning"] = _libvncxx.VpeMagnetometerAdvancedTuningRegister_max_tuning_set
__swig_getmethods__["max_tuning"] = _libvncxx.VpeMagnetometerAdvancedTuningRegister_max_tuning_get
if _newclass:
max_tuning = _swig_property(_libvncxx.VpeMagnetometerAdvancedTuningRegister_max_tuning_get, _libvncxx.VpeMagnetometerAdvancedTuningRegister_max_tuning_set)
def __init__(self, *args):
"""
__init__(vn::sensors::VpeMagnetometerAdvancedTuningRegister self) -> VpeMagnetometerAdvancedTuningRegister
__init__(vn::sensors::VpeMagnetometerAdvancedTuningRegister self, vec3f minFilteringIn, vec3f maxFilteringIn, float maxAdaptRateIn, float disturbanceWindowIn, float maxTuningIn) -> VpeMagnetometerAdvancedTuningRegister
"""
this = _libvncxx.new_VpeMagnetometerAdvancedTuningRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_VpeMagnetometerAdvancedTuningRegister
__del__ = lambda self: None
VpeMagnetometerAdvancedTuningRegister_swigregister = _libvncxx.VpeMagnetometerAdvancedTuningRegister_swigregister
VpeMagnetometerAdvancedTuningRegister_swigregister(VpeMagnetometerAdvancedTuningRegister)
class VpeAccelerometerBasicTuningRegister(_object):
"""Proxy of C++ vn::sensors::VpeAccelerometerBasicTuningRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, VpeAccelerometerBasicTuningRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, VpeAccelerometerBasicTuningRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["base_tuning"] = _libvncxx.VpeAccelerometerBasicTuningRegister_base_tuning_set
__swig_getmethods__["base_tuning"] = _libvncxx.VpeAccelerometerBasicTuningRegister_base_tuning_get
if _newclass:
base_tuning = _swig_property(_libvncxx.VpeAccelerometerBasicTuningRegister_base_tuning_get, _libvncxx.VpeAccelerometerBasicTuningRegister_base_tuning_set)
__swig_setmethods__["adaptive_tuning"] = _libvncxx.VpeAccelerometerBasicTuningRegister_adaptive_tuning_set
__swig_getmethods__["adaptive_tuning"] = _libvncxx.VpeAccelerometerBasicTuningRegister_adaptive_tuning_get
if _newclass:
adaptive_tuning = _swig_property(_libvncxx.VpeAccelerometerBasicTuningRegister_adaptive_tuning_get, _libvncxx.VpeAccelerometerBasicTuningRegister_adaptive_tuning_set)
__swig_setmethods__["adaptive_filtering"] = _libvncxx.VpeAccelerometerBasicTuningRegister_adaptive_filtering_set
__swig_getmethods__["adaptive_filtering"] = _libvncxx.VpeAccelerometerBasicTuningRegister_adaptive_filtering_get
if _newclass:
adaptive_filtering = _swig_property(_libvncxx.VpeAccelerometerBasicTuningRegister_adaptive_filtering_get, _libvncxx.VpeAccelerometerBasicTuningRegister_adaptive_filtering_set)
def __init__(self, *args):
"""
__init__(vn::sensors::VpeAccelerometerBasicTuningRegister self) -> VpeAccelerometerBasicTuningRegister
__init__(vn::sensors::VpeAccelerometerBasicTuningRegister self, vec3f baseTuningIn, vec3f adaptiveTuningIn, vec3f adaptiveFilteringIn) -> VpeAccelerometerBasicTuningRegister
"""
this = _libvncxx.new_VpeAccelerometerBasicTuningRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_VpeAccelerometerBasicTuningRegister
__del__ = lambda self: None
VpeAccelerometerBasicTuningRegister_swigregister = _libvncxx.VpeAccelerometerBasicTuningRegister_swigregister
VpeAccelerometerBasicTuningRegister_swigregister(VpeAccelerometerBasicTuningRegister)
class VpeAccelerometerAdvancedTuningRegister(_object):
"""Proxy of C++ vn::sensors::VpeAccelerometerAdvancedTuningRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, VpeAccelerometerAdvancedTuningRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, VpeAccelerometerAdvancedTuningRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["min_filtering"] = _libvncxx.VpeAccelerometerAdvancedTuningRegister_min_filtering_set
__swig_getmethods__["min_filtering"] = _libvncxx.VpeAccelerometerAdvancedTuningRegister_min_filtering_get
if _newclass:
min_filtering = _swig_property(_libvncxx.VpeAccelerometerAdvancedTuningRegister_min_filtering_get, _libvncxx.VpeAccelerometerAdvancedTuningRegister_min_filtering_set)
__swig_setmethods__["max_filtering"] = _libvncxx.VpeAccelerometerAdvancedTuningRegister_max_filtering_set
__swig_getmethods__["max_filtering"] = _libvncxx.VpeAccelerometerAdvancedTuningRegister_max_filtering_get
if _newclass:
max_filtering = _swig_property(_libvncxx.VpeAccelerometerAdvancedTuningRegister_max_filtering_get, _libvncxx.VpeAccelerometerAdvancedTuningRegister_max_filtering_set)
__swig_setmethods__["max_adapt_rate"] = _libvncxx.VpeAccelerometerAdvancedTuningRegister_max_adapt_rate_set
__swig_getmethods__["max_adapt_rate"] = _libvncxx.VpeAccelerometerAdvancedTuningRegister_max_adapt_rate_get
if _newclass:
max_adapt_rate = _swig_property(_libvncxx.VpeAccelerometerAdvancedTuningRegister_max_adapt_rate_get, _libvncxx.VpeAccelerometerAdvancedTuningRegister_max_adapt_rate_set)
__swig_setmethods__["disturbance_window"] = _libvncxx.VpeAccelerometerAdvancedTuningRegister_disturbance_window_set
__swig_getmethods__["disturbance_window"] = _libvncxx.VpeAccelerometerAdvancedTuningRegister_disturbance_window_get
if _newclass:
disturbance_window = _swig_property(_libvncxx.VpeAccelerometerAdvancedTuningRegister_disturbance_window_get, _libvncxx.VpeAccelerometerAdvancedTuningRegister_disturbance_window_set)
__swig_setmethods__["max_tuning"] = _libvncxx.VpeAccelerometerAdvancedTuningRegister_max_tuning_set
__swig_getmethods__["max_tuning"] = _libvncxx.VpeAccelerometerAdvancedTuningRegister_max_tuning_get
if _newclass:
max_tuning = _swig_property(_libvncxx.VpeAccelerometerAdvancedTuningRegister_max_tuning_get, _libvncxx.VpeAccelerometerAdvancedTuningRegister_max_tuning_set)
def __init__(self, *args):
"""
__init__(vn::sensors::VpeAccelerometerAdvancedTuningRegister self) -> VpeAccelerometerAdvancedTuningRegister
__init__(vn::sensors::VpeAccelerometerAdvancedTuningRegister self, vec3f minFilteringIn, vec3f maxFilteringIn, float maxAdaptRateIn, float disturbanceWindowIn, float maxTuningIn) -> VpeAccelerometerAdvancedTuningRegister
"""
this = _libvncxx.new_VpeAccelerometerAdvancedTuningRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_VpeAccelerometerAdvancedTuningRegister
__del__ = lambda self: None
VpeAccelerometerAdvancedTuningRegister_swigregister = _libvncxx.VpeAccelerometerAdvancedTuningRegister_swigregister
VpeAccelerometerAdvancedTuningRegister_swigregister(VpeAccelerometerAdvancedTuningRegister)
class VpeGyroBasicTuningRegister(_object):
"""Proxy of C++ vn::sensors::VpeGyroBasicTuningRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, VpeGyroBasicTuningRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, VpeGyroBasicTuningRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["angularWalkVariance"] = _libvncxx.VpeGyroBasicTuningRegister_angularWalkVariance_set
__swig_getmethods__["angularWalkVariance"] = _libvncxx.VpeGyroBasicTuningRegister_angularWalkVariance_get
if _newclass:
angularWalkVariance = _swig_property(_libvncxx.VpeGyroBasicTuningRegister_angularWalkVariance_get, _libvncxx.VpeGyroBasicTuningRegister_angularWalkVariance_set)
__swig_setmethods__["baseTuning"] = _libvncxx.VpeGyroBasicTuningRegister_baseTuning_set
__swig_getmethods__["baseTuning"] = _libvncxx.VpeGyroBasicTuningRegister_baseTuning_get
if _newclass:
baseTuning = _swig_property(_libvncxx.VpeGyroBasicTuningRegister_baseTuning_get, _libvncxx.VpeGyroBasicTuningRegister_baseTuning_set)
__swig_setmethods__["adaptiveTuning"] = _libvncxx.VpeGyroBasicTuningRegister_adaptiveTuning_set
__swig_getmethods__["adaptiveTuning"] = _libvncxx.VpeGyroBasicTuningRegister_adaptiveTuning_get
if _newclass:
adaptiveTuning = _swig_property(_libvncxx.VpeGyroBasicTuningRegister_adaptiveTuning_get, _libvncxx.VpeGyroBasicTuningRegister_adaptiveTuning_set)
def __init__(self, *args):
"""
__init__(vn::sensors::VpeGyroBasicTuningRegister self) -> VpeGyroBasicTuningRegister
__init__(vn::sensors::VpeGyroBasicTuningRegister self, vec3f angularWalkVarianceIn, vec3f baseTuningIn, vec3f adaptiveTuningIn) -> VpeGyroBasicTuningRegister
"""
this = _libvncxx.new_VpeGyroBasicTuningRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_VpeGyroBasicTuningRegister
__del__ = lambda self: None
VpeGyroBasicTuningRegister_swigregister = _libvncxx.VpeGyroBasicTuningRegister_swigregister
VpeGyroBasicTuningRegister_swigregister(VpeGyroBasicTuningRegister)
class MagnetometerCalibrationControlRegister(_object):
"""Proxy of C++ vn::sensors::MagnetometerCalibrationControlRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, MagnetometerCalibrationControlRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, MagnetometerCalibrationControlRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["hsi_mode"] = _libvncxx.MagnetometerCalibrationControlRegister_hsi_mode_set
__swig_getmethods__["hsi_mode"] = _libvncxx.MagnetometerCalibrationControlRegister_hsi_mode_get
if _newclass:
hsi_mode = _swig_property(_libvncxx.MagnetometerCalibrationControlRegister_hsi_mode_get, _libvncxx.MagnetometerCalibrationControlRegister_hsi_mode_set)
__swig_setmethods__["hsi_output"] = _libvncxx.MagnetometerCalibrationControlRegister_hsi_output_set
__swig_getmethods__["hsi_output"] = _libvncxx.MagnetometerCalibrationControlRegister_hsi_output_get
if _newclass:
hsi_output = _swig_property(_libvncxx.MagnetometerCalibrationControlRegister_hsi_output_get, _libvncxx.MagnetometerCalibrationControlRegister_hsi_output_set)
__swig_setmethods__["converge_rate"] = _libvncxx.MagnetometerCalibrationControlRegister_converge_rate_set
__swig_getmethods__["converge_rate"] = _libvncxx.MagnetometerCalibrationControlRegister_converge_rate_get
if _newclass:
converge_rate = _swig_property(_libvncxx.MagnetometerCalibrationControlRegister_converge_rate_get, _libvncxx.MagnetometerCalibrationControlRegister_converge_rate_set)
def __init__(self, *args):
"""
__init__(vn::sensors::MagnetometerCalibrationControlRegister self) -> MagnetometerCalibrationControlRegister
__init__(vn::sensors::MagnetometerCalibrationControlRegister self, vn::protocol::uart::HsiMode hsiModeIn, vn::protocol::uart::HsiOutput hsiOutputIn, uint8_t convergeRateIn) -> MagnetometerCalibrationControlRegister
"""
this = _libvncxx.new_MagnetometerCalibrationControlRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_MagnetometerCalibrationControlRegister
__del__ = lambda self: None
MagnetometerCalibrationControlRegister_swigregister = _libvncxx.MagnetometerCalibrationControlRegister_swigregister
MagnetometerCalibrationControlRegister_swigregister(MagnetometerCalibrationControlRegister)
class CalculatedMagnetometerCalibrationRegister(_object):
"""Proxy of C++ vn::sensors::CalculatedMagnetometerCalibrationRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, CalculatedMagnetometerCalibrationRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, CalculatedMagnetometerCalibrationRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["c"] = _libvncxx.CalculatedMagnetometerCalibrationRegister_c_set
__swig_getmethods__["c"] = _libvncxx.CalculatedMagnetometerCalibrationRegister_c_get
if _newclass:
c = _swig_property(_libvncxx.CalculatedMagnetometerCalibrationRegister_c_get, _libvncxx.CalculatedMagnetometerCalibrationRegister_c_set)
__swig_setmethods__["b"] = _libvncxx.CalculatedMagnetometerCalibrationRegister_b_set
__swig_getmethods__["b"] = _libvncxx.CalculatedMagnetometerCalibrationRegister_b_get
if _newclass:
b = _swig_property(_libvncxx.CalculatedMagnetometerCalibrationRegister_b_get, _libvncxx.CalculatedMagnetometerCalibrationRegister_b_set)
def __init__(self, *args):
"""
__init__(vn::sensors::CalculatedMagnetometerCalibrationRegister self) -> CalculatedMagnetometerCalibrationRegister
__init__(vn::sensors::CalculatedMagnetometerCalibrationRegister self, mat3f cIn, vec3f bIn) -> CalculatedMagnetometerCalibrationRegister
"""
this = _libvncxx.new_CalculatedMagnetometerCalibrationRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_CalculatedMagnetometerCalibrationRegister
__del__ = lambda self: None
CalculatedMagnetometerCalibrationRegister_swigregister = _libvncxx.CalculatedMagnetometerCalibrationRegister_swigregister
CalculatedMagnetometerCalibrationRegister_swigregister(CalculatedMagnetometerCalibrationRegister)
class VelocityCompensationControlRegister(_object):
"""Proxy of C++ vn::sensors::VelocityCompensationControlRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, VelocityCompensationControlRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, VelocityCompensationControlRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["mode"] = _libvncxx.VelocityCompensationControlRegister_mode_set
__swig_getmethods__["mode"] = _libvncxx.VelocityCompensationControlRegister_mode_get
if _newclass:
mode = _swig_property(_libvncxx.VelocityCompensationControlRegister_mode_get, _libvncxx.VelocityCompensationControlRegister_mode_set)
__swig_setmethods__["velocity_tuning"] = _libvncxx.VelocityCompensationControlRegister_velocity_tuning_set
__swig_getmethods__["velocity_tuning"] = _libvncxx.VelocityCompensationControlRegister_velocity_tuning_get
if _newclass:
velocity_tuning = _swig_property(_libvncxx.VelocityCompensationControlRegister_velocity_tuning_get, _libvncxx.VelocityCompensationControlRegister_velocity_tuning_set)
__swig_setmethods__["rate_tuning"] = _libvncxx.VelocityCompensationControlRegister_rate_tuning_set
__swig_getmethods__["rate_tuning"] = _libvncxx.VelocityCompensationControlRegister_rate_tuning_get
if _newclass:
rate_tuning = _swig_property(_libvncxx.VelocityCompensationControlRegister_rate_tuning_get, _libvncxx.VelocityCompensationControlRegister_rate_tuning_set)
def __init__(self, *args):
"""
__init__(vn::sensors::VelocityCompensationControlRegister self) -> VelocityCompensationControlRegister
__init__(vn::sensors::VelocityCompensationControlRegister self, vn::protocol::uart::VelocityCompensationMode modeIn, float velocityTuningIn, float rateTuningIn) -> VelocityCompensationControlRegister
"""
this = _libvncxx.new_VelocityCompensationControlRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_VelocityCompensationControlRegister
__del__ = lambda self: None
VelocityCompensationControlRegister_swigregister = _libvncxx.VelocityCompensationControlRegister_swigregister
VelocityCompensationControlRegister_swigregister(VelocityCompensationControlRegister)
class VelocityCompensationStatusRegister(_object):
"""Proxy of C++ vn::sensors::VelocityCompensationStatusRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, VelocityCompensationStatusRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, VelocityCompensationStatusRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["x"] = _libvncxx.VelocityCompensationStatusRegister_x_set
__swig_getmethods__["x"] = _libvncxx.VelocityCompensationStatusRegister_x_get
if _newclass:
x = _swig_property(_libvncxx.VelocityCompensationStatusRegister_x_get, _libvncxx.VelocityCompensationStatusRegister_x_set)
__swig_setmethods__["x_dot"] = _libvncxx.VelocityCompensationStatusRegister_x_dot_set
__swig_getmethods__["x_dot"] = _libvncxx.VelocityCompensationStatusRegister_x_dot_get
if _newclass:
x_dot = _swig_property(_libvncxx.VelocityCompensationStatusRegister_x_dot_get, _libvncxx.VelocityCompensationStatusRegister_x_dot_set)
__swig_setmethods__["accel_offset"] = _libvncxx.VelocityCompensationStatusRegister_accel_offset_set
__swig_getmethods__["accel_offset"] = _libvncxx.VelocityCompensationStatusRegister_accel_offset_get
if _newclass:
accel_offset = _swig_property(_libvncxx.VelocityCompensationStatusRegister_accel_offset_get, _libvncxx.VelocityCompensationStatusRegister_accel_offset_set)
__swig_setmethods__["omega"] = _libvncxx.VelocityCompensationStatusRegister_omega_set
__swig_getmethods__["omega"] = _libvncxx.VelocityCompensationStatusRegister_omega_get
if _newclass:
omega = _swig_property(_libvncxx.VelocityCompensationStatusRegister_omega_get, _libvncxx.VelocityCompensationStatusRegister_omega_set)
def __init__(self, *args):
"""
__init__(vn::sensors::VelocityCompensationStatusRegister self) -> VelocityCompensationStatusRegister
__init__(vn::sensors::VelocityCompensationStatusRegister self, float xIn, float xDotIn, vec3f accelOffsetIn, vec3f omegaIn) -> VelocityCompensationStatusRegister
"""
this = _libvncxx.new_VelocityCompensationStatusRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_VelocityCompensationStatusRegister
__del__ = lambda self: None
VelocityCompensationStatusRegister_swigregister = _libvncxx.VelocityCompensationStatusRegister_swigregister
VelocityCompensationStatusRegister_swigregister(VelocityCompensationStatusRegister)
class ImuMeasurementsRegister(_object):
"""Proxy of C++ vn::sensors::ImuMeasurementsRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, ImuMeasurementsRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, ImuMeasurementsRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["mag"] = _libvncxx.ImuMeasurementsRegister_mag_set
__swig_getmethods__["mag"] = _libvncxx.ImuMeasurementsRegister_mag_get
if _newclass:
mag = _swig_property(_libvncxx.ImuMeasurementsRegister_mag_get, _libvncxx.ImuMeasurementsRegister_mag_set)
__swig_setmethods__["accel"] = _libvncxx.ImuMeasurementsRegister_accel_set
__swig_getmethods__["accel"] = _libvncxx.ImuMeasurementsRegister_accel_get
if _newclass:
accel = _swig_property(_libvncxx.ImuMeasurementsRegister_accel_get, _libvncxx.ImuMeasurementsRegister_accel_set)
__swig_setmethods__["gyro"] = _libvncxx.ImuMeasurementsRegister_gyro_set
__swig_getmethods__["gyro"] = _libvncxx.ImuMeasurementsRegister_gyro_get
if _newclass:
gyro = _swig_property(_libvncxx.ImuMeasurementsRegister_gyro_get, _libvncxx.ImuMeasurementsRegister_gyro_set)
__swig_setmethods__["temp"] = _libvncxx.ImuMeasurementsRegister_temp_set
__swig_getmethods__["temp"] = _libvncxx.ImuMeasurementsRegister_temp_get
if _newclass:
temp = _swig_property(_libvncxx.ImuMeasurementsRegister_temp_get, _libvncxx.ImuMeasurementsRegister_temp_set)
__swig_setmethods__["pressure"] = _libvncxx.ImuMeasurementsRegister_pressure_set
__swig_getmethods__["pressure"] = _libvncxx.ImuMeasurementsRegister_pressure_get
if _newclass:
pressure = _swig_property(_libvncxx.ImuMeasurementsRegister_pressure_get, _libvncxx.ImuMeasurementsRegister_pressure_set)
def __init__(self, *args):
"""
__init__(vn::sensors::ImuMeasurementsRegister self) -> ImuMeasurementsRegister
__init__(vn::sensors::ImuMeasurementsRegister self, vec3f magIn, vec3f accelIn, vec3f gyroIn, float tempIn, float pressureIn) -> ImuMeasurementsRegister
"""
this = _libvncxx.new_ImuMeasurementsRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_ImuMeasurementsRegister
__del__ = lambda self: None
ImuMeasurementsRegister_swigregister = _libvncxx.ImuMeasurementsRegister_swigregister
ImuMeasurementsRegister_swigregister(ImuMeasurementsRegister)
class GpsConfigurationRegister(_object):
"""Proxy of C++ vn::sensors::GpsConfigurationRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, GpsConfigurationRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, GpsConfigurationRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["mode"] = _libvncxx.GpsConfigurationRegister_mode_set
__swig_getmethods__["mode"] = _libvncxx.GpsConfigurationRegister_mode_get
if _newclass:
mode = _swig_property(_libvncxx.GpsConfigurationRegister_mode_get, _libvncxx.GpsConfigurationRegister_mode_set)
__swig_setmethods__["pps_source"] = _libvncxx.GpsConfigurationRegister_pps_source_set
__swig_getmethods__["pps_source"] = _libvncxx.GpsConfigurationRegister_pps_source_get
if _newclass:
pps_source = _swig_property(_libvncxx.GpsConfigurationRegister_pps_source_get, _libvncxx.GpsConfigurationRegister_pps_source_set)
def __init__(self, *args):
"""
__init__(vn::sensors::GpsConfigurationRegister self) -> GpsConfigurationRegister
__init__(vn::sensors::GpsConfigurationRegister self, vn::protocol::uart::GpsMode modeIn, vn::protocol::uart::PpsSource ppsSourceIn) -> GpsConfigurationRegister
"""
this = _libvncxx.new_GpsConfigurationRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_GpsConfigurationRegister
__del__ = lambda self: None
GpsConfigurationRegister_swigregister = _libvncxx.GpsConfigurationRegister_swigregister
GpsConfigurationRegister_swigregister(GpsConfigurationRegister)
class GpsSolutionLlaRegister(_object):
"""Proxy of C++ vn::sensors::GpsSolutionLlaRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, GpsSolutionLlaRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, GpsSolutionLlaRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["time"] = _libvncxx.GpsSolutionLlaRegister_time_set
__swig_getmethods__["time"] = _libvncxx.GpsSolutionLlaRegister_time_get
if _newclass:
time = _swig_property(_libvncxx.GpsSolutionLlaRegister_time_get, _libvncxx.GpsSolutionLlaRegister_time_set)
__swig_setmethods__["week"] = _libvncxx.GpsSolutionLlaRegister_week_set
__swig_getmethods__["week"] = _libvncxx.GpsSolutionLlaRegister_week_get
if _newclass:
week = _swig_property(_libvncxx.GpsSolutionLlaRegister_week_get, _libvncxx.GpsSolutionLlaRegister_week_set)
__swig_setmethods__["gps_fix"] = _libvncxx.GpsSolutionLlaRegister_gps_fix_set
__swig_getmethods__["gps_fix"] = _libvncxx.GpsSolutionLlaRegister_gps_fix_get
if _newclass:
gps_fix = _swig_property(_libvncxx.GpsSolutionLlaRegister_gps_fix_get, _libvncxx.GpsSolutionLlaRegister_gps_fix_set)
__swig_setmethods__["num_sats"] = _libvncxx.GpsSolutionLlaRegister_num_sats_set
__swig_getmethods__["num_sats"] = _libvncxx.GpsSolutionLlaRegister_num_sats_get
if _newclass:
num_sats = _swig_property(_libvncxx.GpsSolutionLlaRegister_num_sats_get, _libvncxx.GpsSolutionLlaRegister_num_sats_set)
__swig_setmethods__["lla"] = _libvncxx.GpsSolutionLlaRegister_lla_set
__swig_getmethods__["lla"] = _libvncxx.GpsSolutionLlaRegister_lla_get
if _newclass:
lla = _swig_property(_libvncxx.GpsSolutionLlaRegister_lla_get, _libvncxx.GpsSolutionLlaRegister_lla_set)
__swig_setmethods__["ned_vel"] = _libvncxx.GpsSolutionLlaRegister_ned_vel_set
__swig_getmethods__["ned_vel"] = _libvncxx.GpsSolutionLlaRegister_ned_vel_get
if _newclass:
ned_vel = _swig_property(_libvncxx.GpsSolutionLlaRegister_ned_vel_get, _libvncxx.GpsSolutionLlaRegister_ned_vel_set)
__swig_setmethods__["ned_acc"] = _libvncxx.GpsSolutionLlaRegister_ned_acc_set
__swig_getmethods__["ned_acc"] = _libvncxx.GpsSolutionLlaRegister_ned_acc_get
if _newclass:
ned_acc = _swig_property(_libvncxx.GpsSolutionLlaRegister_ned_acc_get, _libvncxx.GpsSolutionLlaRegister_ned_acc_set)
__swig_setmethods__["speed_acc"] = _libvncxx.GpsSolutionLlaRegister_speed_acc_set
__swig_getmethods__["speed_acc"] = _libvncxx.GpsSolutionLlaRegister_speed_acc_get
if _newclass:
speed_acc = _swig_property(_libvncxx.GpsSolutionLlaRegister_speed_acc_get, _libvncxx.GpsSolutionLlaRegister_speed_acc_set)
__swig_setmethods__["time_acc"] = _libvncxx.GpsSolutionLlaRegister_time_acc_set
__swig_getmethods__["time_acc"] = _libvncxx.GpsSolutionLlaRegister_time_acc_get
if _newclass:
time_acc = _swig_property(_libvncxx.GpsSolutionLlaRegister_time_acc_get, _libvncxx.GpsSolutionLlaRegister_time_acc_set)
def __init__(self, *args):
"""
__init__(vn::sensors::GpsSolutionLlaRegister self) -> GpsSolutionLlaRegister
__init__(vn::sensors::GpsSolutionLlaRegister self, double timeIn, uint16_t weekIn, vn::protocol::uart::GpsFix gpsFixIn, uint8_t numSatsIn, vec3d llaIn, vec3f nedVelIn, vec3f nedAccIn, float speedAccIn, float timeAccIn) -> GpsSolutionLlaRegister
"""
this = _libvncxx.new_GpsSolutionLlaRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_GpsSolutionLlaRegister
__del__ = lambda self: None
GpsSolutionLlaRegister_swigregister = _libvncxx.GpsSolutionLlaRegister_swigregister
GpsSolutionLlaRegister_swigregister(GpsSolutionLlaRegister)
class GpsSolutionEcefRegister(_object):
"""Proxy of C++ vn::sensors::GpsSolutionEcefRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, GpsSolutionEcefRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, GpsSolutionEcefRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["tow"] = _libvncxx.GpsSolutionEcefRegister_tow_set
__swig_getmethods__["tow"] = _libvncxx.GpsSolutionEcefRegister_tow_get
if _newclass:
tow = _swig_property(_libvncxx.GpsSolutionEcefRegister_tow_get, _libvncxx.GpsSolutionEcefRegister_tow_set)
__swig_setmethods__["week"] = _libvncxx.GpsSolutionEcefRegister_week_set
__swig_getmethods__["week"] = _libvncxx.GpsSolutionEcefRegister_week_get
if _newclass:
week = _swig_property(_libvncxx.GpsSolutionEcefRegister_week_get, _libvncxx.GpsSolutionEcefRegister_week_set)
__swig_setmethods__["gps_fix"] = _libvncxx.GpsSolutionEcefRegister_gps_fix_set
__swig_getmethods__["gps_fix"] = _libvncxx.GpsSolutionEcefRegister_gps_fix_get
if _newclass:
gps_fix = _swig_property(_libvncxx.GpsSolutionEcefRegister_gps_fix_get, _libvncxx.GpsSolutionEcefRegister_gps_fix_set)
__swig_setmethods__["num_sats"] = _libvncxx.GpsSolutionEcefRegister_num_sats_set
__swig_getmethods__["num_sats"] = _libvncxx.GpsSolutionEcefRegister_num_sats_get
if _newclass:
num_sats = _swig_property(_libvncxx.GpsSolutionEcefRegister_num_sats_get, _libvncxx.GpsSolutionEcefRegister_num_sats_set)
__swig_setmethods__["position"] = _libvncxx.GpsSolutionEcefRegister_position_set
__swig_getmethods__["position"] = _libvncxx.GpsSolutionEcefRegister_position_get
if _newclass:
position = _swig_property(_libvncxx.GpsSolutionEcefRegister_position_get, _libvncxx.GpsSolutionEcefRegister_position_set)
__swig_setmethods__["velocity"] = _libvncxx.GpsSolutionEcefRegister_velocity_set
__swig_getmethods__["velocity"] = _libvncxx.GpsSolutionEcefRegister_velocity_get
if _newclass:
velocity = _swig_property(_libvncxx.GpsSolutionEcefRegister_velocity_get, _libvncxx.GpsSolutionEcefRegister_velocity_set)
__swig_setmethods__["pos_acc"] = _libvncxx.GpsSolutionEcefRegister_pos_acc_set
__swig_getmethods__["pos_acc"] = _libvncxx.GpsSolutionEcefRegister_pos_acc_get
if _newclass:
pos_acc = _swig_property(_libvncxx.GpsSolutionEcefRegister_pos_acc_get, _libvncxx.GpsSolutionEcefRegister_pos_acc_set)
__swig_setmethods__["speed_acc"] = _libvncxx.GpsSolutionEcefRegister_speed_acc_set
__swig_getmethods__["speed_acc"] = _libvncxx.GpsSolutionEcefRegister_speed_acc_get
if _newclass:
speed_acc = _swig_property(_libvncxx.GpsSolutionEcefRegister_speed_acc_get, _libvncxx.GpsSolutionEcefRegister_speed_acc_set)
__swig_setmethods__["time_acc"] = _libvncxx.GpsSolutionEcefRegister_time_acc_set
__swig_getmethods__["time_acc"] = _libvncxx.GpsSolutionEcefRegister_time_acc_get
if _newclass:
time_acc = _swig_property(_libvncxx.GpsSolutionEcefRegister_time_acc_get, _libvncxx.GpsSolutionEcefRegister_time_acc_set)
def __init__(self, *args):
"""
__init__(vn::sensors::GpsSolutionEcefRegister self) -> GpsSolutionEcefRegister
__init__(vn::sensors::GpsSolutionEcefRegister self, double towIn, uint16_t weekIn, vn::protocol::uart::GpsFix gpsFixIn, uint8_t numSatsIn, vec3d positionIn, vec3f velocityIn, vec3f posAccIn, float speedAccIn, float timeAccIn) -> GpsSolutionEcefRegister
"""
this = _libvncxx.new_GpsSolutionEcefRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_GpsSolutionEcefRegister
__del__ = lambda self: None
GpsSolutionEcefRegister_swigregister = _libvncxx.GpsSolutionEcefRegister_swigregister
GpsSolutionEcefRegister_swigregister(GpsSolutionEcefRegister)
class InsSolutionLlaRegister(_object):
"""Proxy of C++ vn::sensors::InsSolutionLlaRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, InsSolutionLlaRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, InsSolutionLlaRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["time"] = _libvncxx.InsSolutionLlaRegister_time_set
__swig_getmethods__["time"] = _libvncxx.InsSolutionLlaRegister_time_get
if _newclass:
time = _swig_property(_libvncxx.InsSolutionLlaRegister_time_get, _libvncxx.InsSolutionLlaRegister_time_set)
__swig_setmethods__["week"] = _libvncxx.InsSolutionLlaRegister_week_set
__swig_getmethods__["week"] = _libvncxx.InsSolutionLlaRegister_week_get
if _newclass:
week = _swig_property(_libvncxx.InsSolutionLlaRegister_week_get, _libvncxx.InsSolutionLlaRegister_week_set)
__swig_setmethods__["status"] = _libvncxx.InsSolutionLlaRegister_status_set
__swig_getmethods__["status"] = _libvncxx.InsSolutionLlaRegister_status_get
if _newclass:
status = _swig_property(_libvncxx.InsSolutionLlaRegister_status_get, _libvncxx.InsSolutionLlaRegister_status_set)
__swig_setmethods__["yawPitchRoll"] = _libvncxx.InsSolutionLlaRegister_yawPitchRoll_set
__swig_getmethods__["yawPitchRoll"] = _libvncxx.InsSolutionLlaRegister_yawPitchRoll_get
if _newclass:
yawPitchRoll = _swig_property(_libvncxx.InsSolutionLlaRegister_yawPitchRoll_get, _libvncxx.InsSolutionLlaRegister_yawPitchRoll_set)
__swig_setmethods__["position"] = _libvncxx.InsSolutionLlaRegister_position_set
__swig_getmethods__["position"] = _libvncxx.InsSolutionLlaRegister_position_get
if _newclass:
position = _swig_property(_libvncxx.InsSolutionLlaRegister_position_get, _libvncxx.InsSolutionLlaRegister_position_set)
__swig_setmethods__["nedVel"] = _libvncxx.InsSolutionLlaRegister_nedVel_set
__swig_getmethods__["nedVel"] = _libvncxx.InsSolutionLlaRegister_nedVel_get
if _newclass:
nedVel = _swig_property(_libvncxx.InsSolutionLlaRegister_nedVel_get, _libvncxx.InsSolutionLlaRegister_nedVel_set)
__swig_setmethods__["attUncertainty"] = _libvncxx.InsSolutionLlaRegister_attUncertainty_set
__swig_getmethods__["attUncertainty"] = _libvncxx.InsSolutionLlaRegister_attUncertainty_get
if _newclass:
attUncertainty = _swig_property(_libvncxx.InsSolutionLlaRegister_attUncertainty_get, _libvncxx.InsSolutionLlaRegister_attUncertainty_set)
__swig_setmethods__["posUncertainty"] = _libvncxx.InsSolutionLlaRegister_posUncertainty_set
__swig_getmethods__["posUncertainty"] = _libvncxx.InsSolutionLlaRegister_posUncertainty_get
if _newclass:
posUncertainty = _swig_property(_libvncxx.InsSolutionLlaRegister_posUncertainty_get, _libvncxx.InsSolutionLlaRegister_posUncertainty_set)
__swig_setmethods__["velUncertainty"] = _libvncxx.InsSolutionLlaRegister_velUncertainty_set
__swig_getmethods__["velUncertainty"] = _libvncxx.InsSolutionLlaRegister_velUncertainty_get
if _newclass:
velUncertainty = _swig_property(_libvncxx.InsSolutionLlaRegister_velUncertainty_get, _libvncxx.InsSolutionLlaRegister_velUncertainty_set)
def __init__(self, *args):
"""
__init__(vn::sensors::InsSolutionLlaRegister self) -> InsSolutionLlaRegister
__init__(vn::sensors::InsSolutionLlaRegister self, double timeIn, uint16_t weekIn, uint16_t statusIn, vec3f yawPitchRollIn, vec3d positionIn, vec3f nedVelIn, float attUncertaintyIn, float posUncertaintyIn, float velUncertaintyIn) -> InsSolutionLlaRegister
"""
this = _libvncxx.new_InsSolutionLlaRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_InsSolutionLlaRegister
__del__ = lambda self: None
InsSolutionLlaRegister_swigregister = _libvncxx.InsSolutionLlaRegister_swigregister
InsSolutionLlaRegister_swigregister(InsSolutionLlaRegister)
class InsSolutionEcefRegister(_object):
"""Proxy of C++ vn::sensors::InsSolutionEcefRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, InsSolutionEcefRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, InsSolutionEcefRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["time"] = _libvncxx.InsSolutionEcefRegister_time_set
__swig_getmethods__["time"] = _libvncxx.InsSolutionEcefRegister_time_get
if _newclass:
time = _swig_property(_libvncxx.InsSolutionEcefRegister_time_get, _libvncxx.InsSolutionEcefRegister_time_set)
__swig_setmethods__["week"] = _libvncxx.InsSolutionEcefRegister_week_set
__swig_getmethods__["week"] = _libvncxx.InsSolutionEcefRegister_week_get
if _newclass:
week = _swig_property(_libvncxx.InsSolutionEcefRegister_week_get, _libvncxx.InsSolutionEcefRegister_week_set)
__swig_setmethods__["status"] = _libvncxx.InsSolutionEcefRegister_status_set
__swig_getmethods__["status"] = _libvncxx.InsSolutionEcefRegister_status_get
if _newclass:
status = _swig_property(_libvncxx.InsSolutionEcefRegister_status_get, _libvncxx.InsSolutionEcefRegister_status_set)
__swig_setmethods__["yawPitchRoll"] = _libvncxx.InsSolutionEcefRegister_yawPitchRoll_set
__swig_getmethods__["yawPitchRoll"] = _libvncxx.InsSolutionEcefRegister_yawPitchRoll_get
if _newclass:
yawPitchRoll = _swig_property(_libvncxx.InsSolutionEcefRegister_yawPitchRoll_get, _libvncxx.InsSolutionEcefRegister_yawPitchRoll_set)
__swig_setmethods__["position"] = _libvncxx.InsSolutionEcefRegister_position_set
__swig_getmethods__["position"] = _libvncxx.InsSolutionEcefRegister_position_get
if _newclass:
position = _swig_property(_libvncxx.InsSolutionEcefRegister_position_get, _libvncxx.InsSolutionEcefRegister_position_set)
__swig_setmethods__["velocity"] = _libvncxx.InsSolutionEcefRegister_velocity_set
__swig_getmethods__["velocity"] = _libvncxx.InsSolutionEcefRegister_velocity_get
if _newclass:
velocity = _swig_property(_libvncxx.InsSolutionEcefRegister_velocity_get, _libvncxx.InsSolutionEcefRegister_velocity_set)
__swig_setmethods__["attUncertainty"] = _libvncxx.InsSolutionEcefRegister_attUncertainty_set
__swig_getmethods__["attUncertainty"] = _libvncxx.InsSolutionEcefRegister_attUncertainty_get
if _newclass:
attUncertainty = _swig_property(_libvncxx.InsSolutionEcefRegister_attUncertainty_get, _libvncxx.InsSolutionEcefRegister_attUncertainty_set)
__swig_setmethods__["posUncertainty"] = _libvncxx.InsSolutionEcefRegister_posUncertainty_set
__swig_getmethods__["posUncertainty"] = _libvncxx.InsSolutionEcefRegister_posUncertainty_get
if _newclass:
posUncertainty = _swig_property(_libvncxx.InsSolutionEcefRegister_posUncertainty_get, _libvncxx.InsSolutionEcefRegister_posUncertainty_set)
__swig_setmethods__["velUncertainty"] = _libvncxx.InsSolutionEcefRegister_velUncertainty_set
__swig_getmethods__["velUncertainty"] = _libvncxx.InsSolutionEcefRegister_velUncertainty_get
if _newclass:
velUncertainty = _swig_property(_libvncxx.InsSolutionEcefRegister_velUncertainty_get, _libvncxx.InsSolutionEcefRegister_velUncertainty_set)
def __init__(self, *args):
"""
__init__(vn::sensors::InsSolutionEcefRegister self) -> InsSolutionEcefRegister
__init__(vn::sensors::InsSolutionEcefRegister self, double timeIn, uint16_t weekIn, uint16_t statusIn, vec3f yawPitchRollIn, vec3d positionIn, vec3f velocityIn, float attUncertaintyIn, float posUncertaintyIn, float velUncertaintyIn) -> InsSolutionEcefRegister
"""
this = _libvncxx.new_InsSolutionEcefRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_InsSolutionEcefRegister
__del__ = lambda self: None
InsSolutionEcefRegister_swigregister = _libvncxx.InsSolutionEcefRegister_swigregister
InsSolutionEcefRegister_swigregister(InsSolutionEcefRegister)
class InsBasicConfigurationRegisterVn200(_object):
"""Proxy of C++ vn::sensors::InsBasicConfigurationRegisterVn200 class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, InsBasicConfigurationRegisterVn200, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, InsBasicConfigurationRegisterVn200, name)
__repr__ = _swig_repr
__swig_setmethods__["scenario"] = _libvncxx.InsBasicConfigurationRegisterVn200_scenario_set
__swig_getmethods__["scenario"] = _libvncxx.InsBasicConfigurationRegisterVn200_scenario_get
if _newclass:
scenario = _swig_property(_libvncxx.InsBasicConfigurationRegisterVn200_scenario_get, _libvncxx.InsBasicConfigurationRegisterVn200_scenario_set)
__swig_setmethods__["ahrs_aiding"] = _libvncxx.InsBasicConfigurationRegisterVn200_ahrs_aiding_set
__swig_getmethods__["ahrs_aiding"] = _libvncxx.InsBasicConfigurationRegisterVn200_ahrs_aiding_get
if _newclass:
ahrs_aiding = _swig_property(_libvncxx.InsBasicConfigurationRegisterVn200_ahrs_aiding_get, _libvncxx.InsBasicConfigurationRegisterVn200_ahrs_aiding_set)
def __init__(self, *args):
"""
__init__(vn::sensors::InsBasicConfigurationRegisterVn200 self) -> InsBasicConfigurationRegisterVn200
__init__(vn::sensors::InsBasicConfigurationRegisterVn200 self, vn::protocol::uart::Scenario scenarioIn, bool ahrsAidingIn) -> InsBasicConfigurationRegisterVn200
"""
this = _libvncxx.new_InsBasicConfigurationRegisterVn200(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_InsBasicConfigurationRegisterVn200
__del__ = lambda self: None
InsBasicConfigurationRegisterVn200_swigregister = _libvncxx.InsBasicConfigurationRegisterVn200_swigregister
InsBasicConfigurationRegisterVn200_swigregister(InsBasicConfigurationRegisterVn200)
class InsBasicConfigurationRegisterVn300(_object):
"""Proxy of C++ vn::sensors::InsBasicConfigurationRegisterVn300 class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, InsBasicConfigurationRegisterVn300, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, InsBasicConfigurationRegisterVn300, name)
__repr__ = _swig_repr
__swig_setmethods__["scenario"] = _libvncxx.InsBasicConfigurationRegisterVn300_scenario_set
__swig_getmethods__["scenario"] = _libvncxx.InsBasicConfigurationRegisterVn300_scenario_get
if _newclass:
scenario = _swig_property(_libvncxx.InsBasicConfigurationRegisterVn300_scenario_get, _libvncxx.InsBasicConfigurationRegisterVn300_scenario_set)
__swig_setmethods__["ahrs_aiding"] = _libvncxx.InsBasicConfigurationRegisterVn300_ahrs_aiding_set
__swig_getmethods__["ahrs_aiding"] = _libvncxx.InsBasicConfigurationRegisterVn300_ahrs_aiding_get
if _newclass:
ahrs_aiding = _swig_property(_libvncxx.InsBasicConfigurationRegisterVn300_ahrs_aiding_get, _libvncxx.InsBasicConfigurationRegisterVn300_ahrs_aiding_set)
__swig_setmethods__["est_baseline"] = _libvncxx.InsBasicConfigurationRegisterVn300_est_baseline_set
__swig_getmethods__["est_baseline"] = _libvncxx.InsBasicConfigurationRegisterVn300_est_baseline_get
if _newclass:
est_baseline = _swig_property(_libvncxx.InsBasicConfigurationRegisterVn300_est_baseline_get, _libvncxx.InsBasicConfigurationRegisterVn300_est_baseline_set)
def __init__(self, *args):
"""
__init__(vn::sensors::InsBasicConfigurationRegisterVn300 self) -> InsBasicConfigurationRegisterVn300
__init__(vn::sensors::InsBasicConfigurationRegisterVn300 self, vn::protocol::uart::Scenario scenarioIn, bool ahrsAidingIn, bool estBaselineIn) -> InsBasicConfigurationRegisterVn300
"""
this = _libvncxx.new_InsBasicConfigurationRegisterVn300(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_InsBasicConfigurationRegisterVn300
__del__ = lambda self: None
InsBasicConfigurationRegisterVn300_swigregister = _libvncxx.InsBasicConfigurationRegisterVn300_swigregister
InsBasicConfigurationRegisterVn300_swigregister(InsBasicConfigurationRegisterVn300)
class InsAdvancedConfigurationRegister(_object):
"""Proxy of C++ vn::sensors::InsAdvancedConfigurationRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, InsAdvancedConfigurationRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, InsAdvancedConfigurationRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["use_mag"] = _libvncxx.InsAdvancedConfigurationRegister_use_mag_set
__swig_getmethods__["use_mag"] = _libvncxx.InsAdvancedConfigurationRegister_use_mag_get
if _newclass:
use_mag = _swig_property(_libvncxx.InsAdvancedConfigurationRegister_use_mag_get, _libvncxx.InsAdvancedConfigurationRegister_use_mag_set)
__swig_setmethods__["use_pres"] = _libvncxx.InsAdvancedConfigurationRegister_use_pres_set
__swig_getmethods__["use_pres"] = _libvncxx.InsAdvancedConfigurationRegister_use_pres_get
if _newclass:
use_pres = _swig_property(_libvncxx.InsAdvancedConfigurationRegister_use_pres_get, _libvncxx.InsAdvancedConfigurationRegister_use_pres_set)
__swig_setmethods__["pos_att"] = _libvncxx.InsAdvancedConfigurationRegister_pos_att_set
__swig_getmethods__["pos_att"] = _libvncxx.InsAdvancedConfigurationRegister_pos_att_get
if _newclass:
pos_att = _swig_property(_libvncxx.InsAdvancedConfigurationRegister_pos_att_get, _libvncxx.InsAdvancedConfigurationRegister_pos_att_set)
__swig_setmethods__["vel_att"] = _libvncxx.InsAdvancedConfigurationRegister_vel_att_set
__swig_getmethods__["vel_att"] = _libvncxx.InsAdvancedConfigurationRegister_vel_att_get
if _newclass:
vel_att = _swig_property(_libvncxx.InsAdvancedConfigurationRegister_vel_att_get, _libvncxx.InsAdvancedConfigurationRegister_vel_att_set)
__swig_setmethods__["vel_bias"] = _libvncxx.InsAdvancedConfigurationRegister_vel_bias_set
__swig_getmethods__["vel_bias"] = _libvncxx.InsAdvancedConfigurationRegister_vel_bias_get
if _newclass:
vel_bias = _swig_property(_libvncxx.InsAdvancedConfigurationRegister_vel_bias_get, _libvncxx.InsAdvancedConfigurationRegister_vel_bias_set)
__swig_setmethods__["use_foam"] = _libvncxx.InsAdvancedConfigurationRegister_use_foam_set
__swig_getmethods__["use_foam"] = _libvncxx.InsAdvancedConfigurationRegister_use_foam_get
if _newclass:
use_foam = _swig_property(_libvncxx.InsAdvancedConfigurationRegister_use_foam_get, _libvncxx.InsAdvancedConfigurationRegister_use_foam_set)
__swig_setmethods__["gps_conv_type"] = _libvncxx.InsAdvancedConfigurationRegister_gps_conv_type_set
__swig_getmethods__["gps_conv_type"] = _libvncxx.InsAdvancedConfigurationRegister_gps_conv_type_get
if _newclass:
gps_conv_type = _swig_property(_libvncxx.InsAdvancedConfigurationRegister_gps_conv_type_get, _libvncxx.InsAdvancedConfigurationRegister_gps_conv_type_set)
__swig_setmethods__["vel_count"] = _libvncxx.InsAdvancedConfigurationRegister_vel_count_set
__swig_getmethods__["vel_count"] = _libvncxx.InsAdvancedConfigurationRegister_vel_count_get
if _newclass:
vel_count = _swig_property(_libvncxx.InsAdvancedConfigurationRegister_vel_count_get, _libvncxx.InsAdvancedConfigurationRegister_vel_count_set)
__swig_setmethods__["vel_init"] = _libvncxx.InsAdvancedConfigurationRegister_vel_init_set
__swig_getmethods__["vel_init"] = _libvncxx.InsAdvancedConfigurationRegister_vel_init_get
if _newclass:
vel_init = _swig_property(_libvncxx.InsAdvancedConfigurationRegister_vel_init_get, _libvncxx.InsAdvancedConfigurationRegister_vel_init_set)
__swig_setmethods__["move_origin"] = _libvncxx.InsAdvancedConfigurationRegister_move_origin_set
__swig_getmethods__["move_origin"] = _libvncxx.InsAdvancedConfigurationRegister_move_origin_get
if _newclass:
move_origin = _swig_property(_libvncxx.InsAdvancedConfigurationRegister_move_origin_get, _libvncxx.InsAdvancedConfigurationRegister_move_origin_set)
__swig_setmethods__["gps_timeout"] = _libvncxx.InsAdvancedConfigurationRegister_gps_timeout_set
__swig_getmethods__["gps_timeout"] = _libvncxx.InsAdvancedConfigurationRegister_gps_timeout_get
if _newclass:
gps_timeout = _swig_property(_libvncxx.InsAdvancedConfigurationRegister_gps_timeout_get, _libvncxx.InsAdvancedConfigurationRegister_gps_timeout_set)
__swig_setmethods__["delta_limit_pos"] = _libvncxx.InsAdvancedConfigurationRegister_delta_limit_pos_set
__swig_getmethods__["delta_limit_pos"] = _libvncxx.InsAdvancedConfigurationRegister_delta_limit_pos_get
if _newclass:
delta_limit_pos = _swig_property(_libvncxx.InsAdvancedConfigurationRegister_delta_limit_pos_get, _libvncxx.InsAdvancedConfigurationRegister_delta_limit_pos_set)
__swig_setmethods__["delta_limit_vel"] = _libvncxx.InsAdvancedConfigurationRegister_delta_limit_vel_set
__swig_getmethods__["delta_limit_vel"] = _libvncxx.InsAdvancedConfigurationRegister_delta_limit_vel_get
if _newclass:
delta_limit_vel = _swig_property(_libvncxx.InsAdvancedConfigurationRegister_delta_limit_vel_get, _libvncxx.InsAdvancedConfigurationRegister_delta_limit_vel_set)
__swig_setmethods__["min_pos_uncertainty"] = _libvncxx.InsAdvancedConfigurationRegister_min_pos_uncertainty_set
__swig_getmethods__["min_pos_uncertainty"] = _libvncxx.InsAdvancedConfigurationRegister_min_pos_uncertainty_get
if _newclass:
min_pos_uncertainty = _swig_property(_libvncxx.InsAdvancedConfigurationRegister_min_pos_uncertainty_get, _libvncxx.InsAdvancedConfigurationRegister_min_pos_uncertainty_set)
__swig_setmethods__["min_vel_uncertainty"] = _libvncxx.InsAdvancedConfigurationRegister_min_vel_uncertainty_set
__swig_getmethods__["min_vel_uncertainty"] = _libvncxx.InsAdvancedConfigurationRegister_min_vel_uncertainty_get
if _newclass:
min_vel_uncertainty = _swig_property(_libvncxx.InsAdvancedConfigurationRegister_min_vel_uncertainty_get, _libvncxx.InsAdvancedConfigurationRegister_min_vel_uncertainty_set)
def __init__(self, *args):
"""
__init__(vn::sensors::InsAdvancedConfigurationRegister self) -> InsAdvancedConfigurationRegister
__init__(vn::sensors::InsAdvancedConfigurationRegister self, bool useMagIn, bool usePresIn, bool posAttIn, bool velAttIn, bool velBiasIn, vn::protocol::uart::FoamInit useFoamIn, uint8_t gpsCovTypeIn, uint8_t velCountIn, float velInitIn, float moveOriginIn, float gpsTimeoutIn, float deltaLimitPosIn, float deltaLimitVelIn, float minPosUncertaintyIn, float minVelUncertaintyIn) -> InsAdvancedConfigurationRegister
"""
this = _libvncxx.new_InsAdvancedConfigurationRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_InsAdvancedConfigurationRegister
__del__ = lambda self: None
InsAdvancedConfigurationRegister_swigregister = _libvncxx.InsAdvancedConfigurationRegister_swigregister
InsAdvancedConfigurationRegister_swigregister(InsAdvancedConfigurationRegister)
class InsStateLlaRegister(_object):
"""Proxy of C++ vn::sensors::InsStateLlaRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, InsStateLlaRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, InsStateLlaRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["yaw_pitch_roll"] = _libvncxx.InsStateLlaRegister_yaw_pitch_roll_set
__swig_getmethods__["yaw_pitch_roll"] = _libvncxx.InsStateLlaRegister_yaw_pitch_roll_get
if _newclass:
yaw_pitch_roll = _swig_property(_libvncxx.InsStateLlaRegister_yaw_pitch_roll_get, _libvncxx.InsStateLlaRegister_yaw_pitch_roll_set)
__swig_setmethods__["position"] = _libvncxx.InsStateLlaRegister_position_set
__swig_getmethods__["position"] = _libvncxx.InsStateLlaRegister_position_get
if _newclass:
position = _swig_property(_libvncxx.InsStateLlaRegister_position_get, _libvncxx.InsStateLlaRegister_position_set)
__swig_setmethods__["velocity"] = _libvncxx.InsStateLlaRegister_velocity_set
__swig_getmethods__["velocity"] = _libvncxx.InsStateLlaRegister_velocity_get
if _newclass:
velocity = _swig_property(_libvncxx.InsStateLlaRegister_velocity_get, _libvncxx.InsStateLlaRegister_velocity_set)
__swig_setmethods__["accel"] = _libvncxx.InsStateLlaRegister_accel_set
__swig_getmethods__["accel"] = _libvncxx.InsStateLlaRegister_accel_get
if _newclass:
accel = _swig_property(_libvncxx.InsStateLlaRegister_accel_get, _libvncxx.InsStateLlaRegister_accel_set)
__swig_setmethods__["angular_rate"] = _libvncxx.InsStateLlaRegister_angular_rate_set
__swig_getmethods__["angular_rate"] = _libvncxx.InsStateLlaRegister_angular_rate_get
if _newclass:
angular_rate = _swig_property(_libvncxx.InsStateLlaRegister_angular_rate_get, _libvncxx.InsStateLlaRegister_angular_rate_set)
def __init__(self, *args):
"""
__init__(vn::sensors::InsStateLlaRegister self) -> InsStateLlaRegister
__init__(vn::sensors::InsStateLlaRegister self, vec3f yawPitchRollIn, vec3d positionIn, vec3f velocityIn, vec3f accelIn, vec3f angularRateIn) -> InsStateLlaRegister
"""
this = _libvncxx.new_InsStateLlaRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_InsStateLlaRegister
__del__ = lambda self: None
InsStateLlaRegister_swigregister = _libvncxx.InsStateLlaRegister_swigregister
InsStateLlaRegister_swigregister(InsStateLlaRegister)
class InsStateEcefRegister(_object):
"""Proxy of C++ vn::sensors::InsStateEcefRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, InsStateEcefRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, InsStateEcefRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["yaw_pitch_roll"] = _libvncxx.InsStateEcefRegister_yaw_pitch_roll_set
__swig_getmethods__["yaw_pitch_roll"] = _libvncxx.InsStateEcefRegister_yaw_pitch_roll_get
if _newclass:
yaw_pitch_roll = _swig_property(_libvncxx.InsStateEcefRegister_yaw_pitch_roll_get, _libvncxx.InsStateEcefRegister_yaw_pitch_roll_set)
__swig_setmethods__["position"] = _libvncxx.InsStateEcefRegister_position_set
__swig_getmethods__["position"] = _libvncxx.InsStateEcefRegister_position_get
if _newclass:
position = _swig_property(_libvncxx.InsStateEcefRegister_position_get, _libvncxx.InsStateEcefRegister_position_set)
__swig_setmethods__["velocity"] = _libvncxx.InsStateEcefRegister_velocity_set
__swig_getmethods__["velocity"] = _libvncxx.InsStateEcefRegister_velocity_get
if _newclass:
velocity = _swig_property(_libvncxx.InsStateEcefRegister_velocity_get, _libvncxx.InsStateEcefRegister_velocity_set)
__swig_setmethods__["accel"] = _libvncxx.InsStateEcefRegister_accel_set
__swig_getmethods__["accel"] = _libvncxx.InsStateEcefRegister_accel_get
if _newclass:
accel = _swig_property(_libvncxx.InsStateEcefRegister_accel_get, _libvncxx.InsStateEcefRegister_accel_set)
__swig_setmethods__["angular_rate"] = _libvncxx.InsStateEcefRegister_angular_rate_set
__swig_getmethods__["angular_rate"] = _libvncxx.InsStateEcefRegister_angular_rate_get
if _newclass:
angular_rate = _swig_property(_libvncxx.InsStateEcefRegister_angular_rate_get, _libvncxx.InsStateEcefRegister_angular_rate_set)
def __init__(self, *args):
"""
__init__(vn::sensors::InsStateEcefRegister self) -> InsStateEcefRegister
__init__(vn::sensors::InsStateEcefRegister self, vec3f yawPitchRollIn, vec3d positionIn, vec3f velocityIn, vec3f accelIn, vec3f angularRateIn) -> InsStateEcefRegister
"""
this = _libvncxx.new_InsStateEcefRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_InsStateEcefRegister
__del__ = lambda self: None
InsStateEcefRegister_swigregister = _libvncxx.InsStateEcefRegister_swigregister
InsStateEcefRegister_swigregister(InsStateEcefRegister)
class StartupFilterBiasEstimateRegister(_object):
"""Proxy of C++ vn::sensors::StartupFilterBiasEstimateRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, StartupFilterBiasEstimateRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, StartupFilterBiasEstimateRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["gyro_bias"] = _libvncxx.StartupFilterBiasEstimateRegister_gyro_bias_set
__swig_getmethods__["gyro_bias"] = _libvncxx.StartupFilterBiasEstimateRegister_gyro_bias_get
if _newclass:
gyro_bias = _swig_property(_libvncxx.StartupFilterBiasEstimateRegister_gyro_bias_get, _libvncxx.StartupFilterBiasEstimateRegister_gyro_bias_set)
__swig_setmethods__["accel_bias"] = _libvncxx.StartupFilterBiasEstimateRegister_accel_bias_set
__swig_getmethods__["accel_bias"] = _libvncxx.StartupFilterBiasEstimateRegister_accel_bias_get
if _newclass:
accel_bias = _swig_property(_libvncxx.StartupFilterBiasEstimateRegister_accel_bias_get, _libvncxx.StartupFilterBiasEstimateRegister_accel_bias_set)
__swig_setmethods__["pressure_bias"] = _libvncxx.StartupFilterBiasEstimateRegister_pressure_bias_set
__swig_getmethods__["pressure_bias"] = _libvncxx.StartupFilterBiasEstimateRegister_pressure_bias_get
if _newclass:
pressure_bias = _swig_property(_libvncxx.StartupFilterBiasEstimateRegister_pressure_bias_get, _libvncxx.StartupFilterBiasEstimateRegister_pressure_bias_set)
def __init__(self, *args):
"""
__init__(vn::sensors::StartupFilterBiasEstimateRegister self) -> StartupFilterBiasEstimateRegister
__init__(vn::sensors::StartupFilterBiasEstimateRegister self, vec3f gyroBiasIn, vec3f accelBiasIn, float pressureBiasIn) -> StartupFilterBiasEstimateRegister
"""
this = _libvncxx.new_StartupFilterBiasEstimateRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_StartupFilterBiasEstimateRegister
__del__ = lambda self: None
StartupFilterBiasEstimateRegister_swigregister = _libvncxx.StartupFilterBiasEstimateRegister_swigregister
StartupFilterBiasEstimateRegister_swigregister(StartupFilterBiasEstimateRegister)
class DeltaThetaAndDeltaVelocityRegister(_object):
"""Proxy of C++ vn::sensors::DeltaThetaAndDeltaVelocityRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, DeltaThetaAndDeltaVelocityRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, DeltaThetaAndDeltaVelocityRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["delta_time"] = _libvncxx.DeltaThetaAndDeltaVelocityRegister_delta_time_set
__swig_getmethods__["delta_time"] = _libvncxx.DeltaThetaAndDeltaVelocityRegister_delta_time_get
if _newclass:
delta_time = _swig_property(_libvncxx.DeltaThetaAndDeltaVelocityRegister_delta_time_get, _libvncxx.DeltaThetaAndDeltaVelocityRegister_delta_time_set)
__swig_setmethods__["delta_theta"] = _libvncxx.DeltaThetaAndDeltaVelocityRegister_delta_theta_set
__swig_getmethods__["delta_theta"] = _libvncxx.DeltaThetaAndDeltaVelocityRegister_delta_theta_get
if _newclass:
delta_theta = _swig_property(_libvncxx.DeltaThetaAndDeltaVelocityRegister_delta_theta_get, _libvncxx.DeltaThetaAndDeltaVelocityRegister_delta_theta_set)
__swig_setmethods__["delta_velocity"] = _libvncxx.DeltaThetaAndDeltaVelocityRegister_delta_velocity_set
__swig_getmethods__["delta_velocity"] = _libvncxx.DeltaThetaAndDeltaVelocityRegister_delta_velocity_get
if _newclass:
delta_velocity = _swig_property(_libvncxx.DeltaThetaAndDeltaVelocityRegister_delta_velocity_get, _libvncxx.DeltaThetaAndDeltaVelocityRegister_delta_velocity_set)
def __init__(self, *args):
"""
__init__(vn::sensors::DeltaThetaAndDeltaVelocityRegister self) -> DeltaThetaAndDeltaVelocityRegister
__init__(vn::sensors::DeltaThetaAndDeltaVelocityRegister self, float deltaTimeIn, vec3f deltaThetaIn, vec3f deltaVelocityIn) -> DeltaThetaAndDeltaVelocityRegister
"""
this = _libvncxx.new_DeltaThetaAndDeltaVelocityRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_DeltaThetaAndDeltaVelocityRegister
__del__ = lambda self: None
DeltaThetaAndDeltaVelocityRegister_swigregister = _libvncxx.DeltaThetaAndDeltaVelocityRegister_swigregister
DeltaThetaAndDeltaVelocityRegister_swigregister(DeltaThetaAndDeltaVelocityRegister)
class DeltaThetaAndDeltaVelocityConfigurationRegister(_object):
"""Proxy of C++ vn::sensors::DeltaThetaAndDeltaVelocityConfigurationRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, DeltaThetaAndDeltaVelocityConfigurationRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, DeltaThetaAndDeltaVelocityConfigurationRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["integration_frame"] = _libvncxx.DeltaThetaAndDeltaVelocityConfigurationRegister_integration_frame_set
__swig_getmethods__["integration_frame"] = _libvncxx.DeltaThetaAndDeltaVelocityConfigurationRegister_integration_frame_get
if _newclass:
integration_frame = _swig_property(_libvncxx.DeltaThetaAndDeltaVelocityConfigurationRegister_integration_frame_get, _libvncxx.DeltaThetaAndDeltaVelocityConfigurationRegister_integration_frame_set)
__swig_setmethods__["gyro_compensation"] = _libvncxx.DeltaThetaAndDeltaVelocityConfigurationRegister_gyro_compensation_set
__swig_getmethods__["gyro_compensation"] = _libvncxx.DeltaThetaAndDeltaVelocityConfigurationRegister_gyro_compensation_get
if _newclass:
gyro_compensation = _swig_property(_libvncxx.DeltaThetaAndDeltaVelocityConfigurationRegister_gyro_compensation_get, _libvncxx.DeltaThetaAndDeltaVelocityConfigurationRegister_gyro_compensation_set)
__swig_setmethods__["accel_compensation"] = _libvncxx.DeltaThetaAndDeltaVelocityConfigurationRegister_accel_compensation_set
__swig_getmethods__["accel_compensation"] = _libvncxx.DeltaThetaAndDeltaVelocityConfigurationRegister_accel_compensation_get
if _newclass:
accel_compensation = _swig_property(_libvncxx.DeltaThetaAndDeltaVelocityConfigurationRegister_accel_compensation_get, _libvncxx.DeltaThetaAndDeltaVelocityConfigurationRegister_accel_compensation_set)
def __init__(self, *args):
"""
__init__(vn::sensors::DeltaThetaAndDeltaVelocityConfigurationRegister self) -> DeltaThetaAndDeltaVelocityConfigurationRegister
__init__(vn::sensors::DeltaThetaAndDeltaVelocityConfigurationRegister self, vn::protocol::uart::IntegrationFrame integrationFrameIn, vn::protocol::uart::CompensationMode gyroCompensationIn, vn::protocol::uart::CompensationMode accelCompensationIn) -> DeltaThetaAndDeltaVelocityConfigurationRegister
"""
this = _libvncxx.new_DeltaThetaAndDeltaVelocityConfigurationRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_DeltaThetaAndDeltaVelocityConfigurationRegister
__del__ = lambda self: None
DeltaThetaAndDeltaVelocityConfigurationRegister_swigregister = _libvncxx.DeltaThetaAndDeltaVelocityConfigurationRegister_swigregister
DeltaThetaAndDeltaVelocityConfigurationRegister_swigregister(DeltaThetaAndDeltaVelocityConfigurationRegister)
class ReferenceVectorConfigurationRegister(_object):
"""Proxy of C++ vn::sensors::ReferenceVectorConfigurationRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, ReferenceVectorConfigurationRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, ReferenceVectorConfigurationRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["use_mag_model"] = _libvncxx.ReferenceVectorConfigurationRegister_use_mag_model_set
__swig_getmethods__["use_mag_model"] = _libvncxx.ReferenceVectorConfigurationRegister_use_mag_model_get
if _newclass:
use_mag_model = _swig_property(_libvncxx.ReferenceVectorConfigurationRegister_use_mag_model_get, _libvncxx.ReferenceVectorConfigurationRegister_use_mag_model_set)
__swig_setmethods__["use_gravity_model"] = _libvncxx.ReferenceVectorConfigurationRegister_use_gravity_model_set
__swig_getmethods__["use_gravity_model"] = _libvncxx.ReferenceVectorConfigurationRegister_use_gravity_model_get
if _newclass:
use_gravity_model = _swig_property(_libvncxx.ReferenceVectorConfigurationRegister_use_gravity_model_get, _libvncxx.ReferenceVectorConfigurationRegister_use_gravity_model_set)
__swig_setmethods__["recalc_threshold"] = _libvncxx.ReferenceVectorConfigurationRegister_recalc_threshold_set
__swig_getmethods__["recalc_threshold"] = _libvncxx.ReferenceVectorConfigurationRegister_recalc_threshold_get
if _newclass:
recalc_threshold = _swig_property(_libvncxx.ReferenceVectorConfigurationRegister_recalc_threshold_get, _libvncxx.ReferenceVectorConfigurationRegister_recalc_threshold_set)
__swig_setmethods__["year"] = _libvncxx.ReferenceVectorConfigurationRegister_year_set
__swig_getmethods__["year"] = _libvncxx.ReferenceVectorConfigurationRegister_year_get
if _newclass:
year = _swig_property(_libvncxx.ReferenceVectorConfigurationRegister_year_get, _libvncxx.ReferenceVectorConfigurationRegister_year_set)
__swig_setmethods__["position"] = _libvncxx.ReferenceVectorConfigurationRegister_position_set
__swig_getmethods__["position"] = _libvncxx.ReferenceVectorConfigurationRegister_position_get
if _newclass:
position = _swig_property(_libvncxx.ReferenceVectorConfigurationRegister_position_get, _libvncxx.ReferenceVectorConfigurationRegister_position_set)
def __init__(self, *args):
"""
__init__(vn::sensors::ReferenceVectorConfigurationRegister self) -> ReferenceVectorConfigurationRegister
__init__(vn::sensors::ReferenceVectorConfigurationRegister self, bool useMagModelIn, bool useGravityModelIn, uint32_t recalcThresholdIn, float yearIn, vec3d positionIn) -> ReferenceVectorConfigurationRegister
"""
this = _libvncxx.new_ReferenceVectorConfigurationRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_ReferenceVectorConfigurationRegister
__del__ = lambda self: None
ReferenceVectorConfigurationRegister_swigregister = _libvncxx.ReferenceVectorConfigurationRegister_swigregister
ReferenceVectorConfigurationRegister_swigregister(ReferenceVectorConfigurationRegister)
class GyroCompensationRegister(_object):
"""Proxy of C++ vn::sensors::GyroCompensationRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, GyroCompensationRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, GyroCompensationRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["c"] = _libvncxx.GyroCompensationRegister_c_set
__swig_getmethods__["c"] = _libvncxx.GyroCompensationRegister_c_get
if _newclass:
c = _swig_property(_libvncxx.GyroCompensationRegister_c_get, _libvncxx.GyroCompensationRegister_c_set)
__swig_setmethods__["b"] = _libvncxx.GyroCompensationRegister_b_set
__swig_getmethods__["b"] = _libvncxx.GyroCompensationRegister_b_get
if _newclass:
b = _swig_property(_libvncxx.GyroCompensationRegister_b_get, _libvncxx.GyroCompensationRegister_b_set)
def __init__(self, *args):
"""
__init__(vn::sensors::GyroCompensationRegister self) -> GyroCompensationRegister
__init__(vn::sensors::GyroCompensationRegister self, mat3f cIn, vec3f bIn) -> GyroCompensationRegister
"""
this = _libvncxx.new_GyroCompensationRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_GyroCompensationRegister
__del__ = lambda self: None
GyroCompensationRegister_swigregister = _libvncxx.GyroCompensationRegister_swigregister
GyroCompensationRegister_swigregister(GyroCompensationRegister)
class ImuFilteringConfigurationRegister(_object):
"""Proxy of C++ vn::sensors::ImuFilteringConfigurationRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, ImuFilteringConfigurationRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, ImuFilteringConfigurationRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["mag_window_size"] = _libvncxx.ImuFilteringConfigurationRegister_mag_window_size_set
__swig_getmethods__["mag_window_size"] = _libvncxx.ImuFilteringConfigurationRegister_mag_window_size_get
if _newclass:
mag_window_size = _swig_property(_libvncxx.ImuFilteringConfigurationRegister_mag_window_size_get, _libvncxx.ImuFilteringConfigurationRegister_mag_window_size_set)
__swig_setmethods__["accel_window_size"] = _libvncxx.ImuFilteringConfigurationRegister_accel_window_size_set
__swig_getmethods__["accel_window_size"] = _libvncxx.ImuFilteringConfigurationRegister_accel_window_size_get
if _newclass:
accel_window_size = _swig_property(_libvncxx.ImuFilteringConfigurationRegister_accel_window_size_get, _libvncxx.ImuFilteringConfigurationRegister_accel_window_size_set)
__swig_setmethods__["gyro_window_size"] = _libvncxx.ImuFilteringConfigurationRegister_gyro_window_size_set
__swig_getmethods__["gyro_window_size"] = _libvncxx.ImuFilteringConfigurationRegister_gyro_window_size_get
if _newclass:
gyro_window_size = _swig_property(_libvncxx.ImuFilteringConfigurationRegister_gyro_window_size_get, _libvncxx.ImuFilteringConfigurationRegister_gyro_window_size_set)
__swig_setmethods__["temp_window_size"] = _libvncxx.ImuFilteringConfigurationRegister_temp_window_size_set
__swig_getmethods__["temp_window_size"] = _libvncxx.ImuFilteringConfigurationRegister_temp_window_size_get
if _newclass:
temp_window_size = _swig_property(_libvncxx.ImuFilteringConfigurationRegister_temp_window_size_get, _libvncxx.ImuFilteringConfigurationRegister_temp_window_size_set)
__swig_setmethods__["pres_window_size"] = _libvncxx.ImuFilteringConfigurationRegister_pres_window_size_set
__swig_getmethods__["pres_window_size"] = _libvncxx.ImuFilteringConfigurationRegister_pres_window_size_get
if _newclass:
pres_window_size = _swig_property(_libvncxx.ImuFilteringConfigurationRegister_pres_window_size_get, _libvncxx.ImuFilteringConfigurationRegister_pres_window_size_set)
__swig_setmethods__["mag_filter_mode"] = _libvncxx.ImuFilteringConfigurationRegister_mag_filter_mode_set
__swig_getmethods__["mag_filter_mode"] = _libvncxx.ImuFilteringConfigurationRegister_mag_filter_mode_get
if _newclass:
mag_filter_mode = _swig_property(_libvncxx.ImuFilteringConfigurationRegister_mag_filter_mode_get, _libvncxx.ImuFilteringConfigurationRegister_mag_filter_mode_set)
__swig_setmethods__["accel_filter_mode"] = _libvncxx.ImuFilteringConfigurationRegister_accel_filter_mode_set
__swig_getmethods__["accel_filter_mode"] = _libvncxx.ImuFilteringConfigurationRegister_accel_filter_mode_get
if _newclass:
accel_filter_mode = _swig_property(_libvncxx.ImuFilteringConfigurationRegister_accel_filter_mode_get, _libvncxx.ImuFilteringConfigurationRegister_accel_filter_mode_set)
__swig_setmethods__["gyro_filter_mode"] = _libvncxx.ImuFilteringConfigurationRegister_gyro_filter_mode_set
__swig_getmethods__["gyro_filter_mode"] = _libvncxx.ImuFilteringConfigurationRegister_gyro_filter_mode_get
if _newclass:
gyro_filter_mode = _swig_property(_libvncxx.ImuFilteringConfigurationRegister_gyro_filter_mode_get, _libvncxx.ImuFilteringConfigurationRegister_gyro_filter_mode_set)
__swig_setmethods__["temp_filter_mode"] = _libvncxx.ImuFilteringConfigurationRegister_temp_filter_mode_set
__swig_getmethods__["temp_filter_mode"] = _libvncxx.ImuFilteringConfigurationRegister_temp_filter_mode_get
if _newclass:
temp_filter_mode = _swig_property(_libvncxx.ImuFilteringConfigurationRegister_temp_filter_mode_get, _libvncxx.ImuFilteringConfigurationRegister_temp_filter_mode_set)
__swig_setmethods__["pres_filter_mode"] = _libvncxx.ImuFilteringConfigurationRegister_pres_filter_mode_set
__swig_getmethods__["pres_filter_mode"] = _libvncxx.ImuFilteringConfigurationRegister_pres_filter_mode_get
if _newclass:
pres_filter_mode = _swig_property(_libvncxx.ImuFilteringConfigurationRegister_pres_filter_mode_get, _libvncxx.ImuFilteringConfigurationRegister_pres_filter_mode_set)
def __init__(self, *args):
"""
__init__(vn::sensors::ImuFilteringConfigurationRegister self) -> ImuFilteringConfigurationRegister
__init__(vn::sensors::ImuFilteringConfigurationRegister self, uint16_t magWindowSizeIn, uint16_t accelWindowSizeIn, uint16_t gyroWindowSizeIn, uint16_t tempWindowSizeIn, uint16_t presWindowSizeIn, vn::protocol::uart::FilterMode magFilterModeIn, vn::protocol::uart::FilterMode accelFilterModeIn, vn::protocol::uart::FilterMode gyroFilterModeIn, vn::protocol::uart::FilterMode tempFilterModeIn, vn::protocol::uart::FilterMode presFilterModeIn) -> ImuFilteringConfigurationRegister
"""
this = _libvncxx.new_ImuFilteringConfigurationRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_ImuFilteringConfigurationRegister
__del__ = lambda self: None
ImuFilteringConfigurationRegister_swigregister = _libvncxx.ImuFilteringConfigurationRegister_swigregister
ImuFilteringConfigurationRegister_swigregister(ImuFilteringConfigurationRegister)
class GpsCompassBaselineRegister(_object):
"""Proxy of C++ vn::sensors::GpsCompassBaselineRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, GpsCompassBaselineRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, GpsCompassBaselineRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["position"] = _libvncxx.GpsCompassBaselineRegister_position_set
__swig_getmethods__["position"] = _libvncxx.GpsCompassBaselineRegister_position_get
if _newclass:
position = _swig_property(_libvncxx.GpsCompassBaselineRegister_position_get, _libvncxx.GpsCompassBaselineRegister_position_set)
__swig_setmethods__["uncertainty"] = _libvncxx.GpsCompassBaselineRegister_uncertainty_set
__swig_getmethods__["uncertainty"] = _libvncxx.GpsCompassBaselineRegister_uncertainty_get
if _newclass:
uncertainty = _swig_property(_libvncxx.GpsCompassBaselineRegister_uncertainty_get, _libvncxx.GpsCompassBaselineRegister_uncertainty_set)
def __init__(self, *args):
"""
__init__(vn::sensors::GpsCompassBaselineRegister self) -> GpsCompassBaselineRegister
__init__(vn::sensors::GpsCompassBaselineRegister self, vec3f positionIn, vec3f uncertaintyIn) -> GpsCompassBaselineRegister
"""
this = _libvncxx.new_GpsCompassBaselineRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_GpsCompassBaselineRegister
__del__ = lambda self: None
GpsCompassBaselineRegister_swigregister = _libvncxx.GpsCompassBaselineRegister_swigregister
GpsCompassBaselineRegister_swigregister(GpsCompassBaselineRegister)
class GpsCompassEstimatedBaselineRegister(_object):
"""Proxy of C++ vn::sensors::GpsCompassEstimatedBaselineRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, GpsCompassEstimatedBaselineRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, GpsCompassEstimatedBaselineRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["est_baseline_used"] = _libvncxx.GpsCompassEstimatedBaselineRegister_est_baseline_used_set
__swig_getmethods__["est_baseline_used"] = _libvncxx.GpsCompassEstimatedBaselineRegister_est_baseline_used_get
if _newclass:
est_baseline_used = _swig_property(_libvncxx.GpsCompassEstimatedBaselineRegister_est_baseline_used_get, _libvncxx.GpsCompassEstimatedBaselineRegister_est_baseline_used_set)
__swig_setmethods__["num_meas"] = _libvncxx.GpsCompassEstimatedBaselineRegister_num_meas_set
__swig_getmethods__["num_meas"] = _libvncxx.GpsCompassEstimatedBaselineRegister_num_meas_get
if _newclass:
num_meas = _swig_property(_libvncxx.GpsCompassEstimatedBaselineRegister_num_meas_get, _libvncxx.GpsCompassEstimatedBaselineRegister_num_meas_set)
__swig_setmethods__["position"] = _libvncxx.GpsCompassEstimatedBaselineRegister_position_set
__swig_getmethods__["position"] = _libvncxx.GpsCompassEstimatedBaselineRegister_position_get
if _newclass:
position = _swig_property(_libvncxx.GpsCompassEstimatedBaselineRegister_position_get, _libvncxx.GpsCompassEstimatedBaselineRegister_position_set)
__swig_setmethods__["uncertainty"] = _libvncxx.GpsCompassEstimatedBaselineRegister_uncertainty_set
__swig_getmethods__["uncertainty"] = _libvncxx.GpsCompassEstimatedBaselineRegister_uncertainty_get
if _newclass:
uncertainty = _swig_property(_libvncxx.GpsCompassEstimatedBaselineRegister_uncertainty_get, _libvncxx.GpsCompassEstimatedBaselineRegister_uncertainty_set)
def __init__(self, *args):
"""
__init__(vn::sensors::GpsCompassEstimatedBaselineRegister self) -> GpsCompassEstimatedBaselineRegister
__init__(vn::sensors::GpsCompassEstimatedBaselineRegister self, bool estBaselineUsedIn, uint16_t numMeasIn, vec3f positionIn, vec3f uncertaintyIn) -> GpsCompassEstimatedBaselineRegister
"""
this = _libvncxx.new_GpsCompassEstimatedBaselineRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_GpsCompassEstimatedBaselineRegister
__del__ = lambda self: None
GpsCompassEstimatedBaselineRegister_swigregister = _libvncxx.GpsCompassEstimatedBaselineRegister_swigregister
GpsCompassEstimatedBaselineRegister_swigregister(GpsCompassEstimatedBaselineRegister)
class ImuRateConfigurationRegister(_object):
"""Proxy of C++ vn::sensors::ImuRateConfigurationRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, ImuRateConfigurationRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, ImuRateConfigurationRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["imu_rate"] = _libvncxx.ImuRateConfigurationRegister_imu_rate_set
__swig_getmethods__["imu_rate"] = _libvncxx.ImuRateConfigurationRegister_imu_rate_get
if _newclass:
imu_rate = _swig_property(_libvncxx.ImuRateConfigurationRegister_imu_rate_get, _libvncxx.ImuRateConfigurationRegister_imu_rate_set)
__swig_setmethods__["nav_divisor"] = _libvncxx.ImuRateConfigurationRegister_nav_divisor_set
__swig_getmethods__["nav_divisor"] = _libvncxx.ImuRateConfigurationRegister_nav_divisor_get
if _newclass:
nav_divisor = _swig_property(_libvncxx.ImuRateConfigurationRegister_nav_divisor_get, _libvncxx.ImuRateConfigurationRegister_nav_divisor_set)
__swig_setmethods__["filter_target_rate"] = _libvncxx.ImuRateConfigurationRegister_filter_target_rate_set
__swig_getmethods__["filter_target_rate"] = _libvncxx.ImuRateConfigurationRegister_filter_target_rate_get
if _newclass:
filter_target_rate = _swig_property(_libvncxx.ImuRateConfigurationRegister_filter_target_rate_get, _libvncxx.ImuRateConfigurationRegister_filter_target_rate_set)
__swig_setmethods__["filter_min_rate"] = _libvncxx.ImuRateConfigurationRegister_filter_min_rate_set
__swig_getmethods__["filter_min_rate"] = _libvncxx.ImuRateConfigurationRegister_filter_min_rate_get
if _newclass:
filter_min_rate = _swig_property(_libvncxx.ImuRateConfigurationRegister_filter_min_rate_get, _libvncxx.ImuRateConfigurationRegister_filter_min_rate_set)
def __init__(self, *args):
"""
__init__(vn::sensors::ImuRateConfigurationRegister self) -> ImuRateConfigurationRegister
__init__(vn::sensors::ImuRateConfigurationRegister self, uint16_t imuRateIn, uint16_t navDivisorIn, float filterTargetRateIn, float filterMinRateIn) -> ImuRateConfigurationRegister
"""
this = _libvncxx.new_ImuRateConfigurationRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_ImuRateConfigurationRegister
__del__ = lambda self: None
ImuRateConfigurationRegister_swigregister = _libvncxx.ImuRateConfigurationRegister_swigregister
ImuRateConfigurationRegister_swigregister(ImuRateConfigurationRegister)
class YawPitchRollTrueBodyAccelerationAndAngularRatesRegister(_object):
"""Proxy of C++ vn::sensors::YawPitchRollTrueBodyAccelerationAndAngularRatesRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, YawPitchRollTrueBodyAccelerationAndAngularRatesRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, YawPitchRollTrueBodyAccelerationAndAngularRatesRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["yaw_pitch_roll"] = _libvncxx.YawPitchRollTrueBodyAccelerationAndAngularRatesRegister_yaw_pitch_roll_set
__swig_getmethods__["yaw_pitch_roll"] = _libvncxx.YawPitchRollTrueBodyAccelerationAndAngularRatesRegister_yaw_pitch_roll_get
if _newclass:
yaw_pitch_roll = _swig_property(_libvncxx.YawPitchRollTrueBodyAccelerationAndAngularRatesRegister_yaw_pitch_roll_get, _libvncxx.YawPitchRollTrueBodyAccelerationAndAngularRatesRegister_yaw_pitch_roll_set)
__swig_setmethods__["body_accel"] = _libvncxx.YawPitchRollTrueBodyAccelerationAndAngularRatesRegister_body_accel_set
__swig_getmethods__["body_accel"] = _libvncxx.YawPitchRollTrueBodyAccelerationAndAngularRatesRegister_body_accel_get
if _newclass:
body_accel = _swig_property(_libvncxx.YawPitchRollTrueBodyAccelerationAndAngularRatesRegister_body_accel_get, _libvncxx.YawPitchRollTrueBodyAccelerationAndAngularRatesRegister_body_accel_set)
__swig_setmethods__["gyro"] = _libvncxx.YawPitchRollTrueBodyAccelerationAndAngularRatesRegister_gyro_set
__swig_getmethods__["gyro"] = _libvncxx.YawPitchRollTrueBodyAccelerationAndAngularRatesRegister_gyro_get
if _newclass:
gyro = _swig_property(_libvncxx.YawPitchRollTrueBodyAccelerationAndAngularRatesRegister_gyro_get, _libvncxx.YawPitchRollTrueBodyAccelerationAndAngularRatesRegister_gyro_set)
def __init__(self, *args):
"""
__init__(vn::sensors::YawPitchRollTrueBodyAccelerationAndAngularRatesRegister self) -> YawPitchRollTrueBodyAccelerationAndAngularRatesRegister
__init__(vn::sensors::YawPitchRollTrueBodyAccelerationAndAngularRatesRegister self, vec3f yawPitchRollIn, vec3f bodyAccelIn, vec3f gyroIn) -> YawPitchRollTrueBodyAccelerationAndAngularRatesRegister
"""
this = _libvncxx.new_YawPitchRollTrueBodyAccelerationAndAngularRatesRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_YawPitchRollTrueBodyAccelerationAndAngularRatesRegister
__del__ = lambda self: None
YawPitchRollTrueBodyAccelerationAndAngularRatesRegister_swigregister = _libvncxx.YawPitchRollTrueBodyAccelerationAndAngularRatesRegister_swigregister
YawPitchRollTrueBodyAccelerationAndAngularRatesRegister_swigregister(YawPitchRollTrueBodyAccelerationAndAngularRatesRegister)
class YawPitchRollTrueInertialAccelerationAndAngularRatesRegister(_object):
"""Proxy of C++ vn::sensors::YawPitchRollTrueInertialAccelerationAndAngularRatesRegister class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, YawPitchRollTrueInertialAccelerationAndAngularRatesRegister, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, YawPitchRollTrueInertialAccelerationAndAngularRatesRegister, name)
__repr__ = _swig_repr
__swig_setmethods__["yaw_pitch_roll"] = _libvncxx.YawPitchRollTrueInertialAccelerationAndAngularRatesRegister_yaw_pitch_roll_set
__swig_getmethods__["yaw_pitch_roll"] = _libvncxx.YawPitchRollTrueInertialAccelerationAndAngularRatesRegister_yaw_pitch_roll_get
if _newclass:
yaw_pitch_roll = _swig_property(_libvncxx.YawPitchRollTrueInertialAccelerationAndAngularRatesRegister_yaw_pitch_roll_get, _libvncxx.YawPitchRollTrueInertialAccelerationAndAngularRatesRegister_yaw_pitch_roll_set)
__swig_setmethods__["inertial_accel"] = _libvncxx.YawPitchRollTrueInertialAccelerationAndAngularRatesRegister_inertial_accel_set
__swig_getmethods__["inertial_accel"] = _libvncxx.YawPitchRollTrueInertialAccelerationAndAngularRatesRegister_inertial_accel_get
if _newclass:
inertial_accel = _swig_property(_libvncxx.YawPitchRollTrueInertialAccelerationAndAngularRatesRegister_inertial_accel_get, _libvncxx.YawPitchRollTrueInertialAccelerationAndAngularRatesRegister_inertial_accel_set)
__swig_setmethods__["gyro"] = _libvncxx.YawPitchRollTrueInertialAccelerationAndAngularRatesRegister_gyro_set
__swig_getmethods__["gyro"] = _libvncxx.YawPitchRollTrueInertialAccelerationAndAngularRatesRegister_gyro_get
if _newclass:
gyro = _swig_property(_libvncxx.YawPitchRollTrueInertialAccelerationAndAngularRatesRegister_gyro_get, _libvncxx.YawPitchRollTrueInertialAccelerationAndAngularRatesRegister_gyro_set)
def __init__(self, *args):
"""
__init__(vn::sensors::YawPitchRollTrueInertialAccelerationAndAngularRatesRegister self) -> YawPitchRollTrueInertialAccelerationAndAngularRatesRegister
__init__(vn::sensors::YawPitchRollTrueInertialAccelerationAndAngularRatesRegister self, vec3f yawPitchRollIn, vec3f inertialAccelIn, vec3f gyroIn) -> YawPitchRollTrueInertialAccelerationAndAngularRatesRegister
"""
this = _libvncxx.new_YawPitchRollTrueInertialAccelerationAndAngularRatesRegister(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_YawPitchRollTrueInertialAccelerationAndAngularRatesRegister
__del__ = lambda self: None
YawPitchRollTrueInertialAccelerationAndAngularRatesRegister_swigregister = _libvncxx.YawPitchRollTrueInertialAccelerationAndAngularRatesRegister_swigregister
YawPitchRollTrueInertialAccelerationAndAngularRatesRegister_swigregister(YawPitchRollTrueInertialAccelerationAndAngularRatesRegister)
def str(*args):
"""
str(QuaternionMagneticAccelerationAndAngularRatesRegister reg) -> std::string
str(MagneticAccelerationAndAngularRatesRegister reg) -> std::string
str(MagneticAndGravityReferenceVectorsRegister reg) -> std::string
str(FilterMeasurementsVarianceParametersRegister reg) -> std::string
str(MagnetometerCompensationRegister reg) -> std::string
str(FilterActiveTuningParametersRegister reg) -> std::string
str(AccelerationCompensationRegister reg) -> std::string
str(YawPitchRollMagneticAccelerationAndAngularRatesRegister reg) -> std::string
str(CommunicationProtocolControlRegister reg) -> std::string
str(SynchronizationControlRegister reg) -> std::string
str(SynchronizationStatusRegister reg) -> std::string
str(FilterBasicControlRegister reg) -> std::string
str(VpeBasicControlRegister reg) -> std::string
str(VpeMagnetometerBasicTuningRegister reg) -> std::string
str(VpeMagnetometerAdvancedTuningRegister reg) -> std::string
str(VpeAccelerometerBasicTuningRegister reg) -> std::string
str(VpeAccelerometerAdvancedTuningRegister reg) -> std::string
str(VpeGyroBasicTuningRegister reg) -> std::string
str(MagnetometerCalibrationControlRegister reg) -> std::string
str(CalculatedMagnetometerCalibrationRegister reg) -> std::string
str(VelocityCompensationControlRegister reg) -> std::string
str(VelocityCompensationStatusRegister reg) -> std::string
str(ImuMeasurementsRegister reg) -> std::string
str(GpsConfigurationRegister reg) -> std::string
str(GpsSolutionLlaRegister reg) -> std::string
str(GpsSolutionEcefRegister reg) -> std::string
str(InsSolutionLlaRegister reg) -> std::string
str(InsSolutionEcefRegister reg) -> std::string
str(InsBasicConfigurationRegisterVn200 reg) -> std::string
str(InsBasicConfigurationRegisterVn300 reg) -> std::string
str(InsAdvancedConfigurationRegister reg) -> std::string
str(InsStateLlaRegister reg) -> std::string
str(InsStateEcefRegister reg) -> std::string
str(StartupFilterBiasEstimateRegister reg) -> std::string
str(DeltaThetaAndDeltaVelocityRegister reg) -> std::string
str(DeltaThetaAndDeltaVelocityConfigurationRegister reg) -> std::string
str(ReferenceVectorConfigurationRegister reg) -> std::string
str(GyroCompensationRegister reg) -> std::string
str(ImuFilteringConfigurationRegister reg) -> std::string
str(GpsCompassBaselineRegister reg) -> std::string
str(GpsCompassEstimatedBaselineRegister reg) -> std::string
str(ImuRateConfigurationRegister reg) -> std::string
str(YawPitchRollTrueBodyAccelerationAndAngularRatesRegister reg) -> std::string
str(YawPitchRollTrueInertialAccelerationAndAngularRatesRegister reg) -> std::string
"""
return _libvncxx.str(*args)
def parse(*args):
"""
parse(std::string const & arg1, vn::protocol::uart::AsciiAsync & val, bool allowSloppy=True) -> bool
parse(std::string const & arg1, vn::protocol::uart::AsciiAsync & val) -> bool
parse(std::string const & arg1, vn::protocol::uart::SyncInMode & val, bool allowSloppy=True) -> bool
parse(std::string const & arg1, vn::protocol::uart::SyncInMode & val) -> bool
parse(std::string const & arg1, vn::protocol::uart::SyncInEdge & val, bool allowSloppy=True) -> bool
parse(std::string const & arg1, vn::protocol::uart::SyncInEdge & val) -> bool
parse(std::string const & arg1, vn::protocol::uart::SyncOutMode & val, bool allowSloppy=True) -> bool
parse(std::string const & arg1, vn::protocol::uart::SyncOutMode & val) -> bool
parse(std::string const & arg1, vn::protocol::uart::SyncOutPolarity & val, bool allowSloppy=True) -> bool
parse(std::string const & arg1, vn::protocol::uart::SyncOutPolarity & val) -> bool
parse(std::string const & arg1, vn::protocol::uart::CountMode & val, bool allowSloppy=True) -> bool
parse(std::string const & arg1, vn::protocol::uart::CountMode & val) -> bool
parse(std::string const & arg1, vn::protocol::uart::StatusMode & val, bool allowSloppy=True) -> bool
parse(std::string const & arg1, vn::protocol::uart::StatusMode & val) -> bool
parse(std::string const & arg1, vn::protocol::uart::ChecksumMode & val, bool allowSloppy=True) -> bool
parse(std::string const & arg1, vn::protocol::uart::ChecksumMode & val) -> bool
parse(std::string const & arg1, vn::protocol::uart::ErrorMode & val, bool allowSloppy=True) -> bool
parse(std::string const & arg1, vn::protocol::uart::ErrorMode & val) -> bool
parse(std::string const & arg1, vn::protocol::uart::FilterMode & val, bool allowSloppy=True) -> bool
parse(std::string const & arg1, vn::protocol::uart::FilterMode & val) -> bool
parse(std::string const & arg1, vn::protocol::uart::IntegrationFrame & val, bool allowSloppy=True) -> bool
parse(std::string const & arg1, vn::protocol::uart::IntegrationFrame & val) -> bool
parse(std::string const & arg1, vn::protocol::uart::CompensationMode & val, bool allowSloppy=True) -> bool
parse(std::string const & arg1, vn::protocol::uart::CompensationMode & val) -> bool
parse(std::string const & arg1, vn::protocol::uart::GpsFix & val, bool allowSloppy=True) -> bool
parse(std::string const & arg1, vn::protocol::uart::GpsFix & val) -> bool
parse(std::string const & arg1, vn::protocol::uart::GpsMode & val, bool allowSloppy=True) -> bool
parse(std::string const & arg1, vn::protocol::uart::GpsMode & val) -> bool
parse(std::string const & arg1, vn::protocol::uart::PpsSource & val, bool allowSloppy=True) -> bool
parse(std::string const & arg1, vn::protocol::uart::PpsSource & val) -> bool
parse(std::string const & arg1, vn::protocol::uart::VpeEnable & val, bool allowSloppy=True) -> bool
parse(std::string const & arg1, vn::protocol::uart::VpeEnable & val) -> bool
parse(std::string const & arg1, vn::protocol::uart::HeadingMode & val, bool allowSloppy=True) -> bool
parse(std::string const & arg1, vn::protocol::uart::HeadingMode & val) -> bool
parse(std::string const & arg1, vn::protocol::uart::VpeMode & val, bool allowSloppy=True) -> bool
parse(std::string const & arg1, vn::protocol::uart::VpeMode & val) -> bool
parse(std::string const & arg1, vn::protocol::uart::Scenario & val, bool allowSloppy=True) -> bool
parse(std::string const & arg1, vn::protocol::uart::Scenario & val) -> bool
parse(std::string const & arg1, vn::protocol::uart::HsiMode & val, bool allowSloppy=True) -> bool
parse(std::string const & arg1, vn::protocol::uart::HsiMode & val) -> bool
parse(std::string const & arg1, vn::protocol::uart::HsiOutput & val, bool allowSloppy=True) -> bool
parse(std::string const & arg1, vn::protocol::uart::HsiOutput & val) -> bool
parse(std::string const & arg1, vn::protocol::uart::VelocityCompensationMode & val, bool allowSloppy=True) -> bool
parse(std::string const & arg1, vn::protocol::uart::VelocityCompensationMode & val) -> bool
parse(std::string const & arg1, vn::protocol::uart::MagneticMode & val, bool allowSloppy=True) -> bool
parse(std::string const & arg1, vn::protocol::uart::MagneticMode & val) -> bool
parse(std::string const & arg1, vn::protocol::uart::ExternalSensorMode & val, bool allowSloppy=True) -> bool
parse(std::string const & arg1, vn::protocol::uart::ExternalSensorMode & val) -> bool
parse(std::string const & arg1, vn::protocol::uart::FoamInit & val, bool allowSloppy=True) -> bool
parse(std::string const & arg1, vn::protocol::uart::FoamInit & val) -> bool
parse(std::string const & arg1, MagneticAndGravityReferenceVectorsRegister reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, MagneticAndGravityReferenceVectorsRegister reg) -> bool
parse(std::string const & arg1, FilterMeasurementsVarianceParametersRegister reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, FilterMeasurementsVarianceParametersRegister reg) -> bool
parse(std::string const & arg1, MagnetometerCompensationRegister reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, MagnetometerCompensationRegister reg) -> bool
parse(std::string const & arg1, FilterActiveTuningParametersRegister reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, FilterActiveTuningParametersRegister reg) -> bool
parse(std::string const & arg1, AccelerationCompensationRegister reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, AccelerationCompensationRegister reg) -> bool
parse(std::string const & arg1, CommunicationProtocolControlRegister reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, CommunicationProtocolControlRegister reg) -> bool
parse(std::string const & arg1, SynchronizationControlRegister reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, SynchronizationControlRegister reg) -> bool
parse(std::string const & arg1, SynchronizationStatusRegister reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, SynchronizationStatusRegister reg) -> bool
parse(std::string const & arg1, FilterBasicControlRegister reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, FilterBasicControlRegister reg) -> bool
parse(std::string const & arg1, VpeBasicControlRegister reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, VpeBasicControlRegister reg) -> bool
parse(std::string const & arg1, VpeMagnetometerBasicTuningRegister reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, VpeMagnetometerBasicTuningRegister reg) -> bool
parse(std::string const & arg1, VpeMagnetometerAdvancedTuningRegister reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, VpeMagnetometerAdvancedTuningRegister reg) -> bool
parse(std::string const & arg1, VpeAccelerometerBasicTuningRegister reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, VpeAccelerometerBasicTuningRegister reg) -> bool
parse(std::string const & arg1, VpeAccelerometerAdvancedTuningRegister reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, VpeAccelerometerAdvancedTuningRegister reg) -> bool
parse(std::string const & arg1, VpeGyroBasicTuningRegister reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, VpeGyroBasicTuningRegister reg) -> bool
parse(std::string const & arg1, MagnetometerCalibrationControlRegister reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, MagnetometerCalibrationControlRegister reg) -> bool
parse(std::string const & arg1, VelocityCompensationControlRegister reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, VelocityCompensationControlRegister reg) -> bool
parse(std::string const & arg1, GpsConfigurationRegister reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, GpsConfigurationRegister reg) -> bool
parse(std::string const & arg1, InsBasicConfigurationRegisterVn200 reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, InsBasicConfigurationRegisterVn200 reg) -> bool
parse(std::string const & arg1, InsBasicConfigurationRegisterVn300 reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, InsBasicConfigurationRegisterVn300 reg) -> bool
parse(std::string const & arg1, InsAdvancedConfigurationRegister reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, InsAdvancedConfigurationRegister reg) -> bool
parse(std::string const & arg1, StartupFilterBiasEstimateRegister reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, StartupFilterBiasEstimateRegister reg) -> bool
parse(std::string const & arg1, DeltaThetaAndDeltaVelocityConfigurationRegister reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, DeltaThetaAndDeltaVelocityConfigurationRegister reg) -> bool
parse(std::string const & arg1, ReferenceVectorConfigurationRegister reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, ReferenceVectorConfigurationRegister reg) -> bool
parse(std::string const & arg1, GyroCompensationRegister reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, GyroCompensationRegister reg) -> bool
parse(std::string const & arg1, ImuFilteringConfigurationRegister reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, ImuFilteringConfigurationRegister reg) -> bool
parse(std::string const & arg1, GpsCompassBaselineRegister reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, GpsCompassBaselineRegister reg) -> bool
parse(std::string const & arg1, ImuRateConfigurationRegister reg, bool allowSloppy=True) -> bool
parse(std::string const & arg1, ImuRateConfigurationRegister reg) -> bool
"""
return _libvncxx.parse(*args)
class SwigPyIterator(_object):
"""Proxy of C++ swig::SwigPyIterator class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
__swig_destroy__ = _libvncxx.delete_SwigPyIterator
__del__ = lambda self: None
def value(self):
"""value(SwigPyIterator self) -> PyObject *"""
return _libvncxx.SwigPyIterator_value(self)
def incr(self, n=1):
"""
incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
incr(SwigPyIterator self) -> SwigPyIterator
"""
return _libvncxx.SwigPyIterator_incr(self, n)
def decr(self, n=1):
"""
decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
decr(SwigPyIterator self) -> SwigPyIterator
"""
return _libvncxx.SwigPyIterator_decr(self, n)
def distance(self, x):
"""distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
return _libvncxx.SwigPyIterator_distance(self, x)
def equal(self, x):
"""equal(SwigPyIterator self, SwigPyIterator x) -> bool"""
return _libvncxx.SwigPyIterator_equal(self, x)
def copy(self):
"""copy(SwigPyIterator self) -> SwigPyIterator"""
return _libvncxx.SwigPyIterator_copy(self)
def next(self):
"""next(SwigPyIterator self) -> PyObject *"""
return _libvncxx.SwigPyIterator_next(self)
def __next__(self):
"""__next__(SwigPyIterator self) -> PyObject *"""
return _libvncxx.SwigPyIterator___next__(self)
def previous(self):
"""previous(SwigPyIterator self) -> PyObject *"""
return _libvncxx.SwigPyIterator_previous(self)
def advance(self, n):
"""advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
return _libvncxx.SwigPyIterator_advance(self, n)
def __eq__(self, x):
"""__eq__(SwigPyIterator self, SwigPyIterator x) -> bool"""
return _libvncxx.SwigPyIterator___eq__(self, x)
def __ne__(self, x):
"""__ne__(SwigPyIterator self, SwigPyIterator x) -> bool"""
return _libvncxx.SwigPyIterator___ne__(self, x)
def __iadd__(self, n):
"""__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
return _libvncxx.SwigPyIterator___iadd__(self, n)
def __isub__(self, n):
"""__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
return _libvncxx.SwigPyIterator___isub__(self, n)
def __add__(self, n):
"""__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
return _libvncxx.SwigPyIterator___add__(self, n)
def __sub__(self, *args):
"""
__sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
__sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
"""
return _libvncxx.SwigPyIterator___sub__(self, *args)
def __iter__(self):
return self
SwigPyIterator_swigregister = _libvncxx.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)
class VnSensor(_object):
"""Proxy of C++ vn::sensors::VnSensor class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, VnSensor, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, VnSensor, name)
__repr__ = _swig_repr
VnSensor_Family_Unknown = _libvncxx.VnSensor_VnSensor_Family_Unknown
VnSensor_Family_Vn100 = _libvncxx.VnSensor_VnSensor_Family_Vn100
VnSensor_Family_Vn200 = _libvncxx.VnSensor_VnSensor_Family_Vn200
VnSensor_Family_Vn300 = _libvncxx.VnSensor_VnSensor_Family_Vn300
def __supported_baudrates():
"""__supported_baudrates() -> UInt32Vector"""
return _libvncxx.VnSensor___supported_baudrates()
__supported_baudrates = staticmethod(__supported_baudrates)
def supportedAsyncDataOutputFrequencies():
"""supportedAsyncDataOutputFrequencies() -> UInt32Vector"""
return _libvncxx.VnSensor_supportedAsyncDataOutputFrequencies()
supportedAsyncDataOutputFrequencies = staticmethod(supportedAsyncDataOutputFrequencies)
def __init__(self):
"""__init__(vn::sensors::VnSensor self) -> VnSensor"""
this = _libvncxx.new_VnSensor()
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_VnSensor
__del__ = lambda self: None
def verify_sensor_connectivity(self):
"""verify_sensor_connectivity(VnSensor self) -> bool"""
return _libvncxx.VnSensor_verify_sensor_connectivity(self)
def connect(self, *args):
"""
connect(VnSensor self, std::string const & portName, uint32_t baudrate)
connect(VnSensor self, vn::xplat::IPort * port)
"""
return _libvncxx.VnSensor_connect(self, *args)
def disconnect(self):
"""disconnect(VnSensor self)"""
return _libvncxx.VnSensor_disconnect(self)
def transaction(self, toSend):
"""transaction(VnSensor self, std::string toSend) -> std::string"""
return _libvncxx.VnSensor_transaction(self, toSend)
def tare(self, waitForReply=True):
"""
tare(VnSensor self, bool waitForReply=True)
tare(VnSensor self)
"""
return _libvncxx.VnSensor_tare(self, waitForReply)
def set_gyro_bias(self, waitForReply=True):
"""
set_gyro_bias(VnSensor self, bool waitForReply=True)
set_gyro_bias(VnSensor self)
"""
return _libvncxx.VnSensor_set_gyro_bias(self, waitForReply)
def magnetic_disturbance_present(self, disturbancePresent, waitForReply=True):
"""
magnetic_disturbance_present(VnSensor self, bool disturbancePresent, bool waitForReply=True)
magnetic_disturbance_present(VnSensor self, bool disturbancePresent)
"""
return _libvncxx.VnSensor_magnetic_disturbance_present(self, disturbancePresent, waitForReply)
def acceleration_disturbance_present(self, disturbancePresent, waitForReply=True):
"""
acceleration_disturbance_present(VnSensor self, bool disturbancePresent, bool waitForReply=True)
acceleration_disturbance_present(VnSensor self, bool disturbancePresent)
"""
return _libvncxx.VnSensor_acceleration_disturbance_present(self, disturbancePresent, waitForReply)
def write_settings(self, waitForReply=True):
"""
write_settings(VnSensor self, bool waitForReply=True)
write_settings(VnSensor self)
"""
return _libvncxx.VnSensor_write_settings(self, waitForReply)
def restore_factory_settings(self, waitForReply=True):
"""
restore_factory_settings(VnSensor self, bool waitForReply=True)
restore_factory_settings(VnSensor self)
"""
return _libvncxx.VnSensor_restore_factory_settings(self, waitForReply)
def reset(self, waitForReply=True):
"""
reset(VnSensor self, bool waitForReply=True)
reset(VnSensor self)
"""
return _libvncxx.VnSensor_reset(self, waitForReply)
def change_baudrate(self, baudrate, changeSensorAlso=True, activeSensorPort=0):
"""
change_baudrate(VnSensor self, uint32_t baudrate, bool changeSensorAlso=True, uint8_t activeSensorPort=0)
change_baudrate(VnSensor self, uint32_t baudrate, bool changeSensorAlso=True)
change_baudrate(VnSensor self, uint32_t baudrate)
"""
return _libvncxx.VnSensor_change_baudrate(self, baudrate, changeSensorAlso, activeSensorPort)
def determine_device_family(*args):
"""
determine_device_family() -> vn::sensors::VnSensor::Family
determine_device_family(std::string modelNumber) -> vn::sensors::VnSensor::Family
"""
return _libvncxx.VnSensor_determine_device_family(*args)
determine_device_family = staticmethod(determine_device_family)
def registerRawDataReceivedHandler(self, userData, handler):
"""registerRawDataReceivedHandler(VnSensor self, void * userData, vn::sensors::VnSensor::RawDataReceivedHandler handler)"""
return _libvncxx.VnSensor_registerRawDataReceivedHandler(self, userData, handler)
def unregisterRawDataReceivedHandler(self):
"""unregisterRawDataReceivedHandler(VnSensor self)"""
return _libvncxx.VnSensor_unregisterRawDataReceivedHandler(self)
def registerPossiblePacketFoundHandler(self, userData, handler):
"""registerPossiblePacketFoundHandler(VnSensor self, void * userData, vn::sensors::VnSensor::PossiblePacketFoundHandler handler)"""
return _libvncxx.VnSensor_registerPossiblePacketFoundHandler(self, userData, handler)
def unregisterPossiblePacketFoundHandler(self):
"""unregisterPossiblePacketFoundHandler(VnSensor self)"""
return _libvncxx.VnSensor_unregisterPossiblePacketFoundHandler(self)
def registerAsyncPacketReceivedHandler(self, userData, handler):
"""registerAsyncPacketReceivedHandler(VnSensor self, void * userData, vn::sensors::VnSensor::AsyncPacketReceivedHandler handler)"""
return _libvncxx.VnSensor_registerAsyncPacketReceivedHandler(self, userData, handler)
def unregisterAsyncPacketReceivedHandler(self):
"""unregisterAsyncPacketReceivedHandler(VnSensor self)"""
return _libvncxx.VnSensor_unregisterAsyncPacketReceivedHandler(self)
def registerErrorPacketReceivedHandler(self, userData, handler):
"""registerErrorPacketReceivedHandler(VnSensor self, void * userData, vn::sensors::VnSensor::ErrorPacketReceivedHandler handler)"""
return _libvncxx.VnSensor_registerErrorPacketReceivedHandler(self, userData, handler)
def unregisterErrorPacketReceivedHandler(self):
"""unregisterErrorPacketReceivedHandler(VnSensor self)"""
return _libvncxx.VnSensor_unregisterErrorPacketReceivedHandler(self)
def registerUsbCableUnpluggedNotificationHandler(self, userData, handler):
"""registerUsbCableUnpluggedNotificationHandler(VnSensor self, void * userData, void (*)(void *) handler)"""
return _libvncxx.VnSensor_registerUsbCableUnpluggedNotificationHandler(self, userData, handler)
def unregisterUsbCableUnpluggedNotificationHandler(self):
"""unregisterUsbCableUnpluggedNotificationHandler(VnSensor self)"""
return _libvncxx.VnSensor_unregisterUsbCableUnpluggedNotificationHandler(self)
def read_binary_output_1(self):
"""read_binary_output_1(VnSensor self) -> BinaryOutputRegister"""
return _libvncxx.VnSensor_read_binary_output_1(self)
def write_binary_output_1(self, fields, waitForReply=True):
"""
write_binary_output_1(VnSensor self, BinaryOutputRegister fields, bool waitForReply=True)
write_binary_output_1(VnSensor self, BinaryOutputRegister fields)
"""
return _libvncxx.VnSensor_write_binary_output_1(self, fields, waitForReply)
def read_binary_output_2(self):
"""read_binary_output_2(VnSensor self) -> BinaryOutputRegister"""
return _libvncxx.VnSensor_read_binary_output_2(self)
def write_binary_output_2(self, fields, waitForReply=True):
"""
write_binary_output_2(VnSensor self, BinaryOutputRegister fields, bool waitForReply=True)
write_binary_output_2(VnSensor self, BinaryOutputRegister fields)
"""
return _libvncxx.VnSensor_write_binary_output_2(self, fields, waitForReply)
def read_binary_output_3(self):
"""read_binary_output_3(VnSensor self) -> BinaryOutputRegister"""
return _libvncxx.VnSensor_read_binary_output_3(self)
def write_binary_output_3(self, fields, waitForReply=True):
"""
write_binary_output_3(VnSensor self, BinaryOutputRegister fields, bool waitForReply=True)
write_binary_output_3(VnSensor self, BinaryOutputRegister fields)
"""
return _libvncxx.VnSensor_write_binary_output_3(self, fields, waitForReply)
def read_ins_basic_configuration_vn200(self):
"""read_ins_basic_configuration_vn200(VnSensor self) -> InsBasicConfigurationRegisterVn200"""
return _libvncxx.VnSensor_read_ins_basic_configuration_vn200(self)
def write_ins_basic_configuration_vn200(self, *args):
"""
write_ins_basic_configuration_vn200(VnSensor self, InsBasicConfigurationRegisterVn200 fields, bool waitForReply=True)
write_ins_basic_configuration_vn200(VnSensor self, InsBasicConfigurationRegisterVn200 fields)
write_ins_basic_configuration_vn200(VnSensor self, vn::protocol::uart::Scenario scenario, uint8_t const & ahrsAiding, bool waitForReply=True)
write_ins_basic_configuration_vn200(VnSensor self, vn::protocol::uart::Scenario scenario, uint8_t const & ahrsAiding)
"""
return _libvncxx.VnSensor_write_ins_basic_configuration_vn200(self, *args)
def read_ins_basic_configuration_vn300(self):
"""read_ins_basic_configuration_vn300(VnSensor self) -> InsBasicConfigurationRegisterVn300"""
return _libvncxx.VnSensor_read_ins_basic_configuration_vn300(self)
def write_ins_basic_configuration_vn300(self, *args):
"""
write_ins_basic_configuration_vn300(VnSensor self, InsBasicConfigurationRegisterVn300 fields, bool waitForReply=True)
write_ins_basic_configuration_vn300(VnSensor self, InsBasicConfigurationRegisterVn300 fields)
write_ins_basic_configuration_vn300(VnSensor self, vn::protocol::uart::Scenario scenario, uint8_t const & ahrsAiding, uint8_t const & estBaseline, bool waitForReply=True)
write_ins_basic_configuration_vn300(VnSensor self, vn::protocol::uart::Scenario scenario, uint8_t const & ahrsAiding, uint8_t const & estBaseline)
"""
return _libvncxx.VnSensor_write_ins_basic_configuration_vn300(self, *args)
def read_user_tag(self):
"""read_user_tag(VnSensor self) -> std::string"""
return _libvncxx.VnSensor_read_user_tag(self)
def write_user_tag(self, tag, waitForReply=True):
"""
write_user_tag(VnSensor self, std::string const & tag, bool waitForReply=True)
write_user_tag(VnSensor self, std::string const & tag)
"""
return _libvncxx.VnSensor_write_user_tag(self, tag, waitForReply)
def read_model_number(self):
"""read_model_number(VnSensor self) -> std::string"""
return _libvncxx.VnSensor_read_model_number(self)
def read_hardware_revision(self):
"""read_hardware_revision(VnSensor self) -> uint32_t"""
return _libvncxx.VnSensor_read_hardware_revision(self)
def read_serial_number(self):
"""read_serial_number(VnSensor self) -> uint32_t"""
return _libvncxx.VnSensor_read_serial_number(self)
def read_firmware_version(self):
"""read_firmware_version(VnSensor self) -> std::string"""
return _libvncxx.VnSensor_read_firmware_version(self)
def read_serial_baudrate(self, *args):
"""
read_serial_baudrate(VnSensor self, uint8_t port) -> uint32_t
read_serial_baudrate(VnSensor self) -> uint32_t
"""
return _libvncxx.VnSensor_read_serial_baudrate(self, *args)
def write_serial_baudrate(self, *args):
"""
write_serial_baudrate(VnSensor self, uint32_t const & baudrate, uint8_t port, bool waitForReply=True)
write_serial_baudrate(VnSensor self, uint32_t const & baudrate, uint8_t port)
write_serial_baudrate(VnSensor self, uint32_t const & baudrate, bool waitForReply=True)
write_serial_baudrate(VnSensor self, uint32_t const & baudrate)
"""
return _libvncxx.VnSensor_write_serial_baudrate(self, *args)
def read_async_data_output_type(self, *args):
"""
read_async_data_output_type(VnSensor self, uint8_t port) -> vn::protocol::uart::AsciiAsync
read_async_data_output_type(VnSensor self) -> vn::protocol::uart::AsciiAsync
"""
return _libvncxx.VnSensor_read_async_data_output_type(self, *args)
def write_async_data_output_type(self, *args):
"""
write_async_data_output_type(VnSensor self, vn::protocol::uart::AsciiAsync ador, uint8_t port, bool waitForReply=True)
write_async_data_output_type(VnSensor self, vn::protocol::uart::AsciiAsync ador, uint8_t port)
write_async_data_output_type(VnSensor self, vn::protocol::uart::AsciiAsync ador, bool waitForReply=True)
write_async_data_output_type(VnSensor self, vn::protocol::uart::AsciiAsync ador)
"""
return _libvncxx.VnSensor_write_async_data_output_type(self, *args)
def read_async_data_output_frequency(self, *args):
"""
read_async_data_output_frequency(VnSensor self, uint8_t port) -> uint32_t
read_async_data_output_frequency(VnSensor self) -> uint32_t
"""
return _libvncxx.VnSensor_read_async_data_output_frequency(self, *args)
def write_async_data_output_frequency(self, *args):
"""
write_async_data_output_frequency(VnSensor self, uint32_t const & adof, uint8_t port, bool waitForReply=True)
write_async_data_output_frequency(VnSensor self, uint32_t const & adof, uint8_t port)
write_async_data_output_frequency(VnSensor self, uint32_t const & adof, bool waitForReply=True)
write_async_data_output_frequency(VnSensor self, uint32_t const & adof)
"""
return _libvncxx.VnSensor_write_async_data_output_frequency(self, *args)
def read_yaw_pitch_roll(self):
"""read_yaw_pitch_roll(VnSensor self) -> vec3f"""
return _libvncxx.VnSensor_read_yaw_pitch_roll(self)
def read_attitude_quaternion(self):
"""read_attitude_quaternion(VnSensor self) -> vec4f"""
return _libvncxx.VnSensor_read_attitude_quaternion(self)
def read_quaternion_magnetic_acceleration_and_angular_rates(self):
"""read_quaternion_magnetic_acceleration_and_angular_rates(VnSensor self) -> QuaternionMagneticAccelerationAndAngularRatesRegister"""
return _libvncxx.VnSensor_read_quaternion_magnetic_acceleration_and_angular_rates(self)
def read_magnetic_measurements(self):
"""read_magnetic_measurements(VnSensor self) -> vec3f"""
return _libvncxx.VnSensor_read_magnetic_measurements(self)
def read_acceleration_measurements(self):
"""read_acceleration_measurements(VnSensor self) -> vec3f"""
return _libvncxx.VnSensor_read_acceleration_measurements(self)
def read_angular_rate_measurements(self):
"""read_angular_rate_measurements(VnSensor self) -> vec3f"""
return _libvncxx.VnSensor_read_angular_rate_measurements(self)
def read_magnetic_acceleration_and_angular_rates(self):
"""read_magnetic_acceleration_and_angular_rates(VnSensor self) -> MagneticAccelerationAndAngularRatesRegister"""
return _libvncxx.VnSensor_read_magnetic_acceleration_and_angular_rates(self)
def read_magnetic_and_gravity_reference_vectors(self):
"""read_magnetic_and_gravity_reference_vectors(VnSensor self) -> MagneticAndGravityReferenceVectorsRegister"""
return _libvncxx.VnSensor_read_magnetic_and_gravity_reference_vectors(self)
def write_magnetic_and_gravity_reference_vectors(self, *args):
"""
write_magnetic_and_gravity_reference_vectors(VnSensor self, MagneticAndGravityReferenceVectorsRegister fields, bool waitForReply=True)
write_magnetic_and_gravity_reference_vectors(VnSensor self, MagneticAndGravityReferenceVectorsRegister fields)
write_magnetic_and_gravity_reference_vectors(VnSensor self, vec3f magRef, vec3f accRef, bool waitForReply=True)
write_magnetic_and_gravity_reference_vectors(VnSensor self, vec3f magRef, vec3f accRef)
"""
return _libvncxx.VnSensor_write_magnetic_and_gravity_reference_vectors(self, *args)
def read_filter_measurements_variance_parameters(self):
"""read_filter_measurements_variance_parameters(VnSensor self) -> FilterMeasurementsVarianceParametersRegister"""
return _libvncxx.VnSensor_read_filter_measurements_variance_parameters(self)
def write_filter_measurements_variance_parameters(self, *args):
"""
write_filter_measurements_variance_parameters(VnSensor self, FilterMeasurementsVarianceParametersRegister fields, bool waitForReply=True)
write_filter_measurements_variance_parameters(VnSensor self, FilterMeasurementsVarianceParametersRegister fields)
write_filter_measurements_variance_parameters(VnSensor self, float const & angularWalkVariance, vec3f angularRateVariance, vec3f magneticVariance, vec3f accelerationVariance, bool waitForReply=True)
write_filter_measurements_variance_parameters(VnSensor self, float const & angularWalkVariance, vec3f angularRateVariance, vec3f magneticVariance, vec3f accelerationVariance)
"""
return _libvncxx.VnSensor_write_filter_measurements_variance_parameters(self, *args)
def read_magnetometer_compensation(self):
"""read_magnetometer_compensation(VnSensor self) -> MagnetometerCompensationRegister"""
return _libvncxx.VnSensor_read_magnetometer_compensation(self)
def write_magnetometer_compensation(self, *args):
"""
write_magnetometer_compensation(VnSensor self, MagnetometerCompensationRegister fields, bool waitForReply=True)
write_magnetometer_compensation(VnSensor self, MagnetometerCompensationRegister fields)
write_magnetometer_compensation(VnSensor self, mat3f c, vec3f b, bool waitForReply=True)
write_magnetometer_compensation(VnSensor self, mat3f c, vec3f b)
"""
return _libvncxx.VnSensor_write_magnetometer_compensation(self, *args)
def read_filter_active_tuning_parameters(self):
"""read_filter_active_tuning_parameters(VnSensor self) -> FilterActiveTuningParametersRegister"""
return _libvncxx.VnSensor_read_filter_active_tuning_parameters(self)
def write_filter_active_tuning_parameters(self, *args):
"""
write_filter_active_tuning_parameters(VnSensor self, FilterActiveTuningParametersRegister fields, bool waitForReply=True)
write_filter_active_tuning_parameters(VnSensor self, FilterActiveTuningParametersRegister fields)
write_filter_active_tuning_parameters(VnSensor self, float const & magneticDisturbanceGain, float const & accelerationDisturbanceGain, float const & magneticDisturbanceMemory, float const & accelerationDisturbanceMemory, bool waitForReply=True)
write_filter_active_tuning_parameters(VnSensor self, float const & magneticDisturbanceGain, float const & accelerationDisturbanceGain, float const & magneticDisturbanceMemory, float const & accelerationDisturbanceMemory)
"""
return _libvncxx.VnSensor_write_filter_active_tuning_parameters(self, *args)
def read_acceleration_compensation(self):
"""read_acceleration_compensation(VnSensor self) -> AccelerationCompensationRegister"""
return _libvncxx.VnSensor_read_acceleration_compensation(self)
def write_acceleration_compensation(self, *args):
"""
write_acceleration_compensation(VnSensor self, AccelerationCompensationRegister fields, bool waitForReply=True)
write_acceleration_compensation(VnSensor self, AccelerationCompensationRegister fields)
write_acceleration_compensation(VnSensor self, mat3f c, vec3f b, bool waitForReply=True)
write_acceleration_compensation(VnSensor self, mat3f c, vec3f b)
"""
return _libvncxx.VnSensor_write_acceleration_compensation(self, *args)
def read_reference_frame_rotation(self):
"""read_reference_frame_rotation(VnSensor self) -> mat3f"""
return _libvncxx.VnSensor_read_reference_frame_rotation(self)
def write_reference_frame_rotation(self, c, waitForReply=True):
"""
write_reference_frame_rotation(VnSensor self, mat3f c, bool waitForReply=True)
write_reference_frame_rotation(VnSensor self, mat3f c)
"""
return _libvncxx.VnSensor_write_reference_frame_rotation(self, c, waitForReply)
def read_yaw_pitch_roll_magnetic_acceleration_and_angular_rates(self):
"""read_yaw_pitch_roll_magnetic_acceleration_and_angular_rates(VnSensor self) -> YawPitchRollMagneticAccelerationAndAngularRatesRegister"""
return _libvncxx.VnSensor_read_yaw_pitch_roll_magnetic_acceleration_and_angular_rates(self)
def read_communication_protocol_control(self):
"""read_communication_protocol_control(VnSensor self) -> CommunicationProtocolControlRegister"""
return _libvncxx.VnSensor_read_communication_protocol_control(self)
def write_communication_protocol_control(self, *args):
"""
write_communication_protocol_control(VnSensor self, CommunicationProtocolControlRegister fields, bool waitForReply=True)
write_communication_protocol_control(VnSensor self, CommunicationProtocolControlRegister fields)
write_communication_protocol_control(VnSensor self, vn::protocol::uart::CountMode serialCount, vn::protocol::uart::StatusMode serialStatus, vn::protocol::uart::CountMode spiCount, vn::protocol::uart::StatusMode spiStatus, vn::protocol::uart::ChecksumMode serialChecksum, vn::protocol::uart::ChecksumMode spiChecksum, vn::protocol::uart::ErrorMode errorMode, bool waitForReply=True)
write_communication_protocol_control(VnSensor self, vn::protocol::uart::CountMode serialCount, vn::protocol::uart::StatusMode serialStatus, vn::protocol::uart::CountMode spiCount, vn::protocol::uart::StatusMode spiStatus, vn::protocol::uart::ChecksumMode serialChecksum, vn::protocol::uart::ChecksumMode spiChecksum, vn::protocol::uart::ErrorMode errorMode)
"""
return _libvncxx.VnSensor_write_communication_protocol_control(self, *args)
def read_synchronization_control(self):
"""read_synchronization_control(VnSensor self) -> SynchronizationControlRegister"""
return _libvncxx.VnSensor_read_synchronization_control(self)
def write_synchronization_control(self, *args):
"""
write_synchronization_control(VnSensor self, SynchronizationControlRegister fields, bool waitForReply=True)
write_synchronization_control(VnSensor self, SynchronizationControlRegister fields)
write_synchronization_control(VnSensor self, vn::protocol::uart::SyncInMode syncInMode, vn::protocol::uart::SyncInEdge syncInEdge, uint16_t const & syncInSkipFactor, vn::protocol::uart::SyncOutMode syncOutMode, vn::protocol::uart::SyncOutPolarity syncOutPolarity, uint16_t const & syncOutSkipFactor, uint32_t const & syncOutPulseWidth, bool waitForReply=True)
write_synchronization_control(VnSensor self, vn::protocol::uart::SyncInMode syncInMode, vn::protocol::uart::SyncInEdge syncInEdge, uint16_t const & syncInSkipFactor, vn::protocol::uart::SyncOutMode syncOutMode, vn::protocol::uart::SyncOutPolarity syncOutPolarity, uint16_t const & syncOutSkipFactor, uint32_t const & syncOutPulseWidth)
"""
return _libvncxx.VnSensor_write_synchronization_control(self, *args)
def read_synchronization_status(self):
"""read_synchronization_status(VnSensor self) -> SynchronizationStatusRegister"""
return _libvncxx.VnSensor_read_synchronization_status(self)
def write_synchronization_status(self, *args):
"""
write_synchronization_status(VnSensor self, SynchronizationStatusRegister fields, bool waitForReply=True)
write_synchronization_status(VnSensor self, SynchronizationStatusRegister fields)
write_synchronization_status(VnSensor self, uint32_t const & syncInCount, uint32_t const & syncInTime, uint32_t const & syncOutCount, bool waitForReply=True)
write_synchronization_status(VnSensor self, uint32_t const & syncInCount, uint32_t const & syncInTime, uint32_t const & syncOutCount)
"""
return _libvncxx.VnSensor_write_synchronization_status(self, *args)
def read_filter_basic_control(self):
"""read_filter_basic_control(VnSensor self) -> FilterBasicControlRegister"""
return _libvncxx.VnSensor_read_filter_basic_control(self)
def write_filter_basic_control(self, *args):
"""
write_filter_basic_control(VnSensor self, FilterBasicControlRegister fields, bool waitForReply=True)
write_filter_basic_control(VnSensor self, FilterBasicControlRegister fields)
write_filter_basic_control(VnSensor self, vn::protocol::uart::MagneticMode magMode, vn::protocol::uart::ExternalSensorMode extMagMode, vn::protocol::uart::ExternalSensorMode extAccMode, vn::protocol::uart::ExternalSensorMode extGyroMode, vec3f gyroLimit, bool waitForReply=True)
write_filter_basic_control(VnSensor self, vn::protocol::uart::MagneticMode magMode, vn::protocol::uart::ExternalSensorMode extMagMode, vn::protocol::uart::ExternalSensorMode extAccMode, vn::protocol::uart::ExternalSensorMode extGyroMode, vec3f gyroLimit)
"""
return _libvncxx.VnSensor_write_filter_basic_control(self, *args)
def read_vpe_basic_control(self):
"""read_vpe_basic_control(VnSensor self) -> VpeBasicControlRegister"""
return _libvncxx.VnSensor_read_vpe_basic_control(self)
def write_vpe_basic_control(self, *args):
"""
write_vpe_basic_control(VnSensor self, VpeBasicControlRegister fields, bool waitForReply=True)
write_vpe_basic_control(VnSensor self, VpeBasicControlRegister fields)
write_vpe_basic_control(VnSensor self, vn::protocol::uart::VpeEnable enable, vn::protocol::uart::HeadingMode headingMode, vn::protocol::uart::VpeMode filteringMode, vn::protocol::uart::VpeMode tuningMode, bool waitForReply=True)
write_vpe_basic_control(VnSensor self, vn::protocol::uart::VpeEnable enable, vn::protocol::uart::HeadingMode headingMode, vn::protocol::uart::VpeMode filteringMode, vn::protocol::uart::VpeMode tuningMode)
"""
return _libvncxx.VnSensor_write_vpe_basic_control(self, *args)
def read_vpe_magnetometer_basic_tuning(self):
"""read_vpe_magnetometer_basic_tuning(VnSensor self) -> VpeMagnetometerBasicTuningRegister"""
return _libvncxx.VnSensor_read_vpe_magnetometer_basic_tuning(self)
def write_vpe_magnetometer_basic_tuning(self, *args):
"""
write_vpe_magnetometer_basic_tuning(VnSensor self, VpeMagnetometerBasicTuningRegister fields, bool waitForReply=True)
write_vpe_magnetometer_basic_tuning(VnSensor self, VpeMagnetometerBasicTuningRegister fields)
write_vpe_magnetometer_basic_tuning(VnSensor self, vec3f baseTuning, vec3f adaptiveTuning, vec3f adaptiveFiltering, bool waitForReply=True)
write_vpe_magnetometer_basic_tuning(VnSensor self, vec3f baseTuning, vec3f adaptiveTuning, vec3f adaptiveFiltering)
"""
return _libvncxx.VnSensor_write_vpe_magnetometer_basic_tuning(self, *args)
def read_vpe_magnetometer_advanced_tuning(self):
"""read_vpe_magnetometer_advanced_tuning(VnSensor self) -> VpeMagnetometerAdvancedTuningRegister"""
return _libvncxx.VnSensor_read_vpe_magnetometer_advanced_tuning(self)
def write_vpe_magnetometer_advanced_tuning(self, *args):
"""
write_vpe_magnetometer_advanced_tuning(VnSensor self, VpeMagnetometerAdvancedTuningRegister fields, bool waitForReply=True)
write_vpe_magnetometer_advanced_tuning(VnSensor self, VpeMagnetometerAdvancedTuningRegister fields)
write_vpe_magnetometer_advanced_tuning(VnSensor self, vec3f minFiltering, vec3f maxFiltering, float const & maxAdaptRate, float const & disturbanceWindow, float const & maxTuning, bool waitForReply=True)
write_vpe_magnetometer_advanced_tuning(VnSensor self, vec3f minFiltering, vec3f maxFiltering, float const & maxAdaptRate, float const & disturbanceWindow, float const & maxTuning)
"""
return _libvncxx.VnSensor_write_vpe_magnetometer_advanced_tuning(self, *args)
def read_vpe_accelerometer_basic_tuning(self):
"""read_vpe_accelerometer_basic_tuning(VnSensor self) -> VpeAccelerometerBasicTuningRegister"""
return _libvncxx.VnSensor_read_vpe_accelerometer_basic_tuning(self)
def write_vpe_accelerometer_basic_tuning(self, *args):
"""
write_vpe_accelerometer_basic_tuning(VnSensor self, VpeAccelerometerBasicTuningRegister fields, bool waitForReply=True)
write_vpe_accelerometer_basic_tuning(VnSensor self, VpeAccelerometerBasicTuningRegister fields)
write_vpe_accelerometer_basic_tuning(VnSensor self, vec3f baseTuning, vec3f adaptiveTuning, vec3f adaptiveFiltering, bool waitForReply=True)
write_vpe_accelerometer_basic_tuning(VnSensor self, vec3f baseTuning, vec3f adaptiveTuning, vec3f adaptiveFiltering)
"""
return _libvncxx.VnSensor_write_vpe_accelerometer_basic_tuning(self, *args)
def read_vpe_accelerometer_advanced_tuning(self):
"""read_vpe_accelerometer_advanced_tuning(VnSensor self) -> VpeAccelerometerAdvancedTuningRegister"""
return _libvncxx.VnSensor_read_vpe_accelerometer_advanced_tuning(self)
def write_vpe_accelerometer_advanced_tuning(self, *args):
"""
write_vpe_accelerometer_advanced_tuning(VnSensor self, VpeAccelerometerAdvancedTuningRegister fields, bool waitForReply=True)
write_vpe_accelerometer_advanced_tuning(VnSensor self, VpeAccelerometerAdvancedTuningRegister fields)
write_vpe_accelerometer_advanced_tuning(VnSensor self, vec3f minFiltering, vec3f maxFiltering, float const & maxAdaptRate, float const & disturbanceWindow, float const & maxTuning, bool waitForReply=True)
write_vpe_accelerometer_advanced_tuning(VnSensor self, vec3f minFiltering, vec3f maxFiltering, float const & maxAdaptRate, float const & disturbanceWindow, float const & maxTuning)
"""
return _libvncxx.VnSensor_write_vpe_accelerometer_advanced_tuning(self, *args)
def readVpeGyroBasicTuning(self):
"""readVpeGyroBasicTuning(VnSensor self) -> VpeGyroBasicTuningRegister"""
return _libvncxx.VnSensor_readVpeGyroBasicTuning(self)
def writeVpeGyroBasicTuning(self, *args):
"""
writeVpeGyroBasicTuning(VnSensor self, VpeGyroBasicTuningRegister fields, bool waitForReply=True)
writeVpeGyroBasicTuning(VnSensor self, VpeGyroBasicTuningRegister fields)
writeVpeGyroBasicTuning(VnSensor self, vec3f angularWalkVariance, vec3f baseTuning, vec3f adaptiveTuning, bool waitForReply=True)
writeVpeGyroBasicTuning(VnSensor self, vec3f angularWalkVariance, vec3f baseTuning, vec3f adaptiveTuning)
"""
return _libvncxx.VnSensor_writeVpeGyroBasicTuning(self, *args)
def read_filter_startup_gyro_bias(self):
"""read_filter_startup_gyro_bias(VnSensor self) -> vec3f"""
return _libvncxx.VnSensor_read_filter_startup_gyro_bias(self)
def write_filter_startup_gyro_bias(self, bias, waitForReply=True):
"""
write_filter_startup_gyro_bias(VnSensor self, vec3f bias, bool waitForReply=True)
write_filter_startup_gyro_bias(VnSensor self, vec3f bias)
"""
return _libvncxx.VnSensor_write_filter_startup_gyro_bias(self, bias, waitForReply)
def read_magnetometer_calibration_control(self):
"""read_magnetometer_calibration_control(VnSensor self) -> MagnetometerCalibrationControlRegister"""
return _libvncxx.VnSensor_read_magnetometer_calibration_control(self)
def write_magnetometer_calibration_control(self, *args):
"""
write_magnetometer_calibration_control(VnSensor self, MagnetometerCalibrationControlRegister fields, bool waitForReply=True)
write_magnetometer_calibration_control(VnSensor self, MagnetometerCalibrationControlRegister fields)
write_magnetometer_calibration_control(VnSensor self, vn::protocol::uart::HsiMode hsiMode, vn::protocol::uart::HsiOutput hsiOutput, uint8_t const & convergeRate, bool waitForReply=True)
write_magnetometer_calibration_control(VnSensor self, vn::protocol::uart::HsiMode hsiMode, vn::protocol::uart::HsiOutput hsiOutput, uint8_t const & convergeRate)
"""
return _libvncxx.VnSensor_write_magnetometer_calibration_control(self, *args)
def read_calculated_magnetometer_calibration(self):
"""read_calculated_magnetometer_calibration(VnSensor self) -> CalculatedMagnetometerCalibrationRegister"""
return _libvncxx.VnSensor_read_calculated_magnetometer_calibration(self)
def read_indoor_heading_mode_control(self):
"""read_indoor_heading_mode_control(VnSensor self) -> float"""
return _libvncxx.VnSensor_read_indoor_heading_mode_control(self)
def write_indoor_heading_mode_control(self, maxRateError, waitForReply=True):
"""
write_indoor_heading_mode_control(VnSensor self, float const & maxRateError, bool waitForReply=True)
write_indoor_heading_mode_control(VnSensor self, float const & maxRateError)
"""
return _libvncxx.VnSensor_write_indoor_heading_mode_control(self, maxRateError, waitForReply)
def read_velocity_compensation_measurement(self):
"""read_velocity_compensation_measurement(VnSensor self) -> vec3f"""
return _libvncxx.VnSensor_read_velocity_compensation_measurement(self)
def write_velocity_compensation_measurement(self, velocity, waitForReply=True):
"""
write_velocity_compensation_measurement(VnSensor self, vec3f velocity, bool waitForReply=True)
write_velocity_compensation_measurement(VnSensor self, vec3f velocity)
"""
return _libvncxx.VnSensor_write_velocity_compensation_measurement(self, velocity, waitForReply)
def read_velocity_compensation_control(self):
"""read_velocity_compensation_control(VnSensor self) -> VelocityCompensationControlRegister"""
return _libvncxx.VnSensor_read_velocity_compensation_control(self)
def write_velocity_compensation_control(self, *args):
"""
write_velocity_compensation_control(VnSensor self, VelocityCompensationControlRegister fields, bool waitForReply=True)
write_velocity_compensation_control(VnSensor self, VelocityCompensationControlRegister fields)
write_velocity_compensation_control(VnSensor self, vn::protocol::uart::VelocityCompensationMode mode, float const & velocityTuning, float const & rateTuning, bool waitForReply=True)
write_velocity_compensation_control(VnSensor self, vn::protocol::uart::VelocityCompensationMode mode, float const & velocityTuning, float const & rateTuning)
"""
return _libvncxx.VnSensor_write_velocity_compensation_control(self, *args)
def read_velocity_compensation_status(self):
"""read_velocity_compensation_status(VnSensor self) -> VelocityCompensationStatusRegister"""
return _libvncxx.VnSensor_read_velocity_compensation_status(self)
def read_imu_measurements(self):
"""read_imu_measurements(VnSensor self) -> ImuMeasurementsRegister"""
return _libvncxx.VnSensor_read_imu_measurements(self)
def read_gps_configuration(self):
"""read_gps_configuration(VnSensor self) -> GpsConfigurationRegister"""
return _libvncxx.VnSensor_read_gps_configuration(self)
def write_gps_configuration(self, *args):
"""
write_gps_configuration(VnSensor self, GpsConfigurationRegister fields, bool waitForReply=True)
write_gps_configuration(VnSensor self, GpsConfigurationRegister fields)
write_gps_configuration(VnSensor self, vn::protocol::uart::GpsMode mode, vn::protocol::uart::PpsSource ppsSource, bool waitForReply=True)
write_gps_configuration(VnSensor self, vn::protocol::uart::GpsMode mode, vn::protocol::uart::PpsSource ppsSource)
"""
return _libvncxx.VnSensor_write_gps_configuration(self, *args)
def read_gps_antenna_offset(self):
"""read_gps_antenna_offset(VnSensor self) -> vec3f"""
return _libvncxx.VnSensor_read_gps_antenna_offset(self)
def write_gps_antenna_offset(self, position, waitForReply=True):
"""
write_gps_antenna_offset(VnSensor self, vec3f position, bool waitForReply=True)
write_gps_antenna_offset(VnSensor self, vec3f position)
"""
return _libvncxx.VnSensor_write_gps_antenna_offset(self, position, waitForReply)
def read_gps_solution_lla(self):
"""read_gps_solution_lla(VnSensor self) -> GpsSolutionLlaRegister"""
return _libvncxx.VnSensor_read_gps_solution_lla(self)
def read_gps_solution_ecef(self):
"""read_gps_solution_ecef(VnSensor self) -> GpsSolutionEcefRegister"""
return _libvncxx.VnSensor_read_gps_solution_ecef(self)
def read_ins_solution_lla(self):
"""read_ins_solution_lla(VnSensor self) -> InsSolutionLlaRegister"""
return _libvncxx.VnSensor_read_ins_solution_lla(self)
def read_ins_solution_ecef(self):
"""read_ins_solution_ecef(VnSensor self) -> InsSolutionEcefRegister"""
return _libvncxx.VnSensor_read_ins_solution_ecef(self)
def read_ins_advanced_configuration(self):
"""read_ins_advanced_configuration(VnSensor self) -> InsAdvancedConfigurationRegister"""
return _libvncxx.VnSensor_read_ins_advanced_configuration(self)
def write_ins_advanced_configuration(self, *args):
"""
write_ins_advanced_configuration(VnSensor self, InsAdvancedConfigurationRegister fields, bool waitForReply=True)
write_ins_advanced_configuration(VnSensor self, InsAdvancedConfigurationRegister fields)
write_ins_advanced_configuration(VnSensor self, uint8_t const & useMag, uint8_t const & usePres, uint8_t const & posAtt, uint8_t const & velAtt, uint8_t const & velBias, vn::protocol::uart::FoamInit useFoam, uint8_t const & gpsCovType, uint8_t const & velCount, float const & velInit, float const & moveOrigin, float const & gpsTimeout, float const & deltaLimitPos, float const & deltaLimitVel, float const & minPosUncertainty, float const & minVelUncertainty, bool waitForReply=True)
write_ins_advanced_configuration(VnSensor self, uint8_t const & useMag, uint8_t const & usePres, uint8_t const & posAtt, uint8_t const & velAtt, uint8_t const & velBias, vn::protocol::uart::FoamInit useFoam, uint8_t const & gpsCovType, uint8_t const & velCount, float const & velInit, float const & moveOrigin, float const & gpsTimeout, float const & deltaLimitPos, float const & deltaLimitVel, float const & minPosUncertainty, float const & minVelUncertainty)
"""
return _libvncxx.VnSensor_write_ins_advanced_configuration(self, *args)
def read_ins_state_lla(self):
"""read_ins_state_lla(VnSensor self) -> InsStateLlaRegister"""
return _libvncxx.VnSensor_read_ins_state_lla(self)
def read_ins_state_ecef(self):
"""read_ins_state_ecef(VnSensor self) -> InsStateEcefRegister"""
return _libvncxx.VnSensor_read_ins_state_ecef(self)
def read_startup_filter_bias_estimate(self):
"""read_startup_filter_bias_estimate(VnSensor self) -> StartupFilterBiasEstimateRegister"""
return _libvncxx.VnSensor_read_startup_filter_bias_estimate(self)
def write_startup_filter_bias_estimate(self, *args):
"""
write_startup_filter_bias_estimate(VnSensor self, StartupFilterBiasEstimateRegister fields, bool waitForReply=True)
write_startup_filter_bias_estimate(VnSensor self, StartupFilterBiasEstimateRegister fields)
write_startup_filter_bias_estimate(VnSensor self, vec3f gyroBias, vec3f accelBias, float const & pressureBias, bool waitForReply=True)
write_startup_filter_bias_estimate(VnSensor self, vec3f gyroBias, vec3f accelBias, float const & pressureBias)
"""
return _libvncxx.VnSensor_write_startup_filter_bias_estimate(self, *args)
def read_delta_theta_and_delta_velocity(self):
"""read_delta_theta_and_delta_velocity(VnSensor self) -> DeltaThetaAndDeltaVelocityRegister"""
return _libvncxx.VnSensor_read_delta_theta_and_delta_velocity(self)
def read_delta_theta_and_delta_velocity_configuration(self):
"""read_delta_theta_and_delta_velocity_configuration(VnSensor self) -> DeltaThetaAndDeltaVelocityConfigurationRegister"""
return _libvncxx.VnSensor_read_delta_theta_and_delta_velocity_configuration(self)
def writeDeltaThetaAndDeltaVelocityConfiguration(self, *args):
"""
writeDeltaThetaAndDeltaVelocityConfiguration(VnSensor self, DeltaThetaAndDeltaVelocityConfigurationRegister fields, bool waitForReply=True)
writeDeltaThetaAndDeltaVelocityConfiguration(VnSensor self, DeltaThetaAndDeltaVelocityConfigurationRegister fields)
writeDeltaThetaAndDeltaVelocityConfiguration(VnSensor self, vn::protocol::uart::IntegrationFrame integrationFrame, vn::protocol::uart::CompensationMode gyroCompensation, vn::protocol::uart::CompensationMode accelCompensation, bool waitForReply=True)
writeDeltaThetaAndDeltaVelocityConfiguration(VnSensor self, vn::protocol::uart::IntegrationFrame integrationFrame, vn::protocol::uart::CompensationMode gyroCompensation, vn::protocol::uart::CompensationMode accelCompensation)
"""
return _libvncxx.VnSensor_writeDeltaThetaAndDeltaVelocityConfiguration(self, *args)
def read_reference_vector_configuration(self):
"""read_reference_vector_configuration(VnSensor self) -> ReferenceVectorConfigurationRegister"""
return _libvncxx.VnSensor_read_reference_vector_configuration(self)
def write_reference_vector_configuration(self, *args):
"""
write_reference_vector_configuration(VnSensor self, ReferenceVectorConfigurationRegister fields, bool waitForReply=True)
write_reference_vector_configuration(VnSensor self, ReferenceVectorConfigurationRegister fields)
write_reference_vector_configuration(VnSensor self, uint8_t const & useMagModel, uint8_t const & useGravityModel, uint32_t const & recalcThreshold, float const & year, vec3d position, bool waitForReply=True)
write_reference_vector_configuration(VnSensor self, uint8_t const & useMagModel, uint8_t const & useGravityModel, uint32_t const & recalcThreshold, float const & year, vec3d position)
"""
return _libvncxx.VnSensor_write_reference_vector_configuration(self, *args)
def read_gyro_compensation(self):
"""read_gyro_compensation(VnSensor self) -> GyroCompensationRegister"""
return _libvncxx.VnSensor_read_gyro_compensation(self)
def write_gyro_compensation(self, *args):
"""
write_gyro_compensation(VnSensor self, GyroCompensationRegister fields, bool waitForReply=True)
write_gyro_compensation(VnSensor self, GyroCompensationRegister fields)
write_gyro_compensation(VnSensor self, mat3f c, vec3f b, bool waitForReply=True)
write_gyro_compensation(VnSensor self, mat3f c, vec3f b)
"""
return _libvncxx.VnSensor_write_gyro_compensation(self, *args)
def read_imu_filtering_configuration(self):
"""read_imu_filtering_configuration(VnSensor self) -> ImuFilteringConfigurationRegister"""
return _libvncxx.VnSensor_read_imu_filtering_configuration(self)
def write_imu_filtering_configuration(self, *args):
"""
write_imu_filtering_configuration(VnSensor self, ImuFilteringConfigurationRegister fields, bool waitForReply=True)
write_imu_filtering_configuration(VnSensor self, ImuFilteringConfigurationRegister fields)
write_imu_filtering_configuration(VnSensor self, uint16_t const & magWindowSize, uint16_t const & accelWindowSize, uint16_t const & gyroWindowSize, uint16_t const & tempWindowSize, uint16_t const & presWindowSize, vn::protocol::uart::FilterMode magFilterMode, vn::protocol::uart::FilterMode accelFilterMode, vn::protocol::uart::FilterMode gyroFilterMode, vn::protocol::uart::FilterMode tempFilterMode, vn::protocol::uart::FilterMode presFilterMode, bool waitForReply=True)
write_imu_filtering_configuration(VnSensor self, uint16_t const & magWindowSize, uint16_t const & accelWindowSize, uint16_t const & gyroWindowSize, uint16_t const & tempWindowSize, uint16_t const & presWindowSize, vn::protocol::uart::FilterMode magFilterMode, vn::protocol::uart::FilterMode accelFilterMode, vn::protocol::uart::FilterMode gyroFilterMode, vn::protocol::uart::FilterMode tempFilterMode, vn::protocol::uart::FilterMode presFilterMode)
"""
return _libvncxx.VnSensor_write_imu_filtering_configuration(self, *args)
def read_gps_compass_baseline(self):
"""read_gps_compass_baseline(VnSensor self) -> GpsCompassBaselineRegister"""
return _libvncxx.VnSensor_read_gps_compass_baseline(self)
def write_gps_compass_baseline(self, *args):
"""
write_gps_compass_baseline(VnSensor self, GpsCompassBaselineRegister fields, bool waitForReply=True)
write_gps_compass_baseline(VnSensor self, GpsCompassBaselineRegister fields)
write_gps_compass_baseline(VnSensor self, vec3f position, vec3f uncertainty, bool waitForReply=True)
write_gps_compass_baseline(VnSensor self, vec3f position, vec3f uncertainty)
"""
return _libvncxx.VnSensor_write_gps_compass_baseline(self, *args)
def read_gps_compass_estimated_baseline(self):
"""read_gps_compass_estimated_baseline(VnSensor self) -> GpsCompassEstimatedBaselineRegister"""
return _libvncxx.VnSensor_read_gps_compass_estimated_baseline(self)
def read_imu_rate_configuration(self):
"""read_imu_rate_configuration(VnSensor self) -> ImuRateConfigurationRegister"""
return _libvncxx.VnSensor_read_imu_rate_configuration(self)
def write_imu_rate_configuration(self, *args):
"""
write_imu_rate_configuration(VnSensor self, ImuRateConfigurationRegister fields, bool waitForReply=True)
write_imu_rate_configuration(VnSensor self, ImuRateConfigurationRegister fields)
write_imu_rate_configuration(VnSensor self, uint16_t const & imuRate, uint16_t const & navDivisor, float const & filterTargetRate, float const & filterMinRate, bool waitForReply=True)
write_imu_rate_configuration(VnSensor self, uint16_t const & imuRate, uint16_t const & navDivisor, float const & filterTargetRate, float const & filterMinRate)
"""
return _libvncxx.VnSensor_write_imu_rate_configuration(self, *args)
def read_yaw_pitch_roll_true_body_acceleration_and_angular_rates_register(self):
"""read_yaw_pitch_roll_true_body_acceleration_and_angular_rates_register(VnSensor self) -> YawPitchRollTrueBodyAccelerationAndAngularRatesRegister"""
return _libvncxx.VnSensor_read_yaw_pitch_roll_true_body_acceleration_and_angular_rates_register(self)
def read_yaw_pitch_roll_true_inertial_acceleration_and_angular_rates_register(self):
"""read_yaw_pitch_roll_true_inertial_acceleration_and_angular_rates_register(VnSensor self) -> YawPitchRollTrueInertialAccelerationAndAngularRatesRegister"""
return _libvncxx.VnSensor_read_yaw_pitch_roll_true_inertial_acceleration_and_angular_rates_register(self)
__swig_getmethods__["baudrate"] = _libvncxx.VnSensor_baudrate_get
if _newclass:
baudrate = _swig_property(_libvncxx.VnSensor_baudrate_get)
__swig_getmethods__["port"] = _libvncxx.VnSensor_port_get
if _newclass:
port = _swig_property(_libvncxx.VnSensor_port_get)
__swig_setmethods__["send_error_detection_mode"] = _libvncxx.VnSensor_send_error_detection_mode_set
__swig_getmethods__["send_error_detection_mode"] = _libvncxx.VnSensor_send_error_detection_mode_get
if _newclass:
send_error_detection_mode = _swig_property(_libvncxx.VnSensor_send_error_detection_mode_get, _libvncxx.VnSensor_send_error_detection_mode_set)
__swig_getmethods__["is_connected"] = _libvncxx.VnSensor_is_connected_get
if _newclass:
is_connected = _swig_property(_libvncxx.VnSensor_is_connected_get)
__swig_setmethods__["response_timeout_ms"] = _libvncxx.VnSensor_response_timeout_ms_set
__swig_getmethods__["response_timeout_ms"] = _libvncxx.VnSensor_response_timeout_ms_get
if _newclass:
response_timeout_ms = _swig_property(_libvncxx.VnSensor_response_timeout_ms_get, _libvncxx.VnSensor_response_timeout_ms_set)
__swig_setmethods__["retransmit_delay_ms"] = _libvncxx.VnSensor_retransmit_delay_ms_set
__swig_getmethods__["retransmit_delay_ms"] = _libvncxx.VnSensor_retransmit_delay_ms_get
if _newclass:
retransmit_delay_ms = _swig_property(_libvncxx.VnSensor_retransmit_delay_ms_get, _libvncxx.VnSensor_retransmit_delay_ms_set)
@classmethod
def supported_baudrates(cls):
return list(cls.__supported_baudrates())
def __repr__(self):
return "<vnpy.VnSensor>"
VnSensor_swigregister = _libvncxx.VnSensor_swigregister
VnSensor_swigregister(VnSensor)
def VnSensor___supported_baudrates():
"""VnSensor___supported_baudrates() -> UInt32Vector"""
return _libvncxx.VnSensor___supported_baudrates()
def VnSensor_supportedAsyncDataOutputFrequencies():
"""VnSensor_supportedAsyncDataOutputFrequencies() -> UInt32Vector"""
return _libvncxx.VnSensor_supportedAsyncDataOutputFrequencies()
def VnSensor_determine_device_family(*args):
"""
determine_device_family() -> vn::sensors::VnSensor::Family
VnSensor_determine_device_family(std::string modelNumber) -> vn::sensors::VnSensor::Family
"""
return _libvncxx.VnSensor_determine_device_family(*args)
class UInt32Vector(_object):
"""Proxy of C++ std::vector<(uint32_t)> class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, UInt32Vector, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, UInt32Vector, name)
__repr__ = _swig_repr
def iterator(self):
"""iterator(UInt32Vector self) -> SwigPyIterator"""
return _libvncxx.UInt32Vector_iterator(self)
def __iter__(self):
return self.iterator()
def __nonzero__(self):
"""__nonzero__(UInt32Vector self) -> bool"""
return _libvncxx.UInt32Vector___nonzero__(self)
def __bool__(self):
"""__bool__(UInt32Vector self) -> bool"""
return _libvncxx.UInt32Vector___bool__(self)
def __len__(self):
"""__len__(UInt32Vector self) -> std::vector< unsigned int >::size_type"""
return _libvncxx.UInt32Vector___len__(self)
def __getslice__(self, i, j):
"""__getslice__(UInt32Vector self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j) -> UInt32Vector"""
return _libvncxx.UInt32Vector___getslice__(self, i, j)
def __setslice__(self, *args):
"""
__setslice__(UInt32Vector self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j)
__setslice__(UInt32Vector self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j, UInt32Vector v)
"""
return _libvncxx.UInt32Vector___setslice__(self, *args)
def __delslice__(self, i, j):
"""__delslice__(UInt32Vector self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j)"""
return _libvncxx.UInt32Vector___delslice__(self, i, j)
def __delitem__(self, *args):
"""
__delitem__(UInt32Vector self, std::vector< unsigned int >::difference_type i)
__delitem__(UInt32Vector self, PySliceObject * slice)
"""
return _libvncxx.UInt32Vector___delitem__(self, *args)
def __getitem__(self, *args):
"""
__getitem__(UInt32Vector self, PySliceObject * slice) -> UInt32Vector
__getitem__(UInt32Vector self, std::vector< unsigned int >::difference_type i) -> std::vector< unsigned int >::value_type const &
"""
return _libvncxx.UInt32Vector___getitem__(self, *args)
def __setitem__(self, *args):
"""
__setitem__(UInt32Vector self, PySliceObject * slice, UInt32Vector v)
__setitem__(UInt32Vector self, PySliceObject * slice)
__setitem__(UInt32Vector self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::value_type const & x)
"""
return _libvncxx.UInt32Vector___setitem__(self, *args)
def pop(self):
"""pop(UInt32Vector self) -> std::vector< unsigned int >::value_type"""
return _libvncxx.UInt32Vector_pop(self)
def append(self, x):
"""append(UInt32Vector self, std::vector< unsigned int >::value_type const & x)"""
return _libvncxx.UInt32Vector_append(self, x)
def empty(self):
"""empty(UInt32Vector self) -> bool"""
return _libvncxx.UInt32Vector_empty(self)
def size(self):
"""size(UInt32Vector self) -> std::vector< unsigned int >::size_type"""
return _libvncxx.UInt32Vector_size(self)
def swap(self, v):
"""swap(UInt32Vector self, UInt32Vector v)"""
return _libvncxx.UInt32Vector_swap(self, v)
def begin(self):
"""begin(UInt32Vector self) -> std::vector< unsigned int >::iterator"""
return _libvncxx.UInt32Vector_begin(self)
def end(self):
"""end(UInt32Vector self) -> std::vector< unsigned int >::iterator"""
return _libvncxx.UInt32Vector_end(self)
def rbegin(self):
"""rbegin(UInt32Vector self) -> std::vector< unsigned int >::reverse_iterator"""
return _libvncxx.UInt32Vector_rbegin(self)
def rend(self):
"""rend(UInt32Vector self) -> std::vector< unsigned int >::reverse_iterator"""
return _libvncxx.UInt32Vector_rend(self)
def clear(self):
"""clear(UInt32Vector self)"""
return _libvncxx.UInt32Vector_clear(self)
def get_allocator(self):
"""get_allocator(UInt32Vector self) -> std::vector< unsigned int >::allocator_type"""
return _libvncxx.UInt32Vector_get_allocator(self)
def pop_back(self):
"""pop_back(UInt32Vector self)"""
return _libvncxx.UInt32Vector_pop_back(self)
def erase(self, *args):
"""
erase(UInt32Vector self, std::vector< unsigned int >::iterator pos) -> std::vector< unsigned int >::iterator
erase(UInt32Vector self, std::vector< unsigned int >::iterator first, std::vector< unsigned int >::iterator last) -> std::vector< unsigned int >::iterator
"""
return _libvncxx.UInt32Vector_erase(self, *args)
def __init__(self, *args):
"""
__init__(std::vector<(uint32_t)> self) -> UInt32Vector
__init__(std::vector<(uint32_t)> self, UInt32Vector arg2) -> UInt32Vector
__init__(std::vector<(uint32_t)> self, std::vector< unsigned int >::size_type size) -> UInt32Vector
__init__(std::vector<(uint32_t)> self, std::vector< unsigned int >::size_type size, std::vector< unsigned int >::value_type const & value) -> UInt32Vector
"""
this = _libvncxx.new_UInt32Vector(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
def push_back(self, x):
"""push_back(UInt32Vector self, std::vector< unsigned int >::value_type const & x)"""
return _libvncxx.UInt32Vector_push_back(self, x)
def front(self):
"""front(UInt32Vector self) -> std::vector< unsigned int >::value_type const &"""
return _libvncxx.UInt32Vector_front(self)
def back(self):
"""back(UInt32Vector self) -> std::vector< unsigned int >::value_type const &"""
return _libvncxx.UInt32Vector_back(self)
def assign(self, n, x):
"""assign(UInt32Vector self, std::vector< unsigned int >::size_type n, std::vector< unsigned int >::value_type const & x)"""
return _libvncxx.UInt32Vector_assign(self, n, x)
def resize(self, *args):
"""
resize(UInt32Vector self, std::vector< unsigned int >::size_type new_size)
resize(UInt32Vector self, std::vector< unsigned int >::size_type new_size, std::vector< unsigned int >::value_type const & x)
"""
return _libvncxx.UInt32Vector_resize(self, *args)
def insert(self, *args):
"""
insert(UInt32Vector self, std::vector< unsigned int >::iterator pos, std::vector< unsigned int >::value_type const & x) -> std::vector< unsigned int >::iterator
insert(UInt32Vector self, std::vector< unsigned int >::iterator pos, std::vector< unsigned int >::size_type n, std::vector< unsigned int >::value_type const & x)
"""
return _libvncxx.UInt32Vector_insert(self, *args)
def reserve(self, n):
"""reserve(UInt32Vector self, std::vector< unsigned int >::size_type n)"""
return _libvncxx.UInt32Vector_reserve(self, n)
def capacity(self):
"""capacity(UInt32Vector self) -> std::vector< unsigned int >::size_type"""
return _libvncxx.UInt32Vector_capacity(self)
__swig_destroy__ = _libvncxx.delete_UInt32Vector
__del__ = lambda self: None
UInt32Vector_swigregister = _libvncxx.UInt32Vector_swigregister
UInt32Vector_swigregister(UInt32Vector)
class CompositeData(_object):
"""Proxy of C++ vn::sensors::CompositeData class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, CompositeData, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, CompositeData, name)
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(vn::sensors::CompositeData self) -> CompositeData
__init__(vn::sensors::CompositeData self, CompositeData cd) -> CompositeData
"""
this = _libvncxx.new_CompositeData(*args)
try:
self.this.append(this)
except __builtin__.Exception:
self.this = this
__swig_destroy__ = _libvncxx.delete_CompositeData
__del__ = lambda self: None
def parse(*args):
"""
parse(Packet p) -> CompositeData
parse(Packet p, CompositeData o)
parse(Packet p, std::vector< vn::sensors::CompositeData *,std::allocator< vn::sensors::CompositeData * > > & o)
"""
return _libvncxx.CompositeData_parse(*args)
parse = staticmethod(parse)
def reset(self):
"""reset(CompositeData self)"""
return _libvncxx.CompositeData_reset(self)
def __hasAnyAttitude(self):
"""__hasAnyAttitude(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasAnyAttitude(self)
def __anyAttitude(self):
"""__anyAttitude(CompositeData self) -> Attitude"""
return _libvncxx.CompositeData___anyAttitude(self)
def __hasYawPitchRoll(self):
"""__hasYawPitchRoll(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasYawPitchRoll(self)
def __yawPitchRoll(self):
"""__yawPitchRoll(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___yawPitchRoll(self)
def __hasQuaternion(self):
"""__hasQuaternion(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasQuaternion(self)
def __quaternion(self):
"""__quaternion(CompositeData self) -> vec4f"""
return _libvncxx.CompositeData___quaternion(self)
def __hasDirectionCosineMatrix(self):
"""__hasDirectionCosineMatrix(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasDirectionCosineMatrix(self)
def __directionCosineMatrix(self):
"""__directionCosineMatrix(CompositeData self) -> mat3f"""
return _libvncxx.CompositeData___directionCosineMatrix(self)
def __hasAnyMagnetic(self):
"""__hasAnyMagnetic(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasAnyMagnetic(self)
def __anyMagnetic(self):
"""__anyMagnetic(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___anyMagnetic(self)
def __hasMagnetic(self):
"""__hasMagnetic(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasMagnetic(self)
def __magnetic(self):
"""__magnetic(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___magnetic(self)
def __hasMagneticUncompensated(self):
"""__hasMagneticUncompensated(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasMagneticUncompensated(self)
def __magneticUncompensated(self):
"""__magneticUncompensated(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___magneticUncompensated(self)
def __hasMagneticNed(self):
"""__hasMagneticNed(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasMagneticNed(self)
def __magneticNed(self):
"""__magneticNed(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___magneticNed(self)
def __hasMagneticEcef(self):
"""__hasMagneticEcef(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasMagneticEcef(self)
def __magneticEcef(self):
"""__magneticEcef(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___magneticEcef(self)
def __hasAnyAcceleration(self):
"""__hasAnyAcceleration(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasAnyAcceleration(self)
def __anyAcceleration(self):
"""__anyAcceleration(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___anyAcceleration(self)
def __hasAcceleration(self):
"""__hasAcceleration(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasAcceleration(self)
def __acceleration(self):
"""__acceleration(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___acceleration(self)
def __hasAccelerationLinearBody(self):
"""__hasAccelerationLinearBody(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasAccelerationLinearBody(self)
def __accelerationLinearBody(self):
"""__accelerationLinearBody(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___accelerationLinearBody(self)
def __hasAccelerationUncompensated(self):
"""__hasAccelerationUncompensated(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasAccelerationUncompensated(self)
def __accelerationUncompensated(self):
"""__accelerationUncompensated(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___accelerationUncompensated(self)
def __hasAccelerationLinearNed(self):
"""__hasAccelerationLinearNed(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasAccelerationLinearNed(self)
def __accelerationLinearNed(self):
"""__accelerationLinearNed(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___accelerationLinearNed(self)
def __hasAccelerationLinearEcef(self):
"""__hasAccelerationLinearEcef(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasAccelerationLinearEcef(self)
def __accelerationLinearEcef(self):
"""__accelerationLinearEcef(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___accelerationLinearEcef(self)
def __hasAccelerationNed(self):
"""__hasAccelerationNed(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasAccelerationNed(self)
def __accelerationNed(self):
"""__accelerationNed(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___accelerationNed(self)
def __hasAccelerationEcef(self):
"""__hasAccelerationEcef(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasAccelerationEcef(self)
def __accelerationEcef(self):
"""__accelerationEcef(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___accelerationEcef(self)
def __hasAnyAngularRate(self):
"""__hasAnyAngularRate(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasAnyAngularRate(self)
def __anyAngularRate(self):
"""__anyAngularRate(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___anyAngularRate(self)
def __hasAngularRate(self):
"""__hasAngularRate(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasAngularRate(self)
def __angularRate(self):
"""__angularRate(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___angularRate(self)
def __hasAngularRateUncompensated(self):
"""__hasAngularRateUncompensated(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasAngularRateUncompensated(self)
def __angularRateUncompensated(self):
"""__angularRateUncompensated(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___angularRateUncompensated(self)
def __hasAnyTemperature(self):
"""__hasAnyTemperature(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasAnyTemperature(self)
def __anyTemperature(self):
"""__anyTemperature(CompositeData self) -> float"""
return _libvncxx.CompositeData___anyTemperature(self)
def __hasTemperature(self):
"""__hasTemperature(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasTemperature(self)
def __temperature(self):
"""__temperature(CompositeData self) -> float"""
return _libvncxx.CompositeData___temperature(self)
def __hasAnyPressure(self):
"""__hasAnyPressure(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasAnyPressure(self)
def __anyPressure(self):
"""__anyPressure(CompositeData self) -> float"""
return _libvncxx.CompositeData___anyPressure(self)
def __hasPressure(self):
"""__hasPressure(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasPressure(self)
def __pressure(self):
"""__pressure(CompositeData self) -> float"""
return _libvncxx.CompositeData___pressure(self)
def __hasAnyPosition(self):
"""__hasAnyPosition(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasAnyPosition(self)
def __anyPosition(self):
"""__anyPosition(CompositeData self) -> Position"""
return _libvncxx.CompositeData___anyPosition(self)
def __hasPositionGpsLla(self):
"""__hasPositionGpsLla(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasPositionGpsLla(self)
def __positionGpsLla(self):
"""__positionGpsLla(CompositeData self) -> vec3d"""
return _libvncxx.CompositeData___positionGpsLla(self)
def __hasPositionGpsEcef(self):
"""__hasPositionGpsEcef(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasPositionGpsEcef(self)
def __positionGpsEcef(self):
"""__positionGpsEcef(CompositeData self) -> vec3d"""
return _libvncxx.CompositeData___positionGpsEcef(self)
def __hasPositionEstimatedLla(self):
"""__hasPositionEstimatedLla(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasPositionEstimatedLla(self)
def __positionEstimatedLla(self):
"""__positionEstimatedLla(CompositeData self) -> vec3d"""
return _libvncxx.CompositeData___positionEstimatedLla(self)
def __hasPositionEstimatedEcef(self):
"""__hasPositionEstimatedEcef(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasPositionEstimatedEcef(self)
def __positionEstimatedEcef(self):
"""__positionEstimatedEcef(CompositeData self) -> vec3d"""
return _libvncxx.CompositeData___positionEstimatedEcef(self)
def __hasAnyVelocity(self):
"""__hasAnyVelocity(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasAnyVelocity(self)
def __anyVelocity(self):
"""__anyVelocity(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___anyVelocity(self)
def __hasVelocityGpsNed(self):
"""__hasVelocityGpsNed(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasVelocityGpsNed(self)
def __velocityGpsNed(self):
"""__velocityGpsNed(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___velocityGpsNed(self)
def __hasVelocityGpsEcef(self):
"""__hasVelocityGpsEcef(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasVelocityGpsEcef(self)
def __velocityGpsEcef(self):
"""__velocityGpsEcef(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___velocityGpsEcef(self)
def __hasVelocityEstimatedNed(self):
"""__hasVelocityEstimatedNed(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasVelocityEstimatedNed(self)
def __velocityEstimatedNed(self):
"""__velocityEstimatedNed(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___velocityEstimatedNed(self)
def __hasVelocityEstimatedEcef(self):
"""__hasVelocityEstimatedEcef(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasVelocityEstimatedEcef(self)
def __velocityEstimatedEcef(self):
"""__velocityEstimatedEcef(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___velocityEstimatedEcef(self)
def __hasVelocityEstimatedBody(self):
"""__hasVelocityEstimatedBody(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasVelocityEstimatedBody(self)
def __velocityEstimatedBody(self):
"""__velocityEstimatedBody(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___velocityEstimatedBody(self)
def __hasDeltaTime(self):
"""__hasDeltaTime(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasDeltaTime(self)
def __deltaTime(self):
"""__deltaTime(CompositeData self) -> float"""
return _libvncxx.CompositeData___deltaTime(self)
def __hasDeltaTheta(self):
"""__hasDeltaTheta(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasDeltaTheta(self)
def __deltaTheta(self):
"""__deltaTheta(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___deltaTheta(self)
def __hasDeltaVelocity(self):
"""__hasDeltaVelocity(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasDeltaVelocity(self)
def __deltaVelocity(self):
"""__deltaVelocity(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___deltaVelocity(self)
def __hasTimeStartup(self):
"""__hasTimeStartup(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasTimeStartup(self)
def __timeStartup(self):
"""__timeStartup(CompositeData self) -> uint64_t"""
return _libvncxx.CompositeData___timeStartup(self)
def __hasTimeGps(self):
"""__hasTimeGps(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasTimeGps(self)
def __timeGps(self):
"""__timeGps(CompositeData self) -> uint64_t"""
return _libvncxx.CompositeData___timeGps(self)
def __hasTow(self):
"""__hasTow(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasTow(self)
def __tow(self):
"""__tow(CompositeData self) -> double"""
return _libvncxx.CompositeData___tow(self)
def __hasWeek(self):
"""__hasWeek(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasWeek(self)
def __week(self):
"""__week(CompositeData self) -> uint16_t"""
return _libvncxx.CompositeData___week(self)
def __hasNumSats(self):
"""__hasNumSats(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasNumSats(self)
def __numSats(self):
"""__numSats(CompositeData self) -> uint8_t"""
return _libvncxx.CompositeData___numSats(self)
def __hasTimeSyncIn(self):
"""__hasTimeSyncIn(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasTimeSyncIn(self)
def __timeSyncIn(self):
"""__timeSyncIn(CompositeData self) -> uint64_t"""
return _libvncxx.CompositeData___timeSyncIn(self)
def __hasVpeStatus(self):
"""__hasVpeStatus(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasVpeStatus(self)
def __vpeStatus(self):
"""__vpeStatus(CompositeData self) -> VpeStatus"""
return _libvncxx.CompositeData___vpeStatus(self)
def __hasInsStatus(self):
"""__hasInsStatus(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasInsStatus(self)
def __insStatus(self):
"""__insStatus(CompositeData self) -> vn::protocol::uart::InsStatus"""
return _libvncxx.CompositeData___insStatus(self)
def __hasSyncInCnt(self):
"""__hasSyncInCnt(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasSyncInCnt(self)
def __syncInCnt(self):
"""__syncInCnt(CompositeData self) -> uint32_t"""
return _libvncxx.CompositeData___syncInCnt(self)
def __hasTimeGpsPps(self):
"""__hasTimeGpsPps(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasTimeGpsPps(self)
def __timeGpsPps(self):
"""__timeGpsPps(CompositeData self) -> uint64_t"""
return _libvncxx.CompositeData___timeGpsPps(self)
def __hasGpsTow(self):
"""__hasGpsTow(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasGpsTow(self)
def __gpsTow(self):
"""__gpsTow(CompositeData self) -> uint64_t"""
return _libvncxx.CompositeData___gpsTow(self)
def __hasTimeUtc(self):
"""__hasTimeUtc(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasTimeUtc(self)
def __timeUtc(self):
"""__timeUtc(CompositeData self) -> TimeUtc"""
return _libvncxx.CompositeData___timeUtc(self)
def __hasSensSat(self):
"""__hasSensSat(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasSensSat(self)
def __sensSat(self):
"""__sensSat(CompositeData self) -> vn::protocol::uart::SensSat"""
return _libvncxx.CompositeData___sensSat(self)
def __hasFix(self):
"""__hasFix(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasFix(self)
def __fix(self):
"""__fix(CompositeData self) -> vn::protocol::uart::GpsFix"""
return _libvncxx.CompositeData___fix(self)
def __hasAnyPositionUncertainty(self):
"""__hasAnyPositionUncertainty(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasAnyPositionUncertainty(self)
def __anyPositionUncertainty(self):
"""__anyPositionUncertainty(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___anyPositionUncertainty(self)
def __hasPositionUncertaintyGpsNed(self):
"""__hasPositionUncertaintyGpsNed(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasPositionUncertaintyGpsNed(self)
def __positionUncertaintyGpsNed(self):
"""__positionUncertaintyGpsNed(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___positionUncertaintyGpsNed(self)
def __hasPositionUncertaintyGpsEcef(self):
"""__hasPositionUncertaintyGpsEcef(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasPositionUncertaintyGpsEcef(self)
def __positionUncertaintyGpsEcef(self):
"""__positionUncertaintyGpsEcef(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___positionUncertaintyGpsEcef(self)
def __hasPositionUncertaintyEstimated(self):
"""__hasPositionUncertaintyEstimated(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasPositionUncertaintyEstimated(self)
def __positionUncertaintyEstimated(self):
"""__positionUncertaintyEstimated(CompositeData self) -> float"""
return _libvncxx.CompositeData___positionUncertaintyEstimated(self)
def __hasAnyVelocityUncertainty(self):
"""__hasAnyVelocityUncertainty(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasAnyVelocityUncertainty(self)
def __anyVelocityUncertainty(self):
"""__anyVelocityUncertainty(CompositeData self) -> float"""
return _libvncxx.CompositeData___anyVelocityUncertainty(self)
def __hasVelocityUncertaintyGps(self):
"""__hasVelocityUncertaintyGps(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasVelocityUncertaintyGps(self)
def __velocityUncertaintyGps(self):
"""__velocityUncertaintyGps(CompositeData self) -> float"""
return _libvncxx.CompositeData___velocityUncertaintyGps(self)
def __hasVelocityUncertaintyEstimated(self):
"""__hasVelocityUncertaintyEstimated(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasVelocityUncertaintyEstimated(self)
def __velocityUncertaintyEstimated(self):
"""__velocityUncertaintyEstimated(CompositeData self) -> float"""
return _libvncxx.CompositeData___velocityUncertaintyEstimated(self)
def __hasTimeUncertainty(self):
"""__hasTimeUncertainty(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasTimeUncertainty(self)
def __timeUncertainty(self):
"""__timeUncertainty(CompositeData self) -> uint32_t"""
return _libvncxx.CompositeData___timeUncertainty(self)
def __hasAttitudeUncertainty(self):
"""__hasAttitudeUncertainty(CompositeData self) -> bool"""
return _libvncxx.CompositeData___hasAttitudeUncertainty(self)
def __attitudeUncertainty(self):
"""__attitudeUncertainty(CompositeData self) -> vec3f"""
return _libvncxx.CompositeData___attitudeUncertainty(self)
def hasCourseOverGround(self):
"""hasCourseOverGround(CompositeData self) -> bool"""
return _libvncxx.CompositeData_hasCourseOverGround(self)
def courseOverGround(self):
"""courseOverGround(CompositeData self) -> float"""
return _libvncxx.CompositeData_courseOverGround(self)
def hasSpeedOverGround(self):
"""hasSpeedOverGround(CompositeData self) -> bool"""
return _libvncxx.CompositeData_hasSpeedOverGround(self)
def speedOverGround(self):
"""speedOverGround(CompositeData self) -> float"""
return _libvncxx.CompositeData_speedOverGround(self)
has_any_attitude = property(__hasAnyAttitude)
any_attitude = property(__anyAttitude)
has_yaw_pitch_roll = property(__hasYawPitchRoll)
yaw_pitch_roll = property(__yawPitchRoll)
has_quaternion = property(__hasQuaternion)
quaternion = property(__quaternion)
has_direction_cosine_matrix = property(__hasDirectionCosineMatrix)
direction_cosine_matrix = property(__directionCosineMatrix)
has_any_magnetic = property(__hasAnyMagnetic)
any_magnetic = property(__anyMagnetic)
has_magnetic = property(__hasMagnetic)
magnetic = property(__magnetic)
has_magnetic_uncompensated = property(__hasMagneticUncompensated)
magnetic_uncompensated = property(__magneticUncompensated)
has_magnetic_ned = property(__hasMagneticNed)
magnetic_ned = property(__magneticNed)
has_magnetic_ecef = property(__hasMagneticEcef)
magnetic_ecef = property(__magneticEcef)
has_any_acceleration = property(__hasAnyAcceleration)
any_acceleration = property(__anyAcceleration)
has_acceleration = property(__hasAcceleration)
acceleration = property(__acceleration)
has_acceleration_linear_body = property(__hasAccelerationLinearBody)
acceleration_linear_body = property(__accelerationLinearBody)
has_acceleration_uncompensated = property(__hasAccelerationUncompensated)
acceleration_uncompensated = property(__accelerationUncompensated)
has_acceleration_linear_ned = property(__hasAccelerationLinearNed)
acceleration_linear_ned = property(__accelerationLinearNed)
has_acceleration_linear_ecef = property(__hasAccelerationLinearEcef)
acceleration_linear_ecef = property(__accelerationLinearEcef)
has_acceleration_ned = property(__hasAccelerationNed)
acceleration_ned = property(__accelerationNed)
has_acceleration_ecef = property(__hasAccelerationEcef)
acceleration_ecef = property(__accelerationEcef)
has_any_angular_rate = property(__hasAnyAngularRate)
any_angular_rate = property(__anyAngularRate)
has_angular_rate = property(__hasAngularRate)
angular_rate = property(__angularRate)
has_angular_rate_uncompensated = property(__hasAngularRateUncompensated)
angular_rate_uncompensated = property(__angularRateUncompensated)
has_any_temperature = property(__hasAnyTemperature)
any_temperature = property(__anyTemperature)
has_temperature = property(__hasTemperature)
temperature = property(__temperature)
has_any_pressure = property(__hasAnyPressure)
any_pressure = property(__anyPressure)
has_pressure = property(__hasPressure)
pressure = property(__pressure)
has_any_position = property(__hasAnyPosition)
any_position = property(__anyPosition)
has_position_gps_lla = property(__hasPositionGpsLla)
position_gps_lla = property(__positionGpsLla)
has_position_gps_ecef = property(__hasPositionGpsEcef)
position_gps_ecef = property(__positionGpsEcef)
has_position_estimated_lla = property(__hasPositionEstimatedLla)
position_estimated_lla = property(__positionEstimatedLla)
has_position_estimated_ecef = property(__hasPositionEstimatedEcef)
position_estimated_ecef = property(__positionEstimatedEcef)
has_any_velocity = property(__hasAnyVelocity)
any_velocity = property(__anyVelocity)
has_velocity_gps_ned = property(__hasVelocityGpsNed)
velocity_gps_ned = property(__velocityGpsNed)
has_velocity_gps_ecef = property(__hasVelocityGpsEcef)
velocity_gps_ecef = property(__velocityGpsEcef)
has_velocity_estimated_ned = property(__hasVelocityEstimatedNed)
velocity_estimated_ned = property(__velocityEstimatedNed)
has_velocity_estimated_ecef = property(__hasVelocityEstimatedEcef)
velocity_estimated_ecef = property(__velocityEstimatedEcef)
has_velocity_estimated_body = property(__hasVelocityEstimatedBody)
velocity_estimated_body = property(__velocityEstimatedBody)
has_delta_time = property(__hasDeltaTime)
delta_time = property(__deltaTime)
has_delta_theta = property(__hasDeltaTheta)
delta_theta = property(__deltaTheta)
has_delta_velocity = property(__hasDeltaVelocity)
delta_velocity = property(__deltaVelocity)
has_time_startup = property(__hasTimeStartup)
time_startup = property(__timeStartup)
has_time_gps = property(__hasTimeGps)
time_gps = property(__timeGps)
has_tow = property(__hasTow)
tow = property(__tow)
has_week = property(__hasWeek)
week = property(__week)
has_num_sats = property(__hasNumSats)
num_sats = property(__numSats)
has_time_sync_in = property(__hasTimeSyncIn)
time_sync_in = property(__timeSyncIn)
has_vpe_status = property(__hasVpeStatus)
vpe_status = property(__vpeStatus)
has_ins_status = property(__hasInsStatus)
ins_status = property(__insStatus)
has_sync_in_cnt = property(__hasSyncInCnt)
sync_in_cnt = property(__syncInCnt)
has_time_gps_pps = property(__hasTimeGpsPps)
time_gps_pps = property(__timeGpsPps)
has_gps_tow = property(__hasGpsTow)
gps_tow = property(__gpsTow)
has_time_utc = property(__hasTimeUtc)
time_utc = property(__timeUtc)
has_sens_sat = property(__hasSensSat)
sens_sat = property(__sensSat)
has_fix = property(__hasFix)
fix = property(__fix)
has_any_position_uncertainty = property(__hasAnyPositionUncertainty)
any_position_uncertainty = property(__anyPositionUncertainty)
has_position_uncertainty_gps_ned = property(__hasPositionUncertaintyGpsNed)
position_uncertainty_gps_ned = property(__positionUncertaintyGpsNed)
has_position_uncertainty_gps_ecef = property(__hasPositionUncertaintyGpsEcef)
position_uncertainty_gps_ecef = property(__positionUncertaintyGpsEcef)
has_position_uncertainty_estimated = property(__hasPositionUncertaintyEstimated)
position_uncertainty_estimated = property(__positionUncertaintyEstimated)
has_any_velocity_uncertainty = property(__hasAnyVelocityUncertainty)
any_velocity_uncertainty = property(__anyVelocityUncertainty)
has_velocity_uncertainty_gps = property(__hasVelocityUncertaintyGps)
velocity_uncertainty_gps = property(__velocityUncertaintyGps)
has_velocity_uncertainty_estimated = property(__hasVelocityUncertaintyEstimated)
velocity_uncertainty_estimated = property(__velocityUncertaintyEstimated)
has_time_uncertainty = property(__hasTimeUncertainty)
time_uncertainty = property(__timeUncertainty)
has_attitude_uncertainty = property(__hasAttitudeUncertainty)
attitude_uncertainty = property(__attitudeUncertainty)
def __repr__(self):
return "<vnpy.CompositeData>"
CompositeData_swigregister = _libvncxx.CompositeData_swigregister
CompositeData_swigregister(CompositeData)
def CompositeData_parse(*args):
"""
parse(Packet p) -> CompositeData
parse(Packet p, CompositeData o)
CompositeData_parse(Packet p, std::vector< vn::sensors::CompositeData *,std::allocator< vn::sensors::CompositeData * > > & o)
"""
return _libvncxx.CompositeData_parse(*args)
class EzAsyncData(_object):
"""Proxy of C++ vn::sensors::EzAsyncData class."""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, EzAsyncData, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, EzAsyncData, name)
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined")
__repr__ = _swig_repr
__swig_destroy__ = _libvncxx.delete_EzAsyncData
__del__ = lambda self: None
def __sensor(self):
"""__sensor(EzAsyncData self) -> VnSensor"""
return _libvncxx.EzAsyncData___sensor(self)
def connect(portName, baudrate):
"""connect(std::string portName, uint32_t baudrate) -> EzAsyncData"""
return _libvncxx.EzAsyncData_connect(portName, baudrate)
connect = staticmethod(connect)
def disconnect(self):
"""disconnect(EzAsyncData self)"""
return _libvncxx.EzAsyncData_disconnect(self)
def __currentData(self):
"""__currentData(EzAsyncData self) -> CompositeData"""
return _libvncxx.EzAsyncData___currentData(self)
def next_data(self, *args):
"""
next_data(EzAsyncData self) -> CompositeData
next_data(EzAsyncData self, int timeoutMs) -> CompositeData
"""
return _libvncxx.EzAsyncData_next_data(self, *args)
current_data = property(__currentData)
sensor = property(__sensor)
def __repr__(self):
return "<vnpy.EzAsyncData>"
EzAsyncData_swigregister = _libvncxx.EzAsyncData_swigregister
EzAsyncData_swigregister(EzAsyncData)
def EzAsyncData_connect(portName, baudrate):
"""EzAsyncData_connect(std::string portName, uint32_t baudrate) -> EzAsyncData"""
return _libvncxx.EzAsyncData_connect(portName, baudrate)
# This file is compatible with both classic and new-style classes.
|
nilq/baby-python
|
python
|
# Author: Calebe Elias Ribeiro Brim
# Last Update: 03/06/2018
import numpy as np
def bitsToBytes(values):
'''
Generate relative bits integers
Usage:
bitsToBytes(array.shape(1,10)) => array.shape(1,1)
bitsToBytes(array.shape(2,10)) => array.shape(2,1)
'''
ln = values.shape[1] if values.ndim > 1 else values.shape[0]
processed = np.array(values.dot(2**np.arange(ln)[::-1]))
return processed
def bitsNeededToNumber(number,nbits=1):
ar = np.array(np.ones((1, nbits)).dot(2**np.arange(nbits)[::-1]))
if ar >=number:
return nbits
else:
return bitsNeededToNumber(number,nbits+1)
# tests
def test_bitsNeeded():
assert bitsNeededToNumber(3)==2
def test_bitsToBytes():
assert bitsToBytes(np.array([[1, 1]])) == 3
def test_bitsToBytesOneDim():
assert bitsToBytes(np.array([1, 1])) == 3
def test_bitsToBytesMultiple():
values = bitsToBytes(np.array([[1, 1],[1,1]]))
assert values[0] == 3
assert values[1] == 3
|
nilq/baby-python
|
python
|
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'KeyWizard.ui'
#
# Created by: PyQt5 UI code generator 5.14.0
#
# WARNING! All changes made in this file will be lost!
from PyQt5 import QtCore, QtGui, QtWidgets
class Ui_KeyWizard(object):
def setupUi(self, KeyWizard):
KeyWizard.setObjectName("KeyWizard")
KeyWizard.resize(400, 189)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(KeyWizard.sizePolicy().hasHeightForWidth())
KeyWizard.setSizePolicy(sizePolicy)
KeyWizard.setModal(True)
self.label = QtWidgets.QLabel(KeyWizard)
self.label.setGeometry(QtCore.QRect(30, 20, 341, 141))
self.label.setAlignment(QtCore.Qt.AlignJustify|QtCore.Qt.AlignTop)
self.label.setWordWrap(True)
self.label.setObjectName("label")
self.lineEdit = QtWidgets.QLineEdit(KeyWizard)
self.lineEdit.setGeometry(QtCore.QRect(350, 160, 41, 21))
self.lineEdit.setCursor(QtGui.QCursor(QtCore.Qt.BlankCursor))
self.lineEdit.setAutoFillBackground(False)
self.lineEdit.setStyleSheet("background-color: transparent; border:none")
self.lineEdit.setClearButtonEnabled(False)
self.lineEdit.setObjectName("lineEdit")
self.retranslateUi(KeyWizard)
QtCore.QMetaObject.connectSlotsByName(KeyWizard)
def retranslateUi(self, KeyWizard):
_translate = QtCore.QCoreApplication.translate
KeyWizard.setWindowTitle(_translate("KeyWizard", "Key Wizard"))
self.label.setText(_translate("KeyWizard", "This is the Key Wizard. Simply press the key you would like to assign, and the key caption and keycodes will be set automatically. If you want to add functions for long presses or doubleclicks, or if you would like to add more captions, you can always edit the key manually later by doubleclicking it."))
|
nilq/baby-python
|
python
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from pygame import *
import os
PLATFORM_WIDTH = 32
PLATFORM_HEIGHT = 32
PLATFORM_COLOR = "#FF6262"
ICON_DIR = os.path.dirname(__file__) # Полный путь к каталогу с файлами
class Platform(sprite.Sprite):
def __init__(self, x, y):
sprite.Sprite.__init__(self)
self.image = Surface((PLATFORM_WIDTH, PLATFORM_HEIGHT))
self.image.fill(Color(PLATFORM_COLOR))
self.image = image.load("%s/blocks/platform.png" % ICON_DIR)
self.rect = Rect(x, y, PLATFORM_WIDTH, PLATFORM_HEIGHT)
|
nilq/baby-python
|
python
|
import sys
import os
from setuptools import setup
"""
Use pandoc to convert README.md to README.rst before uploading
$ pandoc README.md -o README.rst
"""
if "publish" in sys.argv:
os.system("python setup.py sdist upload")
os.system("python setup.py bdist_wheel upload")
sys.exit()
setup(
name="piprot",
version="0.10.0a",
author="Brenton Cleeland, Marcin Paliwoda",
author_email="paliwoda.marcin@zoho.com",
packages=["piprot", "piprot.models", "piprot.utils"],
url="http://github.com/mpaliwoda/piprot",
license="MIT License",
description="How rotten are your requirements?",
long_description="",
entry_points={"console_scripts": ["piprot = piprot.entrypoint:entrypoint"]},
install_requires=["aiohttp", "cchardet", "aiodns"],
classifiers=[
"Intended Audience :: Developers",
"Natural Language :: English",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python",
"Topic :: Utilities",
"Programming Language :: Python :: 3.7",
],
)
|
nilq/baby-python
|
python
|
"""Module for working with transcripts, creating transcript DBs and reading from transcript DB"""
from __future__ import division
import gzip
from operator import itemgetter
import pysam
import datetime
import os
class Transcript(object):
"""Class for a single transcript"""
def __init__(self, id=None, version=None, hgnc_id=None, chrom=None, start=None, end=None, strand=None, exons=None,
coding_start=None, coding_end=None, cdna_length=None, prot_length=None, info=None):
"""Constructor of Transcript class
Notes:
start, end: 0-based coordinates coordinates, inclusive for start, exclusive for end
coding_start, coding_end: 0-based coordinates (inclusive for both)
strand: + or -
exons: list of Exon objects
"""
self.id = id
self.version = version
self.hgnc_id = hgnc_id
self.chrom = chrom
self.start = start
self.end = end
self.strand = strand
self.exons = exons
self.coding_start = coding_start
self.coding_end = coding_end
self.cdna_length = cdna_length
self.prot_length = prot_length
self.info = info
def read_from_database_record(self, record):
"""Read transcript from transcript database record
Notes:
record is a dict of column:value pairs
"""
# Set attributes of transcript
for key, value in record.iteritems():
if key in ['start', 'end', 'coding_start', 'coding_end', 'cdna_coding_start', 'cdna_coding_end']:
value = int(value)
if key == 'exons':
self.exons = [Exon(s) for s in value.split(',')]
continue
setattr(self, key, value)
# Finalize transcript
self.finalize()
def set_info(self):
"""Calculate and sets the info field"""
if self._any_unset(['strand', 'start', 'end', 'exons', 'cdna_length', 'prot_length']): return
self.info = '+/' if self.strand == '+' else '-/'
self.info += str(round((self.end - self.start + 1) / 1000, 1)) + 'kb/'
self.info += str(len(self.exons)) + '/' + str(round(self.cdna_length / 1000, 1)) + 'kb/' + str(self.prot_length)
def cds_regions(self):
"""Return list of CDS regions
Notes:
Returned is a list of (x,y) pairs where coordinates x and y are 0-based, inclusive for x and exclusive for y
"""
if self._any_unset(['exons', 'coding_start', 'coding_end']):
return
ret = []
for exon in self.exons:
cds_region = exon.get_cds(self.coding_start, self.coding_end)
if cds_region is not None:
ret.append(cds_region)
return ret
def utr5_regions(self):
"""Return list of UTR5 regions
Notes:
Returned is a list of (x,y) pairs where coordinates x and y are 0-based, inclusive for x and exclusive for y
"""
if self._any_unset(['exons', 'coding_start', 'strand']):
return
ret = []
for exon in self.exons:
utr5_region = exon.get_utr5(self.coding_start, self.strand)
if utr5_region is not None:
ret.append(utr5_region)
return ret
def utr3_regions(self):
"""Return list of UTR3 regions
Notes:
Returned is a list of (x,y) pairs where coordinates x and y are 0-based, inclusive for x and exclusive for y
"""
if self._any_unset(['exons', 'coding_end', 'strand']):
return
ret = []
for exon in self.exons:
utr3_region = exon.get_utr3(self.coding_end, self.strand)
if utr3_region is not None:
ret.append(utr3_region)
return ret
def get_cdna_length(self):
"""Return cDNA length"""
if self.exons is None: return
ret = 0
for e in self.exons: ret += e.length()
return ret
def get_cds_length(self):
"""Return CDS length"""
cds_regions = self.cds_regions()
if cds_regions is None:
return
ret = 0
for (cds_start, cds_end) in cds_regions:
ret += cds_end - cds_start
return ret
def get_protein_length(self):
"""Return protein length"""
cds_length = self.get_cds_length()
if cds_length is None:
return
return int((cds_length - 3) / 3)
def finalize(self):
"""Finalize transcript (set cDNA and protein length, start/end coordinates and info)"""
# Calculate cDNA and protein length
self.cdna_length = self.get_cdna_length()
self.prot_length = self.get_protein_length()
if self._any_unset(['cdna_length', 'prot_length', 'strand', 'exons']): return
# Set start and end fields of transcript
if self.strand == '+':
self.start = self.exons[0].start
self.end = self.exons[-1].end
else:
self.start = self.exons[-1].start
self.end = self.exons[0].end
# Set info field
self.set_info()
def _any_unset(self, fields):
"""Check if any of the required fields is None"""
return any([getattr(self, f) is None for f in fields])
def __str__(self):
"""String representation"""
return self.id + '(' + self.chrom + ':' + str(self.start) + '-' + str(self.end) + ')[' + self.info + ']'
__repr__ = __str__
class Exon(object):
"""Class for a single exon"""
def __init__(self, s):
"""Constructor of Exon class
Notes:
s is a string of the syntax "start-end", where coordinates are 0-based, inclusive for start, exclusive for end
"""
[s, e] = s.split('-')
self.start = int(s)
self.end = int(e)
def length(self):
"""Return length of exon"""
return self.end - self.start
def get_cds(self, coding_start, coding_end):
"""Return CDS interval or None if there is no CDS in the exon"""
coding_min = min(coding_start, coding_end)
coding_max = max(coding_start, coding_end)
if self.end - 1 < coding_min or self.start > coding_max:
return
cds_start = max(self.start, coding_min)
cds_end = min(self.end - 1, coding_max) + 1
return (cds_start, cds_end)
def get_utr5(self, coding_start, strand):
"""Return UTR5 interval or None if there is no UTR5 in the exon"""
if strand == '+':
if self.start >= coding_start:
return
return (self.start, min(coding_start - 1, self.end - 1) + 1)
else:
if self.end - 1 <= coding_start:
return
return (max(self.start, coding_start + 1), self.end)
def get_utr3(self, coding_end, strand):
"""Return UTR3 interval or None if there is no UTR3 in the exon"""
if strand == '+':
if self.end - 1 <= coding_end:
return
return (max(self.start, coding_end + 1), self.end)
else:
if self.start >= coding_end:
return
return (self.start, min(self.end - 1, coding_end - 1) + 1)
def __str__(self):
"""String representation"""
return 'exon:' + str(self.start) + '-' + str(self.end)
__repr__ = __str__
class TranscriptDB(object):
"""Class for a transcript database"""
# Allowed chromosome names
allowed_chroms = map(str, range(1, 24)) + ['X', 'Y', 'MT']
def __init__(self, filename):
"""Constructor of the TranscriptDB class"""
self.source = ''
self.date = ''
self.build = ''
self._filename = filename
self._tabixfile = pysam.Tabixfile(filename)
self._columns = []
self._data = dict()
self._read_header()
def read(self):
"""Read transcript database from file"""
for line in gzip.open(self._filename, 'r'):
line = line.strip()
if line == '' or line.startswith('#'):
continue
cols = line.split('\t')
self._data[cols[self._columns.index('ID')]] = line
def contains(self, transcript_id):
"""Return True if transcript ID is found in the database"""
return transcript_id in self._data
def by_id(self, transcript_id):
"""Return transcript by ID"""
ret = Transcript()
ret.read_from_database_record(self._to_dict(self._data[transcript_id]))
return ret
def search_position(self, chrom, pos):
"""Search transcript database by genomic position"""
ret = []
reg = chrom + ':' + str(pos) + '-' + str(pos)
lines = self._tabixfile.fetch(region=reg)
for line in lines:
t = Transcript()
t.read_from_database_record(self._to_dict(line))
ret.append(t)
return ret
def generator(self):
"""Return transcripts as a generator object"""
for line in gzip.open(self._filename, 'r'):
line = line.strip()
if line == '' or line.startswith('#'):
continue
ret = Transcript()
ret.read_from_database_record(self._to_dict(line))
yield ret
def _read_header(self):
"""Read header information from file"""
for line in gzip.open(self._filename, 'r'):
line = line.strip()
if line == '':
continue
if not line.startswith('#'):
break
if line.startswith('#source:'):
self.source = line[9:].strip()
elif line.startswith('#date:'):
self.date = line[7:].strip()
elif line.startswith('#build:'):
self.build = line[8:].strip()
else:
self._columns = line[1:].split('\t')
def _to_dict(self, line):
"""Convert line to dictionary"""
ret = dict()
cols = line.split('\t')
for i in range(len(self._columns)):
c = self._columns[i].lower()
ret[c] = cols[i]
return ret
class TranscriptDBWriter(object):
"""Class for creating new transcript database"""
def __init__(self, fn, source='', build='', columns=[]):
"""Constructor of the TranscriptDBWriter class"""
self._fn = fn
self._source = source
self._build = build
self._columns = [x.lower() for x in columns]
self._records = {c: [] for c in TranscriptDB.allowed_chroms}
self.idx_chrom = self._columns.index('chrom')
self.idx_start = self._columns.index('start')
self.idx_end = self._columns.index('end')
def add(self, transcript):
"""Add transcript to DB"""
record = []
for c in self._columns:
if c in ['exons', 'cdna_exons']:
record.append(','.join([str(e.start) + '-' + str(e.end) for e in getattr(transcript, c.lower())]))
elif c in ['start', 'end', 'coding_start', 'coding_end', 'cdna_coding_start', 'cdna_coding_end']:
record.append(int(getattr(transcript, c.lower())))
else:
record.append(str(getattr(transcript, c.lower())))
self._records[transcript.chrom].append(record)
def _sort_records(self):
"""Sort records by chrom, start, end"""
idx_start = self._columns.index('start')
idx_end = self._columns.index('end')
for c in TranscriptDB.allowed_chroms:
if c in self._records:
self._records[c] = sorted(self._records[c], key=itemgetter(idx_start, idx_end))
def _index_with_tabix(self):
"""Compress and index output file by Tabix"""
pysam.tabix_compress(self._fn + '_tmp', self._fn + '.gz', force=True)
pysam.tabix_index(self._fn + '.gz', seq_col=self.idx_chrom, start_col=self.idx_start, end_col=self.idx_end,
meta_char='#', force=True)
def finalize(self):
"""Write to file, compress and index, clean up"""
# Sort records by CHROM, START, END
self._sort_records()
# Initialize file and write header
out = open(self._fn + '_tmp', 'w')
out.write('#source: ' + self._source + '\n')
out.write('#date: ' + str(datetime.datetime.today()).split()[0] + '\n')
out.write('#build: ' + self._build + '\n')
out.write('#' + '\t'.join([x.upper() for x in self._columns]) + '\n')
# Write records to file
for c in TranscriptDB.allowed_chroms:
if c in self._records:
for record in self._records[c]:
record = map(str, record)
out.write('\t'.join(record) + '\n')
out.close()
# Compress and index by Tabix
self._index_with_tabix()
# Remove temporary file
os.remove(self._fn + '_tmp')
|
nilq/baby-python
|
python
|
import os
import sys
import time
import subprocess
ITERATIONS = 10
COUNT = 20000000
VERBOSE = False
NL = '\n'
INCLUDE = "../../../src"
CC = 'gcc'
CCPP = 'g++' # LoL
OPT = '-O3'
print(f'Using {CC} compiler')
def execute_command(commands):
print(' '.join(commands))
subprocess.run(commands, shell=True)
# Common args
args = ['-I', INCLUDE, OPT, f'-DCOUNT={COUNT}', '-DCMC_NO_CALLBACKS']
map_args = [CC, 'hashmap.c', '-o', 'hashmap.exe']
mmap_args = [CC, 'hashmultimap.c', '-o', 'hashmultimap.exe']
cpp_args = [CCPP, 'unorderedmap.cpp', '-I', INCLUDE, '-o', 'unorderedmap.exe', OPT, f'-DCOUNT={COUNT}']
map_args.extend(args)
mmap_args.extend(args)
cpp_args.extend(args)
execute_command(map_args)
execute_command(mmap_args)
execute_command(cpp_args)
programs = ['hashmap.exe', 'hashmultimap.exe', 'unorderedmap.exe']
for prog in programs:
total = 0
for i in range(ITERATIONS):
print(f'{i}...', end='')
sys.stdout.flush()
start_time = time.time()
subprocess.run(prog, shell=True)
delta = time.time() - start_time
total += delta
if VERBOSE:
print(f'({delta})')
avg = total / ITERATIONS
print(f'{"" if VERBOSE else NL}{avg} seconds for {COUNT} -> AVG[{int((avg * 1e9) / COUNT)} ns] [{prog}]{NL if VERBOSE else ""}')
|
nilq/baby-python
|
python
|
# Copyright 2011-2013 Colin Scott
# Copyright 2011-2013 Andreas Wundsam
# Copyright 2012-2013 Sam Whitlock
# Copyright 2012-2012 Kyriakos Zarifis
#
# 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 urllib2
import logging
import json
import string
import time
from pox.lib.graph.util import NOMDecoder
from pox.openflow.topology import OpenFlowSwitch
from pox.openflow.flow_table import FlowTable, TableEntry
from pox.openflow.libopenflow_01 import ofp_match, ofp_action_output
from sts.entities import POXController, BigSwitchController
log = logging.getLogger("Snapshot")
class Snapshot(object):
"""
A Snapshot object is a description of the controllers' view of the network in terms that are meaningful
to the debugger. Any snaphsot grabbed from any controller should be transformed
into a Snapshot object in order to be fed to HSA
"""
def __int__(self):
self.time = None
self.switches = []
# The debugger doesn't use the next two (for now anyway)
self.hosts = []
self.links = []
def __repr__(self):
return "<Snapshot object: (%i switches)>"%len(self.switches)
class SnapshotService(object):
"""
Controller-specific SnapshotServices take care of grabbing a snapshot from
their controller in whatever format the controller exports it, and translating
it into a Snaphot object that is meaningful to the debbuger
"""
def __init__(self):
self.snapshot = Snapshot()
def fetchSnapshot(self, controller):
pass
class FlexibleNOMDecoder:
def __init__(self):
self.pox_nom_decoder = NOMDecoder()
def decode(self, json):
if isinstance(json, (str, unicode)) and string.find(json, "__module__")>=0:
return self.pox_nom_decoder.decode(json)
else:
return self.decode_switch(json)
def decode_switch(self, json):
flow_table = self.decode_flow_table(json["flow_table"] if "flow_table" in json else json["flowTable"])
switch = OpenFlowSwitch(json["dpid"], flow_table=flow_table)
return switch
def decode_flow_table(self, json):
ft = FlowTable()
for e in json["entries"]:
ft.add_entry(self.decode_entry(e))
return ft
def decode_entry(self, json):
e = TableEntry()
for (k, v) in json.iteritems():
if k == "match":
e.match = self.decode_match(v)
elif k == "actions":
e.actions = [ self.decode_action(a) for a in v ]
else:
setattr(e, k, v)
return e
def decode_match(self, json):
return ofp_match(**json)
def decode_action(self, json):
a = ofp_action_output(port = json['port'])
return a
class SyncProtoSnapshotService(SnapshotService):
def __init__(self):
SnapshotService.__init__(self)
self.myNOMDecoder = FlexibleNOMDecoder()
def fetchSnapshot(self, controller):
jsonNOM = controller.sync_connection.get_nom_snapshot()
# Update local Snapshot object
self.snapshot.switches = [self.myNOMDecoder.decode(s) for s in jsonNOM["switches"]]
self.snapshot.hosts = [self.myNOMDecoder.decode(h) for h in jsonNOM["hosts"]]
self.snapshot.links = [self.myNOMDecoder.decode(l) for l in jsonNOM["links"]]
self.snapshot.time = time.time()
return self.snapshot
class PoxSnapshotService(SnapshotService):
def __init__(self):
SnapshotService.__init__(self)
self.port = 7790
self.myNOMDecoder = NOMDecoder()
def fetchSnapshot(self, controller):
from pox.lib.util import connect_socket_with_backoff
import socket
snapshotSocket = connect_socket_with_backoff('127.0.0.1', self.port)
log.debug("Sending Request")
snapshotSocket.send("{\"hello\":\"nommessenger\"}")
snapshotSocket.send("{\"getnom\":0}", socket.MSG_WAITALL)
log.debug("Receiving Results")
jsonstr = ""
while True:
data = snapshotSocket.recv(1024)
log.debug("%d byte packet received" % len(data))
if not data: break
jsonstr += data
if len(data) != 1024: break
snapshotSocket.close()
jsonNOM = json.loads(jsonstr) # (json string with the NOM)
# Update local Snapshot object
self.snapshot.switches = [self.myNOMDecoder.decode(s) for s in jsonNOM["switches"]]
self.snapshot.hosts = [self.myNOMDecoder.decode(h) for h in jsonNOM["hosts"]]
self.snapshot.links = [self.myNOMDecoder.decode(l) for l in jsonNOM["links"]]
self.snapshot.time = time.time()
return self.snapshot
class BigSwitchSnapshotService(SnapshotService):
def __init__(self):
SnapshotService.__init__(self)
def fetchSnapshot(self, controller):
req = urllib2.Request('http://localhost:8080/wm/core/proact')
response = urllib2.urlopen(req)
json_data = response.read()
l = json.loads(json_data)
res = []
for m in l:
res.append(Snapshot.from_json_map(m))
return res
# Create local Snapshot object
snapshot = Snapshot()
self.snapshot = snapshot
return self.snapshot
def get_snapshotservice(controller_configs):
'''Return a SnapshotService object determined by the name of the first
controller in the controller_configs.
For now, we only support a homogenous controller environment.'''
# Read from config what controller we are using
# TODO(cs): allow for heterogenous controllers?
if controller_configs != [] and controller_configs[0].sync:
snapshotService = SyncProtoSnapshotService()
elif controller_configs != [] and controller_configs[0].controller_class == POXController:
snapshotService = PoxSnapshotService()
elif controller_configs != [] and controller_configs[0].controller_class == BigSwitchController:
snapshotService = BigSwitchSnapshotService()
else:
# We default snapshotService to POX
snapshotService = PoxSnapshotService()
return snapshotService
|
nilq/baby-python
|
python
|
# Songsheng YING
# coding=utf-8
# python3.6.7 Anaconda
import os, sys
import numpy as np
from progressbar import ProgressBar, Percentage, Bar
import xml.etree.ElementTree as ET
def data_file_reader_fr(file_name, lang):
print(" Working on " + file_name)
if lang == "French":
path = os.getcwd() + '/data/input/French_wnet/'
else:
print("This reader function only supports French file")
return
tree = ET.parse(path + file_name)
root = tree.getroot()
rel_type_dict = {
'near_antonym': '!',
'hypernym': '@',
'instance_hypernym': '@i',
'hyponym': '~',
'instance_hyponym': '~i',
'be_in_state': '#s', # TO VERIFY
'eng_derivative': '+',
'subevent': '*', # TO VERIFY
'also_see': '^',
'verb_group': '$',
'category_domain': ';c',
'derived': '\\',
'similar_to': '&',
'usage_domain': ';u',
'region_domain': ';r',
'holo_part': '#p',
'holo_member': '#m',
'causes': '>',
'holo_portion': '#p', # TO VERIFY
'participle': '<'
}
file_data = {}
offset_list = []
for synset in root:
synsetWrds = []
synsetConnections = []
synsetRelationTypes = []
connectedSynsetPos = []
for word in synset.find('SYNONYM').getchildren():
try:
synsetWrds.append(word.text.replace(' ', '_'))
except:
print(word.tag, word.attrib)
synsetWrds.append('__unknown__')
for relation in synset.findall('ILR') :
synsetRelationTypes.append(rel_type_dict[relation.attrib['type']])
synsetConnections.append(relation.text)
connectedSynsetPos.append(relation.text.split('-')[3])
data = (synsetWrds, synsetConnections, synsetRelationTypes, connectedSynsetPos, None)
file_data.update({synset.find('ID').text:data})
offset_list.append(synset.find('ID').text)
return file_data, offset_list
|
nilq/baby-python
|
python
|
workflow_xml_start = """<workflow-app name="etk-april-2017" xmlns="uri:oozie:workflow:0.5">
<global>
<configuration>
<property>
<name>oozie.launcher.mapreduce.map.memory.mb</name>
<value>10000</value>
</property>
</configuration>
</global>
<start to="shell-1120"/>
<kill name="Kill">
<message>Action failed, error message[${wf:errorMessage(wf:lastErrorNode())}]</message>
</kill>
<action name="shell-1120">
<shell xmlns="uri:oozie:shell-action:0.1">
<job-tracker>${jobTracker}</job-tracker>
<name-node>${nameNode}</name-node>
<configuration>
<property>
<name>mapred.input.dir.recursive</name>
<value>true</value>
</property>
<property>
<name>oozie.action.max.output.data</name>
<value>8192</value>
</property>
</configuration>
<exec>./run.sh</exec>
"""
workflow_xml_end = """ <capture-output/>
</shell>
<ok to="End"/>
<error to="Kill"/>
</action>
<end name="End"/>
</workflow-app>"""
class WM(object):
def __init__(self):
self.workflow_xml_start = workflow_xml_start
self.workflow_xml_end = workflow_xml_end
@staticmethod
def create_file_property_for_workflow_xml(file_path):
v = file_path.split('/')
file_name = v[len(v) - 1].strip()
if file_name and file_name != '':
return '<file>{}#{}</file>'.format(file_path, file_name)
@staticmethod
def create_archive_property_for_workflow_xml(file_path, extension_length=3):
v = file_path.split('/')
file_name = v[len(v) - 1].strip()
file_name = file_name[0:len(file_name) - (extension_length + 1)] # +1 is for the '.'
if file_name and file_name != '':
return '<archive>{}#{}</archive>'.format(file_path, file_name)
@staticmethod
def create_arguments_for_workflow_xml(argument):
return '<argument>{}</argument>'.format(argument)
if __name__ == '__main__':
# print WM.create_file_property_for_workflow_xml('/user/worker/etk/lib/dictionaries/eyecolors.json.gz')
# print WM.create_archive_property_for_workflow_xml('/user/worker/etk/lib/etk_env.zip')
wm = WM()
files = wm.create_file_property_for_workflow_xml('/user/worker/etk/lib/dictionaries/eyecolors.json.gz')
archive = wm.create_archive_property_for_workflow_xml('/user/worker/etk/lib/etk_env.zip')
argument = wm.create_arguments_for_workflow_xml('extraction_config.json')
wf = wm.workflow_xml_start + argument + files + archive + wm.workflow_xml_end
print wf
|
nilq/baby-python
|
python
|
from matplotlib import pyplot as plt
from matplotlib_venn import venn3
def plot_confusion_matrix(cm, cmap=plt.cm.Blues):
"""
Args:
cm (np.ndarray): Confusion matrix to plot
cmap: Color map to be used in matplotlib's imshow
Returns:
Figure and axis on which the confusion matrix is plotted
"""
fig, ax = plt.subplots()
ax.imshow(cm, interpolation="nearest", cmap=cmap)
ax.set_xticks([])
ax.set_yticks([])
ax.set_xlabel("Receiver's action", fontsize=14)
ax.set_ylabel("Sender's state", fontsize=14)
# Loop over data dimensions and create text annotations.
fmt = "d"
thresh = cm.max() / 2.0
for i in range(cm.shape[0]):
for j in range(cm.shape[1]):
ax.text(
j,
i,
format(cm[i, j], fmt),
ha="center",
va="center",
color="white" if cm[i, j] > thresh else "black",
)
fig.tight_layout()
return fig, ax
def plot_venn(ns):
n_diff, n01, n12, n02, n012 = ns
fig, ax = plt.subplots()
venn3(
subsets=(
n_diff + n12 - n012,
n_diff + n02 - n012,
n01 - n012,
n_diff + n01 - n012,
n02 - n012,
n12 - n012,
n012,
),
set_labels=(r"$s_1$", r"$s_2$", r"$s_3$"),
ax=ax,
)
return fig, ax
|
nilq/baby-python
|
python
|
from src import network
import numpy as np
from src.study.utils import downloader
from src.study.mnist_common import mnist_reader
items = ["T-shirt/top","Trouser","Pullover","Dress","Coat","Sandal","Shirt","Sneaker","Bag","Ankle","boot"]
def download_mnist_fashion_data():
downloader.download_data("http://fashion-mnist.s3-website.eu-central-1.amazonaws.com",
["train-images-idx3-ubyte.gz",
"train-labels-idx1-ubyte.gz",
"t10k-images-idx3-ubyte.gz",
"t10k-labels-idx1-ubyte.gz"])
download_mnist_fashion_data()
def train_model():
net = network.Network([784,30,10])
training_data,test_data = mnist_reader.load()
net.train("mnists_fashion_classifier.learnings", training_data, epochs=70, mini_batch_size=4, eta=0.01,
test_data=test_data)
return net
def print_result(actual,expected):
print("%s is detected as %s" % (items[expected],items[actual]))
def evaluate(net):
training_data, test_data = mnist_reader.load()
for test_sample in test_data[9000:]:
print_result(np.argmax(net.feedforward(test_sample[0])),test_sample[1])
if(__name__ == "__main__"):
evaluate(train_model())
|
nilq/baby-python
|
python
|
import re
def modify_en_text(text, modify_mode='BASIC', keep_emoji=True):
""" Make your text easy to read and to translate.
Args:
text(str):
target dirty text.
modify_mode(str):
mode selection
keep_emoji(bool):
call back remove_emoji func or not.
Returns:
text_output(str):
formatted output.
"""
if not keep_emoji:
text = remove_emoji(text)
sents = split_text_to_sentences_en(text)
text_output = mode_factory(modify_mode)(sents)
return text_output
def remove_emoji(text):
""" Remove emoji. """
emoji_pattern = re.compile("["
u"\U0001F600-\U0001F64F" # emoticons
u"\U0001F300-\U0001F5FF" # symbols & pictographs
u"\U0001F680-\U0001F6FF" # transport & map symbols
u"\U0001F1E0-\U0001F1FF" # flags (iOS)
"]+", flags=re.UNICODE)
return emoji_pattern.sub(r'', text)
def split_text_to_sentences_en(text):
""" Make your text easy to read and to translate.
Args:
text(str):
target dirty text.
Returns:
sents(list):
sentences splited.
"""
text = text.replace(" . . . ","...") #replace LaTex ellipses with original ellipses
sents = re.split(r'(?<!\w\.\w.)(?<![A-Z][a-z]\.)(?<=\.|\?)\s', text)
return sents
def mode_factory(modify_mode):
if modify_mode == "BASIC":
return mode_basic
if modify_mode == 'LIST-MARK':
return mode_listmark
def mode_basic(sents):
text_output = ""
for _s in sents:
s = ' '.join(_s.split(), )
text_output += s + "\n\n"
return text_output
def mode_listmark(sents):
text_output = ""
for _s in sents:
s = ' '.join(_s.split(), )
text_output += "- " + s + "\n\n"
return text_output
|
nilq/baby-python
|
python
|
from functools import reduce
testcases = int(input())
for t in range(testcases):
n = int(input())
vals = list(map(int, input().split()))
missed = 0
for i in range(1, len(vals)):
x = abs(vals[i] - vals[i - 1])
if x > 0:
x -= 1
missed += x
print(missed)
|
nilq/baby-python
|
python
|
# Import Required Libraries
from flask import Flask, render_template, request
import pickle
# Initialise the object to run the flask app
app = Flask(__name__, static_folder='static', template_folder='templates')
# Load the pickled model file
model = pickle.load(open('model.pkl', 'rb+'))
@app.route('/', methods=['POST', 'GET'])
def index():
return render_template('index.html')
@app.route('/predict', methods=['POST', 'GET'])
def predict():
if request.method == 'GET':
return render_template('index.html')
if request.method == 'POST':
features = [float(x) for x in request.form.values()]
print(features)
labels = model.predict([features])
print(labels)
species = labels[0]
# If species is 0 = setosa, if species is 1 = VersiColor, if species is 2 = Virginica
if species == 0:
result = "Iris-Setosa"
elif species == 1:
result = "Iris-VersiColor"
else:
result = "Iris-Virginica"
return render_template('index.html', result=result)
# It is the starting point of code
if __name__ == '__main__':
# We need to run the app to run the server this will change when deployed on AWS
app.run(debug=False)
|
nilq/baby-python
|
python
|
# Copyright 2017 Cisco Systems, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import datetime
from nose.tools import *
from ..connection.info import custom_setup, custom_teardown
from ucsmsdk.ucshandle import UcsHandle
from ucsm_apis.admin.auth import *
handle = None
domain_name = "test" + datetime.date.today().strftime('%Y%b%d')
def setup_module():
global handle
handle = custom_setup()
# handle.set_dump_xml()
def teardown_module():
custom_teardown(handle)
@raises(UcsOperationError)
def test_001_auth_domain_delete_domainnotexist():
auth_domain_delete(handle, name=domain_name)
def test_002_auth_domain_exists_domainnotexist():
(status, mo) = auth_domain_exists(handle, name=domain_name)
assert not status
def test_003_auth_domain_create_default():
auth_domain_create(handle, name=domain_name)
def test_004_auth_domain_exist_default():
(status, mo) = auth_domain_exists(handle, name=domain_name)
assert status
def test_005_auth_domain_modify_default():
auth_domain_modify(handle, name=domain_name)
def test_006_auth_domain_modify_descr_empty():
auth_domain_modify(handle, name=domain_name, descr="")
def test_007_auth_domain_modify_descr_default():
auth_domain_modify(handle, name=domain_name, descr="default")
def test_008_auth_domain_realm_configure_default():
auth_domain_realm_configure(handle, domain_name)
def test_009_auth_domain_delete_default():
auth_domain_delete(handle, name=domain_name)
def test_010_native_auth_configure_default():
native_auth_configure(handle)
def test_011_native_auth_default():
native_auth_default(handle)
def test_012_native_auth_console():
native_auth_console(handle)
|
nilq/baby-python
|
python
|
import functools
import operator
import unittest
from migen import *
def cols(rows):
"""
>>> a = [
... [1, 2],
... ['a', 'b'],
... [4, 5],
... ]
>>> for c in cols(a):
... print(c)
[1, 'a', 4]
[2, 'b', 5]
>>> a = [
... [1, 2, 3],
... ['a', 'b', 'c'],
... ]
>>> for c in cols(a):
... print(c)
[1, 'a']
[2, 'b']
[3, 'c']
"""
all_c = []
for ci in range(len(rows[0])):
all_c.append([])
for ci in range(len(rows[0])):
for ri in range(len(rows)):
assert len(rows[ri]) == len(all_c), "len(%r) != %i" % (rows[ri], len(all_c))
all_c[ci].append(rows[ri][ci])
return all_c
def CRC_paralelo(poly, crc_in, data):
"""
k== num_data_bits
len(data_cur) == num_data_bits
>>> for i in range(5):
... l = [0]*5; l[i] = 1
... r = lfsr_serial_shift_crc(
... poly=[0,0,1,0,1], # (5, 2, 0)
... crc_in=l,
... data=[0,0,0,0],
... )
... print("Min[%i] =" % i, r)
Min[0] = [1, 0, 0, 0, 0]
Min[1] = [0, 0, 1, 0, 1]
Min[2] = [0, 1, 0, 1, 0]
Min[3] = [1, 0, 1, 0, 0]
Min[4] = [0, 1, 1, 0, 1]
>>> for i in range(4):
... d = [0]*4; d[i] = 1
... r = lfsr_serial_shift_crc(
... poly=[0,0,1,0,1], # (5, 2, 0)
... crc_in=[0,0,0,0,0],
... data=d,
... )
... print("Nin[%i] =" % i, r)
Nin[0] = [0, 0, 1, 0, 1]
Nin[1] = [0, 1, 0, 1, 0]
Nin[2] = [1, 0, 1, 0, 0]
Nin[3] = [0, 1, 1, 0, 1]
"""
poly = poly[::-1] #Primer elemento debe ser el bit menos significativo
data = data[::-1]
k=len(data)
p=len(poly)
assert p>1
assert len(crc_in) == p
crc_next = list(crc_in)
for j in range(p):
crc_upper_bit = crc_next[p-1]
for i in range(p-1, 0, -1):
if poly[i]:
crc_next[i] = crc_next[i-1] ^ crc_upper_bit ^ data[j]
else:
crc_next[i] = crc_next[i-1]
crc_next[0] = crc_upper_bit ^ data[j]
return list(crc_next[::-1])
def matrices(poly, data_width):
#poly: polinomio en bits (lista), bit mas significativo como primer elemento
#data_width: cantidad de bits de la palabra
poly_size= len(poly)
# data_width*polysize matrix == lfsr(0,Nin)
rows_nin = []
# (a) calculate the N values when Min=0 and Build NxM matrix
# - Each value is one hot encoded (there is only one bit)
# - IE N=4, 0x1, 0x2, 0x4, 0x8
# - Mout = F(Nin,Min=0)
# - Each row contains the results of (a)
# - IE row[0] == 0x1, row[1] == 0x2
# - Output is M-bit wide (CRC width)
# - Each column of the matrix represents an output bit Mout[i] as a function of Nin
info = []
for i in range(data_width):
# crc_in = [0,...,0] = Min
crc_in = [0,]*poly_size
# data = [0,..,1,..,0] = Nin
data = [0,]*data_width
data[i] = 1
# Calculate the CRC
rows_nin.append(CRC_paralelo(poly, crc_in, data))
info.append("lfsr(%r, %r, %r) = %r" % (poly, crc_in, data, rows_nin[-1]))
assert len(rows_nin) == data_width
cols_nin = cols(rows_nin)[::-1]
# polysize*polysize matrix == lfsr(Min,0)
info.append("")
rows_min = []
for i in range(poly_size):
# crc_in = [0,..,1,...,0] = Min
crc_in = [0,]*poly_size
crc_in[i] = 1
# data = [0,..,0] = Nin
data = [0,]*data_width
# Calculate the crc
rows_min.append(CRC_paralelo(poly, crc_in, data))
info.append("lfsr(%r, %r, %r) = %r" % (poly, crc_in, data, rows_min[-1]))
assert len(rows_min) == poly_size
cols_min = cols(rows_min)[::-1]
# (c) Calculate CRC for the M values when Nin=0 and Build MxM matrix
# - Each value is one hot encoded
# - Mout = F(Nin=0,Min)
# - Each row contains results from (7)
info.append("")
#for i in range(data_width, -1, -1):
# info.append("Mout[%i] = %r %r" % (i, cols_nin[i], cols_min[i]))
return info, cols_nin, cols_min
class TxParallelCrcGenerator(Module):
"""
width : int
Width of the CRC.
polynomial : int
CRC polynomial in integer form.
initial : int
Initial value of the CRC register before data starts shifting in.
Input Ports
------------
i_data_payload : Signal(8)
Byte wide data to generate CRC for.
i_data_strobe : Signal(1)
Strobe signal for the payload.
Output Ports
------------
o_crc : Signal(width)
Current CRC value.
"""
def __init__(self, data_width, crc_width, polynomial, initial=0):
self.i_data_payload = Signal(data_width)
self.i_data_strobe = Signal()
self.reset=Signal()
self.o_crc = Signal(crc_width)
crc_dat = Signal(data_width)
crc_cur = Signal(crc_width, reset=initial)
crc_next = Signal(crc_width, reset_less=True)
crc_cur_reset_bits = [
int(i) for i in "{0:0{width}b}".format(
#crc_cur.reset.value,width=crc_width)[::-1]]
crc_cur.reset.value,width=crc_width)]
self.comb += [
#crc_dat.eq(self.i_data_payload[::-1]),
crc_dat.eq(self.i_data_payload),
# FIXME: Is XOR ^ initial actually correct here?
#self.o_crc.eq(crc_cur[::-1] ^ initial),
self.o_crc.eq(crc_cur),
]
self.sync += [
If(self.i_data_strobe,
crc_cur.eq(crc_next),
),
If(self.reset,
crc_cur.eq(initial)
)
]
poly_list = []
#convierte a binario, bit mas significativo como primer elemento
for i in range(crc_width):
poly_list.insert(0, polynomial >> i & 0x1)
assert len(poly_list) == crc_width
_, cols_nin, cols_min = matrices(poly_list, data_width)
crc_next_reset_bits = list(crc_cur_reset_bits)
for i in range(crc_width):
to_xor = []
crc_next_reset_bit_i = []
for j, use in enumerate(cols_nin[i]):
if use:
to_xor.append(crc_dat[j])
crc_next_reset_bit_i.append(0)
for j, use in enumerate(cols_min[i]):
if use:
to_xor.append(crc_cur[j])
crc_next_reset_bit_i.append(crc_cur_reset_bits[j])
crc_next_reset_bits[i] = functools.reduce(operator.xor, crc_next_reset_bit_i)
self.comb += [
crc_next[i].eq(functools.reduce(operator.xor, to_xor)),
]
crc_next_reset_value = int("0b"+"".join(str(i) for i in crc_next_reset_bits[::-1]), 2)
crc_next.reset.value = crc_next_reset_value
def tb(dut):
yield dut.i_data_strobe.eq(1)
yield dut.i_data_payload.eq(0x1a)
yield
yield dut.i_data_payload.eq(0x1b)
yield
yield dut.i_data_payload.eq(0x1c)
yield
yield dut.i_data_payload.eq(0x1d)
yield
yield dut.i_data_payload.eq(0x1f)
yield
yield dut.i_data_payload.eq(0x2a)
yield
yield dut.i_data_payload.eq(0x2b)
yield
yield dut.i_data_payload.eq(0x2c)
yield
yield dut.i_data_strobe.eq(0)
yield
yield dut.reset.eq(1)
yield
yield dut.reset.eq(0)
yield
yield dut.i_data_strobe.eq(1)
yield dut.i_data_payload.eq(0x1a)
yield
yield dut.i_data_payload.eq(0x1b)
yield
yield dut.i_data_payload.eq(0x1c)
yield
yield dut.i_data_payload.eq(0x1d)
yield
yield dut.i_data_payload.eq(0x1f)
yield
yield dut.i_data_payload.eq(0x2a)
yield
yield dut.i_data_payload.eq(0x2b)
yield
yield dut.i_data_payload.eq(0x2c)
yield
dut=TxParallelCrcGenerator(data_width=32, crc_width=20, polynomial=0xc1acf,initial=0xfffff)
run_simulation(dut,tb(dut), vcd_name="prueba_crc.vcd")
|
nilq/baby-python
|
python
|
# -*- coding: utf-8 -*-
"""
DTSA-II Script - J. R. Minter - 2016-10-12
massFractionsTheEasyWay.py
Date Who Comment
---------- --- -----------------------------------------------
2016-10-12 JRM Mass fractions the easy way...
Elapse: 0:00:00.0 ROCPW7ZC5C42
"""
import sys
sys.packageManager.makeJavaPackage("gov.nist.microanalysis.NISTMonte.Gen3", "CharacteristicXRayGeneration3, BremsstrahlungXRayGeneration3,FluorescenceXRayGeneration3, XRayTransport3", None)
import os
import glob
import shutil
import time
import math
import csv
import gov.nist.microanalysis.NISTMonte as nm
import gov.nist.microanalysis.NISTMonte.Gen3 as nm3
import gov.nist.microanalysis.EPQLibrary as epq
import gov.nist.microanalysis.EPQLibrary.Detector as epd
import gov.nist.microanalysis.Utility as epu
import gov.nist.microanalysis.EPQTools as ept
import dtsa2 as dt2
import dtsa2.mcSimulate3 as mc3
gitDir = os.environ['GIT_HOME']
relPrj = "/dtsa2Scripts/utility"
prjDir = gitDir + relPrj
rptDir = prjDir + '/massFractionsTheEasyWay Results/'
azo = material("Al2Zn98O100", density=5.61)
wfAl = round(azo.weightFractionU(epq.Element.Al, True).doubleValue(), 5)
wfZn = round(azo.weightFractionU(epq.Element.Zn, True).doubleValue(), 5)
wfO = round(azo.weightFractionU(epq.Element.O, True).doubleValue(), 5)
AZO = {"Al" : wfAl, "Zn": wfZn, "O" : wfO}
print(AZO)
es = azo.getElementSet()
# print(dir(es))
# clean up cruft
shutil.rmtree(rptDir)
print "Done!"
|
nilq/baby-python
|
python
|
# Import Dependencies
import numpy as np
import pandas as pd
import datetime as dt
import sqlalchemy
from sqlalchemy import desc
from sqlalchemy.ext.automap import automap_base
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import Session
from sqlalchemy import create_engine, func, inspect
from sqlalchemy import Column, Integer, String, Float, Date
from flask import Flask, jsonify
# Create and connect Engine
engine = create_engine("sqlite:///Resources/hawaii.sqlite")
conn = engine.connect()
# reflect an existing database into a new model
Base = automap_base()
# reflect the tables
Base.prepare(engine, reflect=True)
Measurement = Base.classes.measurement
Stations = Base.classes.station
# connect session with engine
session = Session(engine)
app = Flask(__name__)
# Homepage
@app.route("/")
def main():
# Gives the user the options of where they can go
return (
f"Please copy and paste one of the follwing to the end of the above URL:<br/>"
f"<br/>"
f"/api/v1.0/precipitation<br/>"
f"<br/>"
f"/api/v1.0/stations<br/>"
f"<br/>"
f"/api/v1.0/tobs<br/>"
f"<br/>"
f"/api/v1.0/<start><br/>"
f"or<br/>"
f"/api/v1.0/<start>/<end><br/>"
)
@app.route("/api/v1.0/precipitation")
def precipitation():
# Creates a query that looks for the most recent date stripped from the year, month, day
most_recent_date = session.query(
func.max(func.strftime("%Y-%m-%d", Measurement.date))).all()
# Transforms SQl query into a string
string_version = most_recent_date[0][0]
end_date = dt.datetime.strptime(string_version, "%Y-%m-%d")
# Subtracts one year from the most recent data row
start_date = end_date - dt.timedelta(365)
# Creates a query taht retrieves the data and percipitation from anything greater than
# or equal to the start date, filtered by the date
precip_data = session.query(func.strftime("%Y-%m-%d", Measurement.date), Measurement.prcp).\
filter(func.strftime("%Y-%m-%d", Measurement.date) >= start_date).all()
# Creates a dictionary and put the resutls in said dictionary
results = {}
for result in precip_data:
results[result[0]] = result[1]
return jsonify(results)
@app.route("/api/v1.0/stations")
def stations():
# query stations list
stations_ = session.query(Stations).all()
# create a list of dictionaries
stations_list = []
for station in stations_:
station_dict = {}
station_dict["id"] = station.id
station_dict["station"] = station.station
station_dict["name"] = station.name
station_dict["latitude"] = station.latitude
station_dict["longitude"] = station.longitude
station_dict["elevation"] = station.elevation
stations_list.append(station_dict)
return jsonify(stations_list)
# @app.route("/api/v1.0/<start>")
# @api.route("/api/v1.0/<start>/<end>")
|
nilq/baby-python
|
python
|
# Normals are for all puzzles where all 3 sides are the same
# 37 is Skewb
# 38 is Pyraminx main
# 39 is Pyraminx primary corners
# 40 is Pyraminx secondary corners
# 41 is Megaminx main
# 42 is Megaminx secondary
normals = {
2: {'moves': (('U', 'D'), ('F', 'B'), ('R', 'L')), 'directions': ('', "'", '2')},
3: {'moves': (('U', 'D'), ('F', 'B'), ('R', 'L')), 'directions': ('', "'", '2')},
4: {'moves': (('U', 'D'), ('F', 'B'), ('R', 'L')), 'directions': ('', "'", '2', 'w2', 'w', "w'")},
5: {'moves': (('U', 'D'), ('F', 'B'), ('R', 'L')), 'directions': ('', "'", '2', 'w2', 'w', "w'")},
37: {'moves': (('U', 'D'), ('F', 'B'), ('R', 'L')), 'directions': ('', "'")},
38: {'moves': (('U', 'D'), ('F', 'B'), ('R', 'L')), 'directions': ('', "'")},
39: {'moves': ('r', 'l'), 'directions': ('', "'")},
40: {'moves': ('u', 'd'), 'directions': ('', "'")},
41: {'moves': ('R', "D"), 'directions': ('++', "--")},
42: {'moves': 'U', 'directions': ('', "'")}
}
# Irregulars are for puzzles with different sized sides. Use tuples as the key according to (sizeX, sizeY, sizeZ)
irregulars = {
None
}
# Others are for other, will vary case by case
others = {
None
}
|
nilq/baby-python
|
python
|
from setuptools import setup
setup(
name="scripture-burrito",
version="0.0.2",
description="Python library for the Scripture Burrito data interchange format",
url="http://github.com/bible-technology/scripture-burrito-python",
author="BT Tech Consortium",
author_email="jtauber@jtauber.com",
license="MIT",
packages=["scripture_burrito"],
package_data={
"scripture_burrito": ["schema"]
},
install_requires=["jsonschema"],
entry_points={
"console_scripts": [
"validate-sb = scripture_burrito.validate:main",
],
},
)
|
nilq/baby-python
|
python
|
import pytest
import numpy as np
import pennylane as qml
from pennylane_qiskit import AerDevice, BasicAerDevice
from conftest import U, U2, A
np.random.seed(42)
THETA = np.linspace(0.11, 1, 3)
PHI = np.linspace(0.32, 1, 3)
VARPHI = np.linspace(0.02, 1, 3)
@pytest.mark.parametrize("theta, phi", list(zip(THETA, PHI)))
@pytest.mark.parametrize("shots", [None, 8192])
class TestVar:
"""Tests for the variance"""
def test_var(self, theta, phi, device, shots, tol):
"""Tests for variance calculation"""
dev = device(2)
# test correct variance for <Z> of a rotated state
observable = qml.PauliZ(wires=[0])
dev.apply(
[
qml.RX(phi, wires=[0]),
qml.RY(theta, wires=[0]),
],
rotations=[*observable.diagonalizing_gates()],
)
dev._samples = dev.generate_samples()
var = dev.var(observable)
expected = 0.25 * (3 - np.cos(2 * theta) - 2 * np.cos(theta) ** 2 * np.cos(2 * phi))
assert np.allclose(var, expected, **tol)
def test_var_hermitian(self, theta, phi, device, shots, tol):
"""Tests for variance calculation using an arbitrary Hermitian observable"""
dev = device(2)
# test correct variance for <H> of a rotated state
H = np.array([[4, -1 + 6j], [-1 - 6j, 2]])
observable = qml.Hermitian(H, wires=[0])
dev.apply(
[
qml.RX(phi, wires=[0]),
qml.RY(theta, wires=[0]),
],
rotations=[*observable.diagonalizing_gates()],
)
dev._samples = dev.generate_samples()
var = dev.var(observable)
expected = 0.5 * (
2 * np.sin(2 * theta) * np.cos(phi) ** 2
+ 24 * np.sin(phi) * np.cos(phi) * (np.sin(theta) - np.cos(theta))
+ 35 * np.cos(2 * phi)
+ 39
)
assert np.allclose(var, expected, **tol)
@pytest.mark.parametrize("theta, phi, varphi", list(zip(THETA, PHI, VARPHI)))
@pytest.mark.parametrize("shots", [None, 8192])
class TestTensorVar:
"""Tests for variance of tensor observables"""
def test_paulix_pauliy(self, theta, phi, varphi, device, shots, tol):
"""Test that a tensor product involving PauliX and PauliY works correctly"""
dev = device(3)
obs = qml.PauliX(0) @ qml.PauliY(2)
dev.apply(
[
qml.RX(theta, wires=[0]),
qml.RX(phi, wires=[1]),
qml.RX(varphi, wires=[2]),
qml.CNOT(wires=[0, 1]),
qml.CNOT(wires=[1, 2]),
],
rotations=obs.diagonalizing_gates(),
)
dev._samples = dev.generate_samples()
res = dev.var(obs)
expected = (
8 * np.sin(theta) ** 2 * np.cos(2 * varphi) * np.sin(phi) ** 2
- np.cos(2 * (theta - phi))
- np.cos(2 * (theta + phi))
+ 2 * np.cos(2 * theta)
+ 2 * np.cos(2 * phi)
+ 14
) / 16
assert np.allclose(res, expected, **tol)
def test_pauliz_hadamard_pauliy(self, theta, phi, varphi, device, shots, tol):
"""Test that a tensor product involving PauliZ and PauliY and hadamard works correctly"""
dev = device(3)
obs = qml.PauliZ(0) @ qml.Hadamard(1) @ qml.PauliY(2)
dev.apply(
[
qml.RX(theta, wires=[0]),
qml.RX(phi, wires=[1]),
qml.RX(varphi, wires=[2]),
qml.CNOT(wires=[0, 1]),
qml.CNOT(wires=[1, 2]),
],
rotations=obs.diagonalizing_gates(),
)
dev._samples = dev.generate_samples()
res = dev.var(obs)
expected = (
3
+ np.cos(2 * phi) * np.cos(varphi) ** 2
- np.cos(2 * theta) * np.sin(varphi) ** 2
- 2 * np.cos(theta) * np.sin(phi) * np.sin(2 * varphi)
) / 4
assert np.allclose(res, expected, **tol)
def test_hermitian(self, theta, phi, varphi, device, shots, tol):
"""Test that a tensor product involving qml.Hermitian works correctly"""
dev = device(3)
A = np.array(
[
[-6, 2 + 1j, -3, -5 + 2j],
[2 - 1j, 0, 2 - 1j, -5 + 4j],
[-3, 2 + 1j, 0, -4 + 3j],
[-5 - 2j, -5 - 4j, -4 - 3j, -6],
]
)
obs = qml.PauliZ(0) @ qml.Hermitian(A, wires=[1, 2])
dev.apply(
[
qml.RX(theta, wires=[0]),
qml.RX(phi, wires=[1]),
qml.RX(varphi, wires=[2]),
qml.CNOT(wires=[0, 1]),
qml.CNOT(wires=[1, 2]),
],
rotations=obs.diagonalizing_gates(),
)
dev._samples = dev.generate_samples()
res = dev.var(obs)
expected = (
1057
- np.cos(2 * phi)
+ 12 * (27 + np.cos(2 * phi)) * np.cos(varphi)
- 2 * np.cos(2 * varphi) * np.sin(phi) * (16 * np.cos(phi) + 21 * np.sin(phi))
+ 16 * np.sin(2 * phi)
- 8 * (-17 + np.cos(2 * phi) + 2 * np.sin(2 * phi)) * np.sin(varphi)
- 8 * np.cos(2 * theta) * (3 + 3 * np.cos(varphi) + np.sin(varphi)) ** 2
- 24 * np.cos(phi) * (np.cos(phi) + 2 * np.sin(phi)) * np.sin(2 * varphi)
- 8
* np.cos(theta)
* (
4
* np.cos(phi)
* (
4
+ 8 * np.cos(varphi)
+ np.cos(2 * varphi)
- (1 + 6 * np.cos(varphi)) * np.sin(varphi)
)
+ np.sin(phi)
* (
15
+ 8 * np.cos(varphi)
- 11 * np.cos(2 * varphi)
+ 42 * np.sin(varphi)
+ 3 * np.sin(2 * varphi)
)
)
) / 16
assert np.allclose(res, expected, **tol)
|
nilq/baby-python
|
python
|
import argparse
import logging
import os
import sys
sys.path.insert(0, os.path.join(sys.path[0], ".."))
import development.configuration # pylint: disable = wrong-import-position
import development.environment # pylint: disable = wrong-import-position
logger = logging.getLogger("Main")
def main():
current_directory = os.getcwd()
script_path = os.path.realpath(__file__)
workspace_directory = os.path.dirname(os.path.dirname(script_path))
os.chdir(workspace_directory)
try:
environment_instance = development.environment.load_environment()
configuration_instance = development.configuration.load_configuration(environment_instance)
command_list = development.configuration.load_commands()
arguments = parse_arguments(environment_instance, configuration_instance, command_list)
log_level = logging.getLevelName(arguments.verbosity.upper())
development.environment.configure_logging(log_level)
if arguments.log_file is not None:
development.environment.configure_log_file(log_level, arguments.log_file)
show_project_information(configuration_instance, arguments.simulate)
arguments.func(environment_instance, configuration_instance, arguments)
finally:
os.chdir(current_directory)
def parse_arguments(environment_instance, configuration_instance, command_list):
all_log_levels = [ "debug", "info", "warning", "error", "critical" ]
main_parser = argparse.ArgumentParser()
main_parser.add_argument("--verbosity", choices = all_log_levels, default = "info",
metavar = "<level>", help = "set the logging level (%s)" % ", ".join(all_log_levels))
main_parser.add_argument("--simulate", action = "store_true", help = "perform a test run, without writing changes")
main_parser.add_argument("--log-file", metavar = "<file_path>", help = "set the log file path")
main_parser.add_argument("--results", metavar = "<file_path>", help = "set the file path where to store command results")
subparsers = main_parser.add_subparsers(title = "commands", metavar = "<command>")
subparsers.required = True
for command in [ command for command in command_list if "module" in command ]:
command_parser = command["module"].configure_argument_parser(environment_instance, configuration_instance, subparsers)
command_parser.set_defaults(func = command["module"].run)
return main_parser.parse_args()
def show_project_information(configuration_instance, simulate):
logger.info("%s %s", configuration_instance["project_name"], configuration_instance["project_version"]["full"])
logger.info("Script executing in %s %s", os.getcwd(), "(simulation)" if simulate else '')
print("")
if __name__ == "__main__":
main()
|
nilq/baby-python
|
python
|
import sys
import os
import json
import hashlib
import EVMfunction as EVMf
import EVMcompiler as EVMc
import EVMparse as EVMp
print('Kam1n0 script for EVM is now running...')
print('start persisting...')
args = sys.argv
sol_file_name = args[1].split('\\')[-1]
abs_file_name = os.path.abspath(args[1])
json_file_name = abs_file_name
#Compile sol -> bin, asm
print('compile %s' % sol_file_name)
(if_pragma, contract_name_list) = EVMc.compiler(abs_file_name)
#Parse
data = dict()
data['ida_compiler'] = 'Unknown'
data['name'] = abs_file_name
data['md5'] = hashlib.md5(data['name'].encode('utf-8')).hexdigest()
data['architecture'] = {}
data['architecture']['type'] = 'metapc' #evm
data['architecture']['size'] = 'b64' #??
data['architecture']['endian'] = "le" #??
data['vulnerabilities'] = list()
data['contracts'] = list()
(asm, bin, ast) = EVMp.get_code_information(contract_name_list)
contract_count = len(contract_name_list)
ordered_ast = EVMf.get_ordered_ast(ast, contract_count, if_pragma) # get ordered_ast['Function']
#parameter
block_id = 0
current_address = 0
callee = dict()
prev_cont = None
prev_func = None
prev_block = None
for i in range(contract_count):
if asm[i] != None:
(prev_cont, prev_func, prev_block, current_address, block_id, bin) = EVMf.call_parse(
data, asm[i], ordered_ast, contract_name_list[i], current_address,
block_id, callee, bin, prev_cont, prev_func, prev_block, 0)
end_address = current_address
if prev_cont != None:
prev_cont['see'] = end_address
if prev_func != None:
prev_func['see'] = end_address
if prev_block != None:
prev_block['see'] = end_address
#bytes
for c in data['contracts']:
for f in c['functions']:
for b in f['blocks']:
begin = b['sea']*2
end = b['see']*2
b['bytes'] = bin[begin: end]
#print(b['name'], ': ', begin, end, ': ', b['bytes'])
#call
EVMf.get_call(data, callee, end_address)
#Labeling
print('give labels to %s' % sol_file_name)
label_file = '.\\Label.json'
label = EVMf.get_json(label_file);
EVMf.labeling(sol_file_name, data, label);
#concate contracts and functions
data['functions'] = list()
for c in data['contracts']:
for f in c['functions']:
f['name'] = f['name'] + '.' + c['name']
data['functions'].append(f)
#output
with open('%s.tmp0.json' % json_file_name, 'w', encoding="utf-8") as outfile:
json.dump(data, outfile, ensure_ascii=False)
|
nilq/baby-python
|
python
|
#!/usr/bin/env python3
"""Bank account without synchronization cause race condition """
class UnsyncedBankAccount:
"""Bank account without synchronization"""
balance: float
def __init__(self, balance: float = 0):
self.balance: float = balance
def deposit(self, amount: float) -> None:
if amount > 0:
self.balance += amount
else:
raise ValueError("You can't deposit negative amount of money")
def withdraw(self, amount: float) -> None:
if 0 < amount <= self.balance:
self.balance -= amount
else:
raise ValueError("Account does not contain sufficient funds")
|
nilq/baby-python
|
python
|
# import setuptools
# with open("README.md", "r") as fh:
# long_description = fh.read()
# setuptools.setup(
# #Here is the module name.
# name="TOPSIS-Shivansh-101803103",
# #version of the module
# version="0.0.1",
# #Name of Author
# author="Shivansh Kumar",
# #your Email address
# author_email="skumar_be18@thapar.edu",
# #Small Description about module
# description="TOPSIS in Python",
# long_description=long_description,
# #Specifying that we are using markdown file for description
# long_description_content_type="text/markdown",
# packages=setuptools.find_packages(),
# #classifiers like program is suitable for python3, just leave as it is.
# classifiers=[
# "Programming Language :: Python :: 3",
# "License :: OSI Approved :: MIT License",
# "Operating System :: OS Independent",
# ],
# )
from setuptools import setup
with open("README.md","r") as fh:
long_description = fh.read()
setup(
name = 'TOPSIS-Shivansh-101803103',
version = '0.0.1',
description = 'Find the Topsis Score Easily as well as preciously - Multiple Criteria Decision Making!',
py_modules = ["topsis"],
package_dir = {'':'TOPSIS-Shivansh-101803103'},
package_data={'':['LICENSE.txt']},
include_package_data=True,
# url="https://github.com/manmeet-kaur18/Topsis",
author="Shivansh Kumar",
author_email="shivansh.justme@gmail.com",
classifiers=[
'Development Status :: 3 - Alpha',
'Intended Audience :: Developers',
'Topic :: Software Development :: Build Tools',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: 3.8',
],
long_description=long_description,
long_description_content_type="text/markdown",
extras_require={
"dev":[
"pytest>=3.7",
],
},
)
|
nilq/baby-python
|
python
|
from collections import defaultdict
from contextlib import contextmanager
from enum import Enum
import redis_lock
from passari_workflow.redis.connection import get_redis_connection
from rq import Queue
from rq.exceptions import NoSuchJobError
from rq.job import Job
from rq.registry import FailedJobRegistry, StartedJobRegistry
class QueueType(Enum):
"""
Each queue type corresponds to a RQ queue
"""
DOWNLOAD_OBJECT = "download_object"
CREATE_SIP = "create_sip"
SUBMIT_SIP = "submit_sip"
CONFIRM_SIP = "confirm_sip"
ENQUEUE_OBJECTS = "enqueue_objects"
class WorkflowQueue(Queue):
# Workflow tasks have a default timeout of 4 hours
DEFAULT_TIMEOUT = 14400
OBJECT_QUEUE_TYPES = [
QueueType.DOWNLOAD_OBJECT,
QueueType.CREATE_SIP,
QueueType.SUBMIT_SIP,
QueueType.CONFIRM_SIP
]
def job_id_to_object_id(job_id):
"""
Extract the object ID from a RQ job ID
"""
try:
object_id = int(job_id.split("_")[-1])
return object_id
except ValueError:
return None
def get_queue(queue_type):
"""
Get RQ queue according to its QueueType
:param QueueType queue_type: Queue to return
"""
con = get_redis_connection()
queue_type = QueueType(queue_type)
queue = WorkflowQueue(queue_type.value, connection=con)
return queue
def delete_jobs_for_object_id(object_id):
"""
Delete all jobs for the given object ID
"""
object_id = int(object_id)
redis = get_redis_connection()
cancelled_count = 0
for queue_type in QueueType:
job_id = f"{queue_type.value}_{object_id}"
try:
Job.fetch(job_id, connection=redis).delete()
cancelled_count += 1
except NoSuchJobError:
pass
return cancelled_count
def get_enqueued_object_ids():
"""
Get object IDs from every object-related queue including every pending,
executing and failed job.
This can be used to determine which jobs can be enqueued without
risk of duplicates
"""
object_ids = set()
registry_types = (StartedJobRegistry, FailedJobRegistry)
for queue_type in OBJECT_QUEUE_TYPES:
queue = get_queue(queue_type)
# Retrieve started and failed jobs
for registry_type in registry_types:
job_registry = registry_type(queue=queue)
job_ids = job_registry.get_job_ids()
for job_id in job_ids:
object_id = job_id_to_object_id(job_id)
if object_id is not None:
object_ids.add(object_id)
# Retrieve scheduled jobs
for job_id in queue.get_job_ids():
object_id = job_id_to_object_id(job_id)
if object_id is not None:
object_ids.add(object_id)
return object_ids
def get_running_object_ids():
"""
Get object IDs which are currently being executed in the workflow
"""
object_ids = set()
for queue_type in OBJECT_QUEUE_TYPES:
queue = get_queue(queue_type)
job_registry = StartedJobRegistry(queue=queue)
job_ids = job_registry.get_job_ids()
for job_id in job_ids:
object_id = job_id_to_object_id(job_id)
if object_id is not None:
object_ids.add(object_id)
return object_ids
def get_object_id2queue_map(object_ids):
"""
Get a {object_id: queue_names} dictionary of object IDs and the queues they
currently belong to
"""
queue_object_ids = defaultdict(set)
queue_map = {}
for queue_type in OBJECT_QUEUE_TYPES:
queue = get_queue(queue_type)
started_registry = StartedJobRegistry(queue=queue)
job_ids = started_registry.get_job_ids() + queue.get_job_ids()
# Check pending or executing jobs
for job_id in job_ids:
object_id = job_id_to_object_id(job_id)
if object_id is not None:
queue_object_ids[queue_type.value].add(object_id)
failed_registry = FailedJobRegistry(queue=get_queue(queue_type))
job_ids = failed_registry.get_job_ids()
# Check failed jobs
for job_id in job_ids:
object_id = job_id_to_object_id(job_id)
if object_id is not None:
queue_object_ids[queue_type.value].add(object_id)
queue_object_ids["failed"].add(object_id)
# Check for all queues plus the catch-all failed queue
queue_names = [
queue_type.value for queue_type in OBJECT_QUEUE_TYPES
] + ["failed"]
for object_id in object_ids:
queue_map[object_id] = []
for queue_name in queue_names:
if object_id in queue_object_ids[queue_name]:
queue_map[object_id].append(queue_name)
return queue_map
@contextmanager
def lock_queues():
"""
Context manager to lock all queues.
This lock should be acquired when the workflow is affected directly
(eg. enqueueing new jobs) or indirectly (eg. updating database
so that changes an object's qualification to be enqueued or not)
"""
redis = get_redis_connection()
lock = redis_lock.Lock(redis, "workflow-lock", expire=900)
lock.acquire(blocking=True)
try:
yield lock
finally:
lock.release()
|
nilq/baby-python
|
python
|
#!/usr/bin/env python
# coding: utf-8
# # 2. Τιμές, τύποι και μεταβλητές. Συμβολοσειρές
# ## Σταθερές (Constants)
#
# H Python δεν διαθέτει προκαθορισμένες *σταθερές* όπως άλλες γλώσσες προγραμματισμού.
# Όμως κατά σύμβαση και όχι κατά κανόνα έχει συμφωνηθεί οι *σταθερές* να ονοματίζονται με κεφαλαίους χαρακτήρες.
# Η αδυναμία της Python στην περίπτωση της δήλωσης *σταθερών* είναι ότι επιτρέπεται η αλλαγή των τιμών τους
# Παρακάτω παρατίθεται ένα παράδειγμα δήλωσης *σταθερών*.
# In[1]:
RATIO_FEET_TO_METERS = 3.281
RATIO_LB_TO_KG = 2.205
PI = 3.14
# ## Κυριολεκτικές σταθερές (literal constants)
#
# Η κυριολεκτική *σταθερά* ή τιμή είναι ένας αριθμός, ή χαρακτήρας ή μιά συμβολοσειρά. Για παράδειγμα τα παρακάτω
# αποτελούν τιμές: *3.25* (στην python η υποδιαστολή ορίζεται με . και όχι ,), *"ένα τυχαίο κείμενο"*, *5.25e-1*.
# Αυτές οι τιμές δεν μεταβάλλονται κατά τη διάρκεια εκτέλεσης του προγράμματος γι' αυτό και λέγονται σταθερές. Μπορούν να εκχωρηθούν σε μεταβλητές
# και να χρησιμοποιηθούν σαν τελεστέοι σε λογικές εκφράσεις ή σαν παραμέτροι σε συναρτήσεις.
#
# ## Τύποι δεδομένων
#
# Οι τιμές ανήκουν σε τρεις τύπους δεδομένων (data types) ή κλάσσεις (class):
# - τους ακέραιους αριθμούς (integer) π.χ. το 15
# - τους αριθμούς κινητής υποδιαστολής (floating point) π.χ. το 201.25)
# - τις συμβολοσειρές (string) π.χ. το "Time is money"
# Με την εντολή `type` ο διερμηνευτής μας απαντάει με τον τύπο της τιμής, όπως παρακάτω:
# In[2]:
type("No news, good news.")
# Η Python είναι *Dynamic typing* δηλαδή δεν ο τύπος των μεταβλητών δεν προκαθορίζεται κατά την συγγραφή αλλά κατά την εκτέλεση.
# ## Κανόνες ονοματοδοσίας μεταβλητών
#
# Τα ονόματα των μεταβλητών στην Python υπακούουν στους παρακάτω κανόνες:
# - Το όνομα μίας μεταβλητής μπορεί να ξεκινά από ένα γράμμα ή από κάτω πάυλα.
# - Το όνομα μίας μεταβλητής δεν μπορεί με αριθμό.
# - Το όνομα μίας μεταβλητής μπορεί να περιέχει μόνο αλφαριθμητικούς χαρακτήρες.
# - Στα ονόματα των μεταβλήτών γίνεται διάκριση ανάμεσα σε πεζά και κεφαλαία (case sensitive).
# - Οι δεσμευμένες λέξεις της Python (keywords) δεν μπορούν να χρησιμοποιηθούν σε ονόματα μεταβλητών.
# ## Συμβολοσειρές (Strings)
# Μια συμβολοσειρά είναι μια ακολουθία από χαρακτήρες όπως το `"Το πεπρωμένον φυγείν αδύνατον."`.
# Μπορεί να είναι σε κάθε γλώσσα που υποστηρίζεται από το πρώτυπου Unicode. Οι συμβολοσειρές περικλείονται σε μονά, διπλά ή τριπλά εισαγωγικά.
# Με τριπλά εισαγωγικά μπορούν να ενσωματωθούν με ευκολία συμβολοσειρές σε πολλές γραμμές και πολλαπλά εισαγωγικά εντός αυτόν.
# Ακολουθούν παραδείγματα συμβολοσειρά.
"My name is Bond, James Bond."
'There is no smoke without fire'
'''
No bees no honey, no work no money.
A little is better than none
What’s done cannot be undone
'''
# ## Χαρακτήρες διαφυγής,κενά, νέες γραμμές
# Μπορούμε να σπάσουμε μια συμβολοσειρά κατά την συγγραφή σε νέα γραμμή με τον χαρακτήρα `\` και κατά την εκτέλεση με τον χαρακτήρα `\n` π.χ.
# In[3]:
message = 'There is no smoke without fire'
print(message)
# In[4]:
message = 'There is no smoke \nwithout fire'
print(message)
# Ή να ορίσουμε κενά με το `\t`
# In[5]:
message = 'There is no smoke \twithout fire'
print(message)
# Ο χαρακτήρας `\` είναι χαρακτήρας διαφυγής που απενεργοποιεί την ειδική λειτουργία των παραπάνω ή την παράθεση εισαγωγικών μεσα σε εισαγωγικά.
# In[6]:
print('There is no smoke \\n without fire')
# In[7]:
print('Where there\'s a will, there\'s a way')
# ## Ανεπεξέργαστες συμβολοσειρές (Raw Strings)
# Παρόμοιο αποτέλεσμα με τα παραπάνω πετυχαίνουμε τις ανεπεξέργαστες συμβολοσειρές οι οποίες ορίζονται με ένα r σαν πρόθεμα
# In[8]:
print(r"It was made by \n συνέχεια")
# ## Αφαίρεση κενών
# Σε αρκετές περιπτώσεις οι συμβολοσειρές περιέχουν κενά είτε στην αρχή είτε στο τέλος.
# Για παράδειγμα οι παρακάτω συμβολοσειρές δεν είναι το ίδιες για την Python. Και επιβεβαιώνεται σε μέσω ελέγχου ισότητας.
# In[9]:
departmentA='ΤΜΧΠΑ'
departmentB = ' ΤΜΧΠΑ '
print(departmentA == departmentB) #not equal
# Για την αφαίρεση των κένων αριστερά, δεξιά ή ταυτόχρονα και στις δύο πλευρές της συμβολοσειρας χρησιμοποιούμε την μέθοδο `strip` και τις παραλλαγές της `rstrip` και `lstrip`
# In[10]:
print(departmentB.rstrip())
print(departmentB.lstrip())
print(departmentB.strip())
# ## Συνένωση (Concatenation) συμβολοσειρών
#
# Η απλή παράθεση συμβολοσειρών οδηγεί στην συνενωσή τους δηλ.
# In[11]:
message = "Curiosity " "killed " 'the ' '''cat'''
print(message)
# ## Συνένωση συμβολοσειρών και μεταβλητών
#
# Η συνένωση μεταβλητών και συμβολοσειρών γίνεται με τον τελεστη `+`.
# In[12]:
city='Βόλος'
perifereia='Θεσσαλία'
print('O '+city+' είναι πόλη της Ελλάδα στην ' +perifereia)
# ## Η μέθοδος format
# Άλλη μια πιο πρακτική μέθοδος κατά την συννένωση μεταβλητών και συμβολοσειρών είναι η μέθοδος format.
#
# In[13]:
print('O {0} έχει υψόμετρο {1} μέτρα'.format("Όλυμπος", 2918))
print('O {} έχει υψόμετρο {} μέτρα'.format("Όλυμπος", 2918))
print('O {name} έχει υψόμετρο {height} μέτρα'.format(name="Σμόλικας", height= 2637 ))
# ## Δεσμευμένες λέξεις (reserved words)
# Ορισμένες λέξεις έχουν ιδιαίτερη σημασία για την python και δεν μπορούν να χρησιμοποιηθούν σαν ονόματα μεταβλητών. Τα παρακάτω κομμάτια κώδικα θα εκδηλώσουν σφάλμα μεταγλώττισης.
class="Πρώτο εξάμηνο"break='Πότε θα κάνουμε διάλειμμα;'
# Πρόκειται για 33 λέξεις στην τρέχουσα έκδοση της Python.
# Μπορούμε να δούμε ποιές είναι αυτές οι δεσμεύνες λέξεις με την παρακάτω εντολή:
# In[14]:
help("keywords")
# ## Η εντολή help
# Γενικά με την εντολή `help` καλούμε για βοήθεια και πληροφορίες την Python:
# In[15]:
help(print)
# In[16]:
help(abs)
# In[17]:
help(max)
# ## Αλλαγή Πεζών Κεφαλαίων (Convert case)
# Μπορούμε να κάνουμε αλλαγή ανάμεσα σε κεφαλαία και πεζά με τις παρακάτω μεθόδους συμβολοσειρών:`upper()`, `title()`, `lower()`.
# Αξίζει να σημειώσουμε ότι οι μέθοδοι αυτές δεν έχουν επίδραση στην μεταβλητή που τις καλούμε αλλά πρέπει να επαναεκχωρήσουμε το αποτέλεσμα της μεθόδου στην μεταβλητή με το ίδιο όνομα.
# In[18]:
agios="άγιος νικόλαος"
print(agios.upper())
print(agios) # ο agios παραμένει "άγιος νικόλαος"
print(agios.title())
print('ΑΓΊΑ ΕΛΈΝΗ'.lower())
agios = agios.upper()
print(agios) # ο agios μετά την εκχώρηση στην ίδια μεταβλητή γινεται ΆΓΙΟΣ ΝΙΚΌΛΑΟΣ
# ## Οι συμβολοσειρές είναι μη μεταβαλλόμενη δομή δεδομένων
# Οι συμβολοσειρές αποτελούνται από ακολουθίες χαρακτήρων με σταθερό μέγεθος
# και μη μεταβαλλόμενα περιεχόμενα. Αυτό σημαίνει ότι δεν είναι δυνατόν να προστίθενται ή να αφαιρούνται
# χαρακτήρες, ούτε να τροποποιούνται τα περιεχόμενα του αλφαριθμητικού.
# Πρόκειται για μια μη μεταβαλλόμενη (immutable) δομή της Python.
# Η αρίθμηση των χαρακτήρων σε ένα αλφαριθμητικό ξεκινάει από το 0.
#
# Έτσι στην συμβολοσειρά `country = Ελλάδα` έχουμε:
#
# `country[0]` → Ε (η αρίθμηση ξεκινά από το 0)
#
# `country[1]` → λ
#
# `country[2]` → λ
#
# `country[3]` → ά
#
# `country[4]` → δ
#
# `country[5]` → α
#
# Η παραπάνω συμβολοσειρά έχει μήκος 6 χαρακτήρες.
# ## Μήκος συμβολοσειράς
# Μέσω της συνάρτησης `len` η Python μας επιστρέφει το μήκος συμβολοσειράς δηλαδή το πλήθος των χαρακτήρων (μαζί με τα κενά) από τους οποιούς αποτελείται.
# In[19]:
message = 'Ή τώρα ή ποτέ.'
len(message)
# ## Η μέθοδος find
# Η μέθοδος `find` μας επιτρέπει να αναζητήσουμε μια συμβολοσειρά μέσα σε μια άλλη συμβολοσειρά.
# Η μέθοδος μας επιστρέφει την τοποθεσία από την ξεκινάει η αναζητούμενη συμβολοσειρά δηλαδή τον δείκτη (index) στην οποία εντοπίζεται
# ο πρώτος χαρακτηρας της αναζητούμενης συμβολοσειράς μέσα στα περιεχόμενα της αρχικής συμβολοσειράς.
# Στην παρακάτω συμβολοσειρά θα αναζητήσουμε την λέξη `ποτέ`.
# In[20]:
stixos = 'Η Ελλάδα ποτέ δεν πεθαίνει'
index = stixos.find('ποτέ')
# Κανονικά αν πάμε στον χαρακτήρα με ευρετηρίο (index) 9 πρέπει να εντοπίσουμε τον πρώτο χαρακτήρα της συμβολοσειράς που είναι το `π`.
# Πράγματι:
# In[21]:
stixos[index]
# Αν δεν εντοπιστεί η λέξη που αναζητούμε στην συμβολοσειρά η Python θα επιστρέψει: `-1`
# In[22]:
stixos.find('πάντα')
# Η αναζήτηση είναι case sensitive δηλαδή γίνεται διάκριση ανάμεσα σε πεζά και κεφαλαία.
# In[23]:
stixos.find('Ελλάδα') # επιστρέφει τον δείκτη 2 γιατί εντοπίστηκε η λέξη κλειδί
# In[24]:
stixos.find('ΕΛΛΆΔΑ') # επιστρέφει -1 γιατί δεν εντοπίστηκε η λέξη κλειδί
# Μια άλλη σημαντική μέθοδος των συμβολοσειρών είναι η μέθοδος `replace` κατά την οποία μπορούμε να αντικαταστήσουμε τα περιεχόμενα μιας συμβολοσειράς. Στην πρώτη παράμετρο ορίζουμε την συμβολοσειρά που θέλουμε να αντικαταστήσουμε με την δεύτερη παράμετρο.
# In[25]:
stixos.replace('ποτέ', 'πάντα')
|
nilq/baby-python
|
python
|
import os,sys
import numpy as np
import torch
import torch.nn.functional as F
import h5py, time, itertools, datetime
from scipy.ndimage import label
from scipy.ndimage.morphology import binary_erosion
from torch_connectomics.utils.net import *
from torch_connectomics.utils.vis import visualize_aff
def test(args, test_loader, model, device, model_io_size, volume_shape, pad_size, initial_seg=None):
# switch to eval mode
model.eval()
volume_id = 0
ww = blend(model_io_size)
NUM_OUT = args.out_channel
sel_cpu = np.ones((3, 3, 3), dtype=bool)
sel = torch.ones((1, 1, 3, 3, 3), dtype=torch.float32, device=device)
if initial_seg is not None:
result = [np.expand_dims(initial_seg, axis=0)]
else:
result = [np.stack([np.zeros(x, dtype=bool) for _ in range(NUM_OUT)]) for x in volume_shape]
result_raw = [np.stack([np.zeros(x, dtype=np.float32) for _ in range(NUM_OUT)]) for x in volume_shape]
prediction_points = []
weight = [np.zeros(x, dtype=np.float32) for x in volume_shape]
print(result[0].shape, weight[0].shape)
if args.test_augmentation:
print("Will augment (Rotate and Flip) data during inference.")
test_loader.set_out_array(result[0][0])
sz = tuple([NUM_OUT] + list(model_io_size))
start = time.time()
with torch.no_grad():
itr_num = 0
while test_loader.remaining_pos() > 0 :
itr_num += 1
if args.out_channel == 2:
pos, volume, past_pred = test_loader.get_input_data()
volume = volume.to(device)
past_pred = past_pred.to(device)
output_raw = model(torch.cat((volume, past_pred), 1))
else:
pos, volume = test_loader.get_input_data()
volume = volume.to(device)
output_raw = model(volume)
output = output_raw > 0.95
output_raw = output_raw.cpu().detach().numpy()
for idx in range(output.shape[0]):
st = pos[idx]
out_mask = output[idx][0].cpu().detach().numpy().astype(bool)
if out_mask[tuple(test_loader.dataset.half_input_sz)]:
cc_out_mask, _ = label(out_mask)
out_mask = (cc_out_mask == cc_out_mask[tuple(test_loader.dataset.half_input_sz)])
result[st[0]][0, st[1]:st[1]+sz[1], st[2]:st[2]+sz[2], st[3]:st[3]+sz[3]] |= out_mask
result_raw[st[0]][:, st[1]:st[1] + sz[1], st[2]:st[2] + sz[2], st[3]:st[3] + sz[3]] \
= np.maximum(result[st[0]][:, st[1]:st[1] + sz[1], st[2]:st[2] + sz[2], st[3]:st[3] + sz[3]], \
output_raw[idx].reshape(sz))
prediction_points.append(st[1:] - test_loader.dataset.seed_points_offset) # appending center points wrt the unpadded volume
if itr_num < 200:
print('Iteration: ', itr_num)
out_mask = torch.from_numpy(binary_erosion(out_mask, sel_cpu).astype(np.float32)).to(device)
out_mask = out_mask.unsqueeze(0).unsqueeze(0)
edge = (F.conv3d(out_mask, sel, padding=1))[0, 0]
edge = (edge > 0) * (edge < 9)
edge = F.interpolate(edge.unsqueeze(0).unsqueeze(0).float(), scale_factor=1 / 4, mode='trilinear')
edge = edge > .50
edge_pos = (torch.nonzero(edge[0, 0])*4).cpu().detach().numpy().astype(np.uint32)
test_loader.compute_new_pos(out_mask, edge_pos, st[1:])
end = time.time()
print("prediction time:", (end-start))
for vol_id in range(len(result)):
data = result[vol_id]
data = data[:,
pad_size[0]:-pad_size[0],
pad_size[1]:-pad_size[1],
pad_size[2]:-pad_size[2]]
print('Output shape: ', data.shape)
hf = h5py.File(args.output + '/mask_' + str(vol_id) + '.h5', 'w')
hf.create_dataset('main', data=data, compression='gzip')
hf.close()
hf = h5py.File(args.output + '/prediction_points' + str(vol_id) + '.h5', 'w')
hf.create_dataset('main', data=np.array(prediction_points), compression='gzip')
hf.close()
data = result_raw[vol_id]
data = data[:,
pad_size[0]:-pad_size[0],
pad_size[1]:-pad_size[1],
pad_size[2]:-pad_size[2]]
data = (data*255).astype(np.uint8)
hf = h5py.File(args.output + '/mask_raw' + str(vol_id) + '.h5', 'w')
hf.create_dataset('main', data=data, compression='gzip')
hf.close()
def get_augmented(volume):
# perform 16 Augmentations as mentioned in Kisuks thesis
vol0 = volume
vol90 = torch.rot90(vol0, 1, [3, 4])
vol180 = torch.rot90(vol90, 1, [3, 4])
vol270 = torch.rot90(vol180, 1, [3, 4])
vol0f = torch.flip(vol0, [3])
vol90f = torch.flip(vol90, [3])
vol180f = torch.flip(vol180, [3])
vol270f = torch.flip(vol270, [3])
vol0z = torch.flip(vol0, [2])
vol90z = torch.flip(vol90, [2])
vol180z = torch.flip(vol180, [2])
vol270z = torch.flip(vol270, [2])
vol0fz = torch.flip(vol0f, [2])
vol90fz = torch.flip(vol90f, [2])
vol180fz = torch.flip(vol180f, [2])
vol270fz = torch.flip(vol270f, [2])
augmented_volumes = [vol0, vol90, vol180, vol270, vol0f, vol90f, vol180f, vol270f,
vol0z, vol90z, vol180z, vol270z, vol0fz, vol90fz, vol180fz, vol270fz]
return augmented_volumes
def combine_augmented(outputs):
assert len(outputs) == 16
for i in range(8, 16):
outputs[i] = torch.flip(outputs[i], [2])
for i in range(4, 8):
outputs[i] = torch.flip(outputs[i], [3])
for i in range(12, 16):
outputs[i] = torch.flip(outputs[i], [3])
for i in range(1, 16, 4):
outputs[i] = torch.rot90(outputs[i], -1, [3, 4])
for i in range(2, 16, 4):
outputs[i] = torch.rot90(outputs[i], -1, [3, 4])
outputs[i] = torch.rot90(outputs[i], -1, [3, 4])
for i in range(3, 16, 4):
outputs[i] = torch.rot90(outputs[i], 1, [3, 4])
# output = torch.zeros_like(outputs[0], dtype=torch.float64)
# for i in range(len(outputs)):
# output += outputs[i].double()
# output = output / 16.0
for i in range(len(outputs)):
outputs[i] = outputs[i].unsqueeze(0)
output = torch.min(torch.cat(outputs, 0), 0)[0]
return output, outputs
def main():
args = get_args(mode='test')
print('0. initial setup')
model_io_size, device = init(args)
print('model I/O size:', model_io_size)
print('1. setup data')
test_loader, volume_shape, pad_size, initial_seg = get_input(args, model_io_size, 'test')
print('2. setup model')
model, _ = setup_model(args, device, exact=True, model_io_size=model_io_size)
print('3. start testing')
test(args, test_loader, model, device, model_io_size, volume_shape, pad_size, initial_seg)
print('4. finish testing')
if __name__ == "__main__":
main()
|
nilq/baby-python
|
python
|
import ML
import function.saveNewsList
import hook.hooks
import job
import json
from nose.tools import with_setup
from ML import Server
def setup_func():
ML.init(
"57f9edc887d4a7e337b8c231",
master_key="elhmazJfd29ZTFBhR0M3SmJ0R2N6UQ",
)
@with_setup(setup_func)
def test_saveNewsDetail():
fileName = "/Users/mac/Downloads/newslist.json"
fileObject = open(fileName)
try:
news = fileObject.read()
except:
news = ""
response = Server.callFunction('saveNewsList', data=json.dumps({"content":news}))
print "response: "+response.data
|
nilq/baby-python
|
python
|
# -*- coding: utf-8 -*-
# Generated by Django 1.10 on 2016-08-11 15:42
from django.db import migrations
import utilities.fields
class Migration(migrations.Migration):
dependencies = [
('dcim', '0017_rack_add_role'),
]
operations = [
migrations.AddField(
model_name='device',
name='asset_tag',
field=utilities.fields.NullableCharField(blank=True, help_text=b'A unique tag used to identify this device', max_length=50, null=True, unique=True, verbose_name=b'Asset tag'),
),
]
|
nilq/baby-python
|
python
|
import numpy as np
import sqlalchemy
from sqlalchemy.ext.automap import automap_base
from sqlalchemy.orm import Session
from sqlalchemy import create_engine, func
from flask import Flask, jsonify
import datetime
from dateutil.relativedelta import relativedelta
from datetime import datetime
from sqlalchemy import desc
import pandas as pd
from flask import Response
#################################################
# Database Setup
#################################################
engine = create_engine("sqlite:///./Resources/hawaii.sqlite")
# reflect an existing database into a new model
Base = automap_base()
# reflect the tables
Base.prepare(engine, reflect=True)
# Save reference to the table
Measurement = Base.classes.measurement
Station = Base.classes.station
#################################################
# Flask Setup
#################################################
app = Flask(__name__)
#################################################
# Flask Routes
#################################################
@app.route("/")
def welcome():
"""List all available api routes."""
return (
f"Available Routes:<br/>"
f"/api/v1.0/precipitation<br/>"
f"/api/v1.0/stations<br/>"
f"/api/v1.0/tobs<br/>"
f"/api/v1.0/start/end"
)
@app.route("/api/v1.0/precipitation")
def precipitation():
# Create our session (link) from Python to the DB
session = Session(engine)
"""Return a list of all dates and precipitation"""
# Query all dates and precipitation
most_recent_date = '2017-08-23'
last_year_date = (datetime.strptime(most_recent_date, "%Y-%m-%d") + relativedelta(years=-1)).date()
results = session.query(Measurement.date, Measurement.prcp).\
filter(Measurement.date >= last_year_date).\
filter(Measurement.prcp != None).\
order_by(Measurement.date).all()
session.close()
all_dates_prcp=[]
date_dict = {date : prcp for date, prcp in results}
return jsonify(date_dict)
@app.route("/api/v1.0/stations")
def stations():
# Create our session (link) from Python to the DB
session = Session(engine)
"""Return a list of all stations"""
# Query all stations
results = session.query(Station.name, Station.station).order_by(Station.name).all()
session.close()
all_stations=[]
# station = list(np.ravel(results))
for name, station in results:
station_dict = {}
station_dict['name']=name
station_dict['station']=station
all_stations.append(station_dict)
return jsonify(all_stations)
@app.route("/api/v1.0/tobs")
def tobs():
# Create our session (link) from Python to the DB
session = Session(engine)
# Find the most recent date in the data set.
most_recent_date = session.query(func.max(Measurement.date)).one()
most_recent_date = most_recent_date[0]
# Calculate the date one year from the last date in data set.
last_year_date = datetime.strptime(most_recent_date, "%Y-%m-%d") + relativedelta(years=-1)
last_year_date
# Query for the dates and temperature observations of the most active station for the last year of data
station_list = session.query(Measurement.station,func.count(Measurement.station).label('station count')).\
group_by(Measurement.station).\
order_by(desc('station count')).all()
most_active_station_id = station_list[0][0]
temp_observation_data = session.query(Measurement.date, Measurement.tobs).\
filter(Measurement.station == most_active_station_id).\
filter(Measurement.date <= most_recent_date).\
filter(Measurement.date >= last_year_date).order_by(Measurement.date)
session.close()
all_tobs_for_last_year=[]
for date, tobs in temp_observation_data:
tobs_dict = {}
tobs_dict['date']=date
tobs_dict['tobs']=tobs
all_tobs_for_last_year.append(tobs_dict)
return jsonify(all_tobs_for_last_year)
@app.route("/api/v1.0/<start>")
@app.route("/api/v1.0/<start>/<end>")
def temperature_date(start=None, end=None):
# Create our session (link) from Python to the DB
session = Session(engine)
# Find the most recent date in the data set.
most_recent_date = session.query(func.max(Measurement.date)).one()
most_recent_date = most_recent_date[0]
# If start date is greater than most last date in data
if(start > most_recent_date):
return "Start Date is out of the range."
# If end is is not given by user then assign last available date in data
if(end is None):
end = most_recent_date
if(start <= end):
temp_stats = session.query(func.min(Measurement.tobs),func.max(Measurement.tobs),func.avg(Measurement.tobs)).\
filter(Measurement.date >= start).\
filter(Measurement.date <= end).all()
temp_dict = []
temp_dict.append(f'Minimum Temperature: {temp_stats[0][0]}')
temp_dict.append(f'Maximum Temperature: {temp_stats[0][1]}')
temp_dict.append(f'Average Temperature: {round(temp_stats[0][2],1)}')
return jsonify(temp_dict)
else:
return "Start Date should not be greater than End Date"
if __name__ == '__main__':
app.run(debug=True)
|
nilq/baby-python
|
python
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.