code
stringlengths 2
1.05M
| repo_name
stringlengths 5
104
| path
stringlengths 4
251
| language
stringclasses 1
value | license
stringclasses 15
values | size
int32 2
1.05M
|
|---|---|---|---|---|---|
# -*- coding: utf-8 -*-
from datetime import datetime, timedelta
import itertools
import csv, codecs, cStringIO
def parse_date(date_str):
return datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S.%f")
def total_seconds(td):
return (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / float(10**6)
def td_to_str(td, use_ms=True):
mm, ss = divmod(td.seconds, 60)
hh, mm = divmod(mm, 60)
if td.days:
hh += td.days*24
s = "%d:%02d:%02d" % (hh, mm, ss)
if td.microseconds and use_ms:
s += ".%06d" % td.microseconds
return s
def seconds_to_td_str(seconds, use_ms=True):
return td_to_str(timedelta(seconds=seconds), use_ms)
class CSVUnicodeWriter:
"""
A CSV writer which will write rows to CSV file "f",
which is encoded in the given encoding.
"""
def __init__(self, f, dialect=csv.excel, encoding="utf-8", **kwds):
# Redirect output to a queue
self.queue = cStringIO.StringIO()
self.writer = csv.writer(self.queue, dialect=dialect, **kwds)
self.stream = f
self.encoder = codecs.getincrementalencoder(encoding)()
def writerow(self, row):
self.writer.writerow([unicode(s).encode("utf-8") for s in row])
# Fetch UTF-8 output from the queue ...
data = self.queue.getvalue()
data = data.decode("utf-8")
# ... and reencode it into the target encoding
data = self.encoder.encode(data)
# write to the target stream
self.stream.write(data)
# empty queue
self.queue.truncate(0)
def writerows(self, rows):
for row in rows:
row = [v if not v is None else "" for v in row]
row = [v if not type(v) is timedelta else td_to_str(v) for v in row]
self.writerow(row)
def xls_to_lists(workbook_path):
"""
Receives the path to an excel file, which it transforms to a dict
of lists of lists (one dict entry per whorksheet)
"""
csv_data = {}
import xlrd
wb = xlrd.open_workbook(workbook_path)
for sh_name in wb.sheet_names():
sh = wb.sheet_by_name(sh_name)
headers = sh.row_values(0)
data = []
for rownum in xrange(1, sh.nrows):
data.append(sh.row_values(rownum))
csv_data[sh_name] = (headers, data)
return csv_data
def groupby(tuples_iterable, key):
return itertools.groupby(sorted(tuples_iterable, key=key), key)
# Iterates through a list having the previous and next items present
# Stolen from http://stackoverflow.com/a/323910/684253
def neighborhood(iterable):
iterator = iter(iterable)
prev = None
item = iterator.next() # throws StopIteration if empty.
for next in iterator:
yield (prev,item,next)
prev = item
item = next
yield (prev,item,None) | filipefigcorreia/asaanalyzer | asaanalyser/common/util.py | Python | mit | 2,824 |
'''
The kernel installer.
Run `python -m ai.backend.integration.jupyter.install` to use Backend.AI in your Jupyter notebooks.
'''
import argparse
import json
import os
import sys
import webbrowser
from jupyter_client.kernelspec import KernelSpecManager
from IPython.utils.tempdir import TemporaryDirectory
from .kernel import kernels
def clean_kernel_spec(user=True, prefix=None):
mgr = KernelSpecManager()
# NOTE: remove_kernel_spec() and get_all_specs() does not support explicit prefix.
# Sometimes we may need to perform --clean-only multiple times to completely
# remove all kernelspecs installed around venvs and system global directories.
for name, info in mgr.get_all_specs().items():
if name.startswith('backend'):
print("Removing existing Backend.AI kernel: {0}"
.format(info['spec']['display_name']))
mgr.remove_kernel_spec(name)
def install_kernel_spec(name, spec_json, user=True, prefix=None):
with TemporaryDirectory() as td:
os.chmod(td, 0o755) # Starts off as 700, not user readable
with open(os.path.join(td, 'kernel.json'), 'w') as f:
json.dump(spec_json, f, sort_keys=True)
print("Installing Backend.AI Jupyter kernel spec: {0}"
.format(spec_json['display_name']))
KernelSpecManager().install_kernel_spec(
td, name, user=user, replace=True, prefix=prefix)
def query_yes_no(prompt):
valid = {'y': True, 'yes': True, 'n': False, 'no': False}
while True:
choice = input('{0} [y/n] '.format(prompt)).lower()
if choice in valid:
return valid[choice]
else:
prompt = 'Pleas answer in y/yes/n/no.'
def _is_root():
try:
return os.geteuid() == 0
except AttributeError:
return False # assume not an admin on non-Unix platforms
def main(argv=None):
ap = argparse.ArgumentParser()
ap.add_argument('--user', action='store_true',
help="Install to the per-user kernels registry. Default if not root.")
ap.add_argument('--sys-prefix', action='store_true',
help="Install to sys.prefix (e.g. a virtualenv or conda env)")
ap.add_argument('--clean-only', action='store_true',
help="Perform only clean-up of existing Backend.AI kernels.")
ap.add_argument('-q', '--quiet', action='store_true',
help="Do not ask the user anything.")
ap.add_argument('--prefix',
help="Install to the given prefix. "
"Kernelspec will be installed in {PREFIX}/share/jupyter/kernels/")
args = ap.parse_args(argv)
if args.sys_prefix:
args.prefix = sys.prefix
if not args.prefix and not _is_root():
args.user = True
clean_kernel_spec(user=args.user, prefix=args.prefix)
if args.clean_only:
return
for kern in kernels:
spec = {
"argv": [sys.executable, "-m", "ai.backend.integration.jupyter",
"-f", "{connection_file}",
"--",
"-k", kern.__name__],
"display_name": kern.language_info['name'],
"language": kern.language,
}
install_kernel_spec(kern.__name__, spec, user=args.user, prefix=args.prefix)
if not args.quiet:
print()
has_api_key = bool(os.environ.get('BACKEND_ACCESS_KEY', ''))
if has_api_key:
print('It seems that you already configured the API key. Enjoy!')
else:
if query_yes_no('You can get your own API keypair from https://cloud.backend.ai. Do you want to open the site?'):
webbrowser.open_new_tab('https://cloud.backend.ai')
print()
print('If you already have the keypair or just grabbed a new one,')
print('run the following in your shell before running jupyter notebook:\n')
print(' export BACKEND_ACCESS_KEY="AKIA..."')
print(' export BACKEND_SECRET_KEY="......."\n')
if __name__ == '__main__':
main()
| lablup/sorna-jupyter-kernel | src/ai/backend/integration/jupyter/install.py | Python | mit | 4,036 |
#!/usr/bin/env python
# coding: utf-8
"""Generate ./pyui/config.py"""
import os
directory = os.path.dirname(os.path.abspath(__file__))
filename = os.path.join(directory, 'pyui', 'config.py')
if __name__ == "__main__":
s = '''\
#!/usr/bin/env python
# coding: utf-8
"""This python script file is generated automatically by ../config.py
Please do not modify this file manually, or it will be overwritten."""
import sys
if sys.version_info.major < 3:
import constants
else:
from pyui import constants
host = sys.platform
ver = sys.version_info.major
ui = constants.%s
''' % 'CLI'
f = open(filename, 'w')
f.write(s)
f.close()
print ('Done generate config script file: %s' % filename)
| niucheng/PYUI | config.py | Python | mit | 720 |
# coding: utf-8
"""
Swaggy Jenkins
Jenkins API clients generated from Swagger / Open API specification # noqa: E501
The version of the OpenAPI document: 1.1.2-pre.0
Contact: [email protected]
Generated by: https://openapi-generator.tech
"""
try:
from inspect import getfullargspec
except ImportError:
from inspect import getargspec as getfullargspec
import pprint
import re # noqa: F401
import six
from openapi_client.configuration import Configuration
class GithubRepositorypermissions(object):
"""NOTE: This class is auto generated by OpenAPI Generator.
Ref: https://openapi-generator.tech
Do not edit the class manually.
"""
"""
Attributes:
openapi_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict): The key is attribute name
and the value is json key in definition.
"""
openapi_types = {
'admin': 'bool',
'push': 'bool',
'pull': 'bool',
'_class': 'str'
}
attribute_map = {
'admin': 'admin',
'push': 'push',
'pull': 'pull',
'_class': '_class'
}
def __init__(self, admin=None, push=None, pull=None, _class=None, local_vars_configuration=None): # noqa: E501
"""GithubRepositorypermissions - a model defined in OpenAPI""" # noqa: E501
if local_vars_configuration is None:
local_vars_configuration = Configuration.get_default_copy()
self.local_vars_configuration = local_vars_configuration
self._admin = None
self._push = None
self._pull = None
self.__class = None
self.discriminator = None
if admin is not None:
self.admin = admin
if push is not None:
self.push = push
if pull is not None:
self.pull = pull
if _class is not None:
self._class = _class
@property
def admin(self):
"""Gets the admin of this GithubRepositorypermissions. # noqa: E501
:return: The admin of this GithubRepositorypermissions. # noqa: E501
:rtype: bool
"""
return self._admin
@admin.setter
def admin(self, admin):
"""Sets the admin of this GithubRepositorypermissions.
:param admin: The admin of this GithubRepositorypermissions. # noqa: E501
:type admin: bool
"""
self._admin = admin
@property
def push(self):
"""Gets the push of this GithubRepositorypermissions. # noqa: E501
:return: The push of this GithubRepositorypermissions. # noqa: E501
:rtype: bool
"""
return self._push
@push.setter
def push(self, push):
"""Sets the push of this GithubRepositorypermissions.
:param push: The push of this GithubRepositorypermissions. # noqa: E501
:type push: bool
"""
self._push = push
@property
def pull(self):
"""Gets the pull of this GithubRepositorypermissions. # noqa: E501
:return: The pull of this GithubRepositorypermissions. # noqa: E501
:rtype: bool
"""
return self._pull
@pull.setter
def pull(self, pull):
"""Sets the pull of this GithubRepositorypermissions.
:param pull: The pull of this GithubRepositorypermissions. # noqa: E501
:type pull: bool
"""
self._pull = pull
@property
def _class(self):
"""Gets the _class of this GithubRepositorypermissions. # noqa: E501
:return: The _class of this GithubRepositorypermissions. # noqa: E501
:rtype: str
"""
return self.__class
@_class.setter
def _class(self, _class):
"""Sets the _class of this GithubRepositorypermissions.
:param _class: The _class of this GithubRepositorypermissions. # noqa: E501
:type _class: str
"""
self.__class = _class
def to_dict(self, serialize=False):
"""Returns the model properties as a dict"""
result = {}
def convert(x):
if hasattr(x, "to_dict"):
args = getfullargspec(x.to_dict).args
if len(args) == 1:
return x.to_dict()
else:
return x.to_dict(serialize)
else:
return x
for attr, _ in six.iteritems(self.openapi_types):
value = getattr(self, attr)
attr = self.attribute_map.get(attr, attr) if serialize else attr
if isinstance(value, list):
result[attr] = list(map(
lambda x: convert(x),
value
))
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], convert(item[1])),
value.items()
))
else:
result[attr] = convert(value)
return result
def to_str(self):
"""Returns the string representation of the model"""
return pprint.pformat(self.to_dict())
def __repr__(self):
"""For `print` and `pprint`"""
return self.to_str()
def __eq__(self, other):
"""Returns true if both objects are equal"""
if not isinstance(other, GithubRepositorypermissions):
return False
return self.to_dict() == other.to_dict()
def __ne__(self, other):
"""Returns true if both objects are not equal"""
if not isinstance(other, GithubRepositorypermissions):
return True
return self.to_dict() != other.to_dict()
| cliffano/swaggy-jenkins | clients/python-legacy/generated/openapi_client/models/github_repositorypermissions.py | Python | mit | 5,737 |
from bashmu.distserver import DistServer
ds = DistServer('localhost',1708)
@ds.defer
def foo(n, s):
import time
print("Running", n, s)
time.sleep(n)
print("Done", n, s)
return s + 1
@ds.defer
def bar(n):
import time
print("Running",n)
time.sleep(n)
print("Done",n)
return n**2
@ds.defer
def broken(*args, **kwargs):
return "1" + 1
if __name__ == "__main__":
a = foo(1,0)
b = foo(2,a)
c = foo(3,a)
d = foo(4,a)
e = foo(5,a)
print("Printing results:")
print(",".join(map(str,[a,b,c,d,e])))
print("Making array...")
res1 = []
for i in range(100):
res1.append(foo(2,i))
print("Calculating sum:")
print(sum(res1))
# f = broken(2,3,abc=1)
# print(str(f))
ds.stop()
| Renmusxd/Bashmu | tests/testclient.py | Python | mit | 778 |
from rest_framework import serializers
from .fields import NestedHyperlinkedIdentityField, SecondaryKeyRelatedField
from .serializers import UserSerializer, NotebookSerializer, NoteSerializer, TaskSerializer
class UserLinksSerializer(serializers.Serializer):
self = NestedHyperlinkedIdentityField(view_name='user-detail',
lookup_field='username')
notebooks = NestedHyperlinkedIdentityField(view_name='notebook-list',
lookup_url_kwarg='user_username', lookup_field='username')
tasks = NestedHyperlinkedIdentityField(view_name='task-list',
lookup_url_kwarg='user_username', lookup_field='username')
class HyperlinkedUserSerializer(UserSerializer):
links = UserLinksSerializer(read_only=True, source='*')
class Meta(UserSerializer.Meta):
fields = UserSerializer.Meta.fields + ('links',)
def create_hyperlinked_notebook_serializer_class(user_username):
class NotebookLinksSerializer(serializers.Serializer):
self = NestedHyperlinkedIdentityField(view_name='notebook-detail',
lookup_field='ext_id',
parent_lookup=dict(user_username=user_username))
user = NestedHyperlinkedIdentityField(view_name='user-detail',
lookup_url_kwarg='username', lookup_field='user_id')
notes = NestedHyperlinkedIdentityField(view_name='note-list',
lookup_url_kwarg='notebook_ext_id', lookup_field='ext_id',
parent_lookup=dict(user_username=user_username))
class HyperlinkedNotebookSerializer(NotebookSerializer):
links = NotebookLinksSerializer(read_only=True, source='*')
class Meta(NotebookSerializer.Meta):
fields = NotebookSerializer.Meta.fields + ('links',)
return HyperlinkedNotebookSerializer
def create_hyperlinked_note_serializer_class(user_username, notebooks=None):
class NoteLinksSerializer(serializers.Serializer):
self = NestedHyperlinkedIdentityField(view_name='note-detail',
lookup_field='ext_id',
parent_lookup=dict(user_username=user_username),
aux_lookup=dict(notebook_ext_id='notebook_id'))
notebook = NestedHyperlinkedIdentityField(view_name='notebook-detail',
lookup_url_kwarg='ext_id', lookup_field='notebook_id',
parent_lookup=dict(user_username=user_username))
class HyperlinkedNoteSerializer(NoteSerializer):
if notebooks is not None:
notebook = SecondaryKeyRelatedField(queryset=notebooks)
links = NoteLinksSerializer(read_only=True, source='*')
class Meta(NoteSerializer.Meta):
fields = NoteSerializer.Meta.fields + ('links',)
return HyperlinkedNoteSerializer
def create_hyperlinked_task_serializer_class(user_username):
class TaskLinksSerializer(serializers.Serializer):
self = NestedHyperlinkedIdentityField(view_name='task-detail',
lookup_field='ext_id',
parent_lookup=dict(user_username=user_username))
user = NestedHyperlinkedIdentityField(view_name='user-detail',
lookup_url_kwarg='username', lookup_field='user_id')
class HyperlinkedTaskSerializer(TaskSerializer):
links = TaskLinksSerializer(read_only=True, source='*')
class Meta(TaskSerializer.Meta):
fields = TaskSerializer.Meta.fields + ('links',)
return HyperlinkedTaskSerializer
| vsemionov/boomerang | api/rest/links.py | Python | mit | 3,929 |
import re
import os
import hashlib
import shutil
import string
import oelite.fetch
import oelite.util
import local
import url
import git
import svn
FETCHERS = {
"file" : local.LocalFetcher,
"http" : url.UrlFetcher,
"https" : url.UrlFetcher,
"ftp" : url.UrlFetcher,
"git" : git.GitFetcher,
"svn" : svn.SvnFetcher,
}
uri_pattern = re.compile("(?P<scheme>[^:]*)://(?P<location>[^;]+)(;(?P<params>.*))?")
unpack_ext = (
("tar_gz", (".tar.gz", ".tgz", ".tar.Z")),
("tar_bz2", (".tar.bz2", ".tbz", ".tbz2")),
("tar_xz", (".tar.xz", ".txz")),
("tar_lz", (".tar.lz", ".tlz")),
("zip", (".zip", ".jar")),
("gz", (".gz", ".Z", ".z")),
("bz2", (".bz2",)),
("xz", (".xz",)),
("lz", (".lz",)),
)
class OEliteUri:
def __init__(self, uri, d):
self.uri = uri
# Note, do not store reference to meta
self.recipe = "%s:%s_%s"%(d.get("RECIPE_TYPE"),
d.get("PN"), d.get("PV"))
# Try to avoid readinng recipe meta-data here, as it might
# change later on, so better to read the meta-data when
# needed. This is especially problematic with variables
# depending on ${EXTRA_ARCH} which might be changed after all
# parse when resolving task dependencies.
self.ingredients = d.get("INGREDIENTS")
self.isubdir = (d.get("INGREDIENTS_SUBDIR") or
os.path.basename(d.get("FILE_DIRNAME")))
self.strict = d.get("SRC_URI_STRICT") or False
if self.strict == "0":
self.strict = False
m = uri_pattern.match(uri)
if not m:
raise oelite.fetch.InvalidURI(uri, "not an URI at all")
self.scheme = m.group("scheme")
self.location = m.group("location")
if not self.scheme:
raise oelite.fetch.InvalidURI(uri, "no URI scheme")
if not self.location:
raise oelite.fetch.InvalidURI(uri, "no URI location")
self.params = {}
if m.group("params"):
for param in (m.group("params") or "").split(";"):
try:
name, value = param.split("=")
except ValueError:
name = param
value = "1"
self.params[name] = value
try:
self.isubdir = self.params["isubdir"]
except KeyError:
pass
if not self.scheme in FETCHERS:
raise oelite.fetch.InvalidURI(
uri, "unsupported URI scheme: %s"%(self.scheme))
self.fdepends = []
self.fetcher = FETCHERS[self.scheme](self, d)
self.init_unpack_params()
self.add_unpack_fdepends(d)
self.init_patch_params(d)
self.add_patch_fdepends()
self.mirrors = self.init_mirrors(d.get("MIRRORS"))
self.premirrors = self.init_mirrors(d.get("PREMIRRORS"))
self.whitelist = self.init_filter(d.get("URL_WHITELIST"))
self.blacklist = self.init_filter(d.get("URL_BLACKLIST"))
return
def init_mirrors(self, all_mirrors):
if not all_mirrors:
return []
assert isinstance(all_mirrors, basestring)
url = "%s://%s"%(self.scheme, self.location)
all_mirrors = all_mirrors.split("\n")
all_mirrors = map(string.strip, all_mirrors)
all_mirrors = filter(None, all_mirrors)
all_mirrors = map(string.split, all_mirrors)
if not all_mirrors:
return []
mirrors = []
for mirror in all_mirrors:
if len(mirror) != 2:
print "Warning: skipping invalid mirror line:", \
" ".join(mirror)
continue
(src_uri, mirror_uri) = tuple(mirror)
m = re.match(src_uri, url)
if m:
mirrors.append((mirror_uri, url[m.end():]))
return mirrors
def init_filter(self, filterstr):
if not filterstr:
return None
assert isinstance(filterstr, basestring)
return "|".join(filterstr.split())
def compile_filter(self, filterre):
if not filterre:
return None
return re.compile(filterre)
def allow_url(self, url):
try:
blacklist = self.blacklist_re
except AttributeError:
blacklist = self.blacklist_re = self.compile_filter(self.blacklist)
if blacklist and blacklist.match(url):
return False
try:
whitelist = self.whitelist_re
except AttributeError:
whitelist = self.whitelist_re = self.compile_filter(self.whitelist)
if whitelist and not whitelist.match(url):
return False
return True
def __str__(self):
url = "%s://%s"%(self.scheme, self.location)
try:
fetcher_url = self.fetcher.url
except:
return url
if url == fetcher_url:
return url
else:
return "%s %s"%(self.scheme, fetcher_url)
def init_unpack_params(self):
if not "localpath" in dir(self.fetcher):
return
if not "unpack" in self.params:
for (unpack, exts) in unpack_ext:
assert isinstance(exts, tuple)
for ext in exts:
if self.fetcher.localpath.endswith(ext):
self.params["unpack"] = unpack
return
elif self.params["unpack"] == "0":
del self.params["unpack"]
if not "unpack" in self.params:
return
if self.params["unpack"] == "zip":
if "dos" in self.params and self.params["dos"] != "0":
self.params["unpack"] += "_dos"
return
def add_unpack_fdepends(self, d):
if not "unpack" in self.params or not self.params["unpack"]:
return
fdepends = d.get("UNPACK_CMD_FDEPENDS_" + self.params["unpack"])
if fdepends:
self.fdepends.extend(fdepends.split())
return
def init_patch_params(self, d):
if not "localpath" in dir(self.fetcher):
return
if not "apply" in self.params:
patchfile = self.fetcher.localpath
try:
unpack = self.params["unpack"] or None
if unpack == "0":
unpack = None
except KeyError:
unpack = None
if unpack and self.fetcher.localpath.endswith(unpack):
patchfile = self.fetcher.localpath[-len(unpack):]
if patchfile.endswith(".patch") or patchfile.endswith(".diff"):
self.params["apply"] = "yes"
elif not self.params["apply"] in ["yes", "y", "1"]:
del self.params["apply"]
if "apply" in self.params:
patchsubdir = d.get("PATCHSUBDIR")
if "subdir" in self.params:
subdir = self.params["subdir"]
if (subdir != patchsubdir and
not subdir.startswith(patchsubdir + "")):
subdir = os.path.join(patchsubdir, subdir)
else:
subdir = patchsubdir
self.params["subdir"] = subdir
if not "striplevel" in self.params:
self.params["striplevel"] = 1
if "patchdir" in self.params:
raise Exception("patchdir URI parameter support not implemented")
return
def add_patch_fdepends(self):
if not "apply" in self.params or not self.params["apply"]:
return
self.fdepends.append("native:quilt")
return
def signature(self):
try:
return self.fetcher.signature()
except oelite.fetch.NoSignature as e:
if self.strict:
raise e
try:
url = self.fetcher.url
except AttributeError:
url = self.uri
print "%s: no checksum known for %s"%(self.recipe, url)
return ""
def cache(self):
if not "cache" in dir(self.fetcher):
return True
return self.fetcher.cache()
def write_checksum(self, filepath):
md5path = filepath + ".md5"
checksum = hashlib.md5()
with open(filepath) as f:
checksum.update(f.read())
with open(md5path, "w") as f:
f.write(checksum.digest())
def verify_checksum(self, filepath):
md5path = filepath + ".md5"
if not os.path.exists(md5path):
return None
checksum = hashlib.md5()
with open(filepath) as f:
checksum.update(f.read())
with open(md5path) as f:
return f.readline().strip() == checksum.digest()
def fetch(self):
if not "fetch" in dir(self.fetcher):
return True
print "Fetching", str(self)
return self.fetcher.fetch()
def unpack(self, d, cmd):
if not "localpath" in dir(self.fetcher):
return self.fetcher.unpack(d)
if not self._unpack(d, cmd):
return False
if "verify_unpacked" in dir(self.fetcher):
return self.fetcher.verify_unpacked()
return True
def _unpack(self, d, cmd):
print "Unpacking", self.fetcher.localpath
srcpath = os.getcwd()
self.srcfile = None
cwd = None
if "subdir" in self.params:
srcpath = os.path.join(srcpath, self.params["subdir"])
oelite.util.makedirs(srcpath)
cwd = os.getcwd()
os.chdir(srcpath)
try:
if not cmd or not "unpack" in self.params:
if os.path.isdir(self.fetcher.localpath):
shutil.rmtree(srcpath, True)
shutil.copytree(self.fetcher.localpath, self.srcpath(d))
return True
else:
shutil.copy2(self.fetcher.localpath, self.srcpath(d))
return True
if "unpack_to" in self.params:
cmd = cmd%(self.fetcher.localpath, self.srcpath(d))
else:
cmd = cmd%(self.fetcher.localpath)
return oelite.util.shcmd(cmd)
finally:
if cwd:
os.chdir(cwd)
def srcpath(self, d):
srcdir = d.get("SRCDIR")
if "subdir" in self.params:
srcdir = os.path.join(srcdir, self.params["subdir"])
if "unpack_to" in self.params:
return os.path.join(srcdir, self.params["unpack_to"])
else:
return os.path.join(srcdir,
os.path.basename(self.fetcher.localpath))
def patchpath(self, d):
srcpath = self.srcpath(d)
patchdir = d.get("PATCHDIR")
assert srcpath.startswith(patchdir + "/")
return srcpath[len(patchdir) + 1:]
def patch(self, d):
with open("%s/series"%(d.get("PATCHDIR")), "a") as series:
series.write("%s -p%s\n"%(
self.patchpath(d), self.params["striplevel"]))
cmd = ["quilt", "-v", "--quiltrc", d.get("QUILTRC"), "push"]
return oelite.util.shcmd(cmd)
def mirror(self, d, mirror):
if not "localpath" in dir(self.fetcher):
if not "mirror" in dir(self.fetcher):
return True
return self.fetcher.mirror(mirror)
src = self.fetcher.localpath
if not src.startswith(self.ingredients):
return True
dst = os.path.join(mirror, src[len(self.ingredients)+1:])
if os.path.exists(dst):
m = hashlib.md5()
with open(src, "r") as srcfile:
m.update(srcfile.read())
src_md5 = m.hexdigest()
m = hashlib.md5()
with open(dst, "r") as dstfile:
m.update(dstfile.read())
dst_md5 = m.hexdigest()
if src_md5 != dst_md5:
print "Mirror inconsistency:", dst
print "%s != %s"%(src_md5, dst_md5)
return False
return True
mirrordir = os.path.dirname(dst)
if not os.path.exists(mirrordir):
os.makedirs(mirrordir)
print "Mirroring", dst[len(mirror)+1:]
shutil.copy(src, dst)
return True
def patch_init(d):
quiltrc = d.get("QUILTRC")
patchdir = d.get("PATCHDIR")
with open(quiltrc, "w") as quiltrcfile:
quiltrcfile.write("QUILT_PATCHES=%s\n"%(patchdir))
series = os.path.join(patchdir, "series")
if os.path.exists(series):
os.remove(series)
s = d.get("S")
os.chdir(s)
if os.path.exists(".pc"):
while os.path.exists(".pc/applied-patches"):
if oelite.util.shcmd("quilt -v --quiltrc %s pop"%(quiltrc)):
# FIXME: proper error handling
raise Exception("quilt pop failed")
if not os.path.exists(".pc/series") and not os.path.exists(".pc/.quilt_series"):
# FIXME: proper error handling
raise Exception("Bad quilt .pc dir")
| sknsean/core | lib/oelite/fetch/fetch.py | Python | mit | 13,075 |
from flask import render_template, redirect, request, url_for, flash
from flask.ext.login import login_user, logout_user, login_required, \
current_user
from . import auth
from .. import db
from ..models import User
from ..email import send_email
from .forms import LoginForm, RegistrationForm, ChangePasswordForm,\
PasswordResetRequestForm, PasswordResetForm, ChangeEmailForm
@auth.before_app_request
def before_request():
if current_user.is_authenticated:
current_user.ping()
if not current_user.confirmed \
and request.endpoint[:5] != 'auth.' \
and request.endpoint != 'static':
return redirect(url_for('auth.unconfirmed'))
@auth.route('/unconfirmed')
def unconfirmed():
if current_user.is_anonymous or current_user.confirmed:
return redirect(url_for('main.index'))
return render_template('auth/unconfirmed.html')
@auth.route('/login', methods=['GET', 'POST'])
def login():
form = LoginForm()
if form.validate_on_submit():
user = User.query.filter_by(email=form.email.data).first()
if user is not None and user.verify_password(form.password.data):
login_user(user, form.remember_me.data)
return redirect(request.args.get('next') or url_for('main.index'))
flash('Invalid username or password.')
return render_template('auth/login.html', form=form)
@auth.route('/logout')
@login_required
def logout():
logout_user()
flash('You have been logged out.')
return redirect(url_for('main.index'))
@auth.route('/register', methods=['GET', 'POST'])
def register():
form = RegistrationForm()
if form.validate_on_submit():
user = User(email=form.email.data,
first_name=form.first_name.data,
last_name=form.last_name.data,
password=form.password.data)
db.session.add(user)
db.session.commit()
token = user.generate_confirmation_token()
send_email(user.email, 'Confirm Your Account',
'auth/email/confirm', user=user, token=token)
flash('A confirmation email has been sent to you by email.')
return redirect(url_for('auth.login'))
return render_template('auth/register.html', form=form)
@auth.route('/confirm/<token>')
@login_required
def confirm(token):
if current_user.confirmed:
return redirect(url_for('main.index'))
if current_user.confirm(token):
flash('You have confirmed your account. Thanks!')
else:
flash('The confirmation link is invalid or has expired.')
return redirect(url_for('main.index'))
@auth.route('/confirm')
@login_required
def resend_confirmation():
token = current_user.generate_confirmation_token()
send_email(current_user.email, 'Confirm Your Account',
'auth/email/confirm', user=current_user, token=token)
flash('A new confirmation email has been sent to you by email.')
return redirect(url_for('main.index'))
@auth.route('/change-password', methods=['GET', 'POST'])
@login_required
def change_password():
form = ChangePasswordForm()
if form.validate_on_submit():
if current_user.verify_password(form.old_password.data):
current_user.password = form.password.data
db.session.add(current_user)
flash('Your password has been updated.')
return redirect(url_for('main.index'))
else:
flash('Invalid password.')
return render_template("auth/change_password.html", form=form)
@auth.route('/reset', methods=['GET', 'POST'])
def password_reset_request():
if not current_user.is_anonymous:
return redirect(url_for('main.index'))
form = PasswordResetRequestForm()
if form.validate_on_submit():
user = User.query.filter_by(email=form.email.data).first()
if user:
token = user.generate_reset_token()
send_email(user.email, 'Reset Your Password',
'auth/email/reset_password',
user=user, token=token,
next=request.args.get('next'))
flash('An email with instructions to reset your password has been '
'sent to you.')
return redirect(url_for('auth.login'))
return render_template('auth/reset_password.html', form=form)
@auth.route('/reset/<token>', methods=['GET', 'POST'])
def password_reset(token):
if not current_user.is_anonymous:
return redirect(url_for('main.index'))
form = PasswordResetForm()
if form.validate_on_submit():
user = User.query.filter_by(email=form.email.data).first()
if user is None:
return redirect(url_for('main.index'))
if user.reset_password(token, form.password.data):
flash('Your password has been updated.')
return redirect(url_for('auth.login'))
else:
return redirect(url_for('main.index'))
return render_template('auth/reset_password.html', form=form)
@auth.route('/change-email', methods=['GET', 'POST'])
@login_required
def change_email_request():
form = ChangeEmailForm()
if form.validate_on_submit():
if current_user.verify_password(form.password.data):
new_email = form.email.data
token = current_user.generate_email_change_token(new_email)
send_email(new_email, 'Confirm your email address',
'auth/email/change_email',
user=current_user, token=token)
flash('An email with instructions to confirm your new email '
'address has been sent to you.')
return redirect(url_for('main.index'))
else:
flash('Invalid email or password.')
return render_template("auth/change_email.html", form=form)
@auth.route('/change-email/<token>')
@login_required
def change_email(token):
if current_user.change_email(token):
flash('Your email address has been updated.')
else:
flash('Invalid request.')
return redirect(url_for('main.index'))
| mikeyrichardson/kyburz | app/auth/views.py | Python | mit | 6,103 |
from django.db import models
import os
from django.core.files.storage import FileSystemStorage
storage = FileSystemStorage(location='/polls/media')
class Poll(models.Model):
name = models.CharField(max_length=30, null=True)
description = models.CharField(max_length=300, null=True)
category = models.CharField(max_length=60, null=True)
path = '/media/polls/static/'
code = models.TextField(null=True)
pub_date = models.DateTimeField(auto_now_add=True)
image = models.FileField(upload_to='polls/static', null=True)
picture = models.CharField(max_length=60, default= '', help_text="input filename.format") | DenysGurin/projt1 | polls/models.py | Python | mit | 615 |
import _plotly_utils.basevalidators
class BarpolarValidator(_plotly_utils.basevalidators.CompoundValidator):
def __init__(self, plotly_name="barpolar", parent_name="", **kwargs):
super(BarpolarValidator, self).__init__(
plotly_name=plotly_name,
parent_name=parent_name,
data_class_str=kwargs.pop("data_class_str", "Barpolar"),
data_docs=kwargs.pop(
"data_docs",
"""
base
Sets where the bar base is drawn (in radial
axis units). In "stack" barmode, traces that
set "base" will be excluded and drawn in
"overlay" mode instead.
basesrc
Sets the source reference on Chart Studio Cloud
for base .
customdata
Assigns extra data each datum. This may be
useful when listening to hover, click and
selection events. Note that, "scatter" traces
also appends customdata items in the markers
DOM elements
customdatasrc
Sets the source reference on Chart Studio Cloud
for customdata .
dr
Sets the r coordinate step.
dtheta
Sets the theta coordinate step. By default, the
`dtheta` step equals the subplot's period
divided by the length of the `r` coordinates.
hoverinfo
Determines which trace information appear on
hover. If `none` or `skip` are set, no
information is displayed upon hovering. But, if
`none` is set, click and hover events are still
fired.
hoverinfosrc
Sets the source reference on Chart Studio Cloud
for hoverinfo .
hoverlabel
:class:`plotly.graph_objects.barpolar.Hoverlabe
l` instance or dict with compatible properties
hovertemplate
Template string used for rendering the
information that appear on hover box. Note that
this will override `hoverinfo`. Variables are
inserted using %{variable}, for example "y:
%{y}". Numbers are formatted using d3-format's
syntax %{variable:d3-format}, for example
"Price: %{y:$.2f}".
https://github.com/d3/d3-3.x-api-
reference/blob/master/Formatting.md#d3_format
for details on the formatting syntax. Dates are
formatted using d3-time-format's syntax
%{variable|d3-time-format}, for example "Day:
%{2019-01-01|%A}".
https://github.com/d3/d3-3.x-api-
reference/blob/master/Time-Formatting.md#format
for details on the date formatting syntax. The
variables available in `hovertemplate` are the
ones emitted as event data described at this
link https://plotly.com/javascript/plotlyjs-
events/#event-data. Additionally, every
attributes that can be specified per-point (the
ones that are `arrayOk: true`) are available.
Anything contained in tag `<extra>` is
displayed in the secondary box, for example
"<extra>{fullData.name}</extra>". To hide the
secondary box completely, use an empty tag
`<extra></extra>`.
hovertemplatesrc
Sets the source reference on Chart Studio Cloud
for hovertemplate .
hovertext
Same as `text`.
hovertextsrc
Sets the source reference on Chart Studio Cloud
for hovertext .
ids
Assigns id labels to each datum. These ids for
object constancy of data points during
animation. Should be an array of strings, not
numbers or any other type.
idssrc
Sets the source reference on Chart Studio Cloud
for ids .
legendgroup
Sets the legend group for this trace. Traces
part of the same legend group hide/show at the
same time when toggling legend items.
marker
:class:`plotly.graph_objects.barpolar.Marker`
instance or dict with compatible properties
meta
Assigns extra meta information associated with
this trace that can be used in various text
attributes. Attributes such as trace `name`,
graph, axis and colorbar `title.text`,
annotation `text` `rangeselector`,
`updatemenues` and `sliders` `label` text all
support `meta`. To access the trace `meta`
values in an attribute in the same trace,
simply use `%{meta[i]}` where `i` is the index
or key of the `meta` item in question. To
access trace `meta` in layout attributes, use
`%{data[n[.meta[i]}` where `i` is the index or
key of the `meta` and `n` is the trace index.
metasrc
Sets the source reference on Chart Studio Cloud
for meta .
name
Sets the trace name. The trace name appear as
the legend item and on hover.
offset
Shifts the angular position where the bar is
drawn (in "thetatunit" units).
offsetsrc
Sets the source reference on Chart Studio Cloud
for offset .
opacity
Sets the opacity of the trace.
r
Sets the radial coordinates
r0
Alternate to `r`. Builds a linear space of r
coordinates. Use with `dr` where `r0` is the
starting coordinate and `dr` the step.
rsrc
Sets the source reference on Chart Studio Cloud
for r .
selected
:class:`plotly.graph_objects.barpolar.Selected`
instance or dict with compatible properties
selectedpoints
Array containing integer indices of selected
points. Has an effect only for traces that
support selections. Note that an empty array
means an empty selection where the `unselected`
are turned on for all points, whereas, any
other non-array values means no selection all
where the `selected` and `unselected` styles
have no effect.
showlegend
Determines whether or not an item corresponding
to this trace is shown in the legend.
stream
:class:`plotly.graph_objects.barpolar.Stream`
instance or dict with compatible properties
subplot
Sets a reference between this trace's data
coordinates and a polar subplot. If "polar"
(the default value), the data refer to
`layout.polar`. If "polar2", the data refer to
`layout.polar2`, and so on.
text
Sets hover text elements associated with each
bar. If a single string, the same string
appears over all bars. If an array of string,
the items are mapped in order to the this
trace's coordinates.
textsrc
Sets the source reference on Chart Studio Cloud
for text .
theta
Sets the angular coordinates
theta0
Alternate to `theta`. Builds a linear space of
theta coordinates. Use with `dtheta` where
`theta0` is the starting coordinate and
`dtheta` the step.
thetasrc
Sets the source reference on Chart Studio Cloud
for theta .
thetaunit
Sets the unit of input "theta" values. Has an
effect only when on "linear" angular axes.
uid
Assign an id to this trace, Use this to provide
object constancy between traces during
animations and transitions.
uirevision
Controls persistence of some user-driven
changes to the trace: `constraintrange` in
`parcoords` traces, as well as some `editable:
true` modifications such as `name` and
`colorbar.title`. Defaults to
`layout.uirevision`. Note that other user-
driven trace attribute changes are controlled
by `layout` attributes: `trace.visible` is
controlled by `layout.legend.uirevision`,
`selectedpoints` is controlled by
`layout.selectionrevision`, and
`colorbar.(x|y)` (accessible with `config:
{editable: true}`) is controlled by
`layout.editrevision`. Trace changes are
tracked by `uid`, which only falls back on
trace index if no `uid` is provided. So if your
app can add/remove traces before the end of the
`data` array, such that the same trace has a
different index, you can still preserve user-
driven changes if you give each trace a `uid`
that stays with it as it moves.
unselected
:class:`plotly.graph_objects.barpolar.Unselecte
d` instance or dict with compatible properties
visible
Determines whether or not this trace is
visible. If "legendonly", the trace is not
drawn, but can appear as a legend item
(provided that the legend itself is visible).
width
Sets the bar angular width (in "thetaunit"
units).
widthsrc
Sets the source reference on Chart Studio Cloud
for width .
""",
),
**kwargs
)
| plotly/python-api | packages/python/plotly/plotly/validators/_barpolar.py | Python | mit | 10,554 |
import unittest
import nose.tools
import responses
import json
import os
from click.testing import CliRunner
from requests.exceptions import HTTPError
from test_helpers import *
from csa_client import constants
from csa_client import RequestHandler
from csa_client.command import *
class CommandTests(unittest.TestCase):
def tearDown(self):
responses.reset()
if os.path.isfile(constants.TOKEN_FILE):
os.remove(constants.TOKEN_FILE)
@responses.activate
def test_authenticate(self):
runner = CliRunner()
mock_auth_response()
with runner.isolated_filesystem():
result = runner.invoke(authorize, input='admin\ntaliesin\ntaliesin')
nose.tools.assert_false(result.exception)
nose.tools.assert_equal(0, result.exit_code)
##########################################################################
# User tests
##########################################################################
@responses.activate
def test_create_user(self):
runner = CliRunner()
mock_auth_response()
url = RequestHandler._build_end_point_uri('/users/create')
responses.add(responses.POST, url, status=200)
with runner.isolated_filesystem():
result = runner.invoke(authorize, input='admin\ntaliesin\ntaliesin')
nose.tools.assert_false(result.exception)
nose.tools.assert_equal(0, result.exit_code)
user_params = ['sam', 'jackson', '[email protected]', '1985', 'n', '012344567', 'slj11', 'password', 'password']
user_params = '\n'.join(user_params)
result = runner.invoke(cli, ['users', 'create'], input=user_params)
nose.tools.assert_false(result.exception)
nose.tools.assert_equal(0, result.exit_code)
@responses.activate
def test_update_user(self):
runner = CliRunner()
mock_auth_response()
mock_show_user_response(41)
url = RequestHandler._build_end_point_uri('/users/update/:id', {':id': '41'})
responses.add(responses.PUT, url, status=200)
with runner.isolated_filesystem():
result = runner.invoke(authorize, input='admin\ntaliesin\ntaliesin')
nose.tools.assert_false(result.exception)
nose.tools.assert_equal(0, result.exit_code)
result = runner.invoke(cli, ['users', 'update', '--user-id=41', '--firstname=samuel'])
nose.tools.assert_false(result.exception)
nose.tools.assert_equal(0, result.exit_code)
@responses.activate
def test_show_user(self):
runner = CliRunner()
mock_auth_response()
mock_show_user_response(41)
with runner.isolated_filesystem():
result = runner.invoke(authorize, input='admin\ntaliesin\ntaliesin')
nose.tools.assert_false(result.exception)
nose.tools.assert_equal(0, result.exit_code)
result = runner.invoke(cli, ['users', 'show', '--user-id=41'])
nose.tools.assert_false(result.exception)
nose.tools.assert_equal(0, result.exit_code)
@responses.activate
def test_search_users(self):
runner = CliRunner()
mock_auth_response()
fixture = load_fixture('users/search.json')
url = RequestHandler._build_end_point_uri('/users/search')
responses.add(responses.GET, url, status=200, body=fixture)
with runner.isolated_filesystem():
result = runner.invoke(authorize, input='admin\ntaliesin\ntaliesin')
nose.tools.assert_false(result.exception)
nose.tools.assert_equal(0, result.exit_code)
result = runner.invoke(cli, ['users', 'search', '"Loftus"'])
nose.tools.assert_false(result.exception)
nose.tools.assert_equal(0, result.exit_code)
@responses.activate
def test_destroy_user(self):
runner = CliRunner()
mock_auth_response()
url = RequestHandler._build_end_point_uri('/users/destroy/:id', {':id': '41'})
responses.add(responses.DELETE, url, status=200)
with runner.isolated_filesystem():
result = runner.invoke(authorize, input='admin\ntaliesin\ntaliesin')
nose.tools.assert_false(result.exception)
nose.tools.assert_equal(0, result.exit_code)
result = runner.invoke(cli, ['users', 'destroy', '--user-id=41'])
nose.tools.assert_false(result.exception)
nose.tools.assert_equal(0, result.exit_code)
##########################################################################
# Broadcast tests
##########################################################################
@responses.activate
def test_create_broadcast(self):
runner = CliRunner()
mock_auth_response()
mock_show_user_response(41)
url = RequestHandler._build_end_point_uri('/broadcasts/create')
responses.add(responses.POST, url, status=200)
with runner.isolated_filesystem():
result = runner.invoke(authorize, input='admin\ntaliesin\ntaliesin')
nose.tools.assert_false(result.exception)
nose.tools.assert_equal(0, result.exit_code)
result = runner.invoke(cli, ['broadcasts', 'create', '"message"', '-f twitter'])
nose.tools.assert_false(result.exception)
nose.tools.assert_equal(0, result.exit_code)
@responses.activate
def test_search_broadcasts(self):
runner = CliRunner()
mock_auth_response()
fixture = load_fixture('broadcasts/search.json')
url = RequestHandler._build_end_point_uri('/broadcasts/search')
responses.add(responses.GET, url, status=200, body=fixture)
with runner.isolated_filesystem():
result = runner.invoke(authorize, input='admin\ntaliesin\ntaliesin')
nose.tools.assert_false(result.exception)
nose.tools.assert_equal(0, result.exit_code)
result = runner.invoke(cli, ['broadcasts', 'search', '"Chris"'])
nose.tools.assert_false(result.exception)
nose.tools.assert_equal(0, result.exit_code)
@responses.activate
def test_show_broadcast(self):
runner = CliRunner()
mock_auth_response()
fixture = load_fixture('broadcasts/1.json')
url = RequestHandler._build_end_point_uri('/broadcasts/show/:id', {':id': '1'})
responses.add(responses.GET, url, status=200, body=fixture)
with runner.isolated_filesystem():
result = runner.invoke(authorize, input='admin\ntaliesin\ntaliesin')
nose.tools.assert_false(result.exception)
nose.tools.assert_equal(0, result.exit_code)
result = runner.invoke(cli, ['broadcasts', 'show', '1'])
nose.tools.assert_false(result.exception)
nose.tools.assert_equal(0, result.exit_code)
@responses.activate
def test_destroy_broadcast(self):
runner = CliRunner()
mock_auth_response()
url = RequestHandler._build_end_point_uri('/broadcasts/destroy/:id', {':id': '1'})
responses.add(responses.DELETE, url, status=200)
with runner.isolated_filesystem():
result = runner.invoke(authorize, input='admin\ntaliesin\ntaliesin')
nose.tools.assert_false(result.exception)
nose.tools.assert_equal(0, result.exit_code)
result = runner.invoke(cli, ['broadcasts', 'destroy', '1'])
nose.tools.assert_false(result.exception)
nose.tools.assert_equal(0, result.exit_code)
| samueljackson92/CSAlumni-client | tests/command_test.py | Python | mit | 7,643 |
import math
import sys
from functools import reduce
import operator
from mule.InfoError import *
from mule.JobPlatformResources import *
from mule.JobParallelizationDimOptions import *
__all__ = ['JobParallelization']
def _prod(iterable):
return reduce(operator.mul, iterable, 1)
class JobParallelization(InfoError):
"""
This class stores information on how each program should be executed on a platform
The application has to initialize the variables in a sufficient way so that the
final configuration to execute the program on a cluster can be inferred from this.
Terminology:
------------
'num_threads':
Number of running threads within one MPI rank
'num_cores':
Number of physical processing cores
'rank':
MPI rank
"""
def __init__(self, dummy_init = False):
self.init_phase = True
InfoError.__init__(self, "JobParallelization")
self.reset(dummy_init)
#
# WARNING:
# Leave these variables here to ensure being not influenced by reset()
#
#
# Disable utilization of `mpiexec` to run job
# This is required to run e.g. the validation scripts should be
# (currently) executed on a single node and without MPI support
self.mpiexec_disabled = False
# Force disabling of turbo mode (if supported)
self.force_turbo_off = False
# Qualitative settings
# Allow oversubscription (aka Hyperthreading)
self.core_oversubscription = False
# affinities:
# compact, scatter
self.core_affinity = None
# max wallclock time, default: 1h
self.max_wallclock_seconds = 60*60
self.init_phase = False
def __setattr__(self, name, value):
if name != 'init_phase':
if not self.init_phase:
if not name in self.__dict__:
raise Exception("Attribute '"+name+"' does not exist!")
self.__dict__[name] = value
def reset(self, dummy_init = False):
"""
Reset functionality for a fresh configuration in case that a new setup is triggered
"""
# Number of cores per rank
self.num_cores_per_rank : int = None
# Number of threads per rank
self.num_threads_per_rank = None
# Number of ranks per node
self.num_ranks_per_node = None
# Number of cores per node
self.num_cores_per_node : int = None
# Number of total ranks
self.num_ranks = None
# Number of total nodes
self.num_nodes = None
# Number of total cores
self.num_cores = None
# List with parallelization information in each dimension
# Note, that space dimension can and should be treated as a single dimension
self.pardims = None
self.pardims_dict = {}
def get_max_wallclock_seconds_hh_mm_ss(self):
"""
Return properly formatted self.max_wallclock_seconds usable for job scripts
"""
secs = self.max_wallclock_seconds
# seconds
s = int(secs)
m = s // 60
s = s % 60
h = m // 60
m = m % 60
stest = h*60*60 + m*60 + s
if int(secs) != stest:
print(secs)
print(stest)
raise Exception("Internal error!")
return str(h).zfill(2)+":"+str(m).zfill(2)+":"+str(s).zfill(2)
def print(self):
if self.pardims == None:
print("No dimension-wise parallelization information specified")
else:
for i in self.pardims:
i.hline()
i.print()
self.hline()
self.hline()
self.info("num_cores_per_rank: "+str(self.num_cores_per_rank))
self.info("num_threads_per_rank: "+str(self.num_threads_per_rank))
self.info("num_ranks_per_node: "+str(self.num_ranks_per_node))
self.info("num_cores_per_node: "+str(self.num_cores_per_node))
self.info("num_ranks: "+str(self.num_ranks))
self.info("num_nodes: "+str(self.num_nodes))
self.info("num_cores: "+str(self.num_cores))
self.info("max_wallclock_seconds: "+str(self.max_wallclock_seconds))
self.info("mpiexec_disabled: "+str(self.mpiexec_disabled))
self.info("force_turbo_off: "+str(self.force_turbo_off))
def dummy_setup_if_no_setup(self, platform_resources : JobPlatformResources):
"""
Setup a dummy parallelization dimension to use one rank on one node and all cores on the node
"""
if self.pardims == None:
dummy = JobParallelizationDimOptions("dummy")
dummy.num_cores = platform_resources.num_cores_per_node
dummy.num_cores_per_rank = dummy.num_cores
dummy.num_threads_per_rank = dummy.num_cores
dummy.num_ranks = 1
self.setup([dummy], platform_resources)
self.print()
def setup(self, list_pardims, platform_resources : JobPlatformResources):
"""
Setup data which is required by the platform specific scripts to
generate the job scripts
Parameters
----------
list_pardims: JobParallelizationDimOptions
List with options for parallelization in each dimension
platform_resources
reference to jobgeneration class
#mode : string
# 'serial': No parallelization
"""
self.reset()
self.pardims = list_pardims
# # Support space-only parallelization without list
if not isinstance(self.pardims, list):
self.pardims = [self.pardims]
# First, we setup each dimension
# This also runs a validation checker over it
dim_id = 0
self.pardims_dict = {}
for i in self.pardims:
i.setup(dim_id)
dim_id += 1
self.pardims_dict[i.dim_name] = i
# Compute total number of resources over all dimensions
self.num_cores_per_rank = _prod(i.num_cores_per_rank for i in self.pardims)
# Check if number of cores per rank exceeds the available number of cores per node
if self.num_cores_per_rank > platform_resources.num_cores_per_node:
self.print()
self.error("Invalid config for parallelization: self.num_cores_per_rank >= platform_resources.num_cores_per_node")
# Number of ranks
self.num_ranks = _prod(i.num_ranks for i in self.pardims)
if self.num_ranks <= 0:
self.error("self.num_ranks <= 0")
# Check how many ranks we can run on each node
self.num_ranks_per_node = int(math.ceil(platform_resources.num_cores_per_node // self.num_cores_per_rank))
if self.num_ranks_per_node <= 0:
self.error("self.num_ranks_per_node <= 0")
# Reduce ranks per node if only a single node is used with all ranks on this particular node
if self.num_ranks_per_node > self.num_ranks:
self.num_ranks_per_node = self.num_ranks
# Compute number of cores per node
if self.num_cores_per_node == None:
self.num_cores_per_node = self.num_cores_per_rank*self.num_ranks_per_node
#
# Compute raw numbers and compare to new number
# The new number must be always \leq than the raw number
# due to additional restrictions
#
# We do this mainly for debugging restrictions
#
# VALIDATION for inconsistencies
raw_num_ranks = _prod(i.num_ranks for i in self.pardims)
if self.num_ranks < raw_num_ranks:
self.print()
self.error("Internal error: self.num_ranks < raw_num_ranks")
# Number of nodes
self.num_nodes = int(math.ceil(self.num_ranks / self.num_ranks_per_node))
if self.num_nodes <= 0:
self.error("self.num_nodes <= 0")
# VALIDATION for inconsistencies
if self.num_nodes * self.num_ranks_per_node != self.num_ranks:
self.print()
self.error("Error: self.num_nodes * self.num_ranks_per_node != self.num_ranks\n******* Please change your job settings to avoid this *******")
self.num_cores = self.num_nodes * platform_resources.num_cores_per_node
#
# VALIDATION for hardware restrictions
#
# Enough computing cores?
if self.num_ranks*self.num_cores_per_rank > platform_resources.num_cores:
self.print()
self.error("Invalid config for parallelization: self.num_ranks*self.num_cores_per_rank > platform_resources.num_cores")
if self.num_cores > platform_resources.num_cores:
self.print()
self.error("Invalid config for parallelization: self.num_cores > platform_resources.num_cores")
#
# Finally, setup variables without any restrictions
#
# Number of total (e.g. OpenMP) threads per rank (There are no restrictions for logical threading)
self.num_threads_per_rank = _prod(i.num_threads_per_rank for i in self.pardims)
def getUniqueID(self, i_filters):
"""
Return a unique ID including *all* string and number attributes of this class
i_filter:
list of filter names to filter out from unique ID generation
"""
retval = ''
if not 'parallelization' in i_filters:
if not 'parallelization.mpi_ranks' in i_filters:
# mpi ranks
retval += "_r"+str(self.num_ranks).zfill(5)
if not 'parallelization.cores_per_rank' in i_filters:
# cores per rank
retval += "_cpr"+str(self.num_cores_per_rank).zfill(3)
if not 'parallelization.threads_per_rank' in i_filters:
# threads per rank
retval += "_tpr"+str(self.num_threads_per_rank).zfill(3)
if not 'parallelization.dims' in i_filters:
retval += "_DIMS"
for i in self.pardims:
retval += '_'+i.dim_name+str(i.num_cores).zfill(3)
if retval != '':
retval = 'PAR'+retval
return retval
if __name__ == "__main__":
p = JobParallelization()
s = p.getUniqueID()
p.info(s)
p.print()
p.info("FIN")
| schreiberx/sweet | mule/python/mule/JobParallelization.py | Python | mit | 10,391 |
import modules
from modules import *
def run():
print "Usage: spaceclone <command> <options>"
print ""
print "Commands:"
for module in modules.__all__:
print "%s\t\t%s" % (module, getattr(modules, module).__module_desc__)
| nzwulfin/spaceclone | src/spaceclone/usage.py | Python | mit | 249 |
from web3.utils.encoding import (
encode_hex,
)
from populus.migrations import (
String,
Address,
Migration,
Operation,
)
def test_migrations_store_receipts_on_completion(web3, MATH, chain):
registrar = chain.registrar
class MockOperation(Operation):
def execute(self, *args, **kwargs):
return {
'raw-address': web3.eth.coinbase,
'raw-txn': '0xebb0f76aa6a6bb8d178ac2354de83d73a728d704bf47d135c188ca7b6d25f2e4',
'no-key': Address.defer(value=web3.eth.coinbase),
'with-key': String.defer(key='this-is-a-key', value='this-is-a-string'),
}
class TestMigration(Migration):
migration_id = '0001_initial'
dependencies = []
operations = [
MockOperation(),
]
assert registrar.call().exists('migration/0001_initial') is False
assert registrar.call().exists('migration/0001_initial/operation/0') is False
assert registrar.call().exists('migration/0001_initial/operation/0/raw-address') is False
assert registrar.call().exists('migration/0001_initial/operation/0/raw-txn') is False
assert registrar.call().exists('migration/0001_initial/operation/0/no-key') is False
assert registrar.call().exists('this-is-a-key') is False
migration = TestMigration(chain)
migration.execute()
assert registrar.call().exists('migration/0001_initial') is True
assert registrar.call().exists('migration/0001_initial/operation/0') is True
assert registrar.call().exists('migration/0001_initial/operation/0/raw-address') is True
assert registrar.call().exists('migration/0001_initial/operation/0/raw-txn') is True
assert registrar.call().exists('migration/0001_initial/operation/0/no-key') is True
assert registrar.call().exists('this-is-a-key') is True
assert registrar.call().getBool('migration/0001_initial') is True
assert registrar.call().getBool('migration/0001_initial/operation/0') is True
assert registrar.call().getAddress('migration/0001_initial/operation/0/raw-address') == web3.eth.coinbase
assert encode_hex(registrar.call().get('migration/0001_initial/operation/0/raw-txn')) == '0xebb0f76aa6a6bb8d178ac2354de83d73a728d704bf47d135c188ca7b6d25f2e4'
assert registrar.call().getAddress('migration/0001_initial/operation/0/no-key') == web3.eth.coinbase
assert registrar.call().getString('this-is-a-key') == 'this-is-a-string'
| euri10/populus | tests/migrations/test_migration_stores_receipt_values_in_registrar.py | Python | mit | 2,466 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
import locale
import logging
import time
import datetime
from lib import ds18b20
INTERVALLE_ENTRE_2_RELEVES_EN_MINUTES=10
nbMaxTentatives = 3
FORMAT = '%(asctime)-15s:%(levelname)s:%(message)s'
logging.basicConfig(format=FORMAT,level=logging.DEBUG)
logging.info("Initialisation")
ds18b20.init()
locale.setlocale(locale.LC_ALL, 'fr_FR.utf8')
devicesName=ds18b20.getDevicesName()
nbDevices=len(devicesName)
if (nbDevices > 0):
logging.info("Nombre de sondes : %s", nbDevices)
while True:
for deviceName in devicesName:
nbTentatives = 0
temperature = None
while temperature is None and nbTentatives < nbMaxTentatives:
temperature=ds18b20.getTemperature(deviceName)
nbTentatives += 1
if temperature is not None:
now = datetime.datetime.now()
ds18b20.insertTemperature(now, deviceName, temperature)
logging.debug("Température de la sonde %s : %s", deviceName, temperature)
else:
logging.error("Température non récupérée pour la sonde %s : %s tentatives en echec", deviceName, nbMaxTentatives)
#wait x seconds and repeat
logging.debug("Prochain relevé dans %s minutes", INTERVALLE_ENTRE_2_RELEVES_EN_MINUTES)
time.sleep(INTERVALLE_ENTRE_2_RELEVES_EN_MINUTES * 60)
else:
logging.error("Aucune sonde de température")
exit(0)
| manuelsimon/domotique | releverTemperatures.py | Python | mit | 1,328 |
# coding=utf-8
# Global settings.
document_class = "ext" + "article" # Ext is for extsizes package.
font_size = "10pt" # Allowed: 8pt, 9pt, 10pt, 11pt, 12pt, 14pt, 17pt, 20pt
# Front page.
## Setting title to None also ignores authors and date.
title = "Dimensionality Reduction"
authors = None
date = None
abstract = open("abstract.txt", "r").read()
table_contents = False
bibliography_style = "plain"
# Layout, as strings with specified metric unit.
top_margin = "3.5cm"
bot_margin = top_margin
left_margin = top_margin
right_margin = left_margin | GMadorell/coursera-machine-learning | theory/08.02 - Dimensionality Reduction/metadata.py | Python | mit | 557 |
import sqlite3 as dbi
import sys
from copy import deepcopy
class Graph (object):
def __init__(self, foldername):
try:
self.db = dbi.connect(foldername)
self.cu=self.db.cursor()
#print 'success'
except:
#print 'failed'
sys.exit()
#return a list of all the airports codes
def getAirportCodes(self):
cmd="""SELECT Name FROM Airports ORDER BY Name"""
self.cu.execute(cmd)
l=[]
for li in self.cu.fetchall():
l.append(li[0])
return l
#return a list of flights.ID going out from the cityName
def getAttachedLines(self, aptName):
cmd="""SELECT ID FROM Flights
WHERE FromAir='{}'"""
self.cu.execute(cmd.format(aptName))
l=[]
for li in self.cu.fetchall():
l.append(li[0])
return l
#return the cities.Name reached by the flightsID
def getAttachedNodes(self, fltID):
cmd="""SELECT ToAir FROM Flights
WHERE ID='{}' """
self.cu.execute(cmd.format(fltID))
return self.cu.fetchone()
#helper function getting city and state of airport from airportName
def getCityofAirport(self,AptName):
cmdgetcity="""SELECT c.Name, c.State FROM Cities AS c, Airports AS a
WHERE a.cityID=c.ID AND A.Name='{}'"""
self.cu.execute(cmdgetcity.format(AptName))
return self.cu.fetchone()
#helper function getting necessary information of flight for given flight ID and return a string in a format of print
def printFlightInfo(self, fltID):
cmdgetflightinfo="""SELECT f.Number, fc.Name, fc.State, fa.Name, f.DepartTime, tc.Name, tc.State, ta.Name, f.ArrivalTime
FROM Flights AS f, Airlines AS al, Airports AS fa, Airports AS ta, Cities AS fc, Cities AS tc
WHERE al.ID=f.OperatorID AND f.FromAir=fa.Name AND fa.cityID=fc.ID AND f.ToAir=ta.Name AND ta.CityID=tc.ID
AND f.ID={}"""
self.cu.execute(cmdgetflightinfo.format(fltID))
fl = self.cu.fetchone()
s="""on Flight Number {} from {}, {}, ({}) at {}:{:02d}, arrive at {}, {} ({}) at {}:{:02d} \n"""\
.format(fl[0], fl[1],fl[2],fl[3],fl[4]/60,fl[4]%60,fl[5], fl[6], fl[7], fl[8]/60,fl[8]%60)
return s
#helper function getting necessary information of flight for given flight ID and return a list of the infos rather than string
def FlightInfo(self, fltID):
cmdgetflightinfo="""SELECT f.Number, fc.Name, fc.State, fa.Name, f.DepartTime, tc.Name, tc.State, ta.Name, f.ArrivalTime
FROM Flights AS f, Airlines AS al, Airports AS fa, Airports AS ta, Cities AS fc, Cities AS tc
WHERE al.ID=f.OperatorID AND f.FromAir=fa.Name AND fa.cityID=fc.ID AND f.ToAir=ta.Name AND ta.CityID=tc.ID
AND f.ID={}"""
self.cu.execute(cmdgetflightinfo.format(fltID))
return self.cu.fetchone()
def __str__(self):
cmd="""SELECT c.Name, a.Name, a.X, a.Y
FROM Airports AS a, Cities AS c
WHERE a.cityID=c.ID"""
self.cu.execute(cmd)
allApts=self.cu.fetchall()
s='*Airports: \n'
for apt in allApts:
s+="""{} : {} at ({} miles, {} miles) \n""".format(apt[0], apt[1], apt[2], apt[3])
s+='* Flights:\n'
cmd="""SELECT f.Number, al.Name, fc.Name, fc.State, fa.Name, f.DepartTime, tc.Name, tc.State, ta.Name, f.ArrivalTime
FROM Flights AS f, Airlines AS al, Airports AS fa, Airports AS ta, Cities AS fc, Cities AS tc
WHERE al.ID=f.OperatorID AND f.FromAir=fa.Name AND fa.cityID=fc.ID AND f.ToAir=ta.Name AND ta.CityID=tc.ID"""
self.cu.execute(cmd)
allFlights=self.cu.fetchall()
for fl in allFlights:
s+="""Flight Number {} operated by {}: leaving {}, {}, ({}) at {}:{:02d} to {}, {} ({}) arriving at {}:{:02d} \n"""\
.format(fl[0], fl[1],fl[2],fl[3],fl[4],fl[5]/60,fl[5]%60,fl[6], fl[7], fl[8], fl[9]/60,fl[9]%60)
return s
def findPath(self, startName, endName):
cmdtogetapt = """SELECT Name FROM Airports"""
self.cu.execute(cmdtogetapt)
aptList = self.cu.fetchall()
apts=[]
for l in aptList:
apts.append(l[0])
if startName not in apts :
print "unknown AirportName=%s" % startName
if endName not in apts :
print "unknown AirportName=%s" % endName
global pathlist
(traveledLines, traveledNodes)=([],[])
path= dict (nodepath=[], linepath=[], length= 0.0)
pathlist=[]
startName=str(startName)
endName=str(endName)
self.findPathInside(startName,endName, path,traveledNodes[:], traveledLines[:])
return pathlist
def findPathInside(self, startName, endName, path, GtraveledNodes, GtraveledLines):
if startName not in GtraveledNodes:
#traveledNodes=GtraveledNodes[:]
GtraveledNodes.append(startName)
cmdtogettrvltime = """SELECT DepartTime, ArrivalTime FROM Flights
WHERE ID='{}'"""
#get all the path has went through
lastpath=path['linepath']
if len(lastpath) >0:
#get the time information for the previous path has travelled
self.cu.execute(cmdtogettrvltime.format(lastpath[len(lastpath)-1]))
lastDETime = self.cu.fetchone()[0]
self.cu.execute(cmdtogettrvltime.format(lastpath[len(lastpath)-1]))
lastARTime = self.cu.fetchone()[1]
else:
lastARTime=-1
for l in self.getAttachedLines(startName):
self.cu.execute(cmdtogettrvltime.format(l))
newDETime= self.cu.fetchone()[0]
self.cu.execute(cmdtogettrvltime.format(l))
newARTime = self.cu.fetchone()[1]
traveledNodes = GtraveledNodes[:]
traveledLines = GtraveledLines[:]
if (l not in traveledLines):
traveledLines.append(l)
#print type(l)
#print type(self.getAttachedNodes(l))
for n in self.getAttachedNodes(l):
if n not in traveledNodes:
pathInside=deepcopy(path)
pathInside['nodepath'].append(startName)
pathInside['linepath'].append(l)
if lastARTime==-1:
T1=0
else:
T1=newDETime-lastARTime
if T1 <=0 :
T1=T1+24*60
pathInside['length']+=T1+newARTime-newDETime
if n==endName:
pathInside['nodepath'].append(endName)
pathlist.append(pathInside)
else:
self.findPathInside(n, endName, pathInside,traveledNodes, traveledLines)
def findShortestPath(self, startName, endName):
allPath=self.findPath(startName, endName)
#print allPath
shortestLen=allPath[0]['length']
j=0
for i in range(1,len(allPath)):
if allPath[i]['length']<shortestLen:
j=i
shortestLen=allPath[i]['length']
#do all the strings for the print
#get the start, end airport information and the first and last flight in the path for the first print line
spath=allPath[j]
startInfo=self.getCityofAirport(startName)
endInfo=self.getCityofAirport(endName)
firstline=self.FlightInfo(spath['linepath'][0])
lastline=self.FlightInfo(spath['linepath'][len(spath['linepath'])-1])
s='Trip: {}: {}, {} to {}: {}, {}\n departs at {}:{:02d}, arrives at {}:{:02d} after travelling for {}:{:02d} hours\n'\
.format(startName, startInfo[0], startInfo[1], endName, endInfo[0], endInfo[1], firstline[4]/60, firstline[4]%60,\
lastline[8]/60, lastline[8]%60, int(spath['length'])/60, int(spath['length'])%60)
#add each flight information to the printout string
for f in spath['linepath']:
s+=self.printFlightInfo(f)
return s
def numNodes(self):
cmd="""SELECT count(Name) FROM Airports"""
self.cu.execute(cmd)
return self.cu.fetchone()[0]
def numLines(self):
cmd="""SELECT count(ID) FROM Flights"""
self.cu.execute(cmd)
return self.cu.fetchone()[0] | cmfeng/CEE505 | HW6_GraphicUserInterface/files/Graph.py | Python | mit | 9,037 |
import numpy as np
from scipy.sparse import csc_matrix
import math
def pageRank(G, s = .85, maxerr = .001):
"""
Computes the pagerank for each of the n states.
Used in webpage ranking and text summarization using unweighted
or weighted transitions respectively.
Args
----------
G: matrix representing state transitions
Gij can be a boolean or non negative real number representing the
transition weight from state i to j.
Kwargs
----------
s: probability of following a transition. 1-s probability of teleporting
to another state. Defaults to 0.85
maxerr: if the sum of pageranks between iterations is bellow this we will
have converged. Defaults to 0.001
"""
n = G.shape[0]
# transform G into markov matrix M
M = csc_matrix(G,dtype=np.float)
rsums = np.array(M.sum(1))[:,0]
ri, ci = M.nonzero()
M.data /= rsums[ri]
# bool array of sink states
sink = rsums==0
# Compute pagerank r until we converge
ro, r = np.zeros(n), np.ones(n)
while np.sum(np.abs(r-ro)) > maxerr:
ro = r.copy()
# calculate each pagerank at a time
for i in xrange(0,n):
# inlinks of state i
Ii = np.array(M[:,i].todense())[:,0]
# account for sink states
Si = sink / float(n)
# account for teleportation to state i
Ti = np.ones(n) / float(n)
r[i] = ro.dot( Ii*s + Si*s + Ti*(1-s) )
# return normalized pagerank
s = 0.0
for i in r:
s += i * i
return r/math.sqrt(s)
if __name__=='__main__':
# Example extracted from 'Introduction to Information Retrieval'
G = np.array([[0,0,1,0,0,0,0],
[0,1,1,0,0,0,0],
[1,0,1,1,0,0,0],
[0,0,0,1,1,0,0],
[0,0,0,0,0,0,1],
[0,0,0,0,0,1,1],
[0,0,0,1,1,0,1]])
print pageRank(G,s=.85)
| spininertia/graph-mining-rdbms | src/phase-3/src/misc/pagerank.py | Python | mit | 1,975 |
# vim: set ts=8 sw=4 tw=0 fileencoding=utf-8 filetype=python expandtab:
from __future__ import print_function, absolute_import, division, unicode_literals
from datetime import timedelta
import sys
import os
import stat
import time
try:
from configparser import ConfigParser
except ImportError:
from ConfigParser import ConfigParser
from collections import namedtuple
from helperlib import prompt, info, success, error, warning, spinner
from helperlib.logging import scope_logger
import paramiko
import re
__author__ = 'bluec0re'
MTIME = 0
SIZE = 1
MODE = 2
DEFAULT_CONFIG = {
'general': {
#'exclude': None
},
#'<project name>': { }
}
File = namedtuple('File', ('mtime', 'size', 'mode'))
def to_unicode(s):
if sys.version_info >= (3, 0, 0):
if isinstance(s, str):
return s
else:
if isinstance(s, unicode):
return s
try:
return s.decode('ascii')
except UnicodeError:
try:
return s.decode('utf-8')
except UnicodeError:
return s
def string_shortener(string, max_len=50):
if len(string) <= max_len:
return string
return string[:max_len // 2 - 2] + '...' + string[-max_len // 2 - 1:]
def print_file_info(filename, f):
print()
success("New file: %s" % filename)
print(" Size: %d\n UID: %d\n GID: %d\n Mode: %o\n Accesstime: %d\n Modtime: %d" % (
f.st_size, f.st_uid, f.st_gid, f.st_mode, f.st_atime, f.st_mtime))
def print_file_info2(filename, f):
print()
success("File: %s" % filename)
print(" Size: %d\n Mode: %o\n Modtime: %d" % (
f[SIZE], f[MODE], f[MTIME]))
def different(sftp, filename, other, current, local, remote):
if (other[MODE] & 0o777000) != (current[MODE] & 0o777000) and \
other[MODE] != -1:
print()
success("Differences in %s" % filename)
print(" dst vs src")
print(" Mode: %o vs %o" % (other[MODE], current[MODE]))
return True
elif stat.S_ISLNK(other[MODE]): # symlink
rtarget = sftp.readlink(os.path.join(remote, filename))
ltarget = os.readlink(os.path.join(local, filename))
if ltarget != rtarget:
print()
success("Differences in %s" % filename)
print(" dst vs src")
print(" Target: %s vs %s" % (ltarget, rtarget))
return True
elif (other[MTIME] < current[MTIME] or
(other[MTIME] == current[MTIME] and other[SIZE] != current[SIZE])):
print()
success("Differences in %s" % filename)
print(" dst vs src")
print(" Time: %r vs %r" % (other[MTIME], current[MTIME]))
print(" Size: %r vs %r" % (other[SIZE], current[SIZE]))
return True
return False
@scope_logger
class RevisionFile(dict):
def __init__(self, fname):
super(RevisionFile, self).__init__()
self.fname = fname
def add(self, fn, *args):
args = [int(arg) for arg in args[:3]]
if len(args) < 3:
args.append(-1)
self[fn] = File(*args)
def load(self):
if not os.path.exists(self.fname):
self.log.warning('Revisionfile %s does not exist', self.fname)
return
with open(self.fname, "r") as fp:
for line in fp:
parts = to_unicode(line.strip()).split("\t")
fn = parts[0]
self.add(fn, *parts[1:])
self.log.info('Loaded %d files from %s', len(self), self.fname)
def save(self):
with open(self.fname, "w") as fp:
for f, data in self.iteritems():
line = ("%s\t%d\t%d\t%d\n" % (
f,
data[MTIME],
data[SIZE],
data[MODE]))
try:
line = line.encode('utf-8')
except UnicodeDecodeError:
pass
fp.write(line)
self.log.info('Saved %d files to %s', len(self), self.fname)
@scope_logger
class SettingsFile(ConfigParser):
def __init__(self, fname, name):
if sys.version_info.major >= 3:
super(SettingsFile, self).__init__()
else:
ConfigParser.__init__(self)
self.fname = fname
self.name = name
def load(self):
for section in self.sections():
self.remove_section(section)
for section, options in DEFAULT_CONFIG.items():
for option, value in options.items():
self.set(section, option, value)
self.read(['/etc/sftpsync.cfg',
os.path.expanduser('~/.config/sftpsync.cfg'),
'sftpsync.cfg',
self.fname])
def save(self):
with open(self.fname, 'w') as fp:
self.write(fp)
def load_rev_file(fname):
files = RevisionFile(fname)
files.load()
return files
def save_rev_file(fname, files):
if not isinstance(files, RevisionFile):
tmp = RevisionFile(fname)
tmp.update(files)
files = tmp
else:
files.fname = fname
files.save()
@scope_logger
class Sync(object):
def __init__(self, sftp, remote, local,
exclude=None, skip_on_error=False,
subdir=None, dry_run=False):
self.sftp = sftp
self.subdir = to_unicode(subdir or '')
self.remote_root = remote
self.local_root = to_unicode(local)
self.local = os.path.join(to_unicode(local), self.subdir)
self.remote = os.path.join(to_unicode(remote), self.subdir)
self.exclude = exclude
self.skip_on_error = skip_on_error
self.dry_run = dry_run
fname = os.path.join(self.local_root, '.files')
self.revision_file = RevisionFile(fname)
self.revision_file.load()
fname = os.path.join(self.local_root, '.sftpsync')
name = os.path.basename(self.local_root)
self.settings = SettingsFile(fname, name)
self.settings.load()
extra_pattern = None
if self.settings.has_option('general', 'exclude'):
extra_pattern = self.settings.get('general', 'exclude')
if self.settings.has_option(name, 'exclude'):
if extra_pattern:
extra_pattern = '(%s)|(%s)' % (extra_pattern, self.settings.get(name, 'exclude'))
else:
extra_pattern = self.settings.get(name, 'exclude')
orig = self.exclude
if hasattr(orig, 'pattern'):
orig = orig.pattern
if extra_pattern:
self.log.warning("Loaded exclude pattern %s from settings file", extra_pattern)
if orig:
self.exclude = '(%s)|(%s)' % (orig, extra_pattern)
else:
self.exclude = extra_pattern
if not hasattr(self.exclude, 'pattern'):
self.exclude = re.compile(str(self.exclude))
def build_rev_file(self):
if not os.path.lexists(self.local_root):
os.mkdir(self.local_root)
if self.revision_file:
c = prompt("File already exists. Override?[y/n]").lower()
if c != 'y':
return False
remote_files = {}
local_files = {}
spinner.waitfor('Searching remote')
for root, dirs, files in self.walk():
for f in files:
filename = os.path.join(root, f.filename)
if self._exclude(filename):
continue
remote_files[filename] = File(
int(f.st_mtime),
int(f.st_size),
int(f.st_mode)
)
spinner.status(string_shortener(filename))
spinner.succeeded()
spinner.waitfor('Searching local')
for root, dirs, files in os.walk(self.local.encode('utf-8')):
root = to_unicode(root)
relroot = os.path.relpath(root, self.local)
for f in files:
f = to_unicode(f)
filename = os.path.join(relroot, f)
s = os.lstat(os.path.join(root, f))
local_files[filename] = File(
int(s.st_mtime),
int(s.st_size),
int(s.st_mode)
)
spinner.status(string_shortener(filename))
spinner.succeeded()
files = dict([(k, v) for k, v in remote_files.iteritems() if k in local_files])
self.revision_file = RevisionFile(os.path.join(self.local_root, '.files'))
self.revision_file.update(files)
self.revision_file.save()
def _exclude(self, path):
if self.exclude:
self.log.debug("Testing for exclusion: %s (%s)", path, self.exclude.pattern)
if self.exclude.match(path):
self.log.debug("Excluded by regex: %s", path)
return True
basename = os.path.basename(path)
if path[-1] == '~' or path.endswith('.swp') or path.endswith('.swo') \
or basename.startswith('.~') or basename.startswith("~$") \
or basename.endswith('.pyc') or basename.endswith('.pyo') \
or '__pycache__' in path:
self.log.debug("Excluded by default: %s", basename)
return True
return False
def check_dir(self, path):
if self._exclude(path):
return
current_path = self.remote
for segment in path.split('/'):
current_path = os.path.join(current_path, segment)
s = None
try:
s = self.sftp.lstat(current_path)
except KeyboardInterrupt:
raise
except:
pass
if not s and not self._exclude(current_path):
print(" Creating directory %s" % current_path)
if not self.dry_run:
self.sftp.mkdir(current_path)
def walk(self):
directory_stack = [self.remote]
while directory_stack:
directory = directory_stack.pop()
if self._exclude(os.path.relpath(directory, self.remote)):
continue
try:
entries = self.sftp.listdir_attr(directory)
except Exception as e:
if sys.version_info.major >= 3 and False:
#raise IOError("Error during listing of %s" % directory) from e
pass
else:
raise IOError("Error during listing of %s: %s" % (directory, str(e)))
files = []
directories = []
for entry in entries:
if self._exclude(os.path.relpath(os.path.join(directory, entry.filename), self.remote)):
continue
if stat.S_IFMT(entry.st_mode) == stat.S_IFDIR:
directories.append(entry)
else:
files.append(entry)
relative_dir = os.path.relpath(directory, self.remote)
segments = relative_dir.split(os.path.sep, 1)
if segments[0] == os.path.curdir:
if len(segments) > 1:
relative_dir = segments[1]
else:
relative_dir = ''
yield relative_dir, directories, files
for current_dir in directories:
directory_stack.append(os.path.join(directory, current_dir.filename))
def check_revision_against_remote(self):
for root, dirs, files in self.walk():
if self.subdir:
root = os.path.join(self.subdir, root)
for f in files:
filename = os.path.join(root, f.filename)
rdata = File(
int(f.st_mtime),
int(f.st_size),
int(f.st_mode)
)
if filename not in self.revision_file:
error("File only on remote")
print_file_info2(filename, rdata)
elif different(self.sftp, filename, rdata, self.revision_file[filename],
self.local_root, self.remote_root):
del self.revision_file[filename]
else:
del self.revision_file[filename]
for filename, ldata in self.revision_file.items():
error("File only in revision file\n")
print_file_info2(filename, ldata)
def list_local_changes(self):
local_files = {}
for root, dirs, files in os.walk(self.local.encode('utf-8')):
root = to_unicode(root)
if self._exclude(root):
continue
if self.subdir:
root = os.path.join(root, self.subdir)
for d in dirs:
d = to_unicode(d)
path = os.path.join(root, d)
if self._exclude(path):
continue
for f in files:
f = to_unicode(f)
if f in ('.files',):
continue
lfile = os.path.join(root, f)
filename = os.path.relpath(lfile, self.local_root)
if filename.split(os.path.sep)[0] == os.path.curdir:
filename = filename[2:]
if self._exclude(lfile):
continue
s = os.lstat(lfile)
sys.stdout.flush()
local_files[filename] = File(int(s.st_mtime),
int(s.st_size),
int(s.st_mode))
if filename not in self.revision_file:
print("New: {}".format(filename))
else:
lf = local_files[filename]
rf = self.revision_file[filename]
if different(self.sftp, filename, rf, lf, self.local_root, self.remote_root):
print("Changed: {}".format(filename))
def _check_local(self, lfile, lfilename, rfile, rfilename):
if os.path.lexists(lfilename):
stats = os.lstat(lfilename)
mtime, size = map(int, (stats.st_mtime, stats.st_size))
if lfile and mtime != lfile.mtime:
if lfile.mtime != rfile.mtime and mtime != rfile.mtime:
raise ValueError("Conflict with file %s (Both modified (different timestamp))" % rfilename)
if mtime > rfile.mtime:
raise ValueError("Conflict with file %s (local file is newer)" % rfilename)
if size != rfile.size and mtime == rfile.mtime:
raise ValueError("Conflict with file %s (size differs)" % rfilename)
if mtime == rfile.mtime and size == rfile.size:
print()
success("Already downloaded\n")
return False
return True
def down(self):
if not os.path.lexists(self.local_root):
os.mkdir(self.local_root)
self.revision_file.load()
revision_file = self.revision_file
remote_files = {}
spinner.waitfor('Testing')
for root, dirs, files in self.walk():
lroot = os.path.join(self.local, root)
if self._exclude(lroot):
sys.stdout.write("\r[\033[33m#\033[0m] Skipping {0}".format(lroot))
continue
if not os.path.lexists(lroot) and not self.dry_run:
os.mkdir(lroot)
if self.subdir:
root = os.path.join(self.subdir, root)
for f in files:
filename = os.path.join(root, f.filename)
if self._exclude(filename):
continue
spinner.status(string_shortener(filename))
remote_files[filename] = File(
int(f.st_mtime),
int(f.st_size),
int(f.st_mode)
)
if filename not in revision_file:
print_file_info(filename, f)
download = True
else:
lfile = revision_file[filename]
rfile = remote_files[filename]
download = different(self.sftp, filename, lfile, rfile,
self.local_root, self.remote_root)
if download:
spinner.succeeded()
info("Downloading: %s\n" % filename)
mtime = remote_files[filename][0]
lfilename = os.path.join(self.local_root, filename)
try:
if not self._check_local(revision_file.get(filename), lfilename,
remote_files[filename], filename):
spinner.waitfor('Testing')
continue
start = time.time()
def status(total, size):
if size == 0:
return
speed = total / (time.time() - start) * 1.0
if speed > 1024 ** 2:
speed = "%.2f MiByte/s" % (speed / 1024 ** 2,)
elif speed > 1024:
speed = "%.2f KiByte/s" % (speed / 1024,)
else:
speed = "%f Byte/s" % speed
sys.stdout.write("\r%02d%% %d/%d %s" % (
total * 100 / size, total, size, speed))
sys.stdout.flush()
if not self.dry_run:
rfilename = os.path.join(self.remote_root, filename)
if stat.S_ISLNK(f.st_mode):
target = self.sftp.readlink(rfilename)
info("Creating local symlink %s -> %s\n" % (lfilename, target))
try:
os.symlink(target, lfilename)
except OSError as e:
error("Failed: %s\n" % (e,))
else:
self.sftp.get(rfilename, lfilename, status)
os.utime(lfilename, (mtime, mtime))
spinner.waitfor('Testing')
except ValueError:
del remote_files[filename]
revision_file.update(remote_files)
if not self.dry_run:
revision_file.save()
raise
except KeyboardInterrupt:
del remote_files[filename]
revision_file.update(remote_files)
if not self.dry_run:
os.unlink(lfile)
revision_file.save()
exit(1)
except Exception as e:
del remote_files[filename]
if not self.dry_run and filename not in revision_file:
try:
os.unlink(lfile)
except:
pass
if not self.skip_on_error:
revision_file.update(remote_files)
if not self.dry_run:
revision_file.save()
raise
else:
if filename in revision_file: # prevent deletion
remote_files[filename] = revision_file[filename]
error("Error during downloading %s: %s\n" % (filename, str(e)))
spinner.succeeded()
for filename in revision_file.keys():
if self.subdir:
if not filename.startswith(self.subdir):
continue
if filename not in remote_files and not self._exclude(filename):
warning("Deleted file: %s\n" % filename)
print(" Last mod time: %d\n Size: %d\n Mode: %o" % revision_file[filename])
if not self.dry_run:
if not os.path.lexists(os.path.join(self.local_root, filename)):
warning("Already deleted?\n")
del revision_file[filename]
continue
answer = prompt("Delete it locally?[y/n]")
if answer == 'y':
os.unlink(os.path.join(self.local_root, filename))
del revision_file[filename]
revision_file.update(remote_files)
if not self.dry_run:
revision_file.save()
def up(self):
self.sftp.lstat(self.remote)
local_files = {}
spinner.waitfor('Testing')
for root, dirs, files in os.walk(self.local.encode('utf-8')):
root = to_unicode(root)
if self._exclude(root):
continue
for d in dirs:
d = to_unicode(d)
path = os.path.relpath(os.path.join(root, d), self.local)
if self._exclude(path):
continue
self.check_dir(path)
if self.subdir:
root = os.path.join(self.subdir, root)
for f in files:
f = to_unicode(f)
if f in ('.files',):
continue
lfile = os.path.join(root, f)
filename = os.path.relpath(lfile, self.local_root)
if filename.split(os.path.sep)[0] == os.path.curdir:
filename = filename[2:]
if self._exclude(lfile):
continue
rfile = os.path.join(self.remote_root, filename)
s = os.lstat(lfile)
spinner.status(string_shortener(filename))
local_files[filename] = File(int(s.st_mtime), int(s.st_size), int(s.st_mode))
if filename not in self.revision_file:
print_file_info(filename, s)
upload = True
else:
lf = local_files[filename]
rf = self.revision_file[filename]
upload = different(self.sftp, filename, rf, lf,
self.local_root, self.remote_root)
if upload:
spinner.succeeded()
info(" Uploading: %s\n" % filename)
try:
try:
rstat = self.sftp.lstat(rfile)
except KeyboardInterrupt:
raise
except:
pass
else:
if rstat.st_mtime > s.st_mtime:
raise ValueError("Conflict with file %s (remote file is newer)" % filename)
start = time.time()
def status(total, size):
if size == 0:
return
speed = total / (time.time() - start) * 1.0
if speed > 1024 ** 2:
speeds = "%.2f MiByte/s" % (speed / 1024 ** 2,)
elif speed > 1024:
speeds = "%.2f KiByte/s" % (speed / 1024,)
else:
speeds = "%f Byte/s" % speed
remaining = timedelta(seconds=int((size - total) / speed))
sys.stdout.write("\r%02d%% %d/%d %s %s" % (
total * 100 / size, total, size, speeds, remaining))
sys.stdout.flush()
if not self.dry_run:
if stat.S_ISLNK(s.st_mode):
target = os.readlink(lfile)
print()
info("Creating remote symlink %s -> %s\n" % (rfile, target))
try:
self.sftp.symlink(target, rfile)
except paramiko.SSHException as e:
error("Failed: %s\n" % (e,))
except IOError:
pass
else:
self.sftp.put(lfile, rfile, status)
f = self.sftp.file(rfile)
f.utime((s.st_atime, s.st_mtime))
f.close()
spinner.waitfor('Testing')
except ValueError:
del local_files[filename]
self.revision_file.update(local_files)
if not self.dry_run:
self.revision_file.save()
raise
except KeyboardInterrupt:
del local_files[filename]
if not self.dry_run:
self.sftp.unlink(rfile)
self.revision_file.update(local_files)
if not self.dry_run:
self.revision_file.save()
exit(1)
except Exception as e:
del local_files[filename]
if not self.dry_run and filename not in self.revision_file:
self.sftp.unlink(rfile)
if not self.skip_on_error:
self.revision_file.update(local_files)
if not self.dry_run:
self.revision_file.save()
raise
else:
if filename in self.revision_file: # prevent deletion
local_files[filename] = self.revision_file[filename]
error("Error during upload of %s: %s\n" % (filename, str(e)))
spinner.succeeded()
for filename in self.revision_file.keys():
if self.subdir:
if not filename.startswith(self.subdir):
continue
if filename not in local_files and not self._exclude(filename):
warning("Deleted file locally: %s\n" % filename)
print(" Last mod time: %d\n Size: %d\n Mode: %o" % self.revision_file[filename])
if not self.dry_run:
try:
self.sftp.lstat(os.path.join(self.remote_root, filename))
except KeyboardInterrupt:
raise
except:
warning("Can't stat remote file. Maybe already deleted?\n")
del self.revision_file[filename]
continue
answer = prompt("Delete it on remote?[y/n]")
if answer == 'y':
self.sftp.unlink(os.path.join(self.remote_root, filename))
del self.revision_file[filename]
self.revision_file.update(local_files)
if not self.dry_run:
self.revision_file.save()
def sync(sftp, remote, local, direction='down', exclude=None,
dry_run=False, skip_on_error=False, subdir=None):
sync = Sync(sftp, remote, local, exclude, skip_on_error, subdir, dry_run)
if direction == 'check':
sync.check_revision_against_remote()
return
elif direction == 'list':
sync.list_local_changes()
return
if subdir:
info("Syncing %s <-> %s with subdir %s\n" % (remote, local, subdir))
else:
info("Syncing %s <-> %s\n" % (remote, local))
c = prompt("Continue?[y/n]").lower()
if c != 'y':
return False
if direction == 'both':
sync.down()
sync.up()
elif direction == 'down':
return sync.down()
elif direction == 'up':
return sync.up()
elif direction == 'init':
return sync.build_rev_file()
| bluec0re/python-sftpsync | sftp_sync/sync.py | Python | mit | 28,706 |
# coding: utf-8
from __future__ import print_function, unicode_literals
| asyncee/catpcha_extended | __init__.py | Python | mit | 75 |
from aiohttp import web
import asyncio
import os
import pystache
import functools
def Response(text):
return web.Response(body=text.encode('utf-8'))
def Json(obj):
json = str(obj)
return Response(json)
def render_template(template_name, root_path, request, data={}):
renderer = pystache.renderer.Renderer(search_dirs=root_path)
html = renderer.render(renderer.load_template(template_name), data)
return Response(html)
class Route(dict):
def __init__(self, method, path, view_func):
self.method = method
self.path = path
self.view_func = view_func
class Stache(web.Application):
loop = asyncio.get_event_loop()
def __init__(self, instance_file, static_folder="static",
template_folder="templates"):
super().__init__()
self.root_path = os.path.abspath(os.path.dirname(instance_file))
self.static_folder = os.path.join(self.root_path, static_folder)
self.template_folder = os.path.join(self.root_path, template_folder)
@asyncio.coroutine
def create_server(self, loop, host="0.0.0.0", port="8080"):
handler = self.make_handler()
srv = yield from self.loop.create_server(handler, host, port)
return srv, handler
def add_middleware(self, middleware):
self._middlewares += (middleware,)
def route(self, path, methods=["GET"]):
def decorated(f):
for method in methods:
self.router.add_route(method, path, f)
if path.endswith("/"):
self.router.add_route(method, path[:-1], f)
return asyncio.coroutine(f)
return decorated
def template(self, template_name, *args):
def wrapper(func):
@asyncio.coroutine
@functools.wraps(func)
def wrapped(*args):
if asyncio.iscoroutinefunction(func):
coro = func
else:
coro = asyncio.coroutine(func)
request = args[-1]
context = yield from coro(request)
return render_template(
template_name,
self.template_folder,
request,
context)
return wrapped
return wrapper
def register_beard(self, beard, url_prefix=None):
beard.register(self, url_prefix=url_prefix)
def run(self, host="0.0.0.0", port=8080):
srv, self.handler = self.loop.run_until_complete(
self.create_server(self.loop, host, port))
print("Running server on", host, port)
try:
self.loop.run_forever()
except KeyboardInterrupt:
self.loop.run_until_complete(self.handler.finish_connections())
def shutdown(self):
self.loop.run_until_complete(self.handler.finish_connections())
class Beard(Stache):
def __init__(self, instance_file, url_prefix=None):
super().__init__(instance_file)
self.url_prefix = url_prefix
self.routes = []
def register(self, stache, url_prefix=None):
self.stache = stache
if url_prefix is not None:
self.url_prefix = url_prefix
self.register_routes(url_prefix)
def route(self, path, methods=["GET"]):
def decorated(f):
for method in methods:
self.routes.append(Route(method, path, f))
if path.endswith("/"):
self.routes.append(Route(method, path[:-1], f))
return asyncio.coroutine(f)
return decorated
def register_routes(self, url_prefix=None):
for route in self.routes:
if url_prefix is None:
self.stache.router.add_route(
route.method, route.path, route.view_func)
else:
self.stache.router.add_route(
route.method,
self.url_prefix + route.path,
route.view_func
)
| ViktorNova/aiostache | __init__.py | Python | mit | 4,038 |
import json
import requests
import sqlite3
import time
from Item import *
def run(url):
#url = http://services.runescape.com/m=itemdb_rs/api/catalogue/items.json?category=1&alpha=a&page=1
data = requests.get(url)
time.sleep(.01)
if(data.status_code == 404):
print('Item Doesnt Exist.')
return
r = requests.post(url,data)
r.connection.close()
if r:
data = data.json()
#data = json.loads(data)
print (str(json.dumps(data,indent = 4)))
data = data['item']
icon = data['icon']
icon_large = data['icon_large']
id = int(data['id'])
type = data['type']
name = data['name']
description = data['description']
members = data['members']
current_trend = data['current']['trend']
current_price = data['current']['price']
today_trend = data['today']['trend']
today_price = data['today']['price']
day30_trend = data['day30']['trend']
day30_change = data['day30']['change']
day90_trend = data['day90']['trend']
day90_change = data['day90']['change']
day180_trend = data['day180']['trend']
day180_change = data['day180']['change']
item_Record = Item(icon, icon_large,id,type, name, description, members, current_trend,current_price,today_trend,today_price,day30_trend,day30_change,day90_trend,day90_change,day180_trend,day180_change)
con = sqlite3.connect("GE_Data.db")
cur = con.cursor()
cur.execute('''create table if not exists item_Record(Icon text, Icon_Large text,Id int, Type text ,Name text,
Description text, Members bool, Current_trend text, Current_price int, Today_trend text, Today_price text,
Day30_trend text, Day30_change text, Day90_trend text, Day90_change text, Day180_trend text, Day180_change text)''')
sqlq = "SELECT COUNT(1) FROM item_Record WHERE Id = ?"
cur.execute(sqlq,(id,))
if not cur.fetchone()[0]:
sql = "INSERT INTO item_Record VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"
cur.execute(sql,(item_Record.Icon,item_Record.Icon_large,item_Record.Id,item_Record.Type,item_Record.Name,item_Record.Description,item_Record.Members,item_Record.Current_trend,item_Record.Current_price,item_Record.Today_trend,item_Record.Today_price,item_Record.Day30_trend,item_Record.Day30_change,item_Record.Day90_trend,item_Record.Day90_change,item_Record.Day180_trend,item_Record.Day180_change))
con.commit()
else:
print('Record already exists.')
cur.close()
con.close() | jb1361/RS3GEPredictionModel | src(old)/gatherData.py | Python | mit | 2,379 |
import os
def set_cuda_devices(device_list=[]):
"""Masks the CUDA visible devices.
Warning: Running this while another script is executed
might end up in the other script to crash.
Parameters
----------
device_list: list(int)
A list of of CUDA devices, such as [0,1].
"""
if device_list is None:
mask = ''
else:
mask = ','.join(str(d) for d in device_list)
os.environ['CUDA_VISIBLE_DEVICES'] = mask
def get_cuda_devices():
"""Gets the CUDA visible devices mask.
Returns
----------
The CUDA devices as list of int or an empty list
if no specific device(s) are selected.
"""
mask = os.environ['CUDA_VISIBLE_DEVICES']
if mask == '':
return []
else:
return [int(d.strip()) for d in mask.split(',')] | bsautermeister/tensorlight | tensorlight/hardware.py | Python | mit | 833 |
# -*- coding: utf-8 -*-
"""This module contains pybooru object class."""
from __future__ import absolute_import,unicode_literals # get some features not yet in python 3
from .exceptions import PybooruError # get the exception call
from .resources import * # import the dictionaries
import requests # import the http module
import hashlib # import the hash module
import re # import the regular expression module
class Pybooru(object):
"""Pybooru main class.
To initialize Pybooru, you need to specify one of these two
parameters: site_name or site_url. If you specify site_name, Pybooru checks
whether there is in the list of default sites (You can get list of sites in
the resources module).
To specify a site that isn't in list of default sites, you need use site_url
parameter.
Some actions may require you to log in. always specify three parameters to
log in: hash_string, username and password. Default sites has an associate
hash string.
Init Parameters:
site_name (Type STR):
The site name in SITE_LIST, default sites.
site_url (Type STR):
URL of based on Danbooru/Moebooru sites.
hash_string (Type STR):
String that is hashed (required to login).
(See the API documentation of the site for more information).
username (Type STR):
Your username of the site
(Required only for functions that modify the content).
password (Type STR):
Your user password in plain text
(Required only for functions that modify the content).
Attributes:
site_name: Return site name.
site_url: Return URL of based danbooru/Moebooru site.
username: Return user name.
password: Return password in plain text.
hash_string: Return hash_string.
"""
def __init__(self, site_name="", site_url="", username="", password="",
hash_string=""):
# Attributes
self.site_name = site_name.lower()
self.site_url = site_url.lower()
self.username = username
self.password = password
self.hash_string = hash_string
# Validate site_name or site_url
if site_url is not "" or site_name is not "":
if site_name is not "":
self._site_name_validator(self.site_name)
elif site_url is not "":
self._url_validator(self.site_url)
self._check_booru_api(self.site_url) # Check which API to use.
else:
raise PybooruError("Unexpected empty strings,"
" specify parameter site_name or site_url.")
def _site_name_validator(self, site_name):
"""Function that checks the site name and get the url.
Parameters:
site_name (Type STR):
The name of a based Danbooru/Moebooru site. You can get list
of sites in the resources module.
"""
if site_name in list(SITE_LIST.keys()):
self.site_url = SITE_LIST[site_name]['url']
self._check_booru_api(self.site_url)
else:
raise PybooruError(
"The site name is not valid, use the site_url parameter")
def _url_validator(self, url):
"""URL validator for site_url parameter of Pybooru.
Parameters:
url (Type STR):
The URL to validate.
"""
# Regular expression to URL validate
regex = re.compile(
r'^(?:http|https)://' # Scheme only HTTP/HTTPS
r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?| \
[A-Z0-9-]{2,}(?<!-)\.?)|' # Domain
r'localhost|' # localhost...
r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}|' # or ipv4
r'\[?[A-F0-9]*:[A-F0-9:]+\]?)' # or ipv6
r'(?::\d+)?' # Port
r'(?:/?|[/?]\S+)$', re.IGNORECASE)
# Validate URL
if re.match('^(?:http|https)://', url):
if re.search(regex, url):
self.site_url = url
else:
raise PybooruError("Invalid URL", url=url)
else:
raise PybooruError("Invalid URL scheme, use HTTP or HTTPS", url=url)
def _check_booru_api(self, url):
if requests.get(url+"/posts.json").status_code == 200:
# TODO code if danbooru v2
self.base_api = API_BASE_URL_2
self.api_type = "dan2"
elif requests.get(url+"/post.json").status_code == 200:
# TODO code if moebooru
self.base_api = API_BASE_URL_MOE
self.api_type = "moe"
elif requests.get(url+"/post/index.json").status_code == 200:
# TODO code if danbooru v1
self.base_api = API_BASE_URL_1
self.api_type = "dan1"
else:
raise PybooruError("API not currently supported in this module")
def _build_request_url(self, api_name, params=None):
"""Function for build url.
Parameters:
api_name:
The NAME of the API function.
params (Default: None):
The parameters of the API function.
"""
if params is None:
params = {}
# Create url
if 'id' in params:
url = self.site_url + self.base_api[api_name]['url'].replace("id", params['id'])
else:
url = self.site_url + self.base_api[api_name]['url']
method = self.base_api[api_name]['method']
# Build AUTENTICATION hash_string
# Check if hash_string exists
if self.base_api[api_name]['required_login'] is True:
if self.site_name in list(SITE_LIST.keys()) or \
self.hash_string is not "":
# Check if the username and password are empty
if self.username is not "" and self.password is not "":
# Set username login parameter
params['login'] = self.username
# Create hashed string
if self.hash_string is not "":
try:
hash_string = self.hash_string.format(self.password)
except TypeError:
raise PybooruError(r"Use \{0\} in hash_string")
else:
hash_string = SITE_LIST[self.site_name]['hashed_string'].format(self.password)
# Set password_hash parameter
# Convert hashed_string to SHA1 and return hex string
params['password_hash'] = hashlib.sha1( # pylint: disable=E1101
hash_string).hexdigest()
else:
raise PybooruError("Specify the username and password "
"parameter of the Pybooru object, for "
"setting password_hash attribute.")
else:
raise PybooruError(
"Specify the hash_string parameter of the Pybooru"
" object, for the functions which require login.")
return self._json_request(url, params, method)
@staticmethod
def _json_request(url, params, method="GET"):
"""Function to read and returning JSON response.
Parameters:
url:
API function url.
params:
API function parameters.
"""
# Header
headers = {'content-type': 'application/json; charset=utf-8'}
try:
# Request
response = requests.get(url, params=params, headers=headers, timeout=60)
if method == "GET":
response = requests.get(url, params=params, headers=headers, timeout=60)
elif method == "POST":
response = requests.post(url, params=params, headers=headers, timeout=60)
elif method == "PUT":
response = requests.put(url, params=params, headers=headers, timeout=60)
# Enable raise status error
response.raise_for_status()
# Read and return JSON data
return response.json()
except requests.exceptions.HTTPError as err:
raise PybooruError("In _json_request", response.status_code, url)
except requests.exceptions.Timeout as err:
raise PybooruError("Timeout! in url: {0}".format(url))
except ValueError as err:
raise PybooruError("JSON Error: {0} in line {1} column {2}".format(
err.msg, err.lineno, err.colno))
def get_api_type(self):
return self.api_type
def posts_list(self, tags=None, limit=100, page=1):
"""Get a list of posts.
Parameters:
tags:
The tags of the posts (Default: None).
limit:
Limit of posts. Limit is 100 posts per request (Default: 100).
page:
The page number (Default: 1).
"""
params = {'limit': limit, 'page': page}
if tags is not None:
params['tags'] = tags
return self._build_request_url('posts_list', params)
def post_show(self, id_):
"""Get a specific post.
Parameters:
id_:
The id number of the post to retrieve (Type: INT).
"""
params = {'id': id_}
return self._build_request_url('post_show', params)
def posts_create(self, tags, file_=None, rating=None, source=None,
is_rating_locked=None, is_note_locked=None,
parent_id=None, md5=None):
"""Function to create a new post.
There are only two mandatory fields: you need to supply the tags, and
you need to supply the file, either through a multipart form or
through a source URL (Requires login)(UNTESTED).
Parameters:
tags:
A space delimited list of tags.
file_:
The file data encoded as a multipart form.
rating:
The rating for the post. Can be: safe, questionable, or
explicit.
source:
If this is a URL, Danbooru/Moebooru will download the file.
is_rating_locked:
Set to true to prevent others from changing the rating.
is_note_locked:
Set to true to prevent others from adding notes.
parent_id:
The ID of the parent post.
md5:
Supply an MD5 if you want Danbooru/Moebooru to verify the file after
uploading. If the MD5 doesn't match, the post is destroyed.
"""
params = {'post[tags]': tags}
if source is not None or file_ is not None:
if file_ is not None:
params['post[file]'] = file_
if source is not None:
params['post[source]'] = source
if rating is not None:
params['post[rating]'] = rating
if is_rating_locked is not None:
params['post[is_rating_locked]'] = is_rating_locked
if is_note_locked is not None:
params['post[is_note_locked]'] = is_note_locked
if parent_id is not None:
params['post[parent_id]'] = parent_id
if md5 is not None:
params['md5'] = md5
return self._build_request_url('posts_create', params)
else:
raise PybooruError("source or file_ is required")
def posts_update(self, id_, tags, file_, rating, source, is_rating_locked,
is_note_locked, parent_id):
"""Function update a specific post.
Only the id_ parameter is required. Leave the other parameters blank
if you don't want to change them (Requires login)(UNESTED).
Parameters:
id_:
The id number of the post to update (Type: INT).
tags:
A space delimited list of tags (Type: STR).
file_:
The file data ENCODED as a multipart form.
rating:
The rating for the post. Can be: safe, questionable, or
explicit.
source:
If this is a URL, Danbooru/Moebooru will download the file.
is_rating_locked:
Set to true to prevent others from changing the rating.
is_note_locked:
Set to true to prevent others from adding notes.
parent_id:
The ID of the parent post.
"""
params = {'id': id_}
if tags is not None:
params['post[tags]'] = tags
if file_ is not None:
params['post[file]'] = file_
if rating is not None:
params['post[rating]'] = rating
if source is not None:
params['post[source]'] = source
if is_rating_locked is not None:
params['post[is_rating_locked]'] = is_rating_locked
if is_note_locked is not None:
params['post[is_note_locked]'] = is_note_locked
if parent_id is not None:
params['post[parent_id]'] = parent_id
return self._build_request_url('posts_update', params)
def posts_destroy(self, id_):
"""Function to destroy a specific post.
You must also be the user who uploaded the post (or you must be a
moderator) (Requires Login)(UNTESTED).
Parameters:
id_:
The id number of the post to delete.
"""
params = {'id': id_}
response = self._build_request_url('posts_destroy', params)
return response['success']
def posts_revert_tags(self, id_, history_id):
"""Function to reverts a post to a previous set of tags
(Requires login)(UNTESTED).
Parameters:
id_:
The post id number to update (Type: INT).
history_id:
The id number of the tag history.
"""
params = {'id': id_, 'history_id': history_id}
return self._build_request_url('posts_revert_tags', params)
def posts_vote(self, id_, score):
"""Action lets you vote for a post (Requires login).
Parameters:
id_:
The post id (Type: INT).
score:
Be can:
0: No voted or Remove vote.
1: Good.
2: Great.
3: Favorite, add post to favorites.
"""
if score <= 3:
params = {'id': id_, 'score': score}
return self._build_request_url('posts_vote', params)
else:
raise PybooruError("Value of score only can be 0, 1, 2 and 3.")
def tags_list(self, name=None, id_=None, limit=0, page=1, order='name',
after_id=None):
"""Get a list of tags.
Parameters:
name:
The exact name of the tag.
id_:
The id number of the tag.
limit:
How many tags to retrieve. Setting this to 0 will return
every tag (Default value: 0).
page:
The page number.
order:
Can be 'date', 'name' or 'count' (Default: name).
after_id:
Return all tags that have an id number greater than this.
"""
params = {'limit': limit, 'page': page, 'order': order}
if id_ is not None:
params['id'] = id_
elif name is not None:
params['name'] = name
elif after_id is not None:
params['after_id'] = after_id
return self._build_request_url('tags_list', params)
def tags_update(self, name, tag_type, is_ambiguous):
"""Action to lets you update tag (Requires login)(UNTESTED).
Parameters:
name:
The name of the tag to update.
tag_type:
The tag type.
General: 0.
artist: 1.
copyright: 3.
character: 4.
is_ambiguous:
Whether or not this tag is ambiguous. Use 1 for true and 0
for false.
"""
params = {'name': name, 'tag[tag_type]': tag_type,
'tag[is_ambiguous]': is_ambiguous}
return self._build_request_url('tags_update', params)
def tags_related(self, tags, type_=None):
"""Get a list of related tags.
Parameters:
tags:
The tag names to query.
type_:
Restrict results to this tag type. Can be general, artist,
copyright, or character (Default value: None).
"""
params = {'tags': tags}
if type_ is not None:
params['type'] = type_
return self._build_request_url('tags_related', params)
def artists_list(self, name=None, order=None, page=1):
"""Get a list of artists.
Parameters:
name:
The name (or a fragment of the name) of the artist.
order:
Can be date or name (Default value: None).
page:
The page number.
"""
params = {'page': page}
if name is not None:
params['name'] = name
if order is not None:
params['order'] = order
return self._build_request_url('artists_list', params)
def artists_create(self, name, urls, alias, group):
"""Function to create a artist (Requires login)(UNTESTED).
Parameters:
name:
The artist's name.
urls:
A list of URLs associated with the artist, whitespace delimited.
alias:
The artist that this artist is an alias for. Simply enter the
alias artist's name.
group:
The group or cicle that this artist is a member of. Simply
enter the group's name.
"""
params = {'artist[name]': name, 'artist[urls]': urls,
'artist[alias]': alias, 'artist[group]': group}
return self._build_request_url('artists_create', params)
def artists_update(self, id_, name=None, urls=None, alias=None, group=None):
"""Function to update an artists.
Only the id_ parameter is required. The other parameters are optional.
(Requires login)(UNTESTED).
Parameters:
id_:
The id of thr artist to update (Type: INT).
name:
The artist's name.
urls:
A list of URLs associated with the artist, whitespace delimited.
alias:
The artist that this artist is an alias for. Simply enter the
alias artist's name.
group:
The group or cicle that this artist is a member of. Simply
enter the group's name.
"""
params = {'id': id_}
if name is not None:
params['artist[name]'] = name
if urls is not None:
params['artist[urls]'] = urls
if alias is not None:
params['artist[alias]'] = alias
if group is not None:
params['artist[group]'] = group
return self._build_request_url('artists_update', params)
def artists_destroy(self, id_):
"""Action to lets you remove artist (Requires login)(UNTESTED).
Parameters:
id_:
The id of the artist to destroy (Type: INT).
"""
params = {'id': id_}
response = self._build_request_url('artists_destroy', params)
return response['success']
def comments_show(self, id_):
"""Get a specific comment.
Parameters:
id_:
The id number of the comment to retrieve (Type: INT).
"""
params = {'id': id_}
return self._build_request_url('comments_show', params)
def comments_create(self, post_id, comment_body):
"""Action to lets you create a comment (Requires login).
Parameters:
post_id:
The post id number to which you are responding (Type: INT).
comment_body:
The body of the comment.
"""
params = {'comment[post_id]': post_id,
'comment[body]': comment_body}
response = self._build_request_url('comments_create', params)
return response['success']
def comments_destroy(self, id_=None):
"""Remove a specific comment (Requires login).
Parameters:
id_:
The id number of the comment to remove (Type: INT).
"""
params = {'id': id_}
response = self._build_request_url('comments_destroy', params)
return response['success']
def wiki_list(self, query=None, order='title', limit=100, page=1):
"""Function to retrieves a list of every wiki page.
Parameters:
query:
A word or phrase to search for (Default: None).
order:
Can be: title, date (Default: title).
limit:
The number of pages to retrieve (Default: 100).
page:
The page number.
"""
params = {'order': order, 'limit': limit, 'page': page}
if query is not None:
params['query'] = query
return self._build_request_url('wiki_list', params)
def wiki_create(self, title, body):
"""Action to lets you create a wiki page (Requires login)(UNTESTED).
Parameters:
title:
The title of the wiki page.
body:
The body of the wiki page.
"""
params = {'wiki_page[title]': str(title), 'wiki_page[body]': str(body)}
return self._build_request_url('wiki_create', params)
def wiki_update(self, page_title, new_title, page_body):
"""Action to lets you update a wiki page (Requires login)(UNTESTED).
Parameters:
page_title:
The title of the wiki page to update.
new_title:
The new title of the wiki page.
page_body:
The new body of the wiki page.
"""
params = {'title': page_title, 'wiki_page[title]': new_title,
'wiki_page[body]': page_body}
return self._build_request_url('wiki_update', params)
def wiki_show(self, title, version=None):
"""Get a specific wiki page.
Parameters:
title:
The title of the wiki page to retrieve.
version:
The version of the page to retrieve.
"""
params = {'title': title}
if version is not None:
params['version'] = version
return self._build_request_url('wiki_show', params)
def wiki_destroy(self, title):
"""Function to delete a specific wiki page (Requires login)
(Only moderators)(UNTESTED).
Parameters:
title:
The title of the page to delete.
"""
params = {'title': title}
response = self._build_request_url('wiki_destroy', params)
return response['success']
def wiki_lock(self, title):
"""Function to lock a specific wiki page (Requires login)
(Only moderators)(UNTESTED).
Parameters:
title:
The title of the page to lock.
"""
params = {'title': title}
response = self._build_request_url('wiki_lock', params)
return response['success']
def wiki_unlock(self, title):
"""Function to unlock a specific wiki page (Requires login)
(Only moderators)(UNTESTED).
Parameters:
title:
The title of the page to unlock.
"""
params = {'title': title}
response = self._build_request_url('wiki_unlock', params)
return response['success']
def wiki_revert(self, title, version):
"""Function to revert a specific wiki page (Requires login)(UNTESTED).
Parameters:
title:
The title of the wiki page to update.
version:
The version to revert to.
"""
params = {'title': title, 'version': version}
response = self._build_request_url('wiki_revert', params)
return response['success']
def wiki_history(self, title):
"""Get history of specific wiki page.
Parameters:
title:
The title of the wiki page to retrieve versions for.
"""
params = {'title': title}
return self._build_request_url('wiki_history', params)
def notes_list(self, post_id=None):
"""Get note list.
Parameters:
post_id:
The post id number to retrieve notes for (Default: None)
(Type: INT).
"""
if post_id is not None:
params = {'post_id': post_id}
return self._build_request_url('notes_list', params)
else:
return self._build_request_url('notes_list')
def notes_search(self, query):
"""Search specific note.
Parameters:
query:
A word or phrase to search for.
"""
params = {'query': query}
return self._build_request_url('notes_search', params)
def notes_history(self, post_id=None, id_=None, limit=10, page=1):
"""Get history of notes.
Parameters:
post_id:
The post id number to retrieve note versions for.
id_:
The note id number to retrieve versions for (Type: INT).
limit:
How many versions to retrieve (Default: 10).
page:
The note id number to retrieve versions for.
"""
params = {'limit': limit, 'page': page}
if post_id is not None:
params['post_id'] = post_id
elif id_ is not None:
params['id'] = id_
return self._build_request_url('notes_history', params)
def notes_revert(self, id_, version):
"""Function to revert a specific note (Requires login)(UNTESTED).
Parameters:
id_:
The note id to update (Type: INT).
version:
The version to revert to.
"""
params = {'id': id_, 'version': version}
response = self._build_request_url('wiki_revert', params)
return response['success']
def notes_create_update(self, post_id, coor_x, coor_y, width, height,
is_active, body, id_=None):
"""Function to create or update note (Requires login)(UNTESTED).
Parameters:
post_id:
The post id number this note belongs to.
coor_x:
The X coordinate of the note.
coor_y:
The Y coordinate of the note.
width:
The width of the note.
height:
The height of the note.
is_active:
Whether or not the note is visible. Set to 1 for active, 0 for
inactive.
body:
The note message.
id_:
If you are updating a note, this is the note id number to
update.
"""
params = {'note[post_id]': post_id, 'note[x]': coor_x,
'note[y]': coor_y, 'note[width]': width,
'note[height]': height, 'note[body]': body}
if id_ is not None:
params['id'] = id_
if is_active <= 1:
params['note[is_active]'] = is_active
else:
raise PybooruError("is_active parameters required 1 or 0")
return self._build_request_url('notes_create_update', params)
def users_search(self, name=None, id_=None):
"""Search users.
If you don't specify any parameters you'll get a listing of all users.
Parameters:
name:
The name of the user.
id_:
The id number of the user.
"""
if name is not None:
params = {'name': name}
return self._build_request_url('users_search', params)
elif id_ is not None:
params = {'id': id_}
return self._build_request_url('users_search', params)
else:
return self._build_request_url('users_search')
def forum_list(self, parent_id=None):
"""Function to get forum posts.
If you don't specify any parameters you'll get a listing of all users.
Parameters:
parent_id:
The parent ID number. You'll return all the responses to that
forum post.
"""
if parent_id is not None:
params = {'parent_id': parent_id}
return self._build_request_url('forum_list', params)
else:
return self._build_request_url('forum_list')
def pools_list(self, query=None, page=1):
"""Function to get pools.
If you don't specify any parameters you'll get a list of all pools.
Parameters:
query:
The title.
page:
The page.
"""
params = {'page': page}
if query is not None:
params['query'] = query
return self._build_request_url('pools_list', params)
def pools_posts(self, id_=None, page=1):
"""Function to get pools posts.
If you don't specify any parameters you'll get a list of all pools.
Parameters:
id_:
The pool id number.
page:
The page.
"""
params = {'page': page}
if id_ is not None:
params['id'] = id_
return self._build_request_url('pools_posts', params)
def pools_update(self, id_, name, is_public, description):
"""Function to update a pool (Requires login)(UNTESTED).
Parameters:
id_:
The pool id number.
name:
The name.
is_public:
1 or 0, whether or not the pool is public.
description:
A description of the pool.
"""
params = {'id': id_, 'pool[name]': name,
'pool[description]': description}
if is_public <= 1:
params['pool[is_public]'] = is_public
else:
raise PybooruError("is_public require 1 or 0")
return self._build_request_url('pools_update', params)
def pools_create(self, name, is_public, description):
"""Function to create a pool (Require login)(UNTESTED).
Parameters:
name:
The name.
is_public:
1 or 0, whether or not the pool is public.
description:
A description of the pool.
"""
params = {'pool[name]': name, 'pool[description]': description}
if is_public <= 1:
params['pool[name]'] = is_public
else:
raise PybooruError("is_public required 1 or 0")
return self._build_request_url('pools_create', params)
def pools_destroy(self, id_):
"""Function to destroy a specific pool (Require login)(UNTESTED).
Parameters:
id_:
The pool id number (Type: INT).
"""
params = {'id': id_}
response = self._build_request_url('pools_destroy', params)
return response['success']
def pools_add_post(self, pool_id, post_id):
"""Function to add a post (Require login)(UNTESTED).
Parameters:
pool_id:
The pool to add the post to.
post_id:
The post to add.
"""
params = {'pool_id': pool_id, 'post_id': post_id}
return self._build_request_url('pools_add_post', params)
def pools_remove_post(self, pool_id, post_id):
"""Function to remove a post (Require login)(UNTESTED).
Parameters:
pool_id:
The pool to remove the post to.
post_id:
The post to remove.
"""
params = {'pool_id': pool_id, 'post_id': post_id}
return self._build_request_url('pools_remove_post', params)
def favorites_list_users(self, id_):
"""Function to return a list with all users who have added to favorites
a specific post.
Parameters:
id_:
The post id (Type: INT).
"""
params = {'id': id_}
response = self._build_request_url('favorites_list_users', params)
# Return list with users
return response['favorited_users'].split(',')
| buzzbyte/pybooru | pybooru/pybooru.py | Python | mit | 33,500 |
import gtk.gdk
import time
while True:
for i in range(0,15):
time.sleep(.1)
w = gtk.gdk.get_default_root_window()
sz = w.get_size()
print "The size of the window is %d x %d" % sz
pb = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB,False,8,sz[0],sz[1])
pb = pb.get_from_drawable(w,w.get_colormap(),0,0,0,0,sz[0],sz[1])
print bytes(pb)
if (pb != None):
pb.save("../buffer/"+str(i)+".png","png")
# img = open("screenshot.png")
print "Screenshot saved to screenshot.png."
else:
print "Unable to get the screenshot."
# import pyscreenshot as ImageGrab
# # fullscreen
# im=ImageGrab.grab()
# im.show()
# # part of the screen
# im=ImageGrab.grab(bbox=(10,10,510,510)) # X1,Y1,X2,Y2
# im.show() | Brvno/CascadeTV | Test/test.py | Python | mit | 740 |
#!/usr/bin/env python
from string import ascii_uppercase
import caesar
LETTERS = ['etaoinshrdlcumwfgypbvkjxqz']
LETTERS = ['etaoinsh']
DIGRAPHS = ['ST','NG','TH','QU']
ciphertext = """LIVITCSWPIYVEWHEVSRIQMXLEYVEOIEWHRXEXIPFEMVEWHKVSTYLXZIXLIKIIXPIJVSZEYPERRGERIM
WQLMGLMXQERIWGPSRIHMXQEREKIETXMJTPRGEVEKEITREWHEXXLEXXMZITWAWSQWXSWEXTVEPMRXRSJ
GSTVRIEYVIEXCVMUIMWERGMIWXMJMGCSMWXSJOMIQXLIVIQIVIXQSVSTWHKPEGARCSXRWIEVSWIIBXV
IZMXFSJXLIKEGAEWHEPSWYSWIWIEVXLISXLIVXLIRGEPIRQIVIIBGIIHMWYPFLEVHEWHYPSRRFQMXLE
PPXLIECCIEVEWGISJKTVWMRLIHYSPHXLIQIMYLXSJXLIMWRIGXQEROIVFVIZEVAEKPIEWHXEAMWYEPP
XLMWYRMWXSGSWRMHIVEXMSWMGSTPHLEVHPFKPEZINTCMXIVJSVLMRSCMWMSWVIRCIGXMWYMX"""
keys = {}
for ch in ascii_uppercase:
plaintext = caesar.decrypt(ciphertext,ch).upper()
print
print ch,plaintext
print
tscore = 0
score = 4
for dg in DIGRAPHS:
tscore = plaintext.count(dg)*score
score -= 1
keys[ch] = tscore
# print keys
# smax = max(keys.values())
# for ch,tscore in keys.iteritems():
# if tscore == smax:
# print caesar.decrypt(ciphertext,ch)
# break
| mhearne-usgs/handcrypt | crack.py | Python | mit | 1,108 |
# =============================================================================
# FILE: deoplete_elm.py
# AUTHOR: Pawel Bogut
# =============================================================================
from .base import Base
from os import path
import re
import subprocess
import json
class Source(Base):
def __init__(self, vim):
Base.__init__(self, vim)
self.name = 'elm'
self.mark = '[elm]'
self.filetypes = ['elm']
self.rank = 1000
self.input_pattern = r'\w+'
self.current = vim.current
self.vim = vim
def on_init(self, context):
self.oracle_cmd = 'elm-oracle'
def get_complete_position(self, context):
m = re.search(r'[^\s\'"]*$', context['input'])
if m:
return m.start()
def get_complete_query(self, context):
m = re.search(r'[^\s\'"]*$', context['input'])
if m:
return m.group()
return None
def gather_candidates(self, context):
file_path = self.current.buffer.name
current_path = self.get_project_root(file_path)
query = self.get_complete_query(context)
cmd = 'cd {} && {} {} "{}"'.format(current_path, self.oracle_cmd,
file_path, query)
if not query or query == '':
return []
proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, shell=True)
output = proc.stdout.read()
jsonData = str(output.decode('utf-8'))
if not jsonData or jsonData == '':
return []
result = json.loads(jsonData)
if not result:
return []
candidates = []
for item in result:
word = self.get_word(item, query)
candidate = {'word': word,
'abbr': word,
'kind': item['signature'],
'info': item['comment'],
'dup': 0}
candidates.append(candidate)
return candidates
def get_word(self, item, query):
if item['name'].find(query) == 0:
return item['name']
else:
return item['fullName']
def get_project_root(self, file_path):
current_path = path.dirname(file_path)
while current_path != '/' and not path.exists(
path.join(current_path, 'elm-package.json')
):
current_path = path.dirname(current_path)
if current_path == '/':
current_path = path.dirname(file_path)
return current_path
| pbogut/deoplete-elm | rplugin/python3/deoplete/sources/deoplete_elm.py | Python | mit | 2,582 |
# coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for
# license information.
#
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is
# regenerated.
# --------------------------------------------------------------------------
from typing import Any, Optional, TYPE_CHECKING
from azure.core.pipeline.transport import AsyncHttpResponse, HttpRequest
from azure.mgmt.core import AsyncARMPipelineClient
from azure.profiles import KnownProfiles, ProfileDefinition
from azure.profiles.multiapiclient import MultiApiClientMixin
from msrest import Deserializer, Serializer
from ._configuration import NetworkManagementClientConfiguration
from ._operations_mixin import NetworkManagementClientOperationsMixin
if TYPE_CHECKING:
# pylint: disable=unused-import,ungrouped-imports
from azure.core.credentials_async import AsyncTokenCredential
class _SDKClient(object):
def __init__(self, *args, **kwargs):
"""This is a fake class to support current implemetation of MultiApiClientMixin."
Will be removed in final version of multiapi azure-core based client
"""
pass
class NetworkManagementClient(NetworkManagementClientOperationsMixin, MultiApiClientMixin, _SDKClient):
"""Network Client.
This ready contains multiple API versions, to help you deal with all of the Azure clouds
(Azure Stack, Azure Government, Azure China, etc.).
By default, it uses the latest API version available on public Azure.
For production, you should stick to a particular api-version and/or profile.
The profile sets a mapping between an operation group and its API version.
The api-version parameter sets the default API version if the operation
group is not described in the profile.
:param credential: Credential needed for the client to connect to Azure.
:type credential: ~azure.core.credentials_async.AsyncTokenCredential
:param subscription_id: The subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call.
:type subscription_id: str
:param api_version: API version to use if no profile is provided, or if missing in profile.
:type api_version: str
:param base_url: Service URL
:type base_url: str
:param profile: A profile definition, from KnownProfiles to dict.
:type profile: azure.profiles.KnownProfiles
:keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present.
"""
DEFAULT_API_VERSION = '2021-05-01'
_PROFILE_TAG = "azure.mgmt.network.NetworkManagementClient"
LATEST_PROFILE = ProfileDefinition({
_PROFILE_TAG: {
None: DEFAULT_API_VERSION,
'active_connectivity_configurations': '2021-02-01-preview',
'active_security_admin_rules': '2021-02-01-preview',
'active_security_user_rules': '2021-02-01-preview',
'admin_rule_collections': '2021-02-01-preview',
'admin_rules': '2021-02-01-preview',
'connectivity_configurations': '2021-02-01-preview',
'effective_connectivity_configurations': '2021-02-01-preview',
'effective_virtual_networks': '2021-02-01-preview',
'firewall_policy_rule_groups': '2020-04-01',
'interface_endpoints': '2019-02-01',
'network_groups': '2021-02-01-preview',
'network_manager_commits': '2021-02-01-preview',
'network_manager_deployment_status': '2021-02-01-preview',
'network_manager_effective_security_admin_rules': '2021-02-01-preview',
'network_managers': '2021-02-01-preview',
'network_security_perimeters': '2021-02-01-preview',
'p2_svpn_server_configurations': '2019-07-01',
'perimeter_associable_resource_types': '2021-02-01-preview',
'security_admin_configurations': '2021-02-01-preview',
'security_user_configurations': '2021-02-01-preview',
'user_rule_collections': '2021-02-01-preview',
'user_rules': '2021-02-01-preview',
}},
_PROFILE_TAG + " latest"
)
def __init__(
self,
credential: "AsyncTokenCredential",
subscription_id: str,
api_version: Optional[str] = None,
base_url: Optional[str] = None,
profile: KnownProfiles = KnownProfiles.default,
**kwargs # type: Any
) -> None:
if not base_url:
base_url = 'https://management.azure.com'
self._config = NetworkManagementClientConfiguration(credential, subscription_id, **kwargs)
self._client = AsyncARMPipelineClient(base_url=base_url, config=self._config, **kwargs)
super(NetworkManagementClient, self).__init__(
api_version=api_version,
profile=profile
)
@classmethod
def _models_dict(cls, api_version):
return {k: v for k, v in cls.models(api_version).__dict__.items() if isinstance(v, type)}
@classmethod
def models(cls, api_version=DEFAULT_API_VERSION):
"""Module depends on the API version:
* 2015-06-15: :mod:`v2015_06_15.models<azure.mgmt.network.v2015_06_15.models>`
* 2016-09-01: :mod:`v2016_09_01.models<azure.mgmt.network.v2016_09_01.models>`
* 2016-12-01: :mod:`v2016_12_01.models<azure.mgmt.network.v2016_12_01.models>`
* 2017-03-01: :mod:`v2017_03_01.models<azure.mgmt.network.v2017_03_01.models>`
* 2017-06-01: :mod:`v2017_06_01.models<azure.mgmt.network.v2017_06_01.models>`
* 2017-10-01: :mod:`v2017_10_01.models<azure.mgmt.network.v2017_10_01.models>`
* 2018-01-01: :mod:`v2018_01_01.models<azure.mgmt.network.v2018_01_01.models>`
* 2018-02-01: :mod:`v2018_02_01.models<azure.mgmt.network.v2018_02_01.models>`
* 2018-04-01: :mod:`v2018_04_01.models<azure.mgmt.network.v2018_04_01.models>`
* 2018-06-01: :mod:`v2018_06_01.models<azure.mgmt.network.v2018_06_01.models>`
* 2018-07-01: :mod:`v2018_07_01.models<azure.mgmt.network.v2018_07_01.models>`
* 2018-08-01: :mod:`v2018_08_01.models<azure.mgmt.network.v2018_08_01.models>`
* 2018-10-01: :mod:`v2018_10_01.models<azure.mgmt.network.v2018_10_01.models>`
* 2018-11-01: :mod:`v2018_11_01.models<azure.mgmt.network.v2018_11_01.models>`
* 2018-12-01: :mod:`v2018_12_01.models<azure.mgmt.network.v2018_12_01.models>`
* 2019-02-01: :mod:`v2019_02_01.models<azure.mgmt.network.v2019_02_01.models>`
* 2019-04-01: :mod:`v2019_04_01.models<azure.mgmt.network.v2019_04_01.models>`
* 2019-06-01: :mod:`v2019_06_01.models<azure.mgmt.network.v2019_06_01.models>`
* 2019-07-01: :mod:`v2019_07_01.models<azure.mgmt.network.v2019_07_01.models>`
* 2019-08-01: :mod:`v2019_08_01.models<azure.mgmt.network.v2019_08_01.models>`
* 2019-09-01: :mod:`v2019_09_01.models<azure.mgmt.network.v2019_09_01.models>`
* 2019-11-01: :mod:`v2019_11_01.models<azure.mgmt.network.v2019_11_01.models>`
* 2019-12-01: :mod:`v2019_12_01.models<azure.mgmt.network.v2019_12_01.models>`
* 2020-03-01: :mod:`v2020_03_01.models<azure.mgmt.network.v2020_03_01.models>`
* 2020-04-01: :mod:`v2020_04_01.models<azure.mgmt.network.v2020_04_01.models>`
* 2020-05-01: :mod:`v2020_05_01.models<azure.mgmt.network.v2020_05_01.models>`
* 2020-06-01: :mod:`v2020_06_01.models<azure.mgmt.network.v2020_06_01.models>`
* 2020-07-01: :mod:`v2020_07_01.models<azure.mgmt.network.v2020_07_01.models>`
* 2020-08-01: :mod:`v2020_08_01.models<azure.mgmt.network.v2020_08_01.models>`
* 2020-11-01: :mod:`v2020_11_01.models<azure.mgmt.network.v2020_11_01.models>`
* 2021-02-01: :mod:`v2021_02_01.models<azure.mgmt.network.v2021_02_01.models>`
* 2021-02-01-preview: :mod:`v2021_02_01_preview.models<azure.mgmt.network.v2021_02_01_preview.models>`
* 2021-05-01: :mod:`v2021_05_01.models<azure.mgmt.network.v2021_05_01.models>`
"""
if api_version == '2015-06-15':
from ..v2015_06_15 import models
return models
elif api_version == '2016-09-01':
from ..v2016_09_01 import models
return models
elif api_version == '2016-12-01':
from ..v2016_12_01 import models
return models
elif api_version == '2017-03-01':
from ..v2017_03_01 import models
return models
elif api_version == '2017-06-01':
from ..v2017_06_01 import models
return models
elif api_version == '2017-10-01':
from ..v2017_10_01 import models
return models
elif api_version == '2018-01-01':
from ..v2018_01_01 import models
return models
elif api_version == '2018-02-01':
from ..v2018_02_01 import models
return models
elif api_version == '2018-04-01':
from ..v2018_04_01 import models
return models
elif api_version == '2018-06-01':
from ..v2018_06_01 import models
return models
elif api_version == '2018-07-01':
from ..v2018_07_01 import models
return models
elif api_version == '2018-08-01':
from ..v2018_08_01 import models
return models
elif api_version == '2018-10-01':
from ..v2018_10_01 import models
return models
elif api_version == '2018-11-01':
from ..v2018_11_01 import models
return models
elif api_version == '2018-12-01':
from ..v2018_12_01 import models
return models
elif api_version == '2019-02-01':
from ..v2019_02_01 import models
return models
elif api_version == '2019-04-01':
from ..v2019_04_01 import models
return models
elif api_version == '2019-06-01':
from ..v2019_06_01 import models
return models
elif api_version == '2019-07-01':
from ..v2019_07_01 import models
return models
elif api_version == '2019-08-01':
from ..v2019_08_01 import models
return models
elif api_version == '2019-09-01':
from ..v2019_09_01 import models
return models
elif api_version == '2019-11-01':
from ..v2019_11_01 import models
return models
elif api_version == '2019-12-01':
from ..v2019_12_01 import models
return models
elif api_version == '2020-03-01':
from ..v2020_03_01 import models
return models
elif api_version == '2020-04-01':
from ..v2020_04_01 import models
return models
elif api_version == '2020-05-01':
from ..v2020_05_01 import models
return models
elif api_version == '2020-06-01':
from ..v2020_06_01 import models
return models
elif api_version == '2020-07-01':
from ..v2020_07_01 import models
return models
elif api_version == '2020-08-01':
from ..v2020_08_01 import models
return models
elif api_version == '2020-11-01':
from ..v2020_11_01 import models
return models
elif api_version == '2021-02-01':
from ..v2021_02_01 import models
return models
elif api_version == '2021-02-01-preview':
from ..v2021_02_01_preview import models
return models
elif api_version == '2021-05-01':
from ..v2021_05_01 import models
return models
raise ValueError("API version {} is not available".format(api_version))
@property
def active_connectivity_configurations(self):
"""Instance depends on the API version:
* 2021-02-01-preview: :class:`ActiveConnectivityConfigurationsOperations<azure.mgmt.network.v2021_02_01_preview.aio.operations.ActiveConnectivityConfigurationsOperations>`
"""
api_version = self._get_api_version('active_connectivity_configurations')
if api_version == '2021-02-01-preview':
from ..v2021_02_01_preview.aio.operations import ActiveConnectivityConfigurationsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'active_connectivity_configurations'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def active_security_admin_rules(self):
"""Instance depends on the API version:
* 2021-02-01-preview: :class:`ActiveSecurityAdminRulesOperations<azure.mgmt.network.v2021_02_01_preview.aio.operations.ActiveSecurityAdminRulesOperations>`
"""
api_version = self._get_api_version('active_security_admin_rules')
if api_version == '2021-02-01-preview':
from ..v2021_02_01_preview.aio.operations import ActiveSecurityAdminRulesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'active_security_admin_rules'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def active_security_user_rules(self):
"""Instance depends on the API version:
* 2021-02-01-preview: :class:`ActiveSecurityUserRulesOperations<azure.mgmt.network.v2021_02_01_preview.aio.operations.ActiveSecurityUserRulesOperations>`
"""
api_version = self._get_api_version('active_security_user_rules')
if api_version == '2021-02-01-preview':
from ..v2021_02_01_preview.aio.operations import ActiveSecurityUserRulesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'active_security_user_rules'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def admin_rule_collections(self):
"""Instance depends on the API version:
* 2021-02-01-preview: :class:`AdminRuleCollectionsOperations<azure.mgmt.network.v2021_02_01_preview.aio.operations.AdminRuleCollectionsOperations>`
"""
api_version = self._get_api_version('admin_rule_collections')
if api_version == '2021-02-01-preview':
from ..v2021_02_01_preview.aio.operations import AdminRuleCollectionsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'admin_rule_collections'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def admin_rules(self):
"""Instance depends on the API version:
* 2021-02-01-preview: :class:`AdminRulesOperations<azure.mgmt.network.v2021_02_01_preview.aio.operations.AdminRulesOperations>`
"""
api_version = self._get_api_version('admin_rules')
if api_version == '2021-02-01-preview':
from ..v2021_02_01_preview.aio.operations import AdminRulesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'admin_rules'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def application_gateway_private_endpoint_connections(self):
"""Instance depends on the API version:
* 2020-05-01: :class:`ApplicationGatewayPrivateEndpointConnectionsOperations<azure.mgmt.network.v2020_05_01.aio.operations.ApplicationGatewayPrivateEndpointConnectionsOperations>`
* 2020-06-01: :class:`ApplicationGatewayPrivateEndpointConnectionsOperations<azure.mgmt.network.v2020_06_01.aio.operations.ApplicationGatewayPrivateEndpointConnectionsOperations>`
* 2020-07-01: :class:`ApplicationGatewayPrivateEndpointConnectionsOperations<azure.mgmt.network.v2020_07_01.aio.operations.ApplicationGatewayPrivateEndpointConnectionsOperations>`
* 2020-08-01: :class:`ApplicationGatewayPrivateEndpointConnectionsOperations<azure.mgmt.network.v2020_08_01.aio.operations.ApplicationGatewayPrivateEndpointConnectionsOperations>`
* 2020-11-01: :class:`ApplicationGatewayPrivateEndpointConnectionsOperations<azure.mgmt.network.v2020_11_01.aio.operations.ApplicationGatewayPrivateEndpointConnectionsOperations>`
* 2021-02-01: :class:`ApplicationGatewayPrivateEndpointConnectionsOperations<azure.mgmt.network.v2021_02_01.aio.operations.ApplicationGatewayPrivateEndpointConnectionsOperations>`
* 2021-05-01: :class:`ApplicationGatewayPrivateEndpointConnectionsOperations<azure.mgmt.network.v2021_05_01.aio.operations.ApplicationGatewayPrivateEndpointConnectionsOperations>`
"""
api_version = self._get_api_version('application_gateway_private_endpoint_connections')
if api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import ApplicationGatewayPrivateEndpointConnectionsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import ApplicationGatewayPrivateEndpointConnectionsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import ApplicationGatewayPrivateEndpointConnectionsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import ApplicationGatewayPrivateEndpointConnectionsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import ApplicationGatewayPrivateEndpointConnectionsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import ApplicationGatewayPrivateEndpointConnectionsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import ApplicationGatewayPrivateEndpointConnectionsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'application_gateway_private_endpoint_connections'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def application_gateway_private_link_resources(self):
"""Instance depends on the API version:
* 2020-05-01: :class:`ApplicationGatewayPrivateLinkResourcesOperations<azure.mgmt.network.v2020_05_01.aio.operations.ApplicationGatewayPrivateLinkResourcesOperations>`
* 2020-06-01: :class:`ApplicationGatewayPrivateLinkResourcesOperations<azure.mgmt.network.v2020_06_01.aio.operations.ApplicationGatewayPrivateLinkResourcesOperations>`
* 2020-07-01: :class:`ApplicationGatewayPrivateLinkResourcesOperations<azure.mgmt.network.v2020_07_01.aio.operations.ApplicationGatewayPrivateLinkResourcesOperations>`
* 2020-08-01: :class:`ApplicationGatewayPrivateLinkResourcesOperations<azure.mgmt.network.v2020_08_01.aio.operations.ApplicationGatewayPrivateLinkResourcesOperations>`
* 2020-11-01: :class:`ApplicationGatewayPrivateLinkResourcesOperations<azure.mgmt.network.v2020_11_01.aio.operations.ApplicationGatewayPrivateLinkResourcesOperations>`
* 2021-02-01: :class:`ApplicationGatewayPrivateLinkResourcesOperations<azure.mgmt.network.v2021_02_01.aio.operations.ApplicationGatewayPrivateLinkResourcesOperations>`
* 2021-05-01: :class:`ApplicationGatewayPrivateLinkResourcesOperations<azure.mgmt.network.v2021_05_01.aio.operations.ApplicationGatewayPrivateLinkResourcesOperations>`
"""
api_version = self._get_api_version('application_gateway_private_link_resources')
if api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import ApplicationGatewayPrivateLinkResourcesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import ApplicationGatewayPrivateLinkResourcesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import ApplicationGatewayPrivateLinkResourcesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import ApplicationGatewayPrivateLinkResourcesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import ApplicationGatewayPrivateLinkResourcesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import ApplicationGatewayPrivateLinkResourcesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import ApplicationGatewayPrivateLinkResourcesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'application_gateway_private_link_resources'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def application_gateways(self):
"""Instance depends on the API version:
* 2015-06-15: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2015_06_15.aio.operations.ApplicationGatewaysOperations>`
* 2016-09-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2016_09_01.aio.operations.ApplicationGatewaysOperations>`
* 2016-12-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2016_12_01.aio.operations.ApplicationGatewaysOperations>`
* 2017-03-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2017_03_01.aio.operations.ApplicationGatewaysOperations>`
* 2017-06-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2017_06_01.aio.operations.ApplicationGatewaysOperations>`
* 2017-10-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2017_10_01.aio.operations.ApplicationGatewaysOperations>`
* 2018-01-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2018_01_01.aio.operations.ApplicationGatewaysOperations>`
* 2018-02-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2018_02_01.aio.operations.ApplicationGatewaysOperations>`
* 2018-04-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2018_04_01.aio.operations.ApplicationGatewaysOperations>`
* 2018-06-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2018_06_01.aio.operations.ApplicationGatewaysOperations>`
* 2018-07-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2018_07_01.aio.operations.ApplicationGatewaysOperations>`
* 2018-08-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2018_08_01.aio.operations.ApplicationGatewaysOperations>`
* 2018-10-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2018_10_01.aio.operations.ApplicationGatewaysOperations>`
* 2018-11-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2018_11_01.aio.operations.ApplicationGatewaysOperations>`
* 2018-12-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2018_12_01.aio.operations.ApplicationGatewaysOperations>`
* 2019-02-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2019_02_01.aio.operations.ApplicationGatewaysOperations>`
* 2019-04-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2019_04_01.aio.operations.ApplicationGatewaysOperations>`
* 2019-06-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2019_06_01.aio.operations.ApplicationGatewaysOperations>`
* 2019-07-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2019_07_01.aio.operations.ApplicationGatewaysOperations>`
* 2019-08-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2019_08_01.aio.operations.ApplicationGatewaysOperations>`
* 2019-09-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2019_09_01.aio.operations.ApplicationGatewaysOperations>`
* 2019-11-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2019_11_01.aio.operations.ApplicationGatewaysOperations>`
* 2019-12-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2019_12_01.aio.operations.ApplicationGatewaysOperations>`
* 2020-03-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2020_03_01.aio.operations.ApplicationGatewaysOperations>`
* 2020-04-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2020_04_01.aio.operations.ApplicationGatewaysOperations>`
* 2020-05-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2020_05_01.aio.operations.ApplicationGatewaysOperations>`
* 2020-06-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2020_06_01.aio.operations.ApplicationGatewaysOperations>`
* 2020-07-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2020_07_01.aio.operations.ApplicationGatewaysOperations>`
* 2020-08-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2020_08_01.aio.operations.ApplicationGatewaysOperations>`
* 2020-11-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2020_11_01.aio.operations.ApplicationGatewaysOperations>`
* 2021-02-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2021_02_01.aio.operations.ApplicationGatewaysOperations>`
* 2021-05-01: :class:`ApplicationGatewaysOperations<azure.mgmt.network.v2021_05_01.aio.operations.ApplicationGatewaysOperations>`
"""
api_version = self._get_api_version('application_gateways')
if api_version == '2015-06-15':
from ..v2015_06_15.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2016-09-01':
from ..v2016_09_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2016-12-01':
from ..v2016_12_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2017-03-01':
from ..v2017_03_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import ApplicationGatewaysOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import ApplicationGatewaysOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'application_gateways'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def application_security_groups(self):
"""Instance depends on the API version:
* 2017-10-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2017_10_01.aio.operations.ApplicationSecurityGroupsOperations>`
* 2018-01-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2018_01_01.aio.operations.ApplicationSecurityGroupsOperations>`
* 2018-02-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2018_02_01.aio.operations.ApplicationSecurityGroupsOperations>`
* 2018-04-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2018_04_01.aio.operations.ApplicationSecurityGroupsOperations>`
* 2018-06-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2018_06_01.aio.operations.ApplicationSecurityGroupsOperations>`
* 2018-07-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2018_07_01.aio.operations.ApplicationSecurityGroupsOperations>`
* 2018-08-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2018_08_01.aio.operations.ApplicationSecurityGroupsOperations>`
* 2018-10-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2018_10_01.aio.operations.ApplicationSecurityGroupsOperations>`
* 2018-11-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2018_11_01.aio.operations.ApplicationSecurityGroupsOperations>`
* 2018-12-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2018_12_01.aio.operations.ApplicationSecurityGroupsOperations>`
* 2019-02-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2019_02_01.aio.operations.ApplicationSecurityGroupsOperations>`
* 2019-04-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2019_04_01.aio.operations.ApplicationSecurityGroupsOperations>`
* 2019-06-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2019_06_01.aio.operations.ApplicationSecurityGroupsOperations>`
* 2019-07-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2019_07_01.aio.operations.ApplicationSecurityGroupsOperations>`
* 2019-08-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2019_08_01.aio.operations.ApplicationSecurityGroupsOperations>`
* 2019-09-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2019_09_01.aio.operations.ApplicationSecurityGroupsOperations>`
* 2019-11-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2019_11_01.aio.operations.ApplicationSecurityGroupsOperations>`
* 2019-12-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2019_12_01.aio.operations.ApplicationSecurityGroupsOperations>`
* 2020-03-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2020_03_01.aio.operations.ApplicationSecurityGroupsOperations>`
* 2020-04-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2020_04_01.aio.operations.ApplicationSecurityGroupsOperations>`
* 2020-05-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2020_05_01.aio.operations.ApplicationSecurityGroupsOperations>`
* 2020-06-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2020_06_01.aio.operations.ApplicationSecurityGroupsOperations>`
* 2020-07-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2020_07_01.aio.operations.ApplicationSecurityGroupsOperations>`
* 2020-08-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2020_08_01.aio.operations.ApplicationSecurityGroupsOperations>`
* 2020-11-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2020_11_01.aio.operations.ApplicationSecurityGroupsOperations>`
* 2021-02-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2021_02_01.aio.operations.ApplicationSecurityGroupsOperations>`
* 2021-05-01: :class:`ApplicationSecurityGroupsOperations<azure.mgmt.network.v2021_05_01.aio.operations.ApplicationSecurityGroupsOperations>`
"""
api_version = self._get_api_version('application_security_groups')
if api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import ApplicationSecurityGroupsOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import ApplicationSecurityGroupsOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import ApplicationSecurityGroupsOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import ApplicationSecurityGroupsOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import ApplicationSecurityGroupsOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import ApplicationSecurityGroupsOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import ApplicationSecurityGroupsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import ApplicationSecurityGroupsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import ApplicationSecurityGroupsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import ApplicationSecurityGroupsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import ApplicationSecurityGroupsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import ApplicationSecurityGroupsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import ApplicationSecurityGroupsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import ApplicationSecurityGroupsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import ApplicationSecurityGroupsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import ApplicationSecurityGroupsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import ApplicationSecurityGroupsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import ApplicationSecurityGroupsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import ApplicationSecurityGroupsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import ApplicationSecurityGroupsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import ApplicationSecurityGroupsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import ApplicationSecurityGroupsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import ApplicationSecurityGroupsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import ApplicationSecurityGroupsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import ApplicationSecurityGroupsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import ApplicationSecurityGroupsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import ApplicationSecurityGroupsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'application_security_groups'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def available_delegations(self):
"""Instance depends on the API version:
* 2018-08-01: :class:`AvailableDelegationsOperations<azure.mgmt.network.v2018_08_01.aio.operations.AvailableDelegationsOperations>`
* 2018-10-01: :class:`AvailableDelegationsOperations<azure.mgmt.network.v2018_10_01.aio.operations.AvailableDelegationsOperations>`
* 2018-11-01: :class:`AvailableDelegationsOperations<azure.mgmt.network.v2018_11_01.aio.operations.AvailableDelegationsOperations>`
* 2018-12-01: :class:`AvailableDelegationsOperations<azure.mgmt.network.v2018_12_01.aio.operations.AvailableDelegationsOperations>`
* 2019-02-01: :class:`AvailableDelegationsOperations<azure.mgmt.network.v2019_02_01.aio.operations.AvailableDelegationsOperations>`
* 2019-04-01: :class:`AvailableDelegationsOperations<azure.mgmt.network.v2019_04_01.aio.operations.AvailableDelegationsOperations>`
* 2019-06-01: :class:`AvailableDelegationsOperations<azure.mgmt.network.v2019_06_01.aio.operations.AvailableDelegationsOperations>`
* 2019-07-01: :class:`AvailableDelegationsOperations<azure.mgmt.network.v2019_07_01.aio.operations.AvailableDelegationsOperations>`
* 2019-08-01: :class:`AvailableDelegationsOperations<azure.mgmt.network.v2019_08_01.aio.operations.AvailableDelegationsOperations>`
* 2019-09-01: :class:`AvailableDelegationsOperations<azure.mgmt.network.v2019_09_01.aio.operations.AvailableDelegationsOperations>`
* 2019-11-01: :class:`AvailableDelegationsOperations<azure.mgmt.network.v2019_11_01.aio.operations.AvailableDelegationsOperations>`
* 2019-12-01: :class:`AvailableDelegationsOperations<azure.mgmt.network.v2019_12_01.aio.operations.AvailableDelegationsOperations>`
* 2020-03-01: :class:`AvailableDelegationsOperations<azure.mgmt.network.v2020_03_01.aio.operations.AvailableDelegationsOperations>`
* 2020-04-01: :class:`AvailableDelegationsOperations<azure.mgmt.network.v2020_04_01.aio.operations.AvailableDelegationsOperations>`
* 2020-05-01: :class:`AvailableDelegationsOperations<azure.mgmt.network.v2020_05_01.aio.operations.AvailableDelegationsOperations>`
* 2020-06-01: :class:`AvailableDelegationsOperations<azure.mgmt.network.v2020_06_01.aio.operations.AvailableDelegationsOperations>`
* 2020-07-01: :class:`AvailableDelegationsOperations<azure.mgmt.network.v2020_07_01.aio.operations.AvailableDelegationsOperations>`
* 2020-08-01: :class:`AvailableDelegationsOperations<azure.mgmt.network.v2020_08_01.aio.operations.AvailableDelegationsOperations>`
* 2020-11-01: :class:`AvailableDelegationsOperations<azure.mgmt.network.v2020_11_01.aio.operations.AvailableDelegationsOperations>`
* 2021-02-01: :class:`AvailableDelegationsOperations<azure.mgmt.network.v2021_02_01.aio.operations.AvailableDelegationsOperations>`
* 2021-05-01: :class:`AvailableDelegationsOperations<azure.mgmt.network.v2021_05_01.aio.operations.AvailableDelegationsOperations>`
"""
api_version = self._get_api_version('available_delegations')
if api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import AvailableDelegationsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import AvailableDelegationsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import AvailableDelegationsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import AvailableDelegationsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import AvailableDelegationsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import AvailableDelegationsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import AvailableDelegationsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import AvailableDelegationsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import AvailableDelegationsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import AvailableDelegationsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import AvailableDelegationsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import AvailableDelegationsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import AvailableDelegationsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import AvailableDelegationsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import AvailableDelegationsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import AvailableDelegationsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import AvailableDelegationsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import AvailableDelegationsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import AvailableDelegationsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import AvailableDelegationsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import AvailableDelegationsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'available_delegations'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def available_endpoint_services(self):
"""Instance depends on the API version:
* 2017-06-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2017_06_01.aio.operations.AvailableEndpointServicesOperations>`
* 2017-10-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2017_10_01.aio.operations.AvailableEndpointServicesOperations>`
* 2018-01-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2018_01_01.aio.operations.AvailableEndpointServicesOperations>`
* 2018-02-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2018_02_01.aio.operations.AvailableEndpointServicesOperations>`
* 2018-04-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2018_04_01.aio.operations.AvailableEndpointServicesOperations>`
* 2018-06-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2018_06_01.aio.operations.AvailableEndpointServicesOperations>`
* 2018-07-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2018_07_01.aio.operations.AvailableEndpointServicesOperations>`
* 2018-08-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2018_08_01.aio.operations.AvailableEndpointServicesOperations>`
* 2018-10-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2018_10_01.aio.operations.AvailableEndpointServicesOperations>`
* 2018-11-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2018_11_01.aio.operations.AvailableEndpointServicesOperations>`
* 2018-12-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2018_12_01.aio.operations.AvailableEndpointServicesOperations>`
* 2019-02-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2019_02_01.aio.operations.AvailableEndpointServicesOperations>`
* 2019-04-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2019_04_01.aio.operations.AvailableEndpointServicesOperations>`
* 2019-06-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2019_06_01.aio.operations.AvailableEndpointServicesOperations>`
* 2019-07-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2019_07_01.aio.operations.AvailableEndpointServicesOperations>`
* 2019-08-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2019_08_01.aio.operations.AvailableEndpointServicesOperations>`
* 2019-09-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2019_09_01.aio.operations.AvailableEndpointServicesOperations>`
* 2019-11-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2019_11_01.aio.operations.AvailableEndpointServicesOperations>`
* 2019-12-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2019_12_01.aio.operations.AvailableEndpointServicesOperations>`
* 2020-03-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2020_03_01.aio.operations.AvailableEndpointServicesOperations>`
* 2020-04-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2020_04_01.aio.operations.AvailableEndpointServicesOperations>`
* 2020-05-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2020_05_01.aio.operations.AvailableEndpointServicesOperations>`
* 2020-06-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2020_06_01.aio.operations.AvailableEndpointServicesOperations>`
* 2020-07-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2020_07_01.aio.operations.AvailableEndpointServicesOperations>`
* 2020-08-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2020_08_01.aio.operations.AvailableEndpointServicesOperations>`
* 2020-11-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2020_11_01.aio.operations.AvailableEndpointServicesOperations>`
* 2021-02-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2021_02_01.aio.operations.AvailableEndpointServicesOperations>`
* 2021-05-01: :class:`AvailableEndpointServicesOperations<azure.mgmt.network.v2021_05_01.aio.operations.AvailableEndpointServicesOperations>`
"""
api_version = self._get_api_version('available_endpoint_services')
if api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import AvailableEndpointServicesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'available_endpoint_services'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def available_private_endpoint_types(self):
"""Instance depends on the API version:
* 2019-04-01: :class:`AvailablePrivateEndpointTypesOperations<azure.mgmt.network.v2019_04_01.aio.operations.AvailablePrivateEndpointTypesOperations>`
* 2019-06-01: :class:`AvailablePrivateEndpointTypesOperations<azure.mgmt.network.v2019_06_01.aio.operations.AvailablePrivateEndpointTypesOperations>`
* 2019-07-01: :class:`AvailablePrivateEndpointTypesOperations<azure.mgmt.network.v2019_07_01.aio.operations.AvailablePrivateEndpointTypesOperations>`
* 2019-08-01: :class:`AvailablePrivateEndpointTypesOperations<azure.mgmt.network.v2019_08_01.aio.operations.AvailablePrivateEndpointTypesOperations>`
* 2019-09-01: :class:`AvailablePrivateEndpointTypesOperations<azure.mgmt.network.v2019_09_01.aio.operations.AvailablePrivateEndpointTypesOperations>`
* 2019-11-01: :class:`AvailablePrivateEndpointTypesOperations<azure.mgmt.network.v2019_11_01.aio.operations.AvailablePrivateEndpointTypesOperations>`
* 2019-12-01: :class:`AvailablePrivateEndpointTypesOperations<azure.mgmt.network.v2019_12_01.aio.operations.AvailablePrivateEndpointTypesOperations>`
* 2020-03-01: :class:`AvailablePrivateEndpointTypesOperations<azure.mgmt.network.v2020_03_01.aio.operations.AvailablePrivateEndpointTypesOperations>`
* 2020-04-01: :class:`AvailablePrivateEndpointTypesOperations<azure.mgmt.network.v2020_04_01.aio.operations.AvailablePrivateEndpointTypesOperations>`
* 2020-05-01: :class:`AvailablePrivateEndpointTypesOperations<azure.mgmt.network.v2020_05_01.aio.operations.AvailablePrivateEndpointTypesOperations>`
* 2020-06-01: :class:`AvailablePrivateEndpointTypesOperations<azure.mgmt.network.v2020_06_01.aio.operations.AvailablePrivateEndpointTypesOperations>`
* 2020-07-01: :class:`AvailablePrivateEndpointTypesOperations<azure.mgmt.network.v2020_07_01.aio.operations.AvailablePrivateEndpointTypesOperations>`
* 2020-08-01: :class:`AvailablePrivateEndpointTypesOperations<azure.mgmt.network.v2020_08_01.aio.operations.AvailablePrivateEndpointTypesOperations>`
* 2020-11-01: :class:`AvailablePrivateEndpointTypesOperations<azure.mgmt.network.v2020_11_01.aio.operations.AvailablePrivateEndpointTypesOperations>`
* 2021-02-01: :class:`AvailablePrivateEndpointTypesOperations<azure.mgmt.network.v2021_02_01.aio.operations.AvailablePrivateEndpointTypesOperations>`
* 2021-05-01: :class:`AvailablePrivateEndpointTypesOperations<azure.mgmt.network.v2021_05_01.aio.operations.AvailablePrivateEndpointTypesOperations>`
"""
api_version = self._get_api_version('available_private_endpoint_types')
if api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import AvailablePrivateEndpointTypesOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import AvailablePrivateEndpointTypesOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import AvailablePrivateEndpointTypesOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import AvailablePrivateEndpointTypesOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import AvailablePrivateEndpointTypesOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import AvailablePrivateEndpointTypesOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import AvailablePrivateEndpointTypesOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import AvailablePrivateEndpointTypesOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import AvailablePrivateEndpointTypesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import AvailablePrivateEndpointTypesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import AvailablePrivateEndpointTypesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import AvailablePrivateEndpointTypesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import AvailablePrivateEndpointTypesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import AvailablePrivateEndpointTypesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import AvailablePrivateEndpointTypesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import AvailablePrivateEndpointTypesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'available_private_endpoint_types'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def available_resource_group_delegations(self):
"""Instance depends on the API version:
* 2018-08-01: :class:`AvailableResourceGroupDelegationsOperations<azure.mgmt.network.v2018_08_01.aio.operations.AvailableResourceGroupDelegationsOperations>`
* 2018-10-01: :class:`AvailableResourceGroupDelegationsOperations<azure.mgmt.network.v2018_10_01.aio.operations.AvailableResourceGroupDelegationsOperations>`
* 2018-11-01: :class:`AvailableResourceGroupDelegationsOperations<azure.mgmt.network.v2018_11_01.aio.operations.AvailableResourceGroupDelegationsOperations>`
* 2018-12-01: :class:`AvailableResourceGroupDelegationsOperations<azure.mgmt.network.v2018_12_01.aio.operations.AvailableResourceGroupDelegationsOperations>`
* 2019-02-01: :class:`AvailableResourceGroupDelegationsOperations<azure.mgmt.network.v2019_02_01.aio.operations.AvailableResourceGroupDelegationsOperations>`
* 2019-04-01: :class:`AvailableResourceGroupDelegationsOperations<azure.mgmt.network.v2019_04_01.aio.operations.AvailableResourceGroupDelegationsOperations>`
* 2019-06-01: :class:`AvailableResourceGroupDelegationsOperations<azure.mgmt.network.v2019_06_01.aio.operations.AvailableResourceGroupDelegationsOperations>`
* 2019-07-01: :class:`AvailableResourceGroupDelegationsOperations<azure.mgmt.network.v2019_07_01.aio.operations.AvailableResourceGroupDelegationsOperations>`
* 2019-08-01: :class:`AvailableResourceGroupDelegationsOperations<azure.mgmt.network.v2019_08_01.aio.operations.AvailableResourceGroupDelegationsOperations>`
* 2019-09-01: :class:`AvailableResourceGroupDelegationsOperations<azure.mgmt.network.v2019_09_01.aio.operations.AvailableResourceGroupDelegationsOperations>`
* 2019-11-01: :class:`AvailableResourceGroupDelegationsOperations<azure.mgmt.network.v2019_11_01.aio.operations.AvailableResourceGroupDelegationsOperations>`
* 2019-12-01: :class:`AvailableResourceGroupDelegationsOperations<azure.mgmt.network.v2019_12_01.aio.operations.AvailableResourceGroupDelegationsOperations>`
* 2020-03-01: :class:`AvailableResourceGroupDelegationsOperations<azure.mgmt.network.v2020_03_01.aio.operations.AvailableResourceGroupDelegationsOperations>`
* 2020-04-01: :class:`AvailableResourceGroupDelegationsOperations<azure.mgmt.network.v2020_04_01.aio.operations.AvailableResourceGroupDelegationsOperations>`
* 2020-05-01: :class:`AvailableResourceGroupDelegationsOperations<azure.mgmt.network.v2020_05_01.aio.operations.AvailableResourceGroupDelegationsOperations>`
* 2020-06-01: :class:`AvailableResourceGroupDelegationsOperations<azure.mgmt.network.v2020_06_01.aio.operations.AvailableResourceGroupDelegationsOperations>`
* 2020-07-01: :class:`AvailableResourceGroupDelegationsOperations<azure.mgmt.network.v2020_07_01.aio.operations.AvailableResourceGroupDelegationsOperations>`
* 2020-08-01: :class:`AvailableResourceGroupDelegationsOperations<azure.mgmt.network.v2020_08_01.aio.operations.AvailableResourceGroupDelegationsOperations>`
* 2020-11-01: :class:`AvailableResourceGroupDelegationsOperations<azure.mgmt.network.v2020_11_01.aio.operations.AvailableResourceGroupDelegationsOperations>`
* 2021-02-01: :class:`AvailableResourceGroupDelegationsOperations<azure.mgmt.network.v2021_02_01.aio.operations.AvailableResourceGroupDelegationsOperations>`
* 2021-05-01: :class:`AvailableResourceGroupDelegationsOperations<azure.mgmt.network.v2021_05_01.aio.operations.AvailableResourceGroupDelegationsOperations>`
"""
api_version = self._get_api_version('available_resource_group_delegations')
if api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import AvailableResourceGroupDelegationsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import AvailableResourceGroupDelegationsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import AvailableResourceGroupDelegationsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import AvailableResourceGroupDelegationsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import AvailableResourceGroupDelegationsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import AvailableResourceGroupDelegationsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import AvailableResourceGroupDelegationsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import AvailableResourceGroupDelegationsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import AvailableResourceGroupDelegationsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import AvailableResourceGroupDelegationsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import AvailableResourceGroupDelegationsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import AvailableResourceGroupDelegationsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import AvailableResourceGroupDelegationsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import AvailableResourceGroupDelegationsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import AvailableResourceGroupDelegationsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import AvailableResourceGroupDelegationsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import AvailableResourceGroupDelegationsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import AvailableResourceGroupDelegationsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import AvailableResourceGroupDelegationsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import AvailableResourceGroupDelegationsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import AvailableResourceGroupDelegationsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'available_resource_group_delegations'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def available_service_aliases(self):
"""Instance depends on the API version:
* 2019-08-01: :class:`AvailableServiceAliasesOperations<azure.mgmt.network.v2019_08_01.aio.operations.AvailableServiceAliasesOperations>`
* 2019-09-01: :class:`AvailableServiceAliasesOperations<azure.mgmt.network.v2019_09_01.aio.operations.AvailableServiceAliasesOperations>`
* 2019-11-01: :class:`AvailableServiceAliasesOperations<azure.mgmt.network.v2019_11_01.aio.operations.AvailableServiceAliasesOperations>`
* 2019-12-01: :class:`AvailableServiceAliasesOperations<azure.mgmt.network.v2019_12_01.aio.operations.AvailableServiceAliasesOperations>`
* 2020-03-01: :class:`AvailableServiceAliasesOperations<azure.mgmt.network.v2020_03_01.aio.operations.AvailableServiceAliasesOperations>`
* 2020-04-01: :class:`AvailableServiceAliasesOperations<azure.mgmt.network.v2020_04_01.aio.operations.AvailableServiceAliasesOperations>`
* 2020-05-01: :class:`AvailableServiceAliasesOperations<azure.mgmt.network.v2020_05_01.aio.operations.AvailableServiceAliasesOperations>`
* 2020-06-01: :class:`AvailableServiceAliasesOperations<azure.mgmt.network.v2020_06_01.aio.operations.AvailableServiceAliasesOperations>`
* 2020-07-01: :class:`AvailableServiceAliasesOperations<azure.mgmt.network.v2020_07_01.aio.operations.AvailableServiceAliasesOperations>`
* 2020-08-01: :class:`AvailableServiceAliasesOperations<azure.mgmt.network.v2020_08_01.aio.operations.AvailableServiceAliasesOperations>`
* 2020-11-01: :class:`AvailableServiceAliasesOperations<azure.mgmt.network.v2020_11_01.aio.operations.AvailableServiceAliasesOperations>`
* 2021-02-01: :class:`AvailableServiceAliasesOperations<azure.mgmt.network.v2021_02_01.aio.operations.AvailableServiceAliasesOperations>`
* 2021-05-01: :class:`AvailableServiceAliasesOperations<azure.mgmt.network.v2021_05_01.aio.operations.AvailableServiceAliasesOperations>`
"""
api_version = self._get_api_version('available_service_aliases')
if api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import AvailableServiceAliasesOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import AvailableServiceAliasesOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import AvailableServiceAliasesOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import AvailableServiceAliasesOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import AvailableServiceAliasesOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import AvailableServiceAliasesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import AvailableServiceAliasesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import AvailableServiceAliasesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import AvailableServiceAliasesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import AvailableServiceAliasesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import AvailableServiceAliasesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import AvailableServiceAliasesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import AvailableServiceAliasesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'available_service_aliases'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def azure_firewall_fqdn_tags(self):
"""Instance depends on the API version:
* 2018-08-01: :class:`AzureFirewallFqdnTagsOperations<azure.mgmt.network.v2018_08_01.aio.operations.AzureFirewallFqdnTagsOperations>`
* 2018-10-01: :class:`AzureFirewallFqdnTagsOperations<azure.mgmt.network.v2018_10_01.aio.operations.AzureFirewallFqdnTagsOperations>`
* 2018-11-01: :class:`AzureFirewallFqdnTagsOperations<azure.mgmt.network.v2018_11_01.aio.operations.AzureFirewallFqdnTagsOperations>`
* 2018-12-01: :class:`AzureFirewallFqdnTagsOperations<azure.mgmt.network.v2018_12_01.aio.operations.AzureFirewallFqdnTagsOperations>`
* 2019-02-01: :class:`AzureFirewallFqdnTagsOperations<azure.mgmt.network.v2019_02_01.aio.operations.AzureFirewallFqdnTagsOperations>`
* 2019-04-01: :class:`AzureFirewallFqdnTagsOperations<azure.mgmt.network.v2019_04_01.aio.operations.AzureFirewallFqdnTagsOperations>`
* 2019-06-01: :class:`AzureFirewallFqdnTagsOperations<azure.mgmt.network.v2019_06_01.aio.operations.AzureFirewallFqdnTagsOperations>`
* 2019-07-01: :class:`AzureFirewallFqdnTagsOperations<azure.mgmt.network.v2019_07_01.aio.operations.AzureFirewallFqdnTagsOperations>`
* 2019-08-01: :class:`AzureFirewallFqdnTagsOperations<azure.mgmt.network.v2019_08_01.aio.operations.AzureFirewallFqdnTagsOperations>`
* 2019-09-01: :class:`AzureFirewallFqdnTagsOperations<azure.mgmt.network.v2019_09_01.aio.operations.AzureFirewallFqdnTagsOperations>`
* 2019-11-01: :class:`AzureFirewallFqdnTagsOperations<azure.mgmt.network.v2019_11_01.aio.operations.AzureFirewallFqdnTagsOperations>`
* 2019-12-01: :class:`AzureFirewallFqdnTagsOperations<azure.mgmt.network.v2019_12_01.aio.operations.AzureFirewallFqdnTagsOperations>`
* 2020-03-01: :class:`AzureFirewallFqdnTagsOperations<azure.mgmt.network.v2020_03_01.aio.operations.AzureFirewallFqdnTagsOperations>`
* 2020-04-01: :class:`AzureFirewallFqdnTagsOperations<azure.mgmt.network.v2020_04_01.aio.operations.AzureFirewallFqdnTagsOperations>`
* 2020-05-01: :class:`AzureFirewallFqdnTagsOperations<azure.mgmt.network.v2020_05_01.aio.operations.AzureFirewallFqdnTagsOperations>`
* 2020-06-01: :class:`AzureFirewallFqdnTagsOperations<azure.mgmt.network.v2020_06_01.aio.operations.AzureFirewallFqdnTagsOperations>`
* 2020-07-01: :class:`AzureFirewallFqdnTagsOperations<azure.mgmt.network.v2020_07_01.aio.operations.AzureFirewallFqdnTagsOperations>`
* 2020-08-01: :class:`AzureFirewallFqdnTagsOperations<azure.mgmt.network.v2020_08_01.aio.operations.AzureFirewallFqdnTagsOperations>`
* 2020-11-01: :class:`AzureFirewallFqdnTagsOperations<azure.mgmt.network.v2020_11_01.aio.operations.AzureFirewallFqdnTagsOperations>`
* 2021-02-01: :class:`AzureFirewallFqdnTagsOperations<azure.mgmt.network.v2021_02_01.aio.operations.AzureFirewallFqdnTagsOperations>`
* 2021-05-01: :class:`AzureFirewallFqdnTagsOperations<azure.mgmt.network.v2021_05_01.aio.operations.AzureFirewallFqdnTagsOperations>`
"""
api_version = self._get_api_version('azure_firewall_fqdn_tags')
if api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import AzureFirewallFqdnTagsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import AzureFirewallFqdnTagsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import AzureFirewallFqdnTagsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import AzureFirewallFqdnTagsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import AzureFirewallFqdnTagsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import AzureFirewallFqdnTagsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import AzureFirewallFqdnTagsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import AzureFirewallFqdnTagsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import AzureFirewallFqdnTagsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import AzureFirewallFqdnTagsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import AzureFirewallFqdnTagsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import AzureFirewallFqdnTagsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import AzureFirewallFqdnTagsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import AzureFirewallFqdnTagsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import AzureFirewallFqdnTagsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import AzureFirewallFqdnTagsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import AzureFirewallFqdnTagsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import AzureFirewallFqdnTagsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import AzureFirewallFqdnTagsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import AzureFirewallFqdnTagsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import AzureFirewallFqdnTagsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'azure_firewall_fqdn_tags'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def azure_firewalls(self):
"""Instance depends on the API version:
* 2018-04-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2018_04_01.aio.operations.AzureFirewallsOperations>`
* 2018-06-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2018_06_01.aio.operations.AzureFirewallsOperations>`
* 2018-07-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2018_07_01.aio.operations.AzureFirewallsOperations>`
* 2018-08-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2018_08_01.aio.operations.AzureFirewallsOperations>`
* 2018-10-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2018_10_01.aio.operations.AzureFirewallsOperations>`
* 2018-11-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2018_11_01.aio.operations.AzureFirewallsOperations>`
* 2018-12-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2018_12_01.aio.operations.AzureFirewallsOperations>`
* 2019-02-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2019_02_01.aio.operations.AzureFirewallsOperations>`
* 2019-04-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2019_04_01.aio.operations.AzureFirewallsOperations>`
* 2019-06-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2019_06_01.aio.operations.AzureFirewallsOperations>`
* 2019-07-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2019_07_01.aio.operations.AzureFirewallsOperations>`
* 2019-08-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2019_08_01.aio.operations.AzureFirewallsOperations>`
* 2019-09-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2019_09_01.aio.operations.AzureFirewallsOperations>`
* 2019-11-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2019_11_01.aio.operations.AzureFirewallsOperations>`
* 2019-12-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2019_12_01.aio.operations.AzureFirewallsOperations>`
* 2020-03-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2020_03_01.aio.operations.AzureFirewallsOperations>`
* 2020-04-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2020_04_01.aio.operations.AzureFirewallsOperations>`
* 2020-05-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2020_05_01.aio.operations.AzureFirewallsOperations>`
* 2020-06-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2020_06_01.aio.operations.AzureFirewallsOperations>`
* 2020-07-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2020_07_01.aio.operations.AzureFirewallsOperations>`
* 2020-08-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2020_08_01.aio.operations.AzureFirewallsOperations>`
* 2020-11-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2020_11_01.aio.operations.AzureFirewallsOperations>`
* 2021-02-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2021_02_01.aio.operations.AzureFirewallsOperations>`
* 2021-05-01: :class:`AzureFirewallsOperations<azure.mgmt.network.v2021_05_01.aio.operations.AzureFirewallsOperations>`
"""
api_version = self._get_api_version('azure_firewalls')
if api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import AzureFirewallsOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import AzureFirewallsOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import AzureFirewallsOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import AzureFirewallsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import AzureFirewallsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import AzureFirewallsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import AzureFirewallsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import AzureFirewallsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import AzureFirewallsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import AzureFirewallsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import AzureFirewallsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import AzureFirewallsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import AzureFirewallsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import AzureFirewallsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import AzureFirewallsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import AzureFirewallsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import AzureFirewallsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import AzureFirewallsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import AzureFirewallsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import AzureFirewallsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import AzureFirewallsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import AzureFirewallsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import AzureFirewallsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import AzureFirewallsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'azure_firewalls'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def bastion_hosts(self):
"""Instance depends on the API version:
* 2019-04-01: :class:`BastionHostsOperations<azure.mgmt.network.v2019_04_01.aio.operations.BastionHostsOperations>`
* 2019-06-01: :class:`BastionHostsOperations<azure.mgmt.network.v2019_06_01.aio.operations.BastionHostsOperations>`
* 2019-07-01: :class:`BastionHostsOperations<azure.mgmt.network.v2019_07_01.aio.operations.BastionHostsOperations>`
* 2019-08-01: :class:`BastionHostsOperations<azure.mgmt.network.v2019_08_01.aio.operations.BastionHostsOperations>`
* 2019-09-01: :class:`BastionHostsOperations<azure.mgmt.network.v2019_09_01.aio.operations.BastionHostsOperations>`
* 2019-11-01: :class:`BastionHostsOperations<azure.mgmt.network.v2019_11_01.aio.operations.BastionHostsOperations>`
* 2019-12-01: :class:`BastionHostsOperations<azure.mgmt.network.v2019_12_01.aio.operations.BastionHostsOperations>`
* 2020-03-01: :class:`BastionHostsOperations<azure.mgmt.network.v2020_03_01.aio.operations.BastionHostsOperations>`
* 2020-04-01: :class:`BastionHostsOperations<azure.mgmt.network.v2020_04_01.aio.operations.BastionHostsOperations>`
* 2020-05-01: :class:`BastionHostsOperations<azure.mgmt.network.v2020_05_01.aio.operations.BastionHostsOperations>`
* 2020-06-01: :class:`BastionHostsOperations<azure.mgmt.network.v2020_06_01.aio.operations.BastionHostsOperations>`
* 2020-07-01: :class:`BastionHostsOperations<azure.mgmt.network.v2020_07_01.aio.operations.BastionHostsOperations>`
* 2020-08-01: :class:`BastionHostsOperations<azure.mgmt.network.v2020_08_01.aio.operations.BastionHostsOperations>`
* 2020-11-01: :class:`BastionHostsOperations<azure.mgmt.network.v2020_11_01.aio.operations.BastionHostsOperations>`
* 2021-02-01: :class:`BastionHostsOperations<azure.mgmt.network.v2021_02_01.aio.operations.BastionHostsOperations>`
* 2021-05-01: :class:`BastionHostsOperations<azure.mgmt.network.v2021_05_01.aio.operations.BastionHostsOperations>`
"""
api_version = self._get_api_version('bastion_hosts')
if api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import BastionHostsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import BastionHostsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import BastionHostsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import BastionHostsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import BastionHostsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import BastionHostsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import BastionHostsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import BastionHostsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import BastionHostsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import BastionHostsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import BastionHostsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import BastionHostsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import BastionHostsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import BastionHostsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import BastionHostsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import BastionHostsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'bastion_hosts'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def bgp_service_communities(self):
"""Instance depends on the API version:
* 2016-12-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2016_12_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2017-03-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2017_03_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2017-06-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2017_06_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2017-10-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2017_10_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2018-01-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2018_01_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2018-02-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2018_02_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2018-04-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2018_04_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2018-06-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2018_06_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2018-07-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2018_07_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2018-08-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2018_08_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2018-10-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2018_10_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2018-11-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2018_11_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2018-12-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2018_12_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2019-02-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2019_02_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2019-04-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2019_04_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2019-06-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2019_06_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2019-07-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2019_07_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2019-08-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2019_08_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2019-09-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2019_09_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2019-11-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2019_11_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2019-12-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2019_12_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2020-03-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2020_03_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2020-04-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2020_04_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2020-05-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2020_05_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2020-06-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2020_06_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2020-07-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2020_07_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2020-08-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2020_08_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2020-11-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2020_11_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2021-02-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2021_02_01.aio.operations.BgpServiceCommunitiesOperations>`
* 2021-05-01: :class:`BgpServiceCommunitiesOperations<azure.mgmt.network.v2021_05_01.aio.operations.BgpServiceCommunitiesOperations>`
"""
api_version = self._get_api_version('bgp_service_communities')
if api_version == '2016-12-01':
from ..v2016_12_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2017-03-01':
from ..v2017_03_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import BgpServiceCommunitiesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'bgp_service_communities'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def connection_monitors(self):
"""Instance depends on the API version:
* 2017-10-01: :class:`ConnectionMonitorsOperations<azure.mgmt.network.v2017_10_01.aio.operations.ConnectionMonitorsOperations>`
* 2018-01-01: :class:`ConnectionMonitorsOperations<azure.mgmt.network.v2018_01_01.aio.operations.ConnectionMonitorsOperations>`
* 2018-02-01: :class:`ConnectionMonitorsOperations<azure.mgmt.network.v2018_02_01.aio.operations.ConnectionMonitorsOperations>`
* 2018-04-01: :class:`ConnectionMonitorsOperations<azure.mgmt.network.v2018_04_01.aio.operations.ConnectionMonitorsOperations>`
* 2018-06-01: :class:`ConnectionMonitorsOperations<azure.mgmt.network.v2018_06_01.aio.operations.ConnectionMonitorsOperations>`
* 2018-07-01: :class:`ConnectionMonitorsOperations<azure.mgmt.network.v2018_07_01.aio.operations.ConnectionMonitorsOperations>`
* 2018-08-01: :class:`ConnectionMonitorsOperations<azure.mgmt.network.v2018_08_01.aio.operations.ConnectionMonitorsOperations>`
* 2018-10-01: :class:`ConnectionMonitorsOperations<azure.mgmt.network.v2018_10_01.aio.operations.ConnectionMonitorsOperations>`
* 2018-11-01: :class:`ConnectionMonitorsOperations<azure.mgmt.network.v2018_11_01.aio.operations.ConnectionMonitorsOperations>`
* 2018-12-01: :class:`ConnectionMonitorsOperations<azure.mgmt.network.v2018_12_01.aio.operations.ConnectionMonitorsOperations>`
* 2019-02-01: :class:`ConnectionMonitorsOperations<azure.mgmt.network.v2019_02_01.aio.operations.ConnectionMonitorsOperations>`
* 2019-04-01: :class:`ConnectionMonitorsOperations<azure.mgmt.network.v2019_04_01.aio.operations.ConnectionMonitorsOperations>`
* 2019-06-01: :class:`ConnectionMonitorsOperations<azure.mgmt.network.v2019_06_01.aio.operations.ConnectionMonitorsOperations>`
* 2019-07-01: :class:`ConnectionMonitorsOperations<azure.mgmt.network.v2019_07_01.aio.operations.ConnectionMonitorsOperations>`
* 2019-08-01: :class:`ConnectionMonitorsOperations<azure.mgmt.network.v2019_08_01.aio.operations.ConnectionMonitorsOperations>`
* 2019-09-01: :class:`ConnectionMonitorsOperations<azure.mgmt.network.v2019_09_01.aio.operations.ConnectionMonitorsOperations>`
* 2019-11-01: :class:`ConnectionMonitorsOperations<azure.mgmt.network.v2019_11_01.aio.operations.ConnectionMonitorsOperations>`
* 2019-12-01: :class:`ConnectionMonitorsOperations<azure.mgmt.network.v2019_12_01.aio.operations.ConnectionMonitorsOperations>`
* 2020-03-01: :class:`ConnectionMonitorsOperations<azure.mgmt.network.v2020_03_01.aio.operations.ConnectionMonitorsOperations>`
* 2020-04-01: :class:`ConnectionMonitorsOperations<azure.mgmt.network.v2020_04_01.aio.operations.ConnectionMonitorsOperations>`
* 2020-05-01: :class:`ConnectionMonitorsOperations<azure.mgmt.network.v2020_05_01.aio.operations.ConnectionMonitorsOperations>`
* 2020-06-01: :class:`ConnectionMonitorsOperations<azure.mgmt.network.v2020_06_01.aio.operations.ConnectionMonitorsOperations>`
* 2020-07-01: :class:`ConnectionMonitorsOperations<azure.mgmt.network.v2020_07_01.aio.operations.ConnectionMonitorsOperations>`
* 2020-08-01: :class:`ConnectionMonitorsOperations<azure.mgmt.network.v2020_08_01.aio.operations.ConnectionMonitorsOperations>`
* 2020-11-01: :class:`ConnectionMonitorsOperations<azure.mgmt.network.v2020_11_01.aio.operations.ConnectionMonitorsOperations>`
* 2021-02-01: :class:`ConnectionMonitorsOperations<azure.mgmt.network.v2021_02_01.aio.operations.ConnectionMonitorsOperations>`
* 2021-05-01: :class:`ConnectionMonitorsOperations<azure.mgmt.network.v2021_05_01.aio.operations.ConnectionMonitorsOperations>`
"""
api_version = self._get_api_version('connection_monitors')
if api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import ConnectionMonitorsOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import ConnectionMonitorsOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import ConnectionMonitorsOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import ConnectionMonitorsOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import ConnectionMonitorsOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import ConnectionMonitorsOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import ConnectionMonitorsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import ConnectionMonitorsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import ConnectionMonitorsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import ConnectionMonitorsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import ConnectionMonitorsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import ConnectionMonitorsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import ConnectionMonitorsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import ConnectionMonitorsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import ConnectionMonitorsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import ConnectionMonitorsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import ConnectionMonitorsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import ConnectionMonitorsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import ConnectionMonitorsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import ConnectionMonitorsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import ConnectionMonitorsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import ConnectionMonitorsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import ConnectionMonitorsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import ConnectionMonitorsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import ConnectionMonitorsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import ConnectionMonitorsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import ConnectionMonitorsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'connection_monitors'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def connectivity_configurations(self):
"""Instance depends on the API version:
* 2021-02-01-preview: :class:`ConnectivityConfigurationsOperations<azure.mgmt.network.v2021_02_01_preview.aio.operations.ConnectivityConfigurationsOperations>`
"""
api_version = self._get_api_version('connectivity_configurations')
if api_version == '2021-02-01-preview':
from ..v2021_02_01_preview.aio.operations import ConnectivityConfigurationsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'connectivity_configurations'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def custom_ip_prefixes(self):
"""Instance depends on the API version:
* 2020-06-01: :class:`CustomIPPrefixesOperations<azure.mgmt.network.v2020_06_01.aio.operations.CustomIPPrefixesOperations>`
* 2020-07-01: :class:`CustomIPPrefixesOperations<azure.mgmt.network.v2020_07_01.aio.operations.CustomIPPrefixesOperations>`
* 2020-08-01: :class:`CustomIPPrefixesOperations<azure.mgmt.network.v2020_08_01.aio.operations.CustomIPPrefixesOperations>`
* 2020-11-01: :class:`CustomIPPrefixesOperations<azure.mgmt.network.v2020_11_01.aio.operations.CustomIPPrefixesOperations>`
* 2021-02-01: :class:`CustomIPPrefixesOperations<azure.mgmt.network.v2021_02_01.aio.operations.CustomIPPrefixesOperations>`
* 2021-05-01: :class:`CustomIPPrefixesOperations<azure.mgmt.network.v2021_05_01.aio.operations.CustomIPPrefixesOperations>`
"""
api_version = self._get_api_version('custom_ip_prefixes')
if api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import CustomIPPrefixesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import CustomIPPrefixesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import CustomIPPrefixesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import CustomIPPrefixesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import CustomIPPrefixesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import CustomIPPrefixesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'custom_ip_prefixes'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def ddos_custom_policies(self):
"""Instance depends on the API version:
* 2018-11-01: :class:`DdosCustomPoliciesOperations<azure.mgmt.network.v2018_11_01.aio.operations.DdosCustomPoliciesOperations>`
* 2018-12-01: :class:`DdosCustomPoliciesOperations<azure.mgmt.network.v2018_12_01.aio.operations.DdosCustomPoliciesOperations>`
* 2019-02-01: :class:`DdosCustomPoliciesOperations<azure.mgmt.network.v2019_02_01.aio.operations.DdosCustomPoliciesOperations>`
* 2019-04-01: :class:`DdosCustomPoliciesOperations<azure.mgmt.network.v2019_04_01.aio.operations.DdosCustomPoliciesOperations>`
* 2019-06-01: :class:`DdosCustomPoliciesOperations<azure.mgmt.network.v2019_06_01.aio.operations.DdosCustomPoliciesOperations>`
* 2019-07-01: :class:`DdosCustomPoliciesOperations<azure.mgmt.network.v2019_07_01.aio.operations.DdosCustomPoliciesOperations>`
* 2019-08-01: :class:`DdosCustomPoliciesOperations<azure.mgmt.network.v2019_08_01.aio.operations.DdosCustomPoliciesOperations>`
* 2019-09-01: :class:`DdosCustomPoliciesOperations<azure.mgmt.network.v2019_09_01.aio.operations.DdosCustomPoliciesOperations>`
* 2019-11-01: :class:`DdosCustomPoliciesOperations<azure.mgmt.network.v2019_11_01.aio.operations.DdosCustomPoliciesOperations>`
* 2019-12-01: :class:`DdosCustomPoliciesOperations<azure.mgmt.network.v2019_12_01.aio.operations.DdosCustomPoliciesOperations>`
* 2020-03-01: :class:`DdosCustomPoliciesOperations<azure.mgmt.network.v2020_03_01.aio.operations.DdosCustomPoliciesOperations>`
* 2020-04-01: :class:`DdosCustomPoliciesOperations<azure.mgmt.network.v2020_04_01.aio.operations.DdosCustomPoliciesOperations>`
* 2020-05-01: :class:`DdosCustomPoliciesOperations<azure.mgmt.network.v2020_05_01.aio.operations.DdosCustomPoliciesOperations>`
* 2020-06-01: :class:`DdosCustomPoliciesOperations<azure.mgmt.network.v2020_06_01.aio.operations.DdosCustomPoliciesOperations>`
* 2020-07-01: :class:`DdosCustomPoliciesOperations<azure.mgmt.network.v2020_07_01.aio.operations.DdosCustomPoliciesOperations>`
* 2020-08-01: :class:`DdosCustomPoliciesOperations<azure.mgmt.network.v2020_08_01.aio.operations.DdosCustomPoliciesOperations>`
* 2020-11-01: :class:`DdosCustomPoliciesOperations<azure.mgmt.network.v2020_11_01.aio.operations.DdosCustomPoliciesOperations>`
* 2021-02-01: :class:`DdosCustomPoliciesOperations<azure.mgmt.network.v2021_02_01.aio.operations.DdosCustomPoliciesOperations>`
* 2021-05-01: :class:`DdosCustomPoliciesOperations<azure.mgmt.network.v2021_05_01.aio.operations.DdosCustomPoliciesOperations>`
"""
api_version = self._get_api_version('ddos_custom_policies')
if api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import DdosCustomPoliciesOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import DdosCustomPoliciesOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import DdosCustomPoliciesOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import DdosCustomPoliciesOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import DdosCustomPoliciesOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import DdosCustomPoliciesOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import DdosCustomPoliciesOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import DdosCustomPoliciesOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import DdosCustomPoliciesOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import DdosCustomPoliciesOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import DdosCustomPoliciesOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import DdosCustomPoliciesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import DdosCustomPoliciesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import DdosCustomPoliciesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import DdosCustomPoliciesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import DdosCustomPoliciesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import DdosCustomPoliciesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import DdosCustomPoliciesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import DdosCustomPoliciesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'ddos_custom_policies'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def ddos_protection_plans(self):
"""Instance depends on the API version:
* 2018-02-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2018_02_01.aio.operations.DdosProtectionPlansOperations>`
* 2018-04-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2018_04_01.aio.operations.DdosProtectionPlansOperations>`
* 2018-06-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2018_06_01.aio.operations.DdosProtectionPlansOperations>`
* 2018-07-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2018_07_01.aio.operations.DdosProtectionPlansOperations>`
* 2018-08-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2018_08_01.aio.operations.DdosProtectionPlansOperations>`
* 2018-10-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2018_10_01.aio.operations.DdosProtectionPlansOperations>`
* 2018-11-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2018_11_01.aio.operations.DdosProtectionPlansOperations>`
* 2018-12-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2018_12_01.aio.operations.DdosProtectionPlansOperations>`
* 2019-02-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2019_02_01.aio.operations.DdosProtectionPlansOperations>`
* 2019-04-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2019_04_01.aio.operations.DdosProtectionPlansOperations>`
* 2019-06-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2019_06_01.aio.operations.DdosProtectionPlansOperations>`
* 2019-07-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2019_07_01.aio.operations.DdosProtectionPlansOperations>`
* 2019-08-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2019_08_01.aio.operations.DdosProtectionPlansOperations>`
* 2019-09-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2019_09_01.aio.operations.DdosProtectionPlansOperations>`
* 2019-11-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2019_11_01.aio.operations.DdosProtectionPlansOperations>`
* 2019-12-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2019_12_01.aio.operations.DdosProtectionPlansOperations>`
* 2020-03-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2020_03_01.aio.operations.DdosProtectionPlansOperations>`
* 2020-04-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2020_04_01.aio.operations.DdosProtectionPlansOperations>`
* 2020-05-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2020_05_01.aio.operations.DdosProtectionPlansOperations>`
* 2020-06-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2020_06_01.aio.operations.DdosProtectionPlansOperations>`
* 2020-07-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2020_07_01.aio.operations.DdosProtectionPlansOperations>`
* 2020-08-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2020_08_01.aio.operations.DdosProtectionPlansOperations>`
* 2020-11-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2020_11_01.aio.operations.DdosProtectionPlansOperations>`
* 2021-02-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2021_02_01.aio.operations.DdosProtectionPlansOperations>`
* 2021-05-01: :class:`DdosProtectionPlansOperations<azure.mgmt.network.v2021_05_01.aio.operations.DdosProtectionPlansOperations>`
"""
api_version = self._get_api_version('ddos_protection_plans')
if api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import DdosProtectionPlansOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import DdosProtectionPlansOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import DdosProtectionPlansOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import DdosProtectionPlansOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import DdosProtectionPlansOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import DdosProtectionPlansOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import DdosProtectionPlansOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import DdosProtectionPlansOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import DdosProtectionPlansOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import DdosProtectionPlansOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import DdosProtectionPlansOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import DdosProtectionPlansOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import DdosProtectionPlansOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import DdosProtectionPlansOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import DdosProtectionPlansOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import DdosProtectionPlansOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import DdosProtectionPlansOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import DdosProtectionPlansOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import DdosProtectionPlansOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import DdosProtectionPlansOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import DdosProtectionPlansOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import DdosProtectionPlansOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import DdosProtectionPlansOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import DdosProtectionPlansOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import DdosProtectionPlansOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'ddos_protection_plans'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def default_security_rules(self):
"""Instance depends on the API version:
* 2017-06-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2017_06_01.aio.operations.DefaultSecurityRulesOperations>`
* 2017-10-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2017_10_01.aio.operations.DefaultSecurityRulesOperations>`
* 2018-01-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2018_01_01.aio.operations.DefaultSecurityRulesOperations>`
* 2018-02-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2018_02_01.aio.operations.DefaultSecurityRulesOperations>`
* 2018-04-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2018_04_01.aio.operations.DefaultSecurityRulesOperations>`
* 2018-06-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2018_06_01.aio.operations.DefaultSecurityRulesOperations>`
* 2018-07-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2018_07_01.aio.operations.DefaultSecurityRulesOperations>`
* 2018-08-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2018_08_01.aio.operations.DefaultSecurityRulesOperations>`
* 2018-10-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2018_10_01.aio.operations.DefaultSecurityRulesOperations>`
* 2018-11-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2018_11_01.aio.operations.DefaultSecurityRulesOperations>`
* 2018-12-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2018_12_01.aio.operations.DefaultSecurityRulesOperations>`
* 2019-02-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2019_02_01.aio.operations.DefaultSecurityRulesOperations>`
* 2019-04-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2019_04_01.aio.operations.DefaultSecurityRulesOperations>`
* 2019-06-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2019_06_01.aio.operations.DefaultSecurityRulesOperations>`
* 2019-07-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2019_07_01.aio.operations.DefaultSecurityRulesOperations>`
* 2019-08-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2019_08_01.aio.operations.DefaultSecurityRulesOperations>`
* 2019-09-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2019_09_01.aio.operations.DefaultSecurityRulesOperations>`
* 2019-11-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2019_11_01.aio.operations.DefaultSecurityRulesOperations>`
* 2019-12-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2019_12_01.aio.operations.DefaultSecurityRulesOperations>`
* 2020-03-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2020_03_01.aio.operations.DefaultSecurityRulesOperations>`
* 2020-04-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2020_04_01.aio.operations.DefaultSecurityRulesOperations>`
* 2020-05-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2020_05_01.aio.operations.DefaultSecurityRulesOperations>`
* 2020-06-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2020_06_01.aio.operations.DefaultSecurityRulesOperations>`
* 2020-07-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2020_07_01.aio.operations.DefaultSecurityRulesOperations>`
* 2020-08-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2020_08_01.aio.operations.DefaultSecurityRulesOperations>`
* 2020-11-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2020_11_01.aio.operations.DefaultSecurityRulesOperations>`
* 2021-02-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2021_02_01.aio.operations.DefaultSecurityRulesOperations>`
* 2021-05-01: :class:`DefaultSecurityRulesOperations<azure.mgmt.network.v2021_05_01.aio.operations.DefaultSecurityRulesOperations>`
"""
api_version = self._get_api_version('default_security_rules')
if api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import DefaultSecurityRulesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'default_security_rules'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def dscp_configuration(self):
"""Instance depends on the API version:
* 2020-06-01: :class:`DscpConfigurationOperations<azure.mgmt.network.v2020_06_01.aio.operations.DscpConfigurationOperations>`
* 2020-07-01: :class:`DscpConfigurationOperations<azure.mgmt.network.v2020_07_01.aio.operations.DscpConfigurationOperations>`
* 2020-08-01: :class:`DscpConfigurationOperations<azure.mgmt.network.v2020_08_01.aio.operations.DscpConfigurationOperations>`
* 2020-11-01: :class:`DscpConfigurationOperations<azure.mgmt.network.v2020_11_01.aio.operations.DscpConfigurationOperations>`
* 2021-02-01: :class:`DscpConfigurationOperations<azure.mgmt.network.v2021_02_01.aio.operations.DscpConfigurationOperations>`
* 2021-05-01: :class:`DscpConfigurationOperations<azure.mgmt.network.v2021_05_01.aio.operations.DscpConfigurationOperations>`
"""
api_version = self._get_api_version('dscp_configuration')
if api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import DscpConfigurationOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import DscpConfigurationOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import DscpConfigurationOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import DscpConfigurationOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import DscpConfigurationOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import DscpConfigurationOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'dscp_configuration'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def effective_connectivity_configurations(self):
"""Instance depends on the API version:
* 2021-02-01-preview: :class:`EffectiveConnectivityConfigurationsOperations<azure.mgmt.network.v2021_02_01_preview.aio.operations.EffectiveConnectivityConfigurationsOperations>`
"""
api_version = self._get_api_version('effective_connectivity_configurations')
if api_version == '2021-02-01-preview':
from ..v2021_02_01_preview.aio.operations import EffectiveConnectivityConfigurationsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'effective_connectivity_configurations'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def effective_virtual_networks(self):
"""Instance depends on the API version:
* 2021-02-01-preview: :class:`EffectiveVirtualNetworksOperations<azure.mgmt.network.v2021_02_01_preview.aio.operations.EffectiveVirtualNetworksOperations>`
"""
api_version = self._get_api_version('effective_virtual_networks')
if api_version == '2021-02-01-preview':
from ..v2021_02_01_preview.aio.operations import EffectiveVirtualNetworksOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'effective_virtual_networks'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def express_route_circuit_authorizations(self):
"""Instance depends on the API version:
* 2015-06-15: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2015_06_15.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2016-09-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2016_09_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2016-12-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2016_12_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2017-03-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2017_03_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2017-06-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2017_06_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2017-10-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2017_10_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2018-01-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2018_01_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2018-02-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2018_02_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2018-04-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2018_04_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2018-06-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2018_06_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2018-07-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2018_07_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2018-08-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2018_08_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2018-10-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2018_10_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2018-11-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2018_11_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2018-12-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2018_12_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2019-02-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2019_02_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2019-04-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2019_04_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2019-06-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2019_06_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2019-07-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2019_07_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2019-08-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2019_08_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2019-09-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2019_09_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2019-11-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2019_11_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2019-12-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2019_12_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2020-03-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2020_03_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2020-04-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2020_04_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2020-05-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2020_05_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2020-06-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2020_06_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2020-07-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2020_07_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2020-08-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2020_08_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2020-11-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2020_11_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2021-02-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2021_02_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
* 2021-05-01: :class:`ExpressRouteCircuitAuthorizationsOperations<azure.mgmt.network.v2021_05_01.aio.operations.ExpressRouteCircuitAuthorizationsOperations>`
"""
api_version = self._get_api_version('express_route_circuit_authorizations')
if api_version == '2015-06-15':
from ..v2015_06_15.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2016-09-01':
from ..v2016_09_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2016-12-01':
from ..v2016_12_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2017-03-01':
from ..v2017_03_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import ExpressRouteCircuitAuthorizationsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'express_route_circuit_authorizations'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def express_route_circuit_connections(self):
"""Instance depends on the API version:
* 2018-02-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2018_02_01.aio.operations.ExpressRouteCircuitConnectionsOperations>`
* 2018-04-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2018_04_01.aio.operations.ExpressRouteCircuitConnectionsOperations>`
* 2018-06-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2018_06_01.aio.operations.ExpressRouteCircuitConnectionsOperations>`
* 2018-07-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2018_07_01.aio.operations.ExpressRouteCircuitConnectionsOperations>`
* 2018-08-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2018_08_01.aio.operations.ExpressRouteCircuitConnectionsOperations>`
* 2018-10-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2018_10_01.aio.operations.ExpressRouteCircuitConnectionsOperations>`
* 2018-11-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2018_11_01.aio.operations.ExpressRouteCircuitConnectionsOperations>`
* 2018-12-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2018_12_01.aio.operations.ExpressRouteCircuitConnectionsOperations>`
* 2019-02-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2019_02_01.aio.operations.ExpressRouteCircuitConnectionsOperations>`
* 2019-04-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2019_04_01.aio.operations.ExpressRouteCircuitConnectionsOperations>`
* 2019-06-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2019_06_01.aio.operations.ExpressRouteCircuitConnectionsOperations>`
* 2019-07-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2019_07_01.aio.operations.ExpressRouteCircuitConnectionsOperations>`
* 2019-08-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2019_08_01.aio.operations.ExpressRouteCircuitConnectionsOperations>`
* 2019-09-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2019_09_01.aio.operations.ExpressRouteCircuitConnectionsOperations>`
* 2019-11-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2019_11_01.aio.operations.ExpressRouteCircuitConnectionsOperations>`
* 2019-12-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2019_12_01.aio.operations.ExpressRouteCircuitConnectionsOperations>`
* 2020-03-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2020_03_01.aio.operations.ExpressRouteCircuitConnectionsOperations>`
* 2020-04-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2020_04_01.aio.operations.ExpressRouteCircuitConnectionsOperations>`
* 2020-05-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2020_05_01.aio.operations.ExpressRouteCircuitConnectionsOperations>`
* 2020-06-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2020_06_01.aio.operations.ExpressRouteCircuitConnectionsOperations>`
* 2020-07-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2020_07_01.aio.operations.ExpressRouteCircuitConnectionsOperations>`
* 2020-08-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2020_08_01.aio.operations.ExpressRouteCircuitConnectionsOperations>`
* 2020-11-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2020_11_01.aio.operations.ExpressRouteCircuitConnectionsOperations>`
* 2021-02-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2021_02_01.aio.operations.ExpressRouteCircuitConnectionsOperations>`
* 2021-05-01: :class:`ExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2021_05_01.aio.operations.ExpressRouteCircuitConnectionsOperations>`
"""
api_version = self._get_api_version('express_route_circuit_connections')
if api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import ExpressRouteCircuitConnectionsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'express_route_circuit_connections'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def express_route_circuit_peerings(self):
"""Instance depends on the API version:
* 2015-06-15: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2015_06_15.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2016-09-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2016_09_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2016-12-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2016_12_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2017-03-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2017_03_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2017-06-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2017_06_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2017-10-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2017_10_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2018-01-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2018_01_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2018-02-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2018_02_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2018-04-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2018_04_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2018-06-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2018_06_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2018-07-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2018_07_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2018-08-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2018_08_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2018-10-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2018_10_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2018-11-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2018_11_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2018-12-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2018_12_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2019-02-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2019_02_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2019-04-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2019_04_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2019-06-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2019_06_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2019-07-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2019_07_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2019-08-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2019_08_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2019-09-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2019_09_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2019-11-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2019_11_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2019-12-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2019_12_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2020-03-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2020_03_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2020-04-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2020_04_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2020-05-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2020_05_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2020-06-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2020_06_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2020-07-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2020_07_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2020-08-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2020_08_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2020-11-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2020_11_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2021-02-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2021_02_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
* 2021-05-01: :class:`ExpressRouteCircuitPeeringsOperations<azure.mgmt.network.v2021_05_01.aio.operations.ExpressRouteCircuitPeeringsOperations>`
"""
api_version = self._get_api_version('express_route_circuit_peerings')
if api_version == '2015-06-15':
from ..v2015_06_15.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2016-09-01':
from ..v2016_09_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2016-12-01':
from ..v2016_12_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2017-03-01':
from ..v2017_03_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import ExpressRouteCircuitPeeringsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'express_route_circuit_peerings'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def express_route_circuits(self):
"""Instance depends on the API version:
* 2015-06-15: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2015_06_15.aio.operations.ExpressRouteCircuitsOperations>`
* 2016-09-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2016_09_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2016-12-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2016_12_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2017-03-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2017_03_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2017-06-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2017_06_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2017-10-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2017_10_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2018-01-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2018_01_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2018-02-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2018_02_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2018-04-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2018_04_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2018-06-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2018_06_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2018-07-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2018_07_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2018-08-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2018_08_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2018-10-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2018_10_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2018-11-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2018_11_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2018-12-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2018_12_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2019-02-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2019_02_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2019-04-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2019_04_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2019-06-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2019_06_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2019-07-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2019_07_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2019-08-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2019_08_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2019-09-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2019_09_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2019-11-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2019_11_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2019-12-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2019_12_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2020-03-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2020_03_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2020-04-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2020_04_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2020-05-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2020_05_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2020-06-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2020_06_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2020-07-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2020_07_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2020-08-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2020_08_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2020-11-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2020_11_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2021-02-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2021_02_01.aio.operations.ExpressRouteCircuitsOperations>`
* 2021-05-01: :class:`ExpressRouteCircuitsOperations<azure.mgmt.network.v2021_05_01.aio.operations.ExpressRouteCircuitsOperations>`
"""
api_version = self._get_api_version('express_route_circuits')
if api_version == '2015-06-15':
from ..v2015_06_15.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2016-09-01':
from ..v2016_09_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2016-12-01':
from ..v2016_12_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2017-03-01':
from ..v2017_03_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import ExpressRouteCircuitsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'express_route_circuits'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def express_route_connections(self):
"""Instance depends on the API version:
* 2018-08-01: :class:`ExpressRouteConnectionsOperations<azure.mgmt.network.v2018_08_01.aio.operations.ExpressRouteConnectionsOperations>`
* 2018-10-01: :class:`ExpressRouteConnectionsOperations<azure.mgmt.network.v2018_10_01.aio.operations.ExpressRouteConnectionsOperations>`
* 2018-11-01: :class:`ExpressRouteConnectionsOperations<azure.mgmt.network.v2018_11_01.aio.operations.ExpressRouteConnectionsOperations>`
* 2018-12-01: :class:`ExpressRouteConnectionsOperations<azure.mgmt.network.v2018_12_01.aio.operations.ExpressRouteConnectionsOperations>`
* 2019-02-01: :class:`ExpressRouteConnectionsOperations<azure.mgmt.network.v2019_02_01.aio.operations.ExpressRouteConnectionsOperations>`
* 2019-04-01: :class:`ExpressRouteConnectionsOperations<azure.mgmt.network.v2019_04_01.aio.operations.ExpressRouteConnectionsOperations>`
* 2019-06-01: :class:`ExpressRouteConnectionsOperations<azure.mgmt.network.v2019_06_01.aio.operations.ExpressRouteConnectionsOperations>`
* 2019-07-01: :class:`ExpressRouteConnectionsOperations<azure.mgmt.network.v2019_07_01.aio.operations.ExpressRouteConnectionsOperations>`
* 2019-08-01: :class:`ExpressRouteConnectionsOperations<azure.mgmt.network.v2019_08_01.aio.operations.ExpressRouteConnectionsOperations>`
* 2019-09-01: :class:`ExpressRouteConnectionsOperations<azure.mgmt.network.v2019_09_01.aio.operations.ExpressRouteConnectionsOperations>`
* 2019-11-01: :class:`ExpressRouteConnectionsOperations<azure.mgmt.network.v2019_11_01.aio.operations.ExpressRouteConnectionsOperations>`
* 2019-12-01: :class:`ExpressRouteConnectionsOperations<azure.mgmt.network.v2019_12_01.aio.operations.ExpressRouteConnectionsOperations>`
* 2020-03-01: :class:`ExpressRouteConnectionsOperations<azure.mgmt.network.v2020_03_01.aio.operations.ExpressRouteConnectionsOperations>`
* 2020-04-01: :class:`ExpressRouteConnectionsOperations<azure.mgmt.network.v2020_04_01.aio.operations.ExpressRouteConnectionsOperations>`
* 2020-05-01: :class:`ExpressRouteConnectionsOperations<azure.mgmt.network.v2020_05_01.aio.operations.ExpressRouteConnectionsOperations>`
* 2020-06-01: :class:`ExpressRouteConnectionsOperations<azure.mgmt.network.v2020_06_01.aio.operations.ExpressRouteConnectionsOperations>`
* 2020-07-01: :class:`ExpressRouteConnectionsOperations<azure.mgmt.network.v2020_07_01.aio.operations.ExpressRouteConnectionsOperations>`
* 2020-08-01: :class:`ExpressRouteConnectionsOperations<azure.mgmt.network.v2020_08_01.aio.operations.ExpressRouteConnectionsOperations>`
* 2020-11-01: :class:`ExpressRouteConnectionsOperations<azure.mgmt.network.v2020_11_01.aio.operations.ExpressRouteConnectionsOperations>`
* 2021-02-01: :class:`ExpressRouteConnectionsOperations<azure.mgmt.network.v2021_02_01.aio.operations.ExpressRouteConnectionsOperations>`
* 2021-05-01: :class:`ExpressRouteConnectionsOperations<azure.mgmt.network.v2021_05_01.aio.operations.ExpressRouteConnectionsOperations>`
"""
api_version = self._get_api_version('express_route_connections')
if api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import ExpressRouteConnectionsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import ExpressRouteConnectionsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import ExpressRouteConnectionsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import ExpressRouteConnectionsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import ExpressRouteConnectionsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import ExpressRouteConnectionsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import ExpressRouteConnectionsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import ExpressRouteConnectionsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import ExpressRouteConnectionsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import ExpressRouteConnectionsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import ExpressRouteConnectionsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import ExpressRouteConnectionsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import ExpressRouteConnectionsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import ExpressRouteConnectionsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import ExpressRouteConnectionsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import ExpressRouteConnectionsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import ExpressRouteConnectionsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import ExpressRouteConnectionsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import ExpressRouteConnectionsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import ExpressRouteConnectionsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import ExpressRouteConnectionsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'express_route_connections'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def express_route_cross_connection_peerings(self):
"""Instance depends on the API version:
* 2018-02-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2018_02_01.aio.operations.ExpressRouteCrossConnectionPeeringsOperations>`
* 2018-04-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2018_04_01.aio.operations.ExpressRouteCrossConnectionPeeringsOperations>`
* 2018-06-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2018_06_01.aio.operations.ExpressRouteCrossConnectionPeeringsOperations>`
* 2018-07-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2018_07_01.aio.operations.ExpressRouteCrossConnectionPeeringsOperations>`
* 2018-08-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2018_08_01.aio.operations.ExpressRouteCrossConnectionPeeringsOperations>`
* 2018-10-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2018_10_01.aio.operations.ExpressRouteCrossConnectionPeeringsOperations>`
* 2018-11-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2018_11_01.aio.operations.ExpressRouteCrossConnectionPeeringsOperations>`
* 2018-12-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2018_12_01.aio.operations.ExpressRouteCrossConnectionPeeringsOperations>`
* 2019-02-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2019_02_01.aio.operations.ExpressRouteCrossConnectionPeeringsOperations>`
* 2019-04-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2019_04_01.aio.operations.ExpressRouteCrossConnectionPeeringsOperations>`
* 2019-06-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2019_06_01.aio.operations.ExpressRouteCrossConnectionPeeringsOperations>`
* 2019-07-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2019_07_01.aio.operations.ExpressRouteCrossConnectionPeeringsOperations>`
* 2019-08-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2019_08_01.aio.operations.ExpressRouteCrossConnectionPeeringsOperations>`
* 2019-09-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2019_09_01.aio.operations.ExpressRouteCrossConnectionPeeringsOperations>`
* 2019-11-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2019_11_01.aio.operations.ExpressRouteCrossConnectionPeeringsOperations>`
* 2019-12-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2019_12_01.aio.operations.ExpressRouteCrossConnectionPeeringsOperations>`
* 2020-03-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2020_03_01.aio.operations.ExpressRouteCrossConnectionPeeringsOperations>`
* 2020-04-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2020_04_01.aio.operations.ExpressRouteCrossConnectionPeeringsOperations>`
* 2020-05-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2020_05_01.aio.operations.ExpressRouteCrossConnectionPeeringsOperations>`
* 2020-06-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2020_06_01.aio.operations.ExpressRouteCrossConnectionPeeringsOperations>`
* 2020-07-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2020_07_01.aio.operations.ExpressRouteCrossConnectionPeeringsOperations>`
* 2020-08-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2020_08_01.aio.operations.ExpressRouteCrossConnectionPeeringsOperations>`
* 2020-11-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2020_11_01.aio.operations.ExpressRouteCrossConnectionPeeringsOperations>`
* 2021-02-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2021_02_01.aio.operations.ExpressRouteCrossConnectionPeeringsOperations>`
* 2021-05-01: :class:`ExpressRouteCrossConnectionPeeringsOperations<azure.mgmt.network.v2021_05_01.aio.operations.ExpressRouteCrossConnectionPeeringsOperations>`
"""
api_version = self._get_api_version('express_route_cross_connection_peerings')
if api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import ExpressRouteCrossConnectionPeeringsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'express_route_cross_connection_peerings'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def express_route_cross_connections(self):
"""Instance depends on the API version:
* 2018-02-01: :class:`ExpressRouteCrossConnectionsOperations<azure.mgmt.network.v2018_02_01.aio.operations.ExpressRouteCrossConnectionsOperations>`
* 2018-04-01: :class:`ExpressRouteCrossConnectionsOperations<azure.mgmt.network.v2018_04_01.aio.operations.ExpressRouteCrossConnectionsOperations>`
* 2018-06-01: :class:`ExpressRouteCrossConnectionsOperations<azure.mgmt.network.v2018_06_01.aio.operations.ExpressRouteCrossConnectionsOperations>`
* 2018-07-01: :class:`ExpressRouteCrossConnectionsOperations<azure.mgmt.network.v2018_07_01.aio.operations.ExpressRouteCrossConnectionsOperations>`
* 2018-08-01: :class:`ExpressRouteCrossConnectionsOperations<azure.mgmt.network.v2018_08_01.aio.operations.ExpressRouteCrossConnectionsOperations>`
* 2018-10-01: :class:`ExpressRouteCrossConnectionsOperations<azure.mgmt.network.v2018_10_01.aio.operations.ExpressRouteCrossConnectionsOperations>`
* 2018-11-01: :class:`ExpressRouteCrossConnectionsOperations<azure.mgmt.network.v2018_11_01.aio.operations.ExpressRouteCrossConnectionsOperations>`
* 2018-12-01: :class:`ExpressRouteCrossConnectionsOperations<azure.mgmt.network.v2018_12_01.aio.operations.ExpressRouteCrossConnectionsOperations>`
* 2019-02-01: :class:`ExpressRouteCrossConnectionsOperations<azure.mgmt.network.v2019_02_01.aio.operations.ExpressRouteCrossConnectionsOperations>`
* 2019-04-01: :class:`ExpressRouteCrossConnectionsOperations<azure.mgmt.network.v2019_04_01.aio.operations.ExpressRouteCrossConnectionsOperations>`
* 2019-06-01: :class:`ExpressRouteCrossConnectionsOperations<azure.mgmt.network.v2019_06_01.aio.operations.ExpressRouteCrossConnectionsOperations>`
* 2019-07-01: :class:`ExpressRouteCrossConnectionsOperations<azure.mgmt.network.v2019_07_01.aio.operations.ExpressRouteCrossConnectionsOperations>`
* 2019-08-01: :class:`ExpressRouteCrossConnectionsOperations<azure.mgmt.network.v2019_08_01.aio.operations.ExpressRouteCrossConnectionsOperations>`
* 2019-09-01: :class:`ExpressRouteCrossConnectionsOperations<azure.mgmt.network.v2019_09_01.aio.operations.ExpressRouteCrossConnectionsOperations>`
* 2019-11-01: :class:`ExpressRouteCrossConnectionsOperations<azure.mgmt.network.v2019_11_01.aio.operations.ExpressRouteCrossConnectionsOperations>`
* 2019-12-01: :class:`ExpressRouteCrossConnectionsOperations<azure.mgmt.network.v2019_12_01.aio.operations.ExpressRouteCrossConnectionsOperations>`
* 2020-03-01: :class:`ExpressRouteCrossConnectionsOperations<azure.mgmt.network.v2020_03_01.aio.operations.ExpressRouteCrossConnectionsOperations>`
* 2020-04-01: :class:`ExpressRouteCrossConnectionsOperations<azure.mgmt.network.v2020_04_01.aio.operations.ExpressRouteCrossConnectionsOperations>`
* 2020-05-01: :class:`ExpressRouteCrossConnectionsOperations<azure.mgmt.network.v2020_05_01.aio.operations.ExpressRouteCrossConnectionsOperations>`
* 2020-06-01: :class:`ExpressRouteCrossConnectionsOperations<azure.mgmt.network.v2020_06_01.aio.operations.ExpressRouteCrossConnectionsOperations>`
* 2020-07-01: :class:`ExpressRouteCrossConnectionsOperations<azure.mgmt.network.v2020_07_01.aio.operations.ExpressRouteCrossConnectionsOperations>`
* 2020-08-01: :class:`ExpressRouteCrossConnectionsOperations<azure.mgmt.network.v2020_08_01.aio.operations.ExpressRouteCrossConnectionsOperations>`
* 2020-11-01: :class:`ExpressRouteCrossConnectionsOperations<azure.mgmt.network.v2020_11_01.aio.operations.ExpressRouteCrossConnectionsOperations>`
* 2021-02-01: :class:`ExpressRouteCrossConnectionsOperations<azure.mgmt.network.v2021_02_01.aio.operations.ExpressRouteCrossConnectionsOperations>`
* 2021-05-01: :class:`ExpressRouteCrossConnectionsOperations<azure.mgmt.network.v2021_05_01.aio.operations.ExpressRouteCrossConnectionsOperations>`
"""
api_version = self._get_api_version('express_route_cross_connections')
if api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import ExpressRouteCrossConnectionsOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import ExpressRouteCrossConnectionsOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import ExpressRouteCrossConnectionsOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import ExpressRouteCrossConnectionsOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import ExpressRouteCrossConnectionsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import ExpressRouteCrossConnectionsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import ExpressRouteCrossConnectionsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import ExpressRouteCrossConnectionsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import ExpressRouteCrossConnectionsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import ExpressRouteCrossConnectionsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import ExpressRouteCrossConnectionsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import ExpressRouteCrossConnectionsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import ExpressRouteCrossConnectionsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import ExpressRouteCrossConnectionsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import ExpressRouteCrossConnectionsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import ExpressRouteCrossConnectionsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import ExpressRouteCrossConnectionsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import ExpressRouteCrossConnectionsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import ExpressRouteCrossConnectionsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import ExpressRouteCrossConnectionsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import ExpressRouteCrossConnectionsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import ExpressRouteCrossConnectionsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import ExpressRouteCrossConnectionsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import ExpressRouteCrossConnectionsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import ExpressRouteCrossConnectionsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'express_route_cross_connections'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def express_route_gateways(self):
"""Instance depends on the API version:
* 2018-08-01: :class:`ExpressRouteGatewaysOperations<azure.mgmt.network.v2018_08_01.aio.operations.ExpressRouteGatewaysOperations>`
* 2018-10-01: :class:`ExpressRouteGatewaysOperations<azure.mgmt.network.v2018_10_01.aio.operations.ExpressRouteGatewaysOperations>`
* 2018-11-01: :class:`ExpressRouteGatewaysOperations<azure.mgmt.network.v2018_11_01.aio.operations.ExpressRouteGatewaysOperations>`
* 2018-12-01: :class:`ExpressRouteGatewaysOperations<azure.mgmt.network.v2018_12_01.aio.operations.ExpressRouteGatewaysOperations>`
* 2019-02-01: :class:`ExpressRouteGatewaysOperations<azure.mgmt.network.v2019_02_01.aio.operations.ExpressRouteGatewaysOperations>`
* 2019-04-01: :class:`ExpressRouteGatewaysOperations<azure.mgmt.network.v2019_04_01.aio.operations.ExpressRouteGatewaysOperations>`
* 2019-06-01: :class:`ExpressRouteGatewaysOperations<azure.mgmt.network.v2019_06_01.aio.operations.ExpressRouteGatewaysOperations>`
* 2019-07-01: :class:`ExpressRouteGatewaysOperations<azure.mgmt.network.v2019_07_01.aio.operations.ExpressRouteGatewaysOperations>`
* 2019-08-01: :class:`ExpressRouteGatewaysOperations<azure.mgmt.network.v2019_08_01.aio.operations.ExpressRouteGatewaysOperations>`
* 2019-09-01: :class:`ExpressRouteGatewaysOperations<azure.mgmt.network.v2019_09_01.aio.operations.ExpressRouteGatewaysOperations>`
* 2019-11-01: :class:`ExpressRouteGatewaysOperations<azure.mgmt.network.v2019_11_01.aio.operations.ExpressRouteGatewaysOperations>`
* 2019-12-01: :class:`ExpressRouteGatewaysOperations<azure.mgmt.network.v2019_12_01.aio.operations.ExpressRouteGatewaysOperations>`
* 2020-03-01: :class:`ExpressRouteGatewaysOperations<azure.mgmt.network.v2020_03_01.aio.operations.ExpressRouteGatewaysOperations>`
* 2020-04-01: :class:`ExpressRouteGatewaysOperations<azure.mgmt.network.v2020_04_01.aio.operations.ExpressRouteGatewaysOperations>`
* 2020-05-01: :class:`ExpressRouteGatewaysOperations<azure.mgmt.network.v2020_05_01.aio.operations.ExpressRouteGatewaysOperations>`
* 2020-06-01: :class:`ExpressRouteGatewaysOperations<azure.mgmt.network.v2020_06_01.aio.operations.ExpressRouteGatewaysOperations>`
* 2020-07-01: :class:`ExpressRouteGatewaysOperations<azure.mgmt.network.v2020_07_01.aio.operations.ExpressRouteGatewaysOperations>`
* 2020-08-01: :class:`ExpressRouteGatewaysOperations<azure.mgmt.network.v2020_08_01.aio.operations.ExpressRouteGatewaysOperations>`
* 2020-11-01: :class:`ExpressRouteGatewaysOperations<azure.mgmt.network.v2020_11_01.aio.operations.ExpressRouteGatewaysOperations>`
* 2021-02-01: :class:`ExpressRouteGatewaysOperations<azure.mgmt.network.v2021_02_01.aio.operations.ExpressRouteGatewaysOperations>`
* 2021-05-01: :class:`ExpressRouteGatewaysOperations<azure.mgmt.network.v2021_05_01.aio.operations.ExpressRouteGatewaysOperations>`
"""
api_version = self._get_api_version('express_route_gateways')
if api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import ExpressRouteGatewaysOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import ExpressRouteGatewaysOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import ExpressRouteGatewaysOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import ExpressRouteGatewaysOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import ExpressRouteGatewaysOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import ExpressRouteGatewaysOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import ExpressRouteGatewaysOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import ExpressRouteGatewaysOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import ExpressRouteGatewaysOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import ExpressRouteGatewaysOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import ExpressRouteGatewaysOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import ExpressRouteGatewaysOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import ExpressRouteGatewaysOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import ExpressRouteGatewaysOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import ExpressRouteGatewaysOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import ExpressRouteGatewaysOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import ExpressRouteGatewaysOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import ExpressRouteGatewaysOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import ExpressRouteGatewaysOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import ExpressRouteGatewaysOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import ExpressRouteGatewaysOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'express_route_gateways'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def express_route_links(self):
"""Instance depends on the API version:
* 2018-08-01: :class:`ExpressRouteLinksOperations<azure.mgmt.network.v2018_08_01.aio.operations.ExpressRouteLinksOperations>`
* 2018-10-01: :class:`ExpressRouteLinksOperations<azure.mgmt.network.v2018_10_01.aio.operations.ExpressRouteLinksOperations>`
* 2018-11-01: :class:`ExpressRouteLinksOperations<azure.mgmt.network.v2018_11_01.aio.operations.ExpressRouteLinksOperations>`
* 2018-12-01: :class:`ExpressRouteLinksOperations<azure.mgmt.network.v2018_12_01.aio.operations.ExpressRouteLinksOperations>`
* 2019-02-01: :class:`ExpressRouteLinksOperations<azure.mgmt.network.v2019_02_01.aio.operations.ExpressRouteLinksOperations>`
* 2019-04-01: :class:`ExpressRouteLinksOperations<azure.mgmt.network.v2019_04_01.aio.operations.ExpressRouteLinksOperations>`
* 2019-06-01: :class:`ExpressRouteLinksOperations<azure.mgmt.network.v2019_06_01.aio.operations.ExpressRouteLinksOperations>`
* 2019-07-01: :class:`ExpressRouteLinksOperations<azure.mgmt.network.v2019_07_01.aio.operations.ExpressRouteLinksOperations>`
* 2019-08-01: :class:`ExpressRouteLinksOperations<azure.mgmt.network.v2019_08_01.aio.operations.ExpressRouteLinksOperations>`
* 2019-09-01: :class:`ExpressRouteLinksOperations<azure.mgmt.network.v2019_09_01.aio.operations.ExpressRouteLinksOperations>`
* 2019-11-01: :class:`ExpressRouteLinksOperations<azure.mgmt.network.v2019_11_01.aio.operations.ExpressRouteLinksOperations>`
* 2019-12-01: :class:`ExpressRouteLinksOperations<azure.mgmt.network.v2019_12_01.aio.operations.ExpressRouteLinksOperations>`
* 2020-03-01: :class:`ExpressRouteLinksOperations<azure.mgmt.network.v2020_03_01.aio.operations.ExpressRouteLinksOperations>`
* 2020-04-01: :class:`ExpressRouteLinksOperations<azure.mgmt.network.v2020_04_01.aio.operations.ExpressRouteLinksOperations>`
* 2020-05-01: :class:`ExpressRouteLinksOperations<azure.mgmt.network.v2020_05_01.aio.operations.ExpressRouteLinksOperations>`
* 2020-06-01: :class:`ExpressRouteLinksOperations<azure.mgmt.network.v2020_06_01.aio.operations.ExpressRouteLinksOperations>`
* 2020-07-01: :class:`ExpressRouteLinksOperations<azure.mgmt.network.v2020_07_01.aio.operations.ExpressRouteLinksOperations>`
* 2020-08-01: :class:`ExpressRouteLinksOperations<azure.mgmt.network.v2020_08_01.aio.operations.ExpressRouteLinksOperations>`
* 2020-11-01: :class:`ExpressRouteLinksOperations<azure.mgmt.network.v2020_11_01.aio.operations.ExpressRouteLinksOperations>`
* 2021-02-01: :class:`ExpressRouteLinksOperations<azure.mgmt.network.v2021_02_01.aio.operations.ExpressRouteLinksOperations>`
* 2021-05-01: :class:`ExpressRouteLinksOperations<azure.mgmt.network.v2021_05_01.aio.operations.ExpressRouteLinksOperations>`
"""
api_version = self._get_api_version('express_route_links')
if api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import ExpressRouteLinksOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import ExpressRouteLinksOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import ExpressRouteLinksOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import ExpressRouteLinksOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import ExpressRouteLinksOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import ExpressRouteLinksOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import ExpressRouteLinksOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import ExpressRouteLinksOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import ExpressRouteLinksOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import ExpressRouteLinksOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import ExpressRouteLinksOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import ExpressRouteLinksOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import ExpressRouteLinksOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import ExpressRouteLinksOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import ExpressRouteLinksOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import ExpressRouteLinksOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import ExpressRouteLinksOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import ExpressRouteLinksOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import ExpressRouteLinksOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import ExpressRouteLinksOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import ExpressRouteLinksOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'express_route_links'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def express_route_ports(self):
"""Instance depends on the API version:
* 2018-08-01: :class:`ExpressRoutePortsOperations<azure.mgmt.network.v2018_08_01.aio.operations.ExpressRoutePortsOperations>`
* 2018-10-01: :class:`ExpressRoutePortsOperations<azure.mgmt.network.v2018_10_01.aio.operations.ExpressRoutePortsOperations>`
* 2018-11-01: :class:`ExpressRoutePortsOperations<azure.mgmt.network.v2018_11_01.aio.operations.ExpressRoutePortsOperations>`
* 2018-12-01: :class:`ExpressRoutePortsOperations<azure.mgmt.network.v2018_12_01.aio.operations.ExpressRoutePortsOperations>`
* 2019-02-01: :class:`ExpressRoutePortsOperations<azure.mgmt.network.v2019_02_01.aio.operations.ExpressRoutePortsOperations>`
* 2019-04-01: :class:`ExpressRoutePortsOperations<azure.mgmt.network.v2019_04_01.aio.operations.ExpressRoutePortsOperations>`
* 2019-06-01: :class:`ExpressRoutePortsOperations<azure.mgmt.network.v2019_06_01.aio.operations.ExpressRoutePortsOperations>`
* 2019-07-01: :class:`ExpressRoutePortsOperations<azure.mgmt.network.v2019_07_01.aio.operations.ExpressRoutePortsOperations>`
* 2019-08-01: :class:`ExpressRoutePortsOperations<azure.mgmt.network.v2019_08_01.aio.operations.ExpressRoutePortsOperations>`
* 2019-09-01: :class:`ExpressRoutePortsOperations<azure.mgmt.network.v2019_09_01.aio.operations.ExpressRoutePortsOperations>`
* 2019-11-01: :class:`ExpressRoutePortsOperations<azure.mgmt.network.v2019_11_01.aio.operations.ExpressRoutePortsOperations>`
* 2019-12-01: :class:`ExpressRoutePortsOperations<azure.mgmt.network.v2019_12_01.aio.operations.ExpressRoutePortsOperations>`
* 2020-03-01: :class:`ExpressRoutePortsOperations<azure.mgmt.network.v2020_03_01.aio.operations.ExpressRoutePortsOperations>`
* 2020-04-01: :class:`ExpressRoutePortsOperations<azure.mgmt.network.v2020_04_01.aio.operations.ExpressRoutePortsOperations>`
* 2020-05-01: :class:`ExpressRoutePortsOperations<azure.mgmt.network.v2020_05_01.aio.operations.ExpressRoutePortsOperations>`
* 2020-06-01: :class:`ExpressRoutePortsOperations<azure.mgmt.network.v2020_06_01.aio.operations.ExpressRoutePortsOperations>`
* 2020-07-01: :class:`ExpressRoutePortsOperations<azure.mgmt.network.v2020_07_01.aio.operations.ExpressRoutePortsOperations>`
* 2020-08-01: :class:`ExpressRoutePortsOperations<azure.mgmt.network.v2020_08_01.aio.operations.ExpressRoutePortsOperations>`
* 2020-11-01: :class:`ExpressRoutePortsOperations<azure.mgmt.network.v2020_11_01.aio.operations.ExpressRoutePortsOperations>`
* 2021-02-01: :class:`ExpressRoutePortsOperations<azure.mgmt.network.v2021_02_01.aio.operations.ExpressRoutePortsOperations>`
* 2021-05-01: :class:`ExpressRoutePortsOperations<azure.mgmt.network.v2021_05_01.aio.operations.ExpressRoutePortsOperations>`
"""
api_version = self._get_api_version('express_route_ports')
if api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import ExpressRoutePortsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import ExpressRoutePortsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import ExpressRoutePortsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import ExpressRoutePortsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import ExpressRoutePortsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import ExpressRoutePortsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import ExpressRoutePortsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import ExpressRoutePortsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import ExpressRoutePortsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import ExpressRoutePortsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import ExpressRoutePortsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import ExpressRoutePortsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import ExpressRoutePortsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import ExpressRoutePortsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import ExpressRoutePortsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import ExpressRoutePortsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import ExpressRoutePortsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import ExpressRoutePortsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import ExpressRoutePortsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import ExpressRoutePortsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import ExpressRoutePortsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'express_route_ports'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def express_route_ports_locations(self):
"""Instance depends on the API version:
* 2018-08-01: :class:`ExpressRoutePortsLocationsOperations<azure.mgmt.network.v2018_08_01.aio.operations.ExpressRoutePortsLocationsOperations>`
* 2018-10-01: :class:`ExpressRoutePortsLocationsOperations<azure.mgmt.network.v2018_10_01.aio.operations.ExpressRoutePortsLocationsOperations>`
* 2018-11-01: :class:`ExpressRoutePortsLocationsOperations<azure.mgmt.network.v2018_11_01.aio.operations.ExpressRoutePortsLocationsOperations>`
* 2018-12-01: :class:`ExpressRoutePortsLocationsOperations<azure.mgmt.network.v2018_12_01.aio.operations.ExpressRoutePortsLocationsOperations>`
* 2019-02-01: :class:`ExpressRoutePortsLocationsOperations<azure.mgmt.network.v2019_02_01.aio.operations.ExpressRoutePortsLocationsOperations>`
* 2019-04-01: :class:`ExpressRoutePortsLocationsOperations<azure.mgmt.network.v2019_04_01.aio.operations.ExpressRoutePortsLocationsOperations>`
* 2019-06-01: :class:`ExpressRoutePortsLocationsOperations<azure.mgmt.network.v2019_06_01.aio.operations.ExpressRoutePortsLocationsOperations>`
* 2019-07-01: :class:`ExpressRoutePortsLocationsOperations<azure.mgmt.network.v2019_07_01.aio.operations.ExpressRoutePortsLocationsOperations>`
* 2019-08-01: :class:`ExpressRoutePortsLocationsOperations<azure.mgmt.network.v2019_08_01.aio.operations.ExpressRoutePortsLocationsOperations>`
* 2019-09-01: :class:`ExpressRoutePortsLocationsOperations<azure.mgmt.network.v2019_09_01.aio.operations.ExpressRoutePortsLocationsOperations>`
* 2019-11-01: :class:`ExpressRoutePortsLocationsOperations<azure.mgmt.network.v2019_11_01.aio.operations.ExpressRoutePortsLocationsOperations>`
* 2019-12-01: :class:`ExpressRoutePortsLocationsOperations<azure.mgmt.network.v2019_12_01.aio.operations.ExpressRoutePortsLocationsOperations>`
* 2020-03-01: :class:`ExpressRoutePortsLocationsOperations<azure.mgmt.network.v2020_03_01.aio.operations.ExpressRoutePortsLocationsOperations>`
* 2020-04-01: :class:`ExpressRoutePortsLocationsOperations<azure.mgmt.network.v2020_04_01.aio.operations.ExpressRoutePortsLocationsOperations>`
* 2020-05-01: :class:`ExpressRoutePortsLocationsOperations<azure.mgmt.network.v2020_05_01.aio.operations.ExpressRoutePortsLocationsOperations>`
* 2020-06-01: :class:`ExpressRoutePortsLocationsOperations<azure.mgmt.network.v2020_06_01.aio.operations.ExpressRoutePortsLocationsOperations>`
* 2020-07-01: :class:`ExpressRoutePortsLocationsOperations<azure.mgmt.network.v2020_07_01.aio.operations.ExpressRoutePortsLocationsOperations>`
* 2020-08-01: :class:`ExpressRoutePortsLocationsOperations<azure.mgmt.network.v2020_08_01.aio.operations.ExpressRoutePortsLocationsOperations>`
* 2020-11-01: :class:`ExpressRoutePortsLocationsOperations<azure.mgmt.network.v2020_11_01.aio.operations.ExpressRoutePortsLocationsOperations>`
* 2021-02-01: :class:`ExpressRoutePortsLocationsOperations<azure.mgmt.network.v2021_02_01.aio.operations.ExpressRoutePortsLocationsOperations>`
* 2021-05-01: :class:`ExpressRoutePortsLocationsOperations<azure.mgmt.network.v2021_05_01.aio.operations.ExpressRoutePortsLocationsOperations>`
"""
api_version = self._get_api_version('express_route_ports_locations')
if api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import ExpressRoutePortsLocationsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import ExpressRoutePortsLocationsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import ExpressRoutePortsLocationsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import ExpressRoutePortsLocationsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import ExpressRoutePortsLocationsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import ExpressRoutePortsLocationsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import ExpressRoutePortsLocationsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import ExpressRoutePortsLocationsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import ExpressRoutePortsLocationsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import ExpressRoutePortsLocationsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import ExpressRoutePortsLocationsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import ExpressRoutePortsLocationsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import ExpressRoutePortsLocationsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import ExpressRoutePortsLocationsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import ExpressRoutePortsLocationsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import ExpressRoutePortsLocationsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import ExpressRoutePortsLocationsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import ExpressRoutePortsLocationsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import ExpressRoutePortsLocationsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import ExpressRoutePortsLocationsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import ExpressRoutePortsLocationsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'express_route_ports_locations'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def express_route_service_providers(self):
"""Instance depends on the API version:
* 2015-06-15: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2015_06_15.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2016-09-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2016_09_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2016-12-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2016_12_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2017-03-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2017_03_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2017-06-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2017_06_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2017-10-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2017_10_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2018-01-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2018_01_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2018-02-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2018_02_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2018-04-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2018_04_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2018-06-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2018_06_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2018-07-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2018_07_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2018-08-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2018_08_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2018-10-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2018_10_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2018-11-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2018_11_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2018-12-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2018_12_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2019-02-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2019_02_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2019-04-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2019_04_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2019-06-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2019_06_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2019-07-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2019_07_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2019-08-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2019_08_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2019-09-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2019_09_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2019-11-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2019_11_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2019-12-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2019_12_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2020-03-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2020_03_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2020-04-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2020_04_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2020-05-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2020_05_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2020-06-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2020_06_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2020-07-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2020_07_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2020-08-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2020_08_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2020-11-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2020_11_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2021-02-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2021_02_01.aio.operations.ExpressRouteServiceProvidersOperations>`
* 2021-05-01: :class:`ExpressRouteServiceProvidersOperations<azure.mgmt.network.v2021_05_01.aio.operations.ExpressRouteServiceProvidersOperations>`
"""
api_version = self._get_api_version('express_route_service_providers')
if api_version == '2015-06-15':
from ..v2015_06_15.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2016-09-01':
from ..v2016_09_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2016-12-01':
from ..v2016_12_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2017-03-01':
from ..v2017_03_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import ExpressRouteServiceProvidersOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'express_route_service_providers'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def firewall_policies(self):
"""Instance depends on the API version:
* 2019-06-01: :class:`FirewallPoliciesOperations<azure.mgmt.network.v2019_06_01.aio.operations.FirewallPoliciesOperations>`
* 2019-07-01: :class:`FirewallPoliciesOperations<azure.mgmt.network.v2019_07_01.aio.operations.FirewallPoliciesOperations>`
* 2019-08-01: :class:`FirewallPoliciesOperations<azure.mgmt.network.v2019_08_01.aio.operations.FirewallPoliciesOperations>`
* 2019-09-01: :class:`FirewallPoliciesOperations<azure.mgmt.network.v2019_09_01.aio.operations.FirewallPoliciesOperations>`
* 2019-11-01: :class:`FirewallPoliciesOperations<azure.mgmt.network.v2019_11_01.aio.operations.FirewallPoliciesOperations>`
* 2019-12-01: :class:`FirewallPoliciesOperations<azure.mgmt.network.v2019_12_01.aio.operations.FirewallPoliciesOperations>`
* 2020-03-01: :class:`FirewallPoliciesOperations<azure.mgmt.network.v2020_03_01.aio.operations.FirewallPoliciesOperations>`
* 2020-04-01: :class:`FirewallPoliciesOperations<azure.mgmt.network.v2020_04_01.aio.operations.FirewallPoliciesOperations>`
* 2020-05-01: :class:`FirewallPoliciesOperations<azure.mgmt.network.v2020_05_01.aio.operations.FirewallPoliciesOperations>`
* 2020-06-01: :class:`FirewallPoliciesOperations<azure.mgmt.network.v2020_06_01.aio.operations.FirewallPoliciesOperations>`
* 2020-07-01: :class:`FirewallPoliciesOperations<azure.mgmt.network.v2020_07_01.aio.operations.FirewallPoliciesOperations>`
* 2020-08-01: :class:`FirewallPoliciesOperations<azure.mgmt.network.v2020_08_01.aio.operations.FirewallPoliciesOperations>`
* 2020-11-01: :class:`FirewallPoliciesOperations<azure.mgmt.network.v2020_11_01.aio.operations.FirewallPoliciesOperations>`
* 2021-02-01: :class:`FirewallPoliciesOperations<azure.mgmt.network.v2021_02_01.aio.operations.FirewallPoliciesOperations>`
* 2021-05-01: :class:`FirewallPoliciesOperations<azure.mgmt.network.v2021_05_01.aio.operations.FirewallPoliciesOperations>`
"""
api_version = self._get_api_version('firewall_policies')
if api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import FirewallPoliciesOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import FirewallPoliciesOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import FirewallPoliciesOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import FirewallPoliciesOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import FirewallPoliciesOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import FirewallPoliciesOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import FirewallPoliciesOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import FirewallPoliciesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import FirewallPoliciesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import FirewallPoliciesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import FirewallPoliciesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import FirewallPoliciesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import FirewallPoliciesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import FirewallPoliciesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import FirewallPoliciesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'firewall_policies'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def firewall_policy_idps_signatures(self):
"""Instance depends on the API version:
* 2021-05-01: :class:`FirewallPolicyIdpsSignaturesOperations<azure.mgmt.network.v2021_05_01.aio.operations.FirewallPolicyIdpsSignaturesOperations>`
"""
api_version = self._get_api_version('firewall_policy_idps_signatures')
if api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import FirewallPolicyIdpsSignaturesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'firewall_policy_idps_signatures'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def firewall_policy_idps_signatures_filter_values(self):
"""Instance depends on the API version:
* 2021-05-01: :class:`FirewallPolicyIdpsSignaturesFilterValuesOperations<azure.mgmt.network.v2021_05_01.aio.operations.FirewallPolicyIdpsSignaturesFilterValuesOperations>`
"""
api_version = self._get_api_version('firewall_policy_idps_signatures_filter_values')
if api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import FirewallPolicyIdpsSignaturesFilterValuesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'firewall_policy_idps_signatures_filter_values'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def firewall_policy_idps_signatures_overrides(self):
"""Instance depends on the API version:
* 2021-05-01: :class:`FirewallPolicyIdpsSignaturesOverridesOperations<azure.mgmt.network.v2021_05_01.aio.operations.FirewallPolicyIdpsSignaturesOverridesOperations>`
"""
api_version = self._get_api_version('firewall_policy_idps_signatures_overrides')
if api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import FirewallPolicyIdpsSignaturesOverridesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'firewall_policy_idps_signatures_overrides'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def firewall_policy_rule_collection_groups(self):
"""Instance depends on the API version:
* 2020-05-01: :class:`FirewallPolicyRuleCollectionGroupsOperations<azure.mgmt.network.v2020_05_01.aio.operations.FirewallPolicyRuleCollectionGroupsOperations>`
* 2020-06-01: :class:`FirewallPolicyRuleCollectionGroupsOperations<azure.mgmt.network.v2020_06_01.aio.operations.FirewallPolicyRuleCollectionGroupsOperations>`
* 2020-07-01: :class:`FirewallPolicyRuleCollectionGroupsOperations<azure.mgmt.network.v2020_07_01.aio.operations.FirewallPolicyRuleCollectionGroupsOperations>`
* 2020-08-01: :class:`FirewallPolicyRuleCollectionGroupsOperations<azure.mgmt.network.v2020_08_01.aio.operations.FirewallPolicyRuleCollectionGroupsOperations>`
* 2020-11-01: :class:`FirewallPolicyRuleCollectionGroupsOperations<azure.mgmt.network.v2020_11_01.aio.operations.FirewallPolicyRuleCollectionGroupsOperations>`
* 2021-02-01: :class:`FirewallPolicyRuleCollectionGroupsOperations<azure.mgmt.network.v2021_02_01.aio.operations.FirewallPolicyRuleCollectionGroupsOperations>`
* 2021-05-01: :class:`FirewallPolicyRuleCollectionGroupsOperations<azure.mgmt.network.v2021_05_01.aio.operations.FirewallPolicyRuleCollectionGroupsOperations>`
"""
api_version = self._get_api_version('firewall_policy_rule_collection_groups')
if api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import FirewallPolicyRuleCollectionGroupsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import FirewallPolicyRuleCollectionGroupsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import FirewallPolicyRuleCollectionGroupsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import FirewallPolicyRuleCollectionGroupsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import FirewallPolicyRuleCollectionGroupsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import FirewallPolicyRuleCollectionGroupsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import FirewallPolicyRuleCollectionGroupsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'firewall_policy_rule_collection_groups'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def firewall_policy_rule_groups(self):
"""Instance depends on the API version:
* 2019-06-01: :class:`FirewallPolicyRuleGroupsOperations<azure.mgmt.network.v2019_06_01.aio.operations.FirewallPolicyRuleGroupsOperations>`
* 2019-07-01: :class:`FirewallPolicyRuleGroupsOperations<azure.mgmt.network.v2019_07_01.aio.operations.FirewallPolicyRuleGroupsOperations>`
* 2019-08-01: :class:`FirewallPolicyRuleGroupsOperations<azure.mgmt.network.v2019_08_01.aio.operations.FirewallPolicyRuleGroupsOperations>`
* 2019-09-01: :class:`FirewallPolicyRuleGroupsOperations<azure.mgmt.network.v2019_09_01.aio.operations.FirewallPolicyRuleGroupsOperations>`
* 2019-11-01: :class:`FirewallPolicyRuleGroupsOperations<azure.mgmt.network.v2019_11_01.aio.operations.FirewallPolicyRuleGroupsOperations>`
* 2019-12-01: :class:`FirewallPolicyRuleGroupsOperations<azure.mgmt.network.v2019_12_01.aio.operations.FirewallPolicyRuleGroupsOperations>`
* 2020-03-01: :class:`FirewallPolicyRuleGroupsOperations<azure.mgmt.network.v2020_03_01.aio.operations.FirewallPolicyRuleGroupsOperations>`
* 2020-04-01: :class:`FirewallPolicyRuleGroupsOperations<azure.mgmt.network.v2020_04_01.aio.operations.FirewallPolicyRuleGroupsOperations>`
"""
api_version = self._get_api_version('firewall_policy_rule_groups')
if api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import FirewallPolicyRuleGroupsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import FirewallPolicyRuleGroupsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import FirewallPolicyRuleGroupsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import FirewallPolicyRuleGroupsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import FirewallPolicyRuleGroupsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import FirewallPolicyRuleGroupsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import FirewallPolicyRuleGroupsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import FirewallPolicyRuleGroupsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'firewall_policy_rule_groups'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def flow_logs(self):
"""Instance depends on the API version:
* 2019-11-01: :class:`FlowLogsOperations<azure.mgmt.network.v2019_11_01.aio.operations.FlowLogsOperations>`
* 2019-12-01: :class:`FlowLogsOperations<azure.mgmt.network.v2019_12_01.aio.operations.FlowLogsOperations>`
* 2020-03-01: :class:`FlowLogsOperations<azure.mgmt.network.v2020_03_01.aio.operations.FlowLogsOperations>`
* 2020-04-01: :class:`FlowLogsOperations<azure.mgmt.network.v2020_04_01.aio.operations.FlowLogsOperations>`
* 2020-05-01: :class:`FlowLogsOperations<azure.mgmt.network.v2020_05_01.aio.operations.FlowLogsOperations>`
* 2020-06-01: :class:`FlowLogsOperations<azure.mgmt.network.v2020_06_01.aio.operations.FlowLogsOperations>`
* 2020-07-01: :class:`FlowLogsOperations<azure.mgmt.network.v2020_07_01.aio.operations.FlowLogsOperations>`
* 2020-08-01: :class:`FlowLogsOperations<azure.mgmt.network.v2020_08_01.aio.operations.FlowLogsOperations>`
* 2020-11-01: :class:`FlowLogsOperations<azure.mgmt.network.v2020_11_01.aio.operations.FlowLogsOperations>`
* 2021-02-01: :class:`FlowLogsOperations<azure.mgmt.network.v2021_02_01.aio.operations.FlowLogsOperations>`
* 2021-05-01: :class:`FlowLogsOperations<azure.mgmt.network.v2021_05_01.aio.operations.FlowLogsOperations>`
"""
api_version = self._get_api_version('flow_logs')
if api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import FlowLogsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import FlowLogsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import FlowLogsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import FlowLogsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import FlowLogsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import FlowLogsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import FlowLogsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import FlowLogsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import FlowLogsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import FlowLogsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import FlowLogsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'flow_logs'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def hub_route_tables(self):
"""Instance depends on the API version:
* 2020-04-01: :class:`HubRouteTablesOperations<azure.mgmt.network.v2020_04_01.aio.operations.HubRouteTablesOperations>`
* 2020-05-01: :class:`HubRouteTablesOperations<azure.mgmt.network.v2020_05_01.aio.operations.HubRouteTablesOperations>`
* 2020-06-01: :class:`HubRouteTablesOperations<azure.mgmt.network.v2020_06_01.aio.operations.HubRouteTablesOperations>`
* 2020-07-01: :class:`HubRouteTablesOperations<azure.mgmt.network.v2020_07_01.aio.operations.HubRouteTablesOperations>`
* 2020-08-01: :class:`HubRouteTablesOperations<azure.mgmt.network.v2020_08_01.aio.operations.HubRouteTablesOperations>`
* 2020-11-01: :class:`HubRouteTablesOperations<azure.mgmt.network.v2020_11_01.aio.operations.HubRouteTablesOperations>`
* 2021-02-01: :class:`HubRouteTablesOperations<azure.mgmt.network.v2021_02_01.aio.operations.HubRouteTablesOperations>`
* 2021-05-01: :class:`HubRouteTablesOperations<azure.mgmt.network.v2021_05_01.aio.operations.HubRouteTablesOperations>`
"""
api_version = self._get_api_version('hub_route_tables')
if api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import HubRouteTablesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import HubRouteTablesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import HubRouteTablesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import HubRouteTablesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import HubRouteTablesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import HubRouteTablesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import HubRouteTablesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import HubRouteTablesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'hub_route_tables'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def hub_virtual_network_connections(self):
"""Instance depends on the API version:
* 2018-04-01: :class:`HubVirtualNetworkConnectionsOperations<azure.mgmt.network.v2018_04_01.aio.operations.HubVirtualNetworkConnectionsOperations>`
* 2018-06-01: :class:`HubVirtualNetworkConnectionsOperations<azure.mgmt.network.v2018_06_01.aio.operations.HubVirtualNetworkConnectionsOperations>`
* 2018-07-01: :class:`HubVirtualNetworkConnectionsOperations<azure.mgmt.network.v2018_07_01.aio.operations.HubVirtualNetworkConnectionsOperations>`
* 2018-08-01: :class:`HubVirtualNetworkConnectionsOperations<azure.mgmt.network.v2018_08_01.aio.operations.HubVirtualNetworkConnectionsOperations>`
* 2018-10-01: :class:`HubVirtualNetworkConnectionsOperations<azure.mgmt.network.v2018_10_01.aio.operations.HubVirtualNetworkConnectionsOperations>`
* 2018-11-01: :class:`HubVirtualNetworkConnectionsOperations<azure.mgmt.network.v2018_11_01.aio.operations.HubVirtualNetworkConnectionsOperations>`
* 2018-12-01: :class:`HubVirtualNetworkConnectionsOperations<azure.mgmt.network.v2018_12_01.aio.operations.HubVirtualNetworkConnectionsOperations>`
* 2019-02-01: :class:`HubVirtualNetworkConnectionsOperations<azure.mgmt.network.v2019_02_01.aio.operations.HubVirtualNetworkConnectionsOperations>`
* 2019-04-01: :class:`HubVirtualNetworkConnectionsOperations<azure.mgmt.network.v2019_04_01.aio.operations.HubVirtualNetworkConnectionsOperations>`
* 2019-06-01: :class:`HubVirtualNetworkConnectionsOperations<azure.mgmt.network.v2019_06_01.aio.operations.HubVirtualNetworkConnectionsOperations>`
* 2019-07-01: :class:`HubVirtualNetworkConnectionsOperations<azure.mgmt.network.v2019_07_01.aio.operations.HubVirtualNetworkConnectionsOperations>`
* 2019-08-01: :class:`HubVirtualNetworkConnectionsOperations<azure.mgmt.network.v2019_08_01.aio.operations.HubVirtualNetworkConnectionsOperations>`
* 2019-09-01: :class:`HubVirtualNetworkConnectionsOperations<azure.mgmt.network.v2019_09_01.aio.operations.HubVirtualNetworkConnectionsOperations>`
* 2019-11-01: :class:`HubVirtualNetworkConnectionsOperations<azure.mgmt.network.v2019_11_01.aio.operations.HubVirtualNetworkConnectionsOperations>`
* 2019-12-01: :class:`HubVirtualNetworkConnectionsOperations<azure.mgmt.network.v2019_12_01.aio.operations.HubVirtualNetworkConnectionsOperations>`
* 2020-03-01: :class:`HubVirtualNetworkConnectionsOperations<azure.mgmt.network.v2020_03_01.aio.operations.HubVirtualNetworkConnectionsOperations>`
* 2020-04-01: :class:`HubVirtualNetworkConnectionsOperations<azure.mgmt.network.v2020_04_01.aio.operations.HubVirtualNetworkConnectionsOperations>`
* 2020-05-01: :class:`HubVirtualNetworkConnectionsOperations<azure.mgmt.network.v2020_05_01.aio.operations.HubVirtualNetworkConnectionsOperations>`
* 2020-06-01: :class:`HubVirtualNetworkConnectionsOperations<azure.mgmt.network.v2020_06_01.aio.operations.HubVirtualNetworkConnectionsOperations>`
* 2020-07-01: :class:`HubVirtualNetworkConnectionsOperations<azure.mgmt.network.v2020_07_01.aio.operations.HubVirtualNetworkConnectionsOperations>`
* 2020-08-01: :class:`HubVirtualNetworkConnectionsOperations<azure.mgmt.network.v2020_08_01.aio.operations.HubVirtualNetworkConnectionsOperations>`
* 2020-11-01: :class:`HubVirtualNetworkConnectionsOperations<azure.mgmt.network.v2020_11_01.aio.operations.HubVirtualNetworkConnectionsOperations>`
* 2021-02-01: :class:`HubVirtualNetworkConnectionsOperations<azure.mgmt.network.v2021_02_01.aio.operations.HubVirtualNetworkConnectionsOperations>`
* 2021-05-01: :class:`HubVirtualNetworkConnectionsOperations<azure.mgmt.network.v2021_05_01.aio.operations.HubVirtualNetworkConnectionsOperations>`
"""
api_version = self._get_api_version('hub_virtual_network_connections')
if api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import HubVirtualNetworkConnectionsOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import HubVirtualNetworkConnectionsOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import HubVirtualNetworkConnectionsOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import HubVirtualNetworkConnectionsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import HubVirtualNetworkConnectionsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import HubVirtualNetworkConnectionsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import HubVirtualNetworkConnectionsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import HubVirtualNetworkConnectionsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import HubVirtualNetworkConnectionsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import HubVirtualNetworkConnectionsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import HubVirtualNetworkConnectionsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import HubVirtualNetworkConnectionsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import HubVirtualNetworkConnectionsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import HubVirtualNetworkConnectionsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import HubVirtualNetworkConnectionsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import HubVirtualNetworkConnectionsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import HubVirtualNetworkConnectionsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import HubVirtualNetworkConnectionsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import HubVirtualNetworkConnectionsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import HubVirtualNetworkConnectionsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import HubVirtualNetworkConnectionsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import HubVirtualNetworkConnectionsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import HubVirtualNetworkConnectionsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import HubVirtualNetworkConnectionsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'hub_virtual_network_connections'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def inbound_nat_rules(self):
"""Instance depends on the API version:
* 2017-06-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2017_06_01.aio.operations.InboundNatRulesOperations>`
* 2017-10-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2017_10_01.aio.operations.InboundNatRulesOperations>`
* 2018-01-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2018_01_01.aio.operations.InboundNatRulesOperations>`
* 2018-02-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2018_02_01.aio.operations.InboundNatRulesOperations>`
* 2018-04-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2018_04_01.aio.operations.InboundNatRulesOperations>`
* 2018-06-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2018_06_01.aio.operations.InboundNatRulesOperations>`
* 2018-07-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2018_07_01.aio.operations.InboundNatRulesOperations>`
* 2018-08-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2018_08_01.aio.operations.InboundNatRulesOperations>`
* 2018-10-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2018_10_01.aio.operations.InboundNatRulesOperations>`
* 2018-11-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2018_11_01.aio.operations.InboundNatRulesOperations>`
* 2018-12-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2018_12_01.aio.operations.InboundNatRulesOperations>`
* 2019-02-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2019_02_01.aio.operations.InboundNatRulesOperations>`
* 2019-04-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2019_04_01.aio.operations.InboundNatRulesOperations>`
* 2019-06-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2019_06_01.aio.operations.InboundNatRulesOperations>`
* 2019-07-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2019_07_01.aio.operations.InboundNatRulesOperations>`
* 2019-08-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2019_08_01.aio.operations.InboundNatRulesOperations>`
* 2019-09-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2019_09_01.aio.operations.InboundNatRulesOperations>`
* 2019-11-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2019_11_01.aio.operations.InboundNatRulesOperations>`
* 2019-12-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2019_12_01.aio.operations.InboundNatRulesOperations>`
* 2020-03-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2020_03_01.aio.operations.InboundNatRulesOperations>`
* 2020-04-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2020_04_01.aio.operations.InboundNatRulesOperations>`
* 2020-05-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2020_05_01.aio.operations.InboundNatRulesOperations>`
* 2020-06-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2020_06_01.aio.operations.InboundNatRulesOperations>`
* 2020-07-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2020_07_01.aio.operations.InboundNatRulesOperations>`
* 2020-08-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2020_08_01.aio.operations.InboundNatRulesOperations>`
* 2020-11-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2020_11_01.aio.operations.InboundNatRulesOperations>`
* 2021-02-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2021_02_01.aio.operations.InboundNatRulesOperations>`
* 2021-05-01: :class:`InboundNatRulesOperations<azure.mgmt.network.v2021_05_01.aio.operations.InboundNatRulesOperations>`
"""
api_version = self._get_api_version('inbound_nat_rules')
if api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import InboundNatRulesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import InboundNatRulesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'inbound_nat_rules'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def inbound_security_rule(self):
"""Instance depends on the API version:
* 2020-06-01: :class:`InboundSecurityRuleOperations<azure.mgmt.network.v2020_06_01.aio.operations.InboundSecurityRuleOperations>`
* 2020-07-01: :class:`InboundSecurityRuleOperations<azure.mgmt.network.v2020_07_01.aio.operations.InboundSecurityRuleOperations>`
* 2020-08-01: :class:`InboundSecurityRuleOperations<azure.mgmt.network.v2020_08_01.aio.operations.InboundSecurityRuleOperations>`
* 2020-11-01: :class:`InboundSecurityRuleOperations<azure.mgmt.network.v2020_11_01.aio.operations.InboundSecurityRuleOperations>`
* 2021-02-01: :class:`InboundSecurityRuleOperations<azure.mgmt.network.v2021_02_01.aio.operations.InboundSecurityRuleOperations>`
* 2021-05-01: :class:`InboundSecurityRuleOperations<azure.mgmt.network.v2021_05_01.aio.operations.InboundSecurityRuleOperations>`
"""
api_version = self._get_api_version('inbound_security_rule')
if api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import InboundSecurityRuleOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import InboundSecurityRuleOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import InboundSecurityRuleOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import InboundSecurityRuleOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import InboundSecurityRuleOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import InboundSecurityRuleOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'inbound_security_rule'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def interface_endpoints(self):
"""Instance depends on the API version:
* 2018-08-01: :class:`InterfaceEndpointsOperations<azure.mgmt.network.v2018_08_01.aio.operations.InterfaceEndpointsOperations>`
* 2018-10-01: :class:`InterfaceEndpointsOperations<azure.mgmt.network.v2018_10_01.aio.operations.InterfaceEndpointsOperations>`
* 2018-11-01: :class:`InterfaceEndpointsOperations<azure.mgmt.network.v2018_11_01.aio.operations.InterfaceEndpointsOperations>`
* 2018-12-01: :class:`InterfaceEndpointsOperations<azure.mgmt.network.v2018_12_01.aio.operations.InterfaceEndpointsOperations>`
* 2019-02-01: :class:`InterfaceEndpointsOperations<azure.mgmt.network.v2019_02_01.aio.operations.InterfaceEndpointsOperations>`
"""
api_version = self._get_api_version('interface_endpoints')
if api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import InterfaceEndpointsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import InterfaceEndpointsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import InterfaceEndpointsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import InterfaceEndpointsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import InterfaceEndpointsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'interface_endpoints'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def ip_allocations(self):
"""Instance depends on the API version:
* 2020-03-01: :class:`IpAllocationsOperations<azure.mgmt.network.v2020_03_01.aio.operations.IpAllocationsOperations>`
* 2020-04-01: :class:`IpAllocationsOperations<azure.mgmt.network.v2020_04_01.aio.operations.IpAllocationsOperations>`
* 2020-05-01: :class:`IpAllocationsOperations<azure.mgmt.network.v2020_05_01.aio.operations.IpAllocationsOperations>`
* 2020-06-01: :class:`IpAllocationsOperations<azure.mgmt.network.v2020_06_01.aio.operations.IpAllocationsOperations>`
* 2020-07-01: :class:`IpAllocationsOperations<azure.mgmt.network.v2020_07_01.aio.operations.IpAllocationsOperations>`
* 2020-08-01: :class:`IpAllocationsOperations<azure.mgmt.network.v2020_08_01.aio.operations.IpAllocationsOperations>`
* 2020-11-01: :class:`IpAllocationsOperations<azure.mgmt.network.v2020_11_01.aio.operations.IpAllocationsOperations>`
* 2021-02-01: :class:`IpAllocationsOperations<azure.mgmt.network.v2021_02_01.aio.operations.IpAllocationsOperations>`
* 2021-05-01: :class:`IpAllocationsOperations<azure.mgmt.network.v2021_05_01.aio.operations.IpAllocationsOperations>`
"""
api_version = self._get_api_version('ip_allocations')
if api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import IpAllocationsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import IpAllocationsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import IpAllocationsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import IpAllocationsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import IpAllocationsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import IpAllocationsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import IpAllocationsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import IpAllocationsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import IpAllocationsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'ip_allocations'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def ip_groups(self):
"""Instance depends on the API version:
* 2019-09-01: :class:`IpGroupsOperations<azure.mgmt.network.v2019_09_01.aio.operations.IpGroupsOperations>`
* 2019-11-01: :class:`IpGroupsOperations<azure.mgmt.network.v2019_11_01.aio.operations.IpGroupsOperations>`
* 2019-12-01: :class:`IpGroupsOperations<azure.mgmt.network.v2019_12_01.aio.operations.IpGroupsOperations>`
* 2020-03-01: :class:`IpGroupsOperations<azure.mgmt.network.v2020_03_01.aio.operations.IpGroupsOperations>`
* 2020-04-01: :class:`IpGroupsOperations<azure.mgmt.network.v2020_04_01.aio.operations.IpGroupsOperations>`
* 2020-05-01: :class:`IpGroupsOperations<azure.mgmt.network.v2020_05_01.aio.operations.IpGroupsOperations>`
* 2020-06-01: :class:`IpGroupsOperations<azure.mgmt.network.v2020_06_01.aio.operations.IpGroupsOperations>`
* 2020-07-01: :class:`IpGroupsOperations<azure.mgmt.network.v2020_07_01.aio.operations.IpGroupsOperations>`
* 2020-08-01: :class:`IpGroupsOperations<azure.mgmt.network.v2020_08_01.aio.operations.IpGroupsOperations>`
* 2020-11-01: :class:`IpGroupsOperations<azure.mgmt.network.v2020_11_01.aio.operations.IpGroupsOperations>`
* 2021-02-01: :class:`IpGroupsOperations<azure.mgmt.network.v2021_02_01.aio.operations.IpGroupsOperations>`
* 2021-05-01: :class:`IpGroupsOperations<azure.mgmt.network.v2021_05_01.aio.operations.IpGroupsOperations>`
"""
api_version = self._get_api_version('ip_groups')
if api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import IpGroupsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import IpGroupsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import IpGroupsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import IpGroupsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import IpGroupsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import IpGroupsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import IpGroupsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import IpGroupsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import IpGroupsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import IpGroupsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import IpGroupsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import IpGroupsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'ip_groups'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def load_balancer_backend_address_pools(self):
"""Instance depends on the API version:
* 2017-06-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2017_06_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
* 2017-10-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2017_10_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
* 2018-01-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2018_01_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
* 2018-02-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2018_02_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
* 2018-04-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2018_04_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
* 2018-06-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2018_06_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
* 2018-07-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2018_07_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
* 2018-08-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2018_08_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
* 2018-10-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2018_10_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
* 2018-11-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2018_11_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
* 2018-12-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2018_12_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
* 2019-02-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2019_02_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
* 2019-04-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2019_04_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
* 2019-06-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2019_06_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
* 2019-07-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2019_07_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
* 2019-08-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2019_08_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
* 2019-09-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2019_09_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
* 2019-11-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2019_11_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
* 2019-12-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2019_12_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
* 2020-03-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2020_03_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
* 2020-04-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2020_04_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
* 2020-05-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2020_05_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
* 2020-06-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2020_06_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
* 2020-07-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2020_07_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
* 2020-08-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2020_08_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
* 2020-11-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2020_11_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
* 2021-02-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2021_02_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
* 2021-05-01: :class:`LoadBalancerBackendAddressPoolsOperations<azure.mgmt.network.v2021_05_01.aio.operations.LoadBalancerBackendAddressPoolsOperations>`
"""
api_version = self._get_api_version('load_balancer_backend_address_pools')
if api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import LoadBalancerBackendAddressPoolsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'load_balancer_backend_address_pools'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def load_balancer_frontend_ip_configurations(self):
"""Instance depends on the API version:
* 2017-06-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2017_06_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
* 2017-10-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2017_10_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
* 2018-01-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2018_01_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
* 2018-02-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2018_02_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
* 2018-04-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2018_04_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
* 2018-06-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2018_06_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
* 2018-07-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2018_07_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
* 2018-08-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2018_08_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
* 2018-10-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2018_10_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
* 2018-11-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2018_11_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
* 2018-12-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2018_12_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
* 2019-02-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2019_02_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
* 2019-04-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2019_04_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
* 2019-06-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2019_06_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
* 2019-07-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2019_07_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
* 2019-08-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2019_08_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
* 2019-09-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2019_09_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
* 2019-11-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2019_11_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
* 2019-12-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2019_12_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
* 2020-03-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2020_03_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
* 2020-04-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2020_04_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
* 2020-05-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2020_05_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
* 2020-06-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2020_06_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
* 2020-07-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2020_07_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
* 2020-08-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2020_08_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
* 2020-11-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2020_11_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
* 2021-02-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2021_02_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
* 2021-05-01: :class:`LoadBalancerFrontendIPConfigurationsOperations<azure.mgmt.network.v2021_05_01.aio.operations.LoadBalancerFrontendIPConfigurationsOperations>`
"""
api_version = self._get_api_version('load_balancer_frontend_ip_configurations')
if api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import LoadBalancerFrontendIPConfigurationsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'load_balancer_frontend_ip_configurations'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def load_balancer_load_balancing_rules(self):
"""Instance depends on the API version:
* 2017-06-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2017_06_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
* 2017-10-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2017_10_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
* 2018-01-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2018_01_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
* 2018-02-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2018_02_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
* 2018-04-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2018_04_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
* 2018-06-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2018_06_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
* 2018-07-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2018_07_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
* 2018-08-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2018_08_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
* 2018-10-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2018_10_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
* 2018-11-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2018_11_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
* 2018-12-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2018_12_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
* 2019-02-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2019_02_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
* 2019-04-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2019_04_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
* 2019-06-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2019_06_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
* 2019-07-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2019_07_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
* 2019-08-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2019_08_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
* 2019-09-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2019_09_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
* 2019-11-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2019_11_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
* 2019-12-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2019_12_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
* 2020-03-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2020_03_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
* 2020-04-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2020_04_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
* 2020-05-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2020_05_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
* 2020-06-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2020_06_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
* 2020-07-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2020_07_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
* 2020-08-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2020_08_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
* 2020-11-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2020_11_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
* 2021-02-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2021_02_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
* 2021-05-01: :class:`LoadBalancerLoadBalancingRulesOperations<azure.mgmt.network.v2021_05_01.aio.operations.LoadBalancerLoadBalancingRulesOperations>`
"""
api_version = self._get_api_version('load_balancer_load_balancing_rules')
if api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import LoadBalancerLoadBalancingRulesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'load_balancer_load_balancing_rules'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def load_balancer_network_interfaces(self):
"""Instance depends on the API version:
* 2017-06-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2017_06_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
* 2017-10-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2017_10_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
* 2018-01-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2018_01_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
* 2018-02-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2018_02_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
* 2018-04-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2018_04_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
* 2018-06-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2018_06_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
* 2018-07-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2018_07_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
* 2018-08-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2018_08_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
* 2018-10-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2018_10_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
* 2018-11-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2018_11_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
* 2018-12-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2018_12_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
* 2019-02-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2019_02_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
* 2019-04-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2019_04_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
* 2019-06-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2019_06_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
* 2019-07-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2019_07_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
* 2019-08-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2019_08_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
* 2019-09-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2019_09_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
* 2019-11-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2019_11_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
* 2019-12-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2019_12_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
* 2020-03-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2020_03_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
* 2020-04-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2020_04_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
* 2020-05-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2020_05_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
* 2020-06-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2020_06_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
* 2020-07-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2020_07_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
* 2020-08-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2020_08_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
* 2020-11-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2020_11_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
* 2021-02-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2021_02_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
* 2021-05-01: :class:`LoadBalancerNetworkInterfacesOperations<azure.mgmt.network.v2021_05_01.aio.operations.LoadBalancerNetworkInterfacesOperations>`
"""
api_version = self._get_api_version('load_balancer_network_interfaces')
if api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import LoadBalancerNetworkInterfacesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'load_balancer_network_interfaces'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def load_balancer_outbound_rules(self):
"""Instance depends on the API version:
* 2018-08-01: :class:`LoadBalancerOutboundRulesOperations<azure.mgmt.network.v2018_08_01.aio.operations.LoadBalancerOutboundRulesOperations>`
* 2018-10-01: :class:`LoadBalancerOutboundRulesOperations<azure.mgmt.network.v2018_10_01.aio.operations.LoadBalancerOutboundRulesOperations>`
* 2018-11-01: :class:`LoadBalancerOutboundRulesOperations<azure.mgmt.network.v2018_11_01.aio.operations.LoadBalancerOutboundRulesOperations>`
* 2018-12-01: :class:`LoadBalancerOutboundRulesOperations<azure.mgmt.network.v2018_12_01.aio.operations.LoadBalancerOutboundRulesOperations>`
* 2019-02-01: :class:`LoadBalancerOutboundRulesOperations<azure.mgmt.network.v2019_02_01.aio.operations.LoadBalancerOutboundRulesOperations>`
* 2019-04-01: :class:`LoadBalancerOutboundRulesOperations<azure.mgmt.network.v2019_04_01.aio.operations.LoadBalancerOutboundRulesOperations>`
* 2019-06-01: :class:`LoadBalancerOutboundRulesOperations<azure.mgmt.network.v2019_06_01.aio.operations.LoadBalancerOutboundRulesOperations>`
* 2019-07-01: :class:`LoadBalancerOutboundRulesOperations<azure.mgmt.network.v2019_07_01.aio.operations.LoadBalancerOutboundRulesOperations>`
* 2019-08-01: :class:`LoadBalancerOutboundRulesOperations<azure.mgmt.network.v2019_08_01.aio.operations.LoadBalancerOutboundRulesOperations>`
* 2019-09-01: :class:`LoadBalancerOutboundRulesOperations<azure.mgmt.network.v2019_09_01.aio.operations.LoadBalancerOutboundRulesOperations>`
* 2019-11-01: :class:`LoadBalancerOutboundRulesOperations<azure.mgmt.network.v2019_11_01.aio.operations.LoadBalancerOutboundRulesOperations>`
* 2019-12-01: :class:`LoadBalancerOutboundRulesOperations<azure.mgmt.network.v2019_12_01.aio.operations.LoadBalancerOutboundRulesOperations>`
* 2020-03-01: :class:`LoadBalancerOutboundRulesOperations<azure.mgmt.network.v2020_03_01.aio.operations.LoadBalancerOutboundRulesOperations>`
* 2020-04-01: :class:`LoadBalancerOutboundRulesOperations<azure.mgmt.network.v2020_04_01.aio.operations.LoadBalancerOutboundRulesOperations>`
* 2020-05-01: :class:`LoadBalancerOutboundRulesOperations<azure.mgmt.network.v2020_05_01.aio.operations.LoadBalancerOutboundRulesOperations>`
* 2020-06-01: :class:`LoadBalancerOutboundRulesOperations<azure.mgmt.network.v2020_06_01.aio.operations.LoadBalancerOutboundRulesOperations>`
* 2020-07-01: :class:`LoadBalancerOutboundRulesOperations<azure.mgmt.network.v2020_07_01.aio.operations.LoadBalancerOutboundRulesOperations>`
* 2020-08-01: :class:`LoadBalancerOutboundRulesOperations<azure.mgmt.network.v2020_08_01.aio.operations.LoadBalancerOutboundRulesOperations>`
* 2020-11-01: :class:`LoadBalancerOutboundRulesOperations<azure.mgmt.network.v2020_11_01.aio.operations.LoadBalancerOutboundRulesOperations>`
* 2021-02-01: :class:`LoadBalancerOutboundRulesOperations<azure.mgmt.network.v2021_02_01.aio.operations.LoadBalancerOutboundRulesOperations>`
* 2021-05-01: :class:`LoadBalancerOutboundRulesOperations<azure.mgmt.network.v2021_05_01.aio.operations.LoadBalancerOutboundRulesOperations>`
"""
api_version = self._get_api_version('load_balancer_outbound_rules')
if api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import LoadBalancerOutboundRulesOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import LoadBalancerOutboundRulesOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import LoadBalancerOutboundRulesOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import LoadBalancerOutboundRulesOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import LoadBalancerOutboundRulesOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import LoadBalancerOutboundRulesOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import LoadBalancerOutboundRulesOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import LoadBalancerOutboundRulesOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import LoadBalancerOutboundRulesOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import LoadBalancerOutboundRulesOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import LoadBalancerOutboundRulesOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import LoadBalancerOutboundRulesOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import LoadBalancerOutboundRulesOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import LoadBalancerOutboundRulesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import LoadBalancerOutboundRulesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import LoadBalancerOutboundRulesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import LoadBalancerOutboundRulesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import LoadBalancerOutboundRulesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import LoadBalancerOutboundRulesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import LoadBalancerOutboundRulesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import LoadBalancerOutboundRulesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'load_balancer_outbound_rules'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def load_balancer_probes(self):
"""Instance depends on the API version:
* 2017-06-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2017_06_01.aio.operations.LoadBalancerProbesOperations>`
* 2017-10-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2017_10_01.aio.operations.LoadBalancerProbesOperations>`
* 2018-01-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2018_01_01.aio.operations.LoadBalancerProbesOperations>`
* 2018-02-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2018_02_01.aio.operations.LoadBalancerProbesOperations>`
* 2018-04-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2018_04_01.aio.operations.LoadBalancerProbesOperations>`
* 2018-06-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2018_06_01.aio.operations.LoadBalancerProbesOperations>`
* 2018-07-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2018_07_01.aio.operations.LoadBalancerProbesOperations>`
* 2018-08-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2018_08_01.aio.operations.LoadBalancerProbesOperations>`
* 2018-10-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2018_10_01.aio.operations.LoadBalancerProbesOperations>`
* 2018-11-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2018_11_01.aio.operations.LoadBalancerProbesOperations>`
* 2018-12-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2018_12_01.aio.operations.LoadBalancerProbesOperations>`
* 2019-02-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2019_02_01.aio.operations.LoadBalancerProbesOperations>`
* 2019-04-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2019_04_01.aio.operations.LoadBalancerProbesOperations>`
* 2019-06-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2019_06_01.aio.operations.LoadBalancerProbesOperations>`
* 2019-07-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2019_07_01.aio.operations.LoadBalancerProbesOperations>`
* 2019-08-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2019_08_01.aio.operations.LoadBalancerProbesOperations>`
* 2019-09-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2019_09_01.aio.operations.LoadBalancerProbesOperations>`
* 2019-11-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2019_11_01.aio.operations.LoadBalancerProbesOperations>`
* 2019-12-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2019_12_01.aio.operations.LoadBalancerProbesOperations>`
* 2020-03-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2020_03_01.aio.operations.LoadBalancerProbesOperations>`
* 2020-04-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2020_04_01.aio.operations.LoadBalancerProbesOperations>`
* 2020-05-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2020_05_01.aio.operations.LoadBalancerProbesOperations>`
* 2020-06-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2020_06_01.aio.operations.LoadBalancerProbesOperations>`
* 2020-07-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2020_07_01.aio.operations.LoadBalancerProbesOperations>`
* 2020-08-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2020_08_01.aio.operations.LoadBalancerProbesOperations>`
* 2020-11-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2020_11_01.aio.operations.LoadBalancerProbesOperations>`
* 2021-02-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2021_02_01.aio.operations.LoadBalancerProbesOperations>`
* 2021-05-01: :class:`LoadBalancerProbesOperations<azure.mgmt.network.v2021_05_01.aio.operations.LoadBalancerProbesOperations>`
"""
api_version = self._get_api_version('load_balancer_probes')
if api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import LoadBalancerProbesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import LoadBalancerProbesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'load_balancer_probes'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def load_balancers(self):
"""Instance depends on the API version:
* 2015-06-15: :class:`LoadBalancersOperations<azure.mgmt.network.v2015_06_15.aio.operations.LoadBalancersOperations>`
* 2016-09-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2016_09_01.aio.operations.LoadBalancersOperations>`
* 2016-12-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2016_12_01.aio.operations.LoadBalancersOperations>`
* 2017-03-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2017_03_01.aio.operations.LoadBalancersOperations>`
* 2017-06-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2017_06_01.aio.operations.LoadBalancersOperations>`
* 2017-10-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2017_10_01.aio.operations.LoadBalancersOperations>`
* 2018-01-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2018_01_01.aio.operations.LoadBalancersOperations>`
* 2018-02-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2018_02_01.aio.operations.LoadBalancersOperations>`
* 2018-04-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2018_04_01.aio.operations.LoadBalancersOperations>`
* 2018-06-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2018_06_01.aio.operations.LoadBalancersOperations>`
* 2018-07-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2018_07_01.aio.operations.LoadBalancersOperations>`
* 2018-08-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2018_08_01.aio.operations.LoadBalancersOperations>`
* 2018-10-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2018_10_01.aio.operations.LoadBalancersOperations>`
* 2018-11-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2018_11_01.aio.operations.LoadBalancersOperations>`
* 2018-12-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2018_12_01.aio.operations.LoadBalancersOperations>`
* 2019-02-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2019_02_01.aio.operations.LoadBalancersOperations>`
* 2019-04-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2019_04_01.aio.operations.LoadBalancersOperations>`
* 2019-06-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2019_06_01.aio.operations.LoadBalancersOperations>`
* 2019-07-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2019_07_01.aio.operations.LoadBalancersOperations>`
* 2019-08-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2019_08_01.aio.operations.LoadBalancersOperations>`
* 2019-09-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2019_09_01.aio.operations.LoadBalancersOperations>`
* 2019-11-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2019_11_01.aio.operations.LoadBalancersOperations>`
* 2019-12-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2019_12_01.aio.operations.LoadBalancersOperations>`
* 2020-03-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2020_03_01.aio.operations.LoadBalancersOperations>`
* 2020-04-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2020_04_01.aio.operations.LoadBalancersOperations>`
* 2020-05-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2020_05_01.aio.operations.LoadBalancersOperations>`
* 2020-06-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2020_06_01.aio.operations.LoadBalancersOperations>`
* 2020-07-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2020_07_01.aio.operations.LoadBalancersOperations>`
* 2020-08-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2020_08_01.aio.operations.LoadBalancersOperations>`
* 2020-11-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2020_11_01.aio.operations.LoadBalancersOperations>`
* 2021-02-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2021_02_01.aio.operations.LoadBalancersOperations>`
* 2021-05-01: :class:`LoadBalancersOperations<azure.mgmt.network.v2021_05_01.aio.operations.LoadBalancersOperations>`
"""
api_version = self._get_api_version('load_balancers')
if api_version == '2015-06-15':
from ..v2015_06_15.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2016-09-01':
from ..v2016_09_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2016-12-01':
from ..v2016_12_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2017-03-01':
from ..v2017_03_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import LoadBalancersOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import LoadBalancersOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'load_balancers'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def local_network_gateways(self):
"""Instance depends on the API version:
* 2015-06-15: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2015_06_15.aio.operations.LocalNetworkGatewaysOperations>`
* 2016-09-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2016_09_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2016-12-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2016_12_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2017-03-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2017_03_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2017-06-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2017_06_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2017-10-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2017_10_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2018-01-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2018_01_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2018-02-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2018_02_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2018-04-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2018_04_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2018-06-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2018_06_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2018-07-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2018_07_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2018-08-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2018_08_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2018-10-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2018_10_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2018-11-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2018_11_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2018-12-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2018_12_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2019-02-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2019_02_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2019-04-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2019_04_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2019-06-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2019_06_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2019-07-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2019_07_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2019-08-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2019_08_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2019-09-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2019_09_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2019-11-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2019_11_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2019-12-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2019_12_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2020-03-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2020_03_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2020-04-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2020_04_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2020-05-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2020_05_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2020-06-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2020_06_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2020-07-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2020_07_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2020-08-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2020_08_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2020-11-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2020_11_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2021-02-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2021_02_01.aio.operations.LocalNetworkGatewaysOperations>`
* 2021-05-01: :class:`LocalNetworkGatewaysOperations<azure.mgmt.network.v2021_05_01.aio.operations.LocalNetworkGatewaysOperations>`
"""
api_version = self._get_api_version('local_network_gateways')
if api_version == '2015-06-15':
from ..v2015_06_15.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2016-09-01':
from ..v2016_09_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2016-12-01':
from ..v2016_12_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2017-03-01':
from ..v2017_03_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import LocalNetworkGatewaysOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'local_network_gateways'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def nat_gateways(self):
"""Instance depends on the API version:
* 2019-02-01: :class:`NatGatewaysOperations<azure.mgmt.network.v2019_02_01.aio.operations.NatGatewaysOperations>`
* 2019-04-01: :class:`NatGatewaysOperations<azure.mgmt.network.v2019_04_01.aio.operations.NatGatewaysOperations>`
* 2019-06-01: :class:`NatGatewaysOperations<azure.mgmt.network.v2019_06_01.aio.operations.NatGatewaysOperations>`
* 2019-07-01: :class:`NatGatewaysOperations<azure.mgmt.network.v2019_07_01.aio.operations.NatGatewaysOperations>`
* 2019-08-01: :class:`NatGatewaysOperations<azure.mgmt.network.v2019_08_01.aio.operations.NatGatewaysOperations>`
* 2019-09-01: :class:`NatGatewaysOperations<azure.mgmt.network.v2019_09_01.aio.operations.NatGatewaysOperations>`
* 2019-11-01: :class:`NatGatewaysOperations<azure.mgmt.network.v2019_11_01.aio.operations.NatGatewaysOperations>`
* 2019-12-01: :class:`NatGatewaysOperations<azure.mgmt.network.v2019_12_01.aio.operations.NatGatewaysOperations>`
* 2020-03-01: :class:`NatGatewaysOperations<azure.mgmt.network.v2020_03_01.aio.operations.NatGatewaysOperations>`
* 2020-04-01: :class:`NatGatewaysOperations<azure.mgmt.network.v2020_04_01.aio.operations.NatGatewaysOperations>`
* 2020-05-01: :class:`NatGatewaysOperations<azure.mgmt.network.v2020_05_01.aio.operations.NatGatewaysOperations>`
* 2020-06-01: :class:`NatGatewaysOperations<azure.mgmt.network.v2020_06_01.aio.operations.NatGatewaysOperations>`
* 2020-07-01: :class:`NatGatewaysOperations<azure.mgmt.network.v2020_07_01.aio.operations.NatGatewaysOperations>`
* 2020-08-01: :class:`NatGatewaysOperations<azure.mgmt.network.v2020_08_01.aio.operations.NatGatewaysOperations>`
* 2020-11-01: :class:`NatGatewaysOperations<azure.mgmt.network.v2020_11_01.aio.operations.NatGatewaysOperations>`
* 2021-02-01: :class:`NatGatewaysOperations<azure.mgmt.network.v2021_02_01.aio.operations.NatGatewaysOperations>`
* 2021-05-01: :class:`NatGatewaysOperations<azure.mgmt.network.v2021_05_01.aio.operations.NatGatewaysOperations>`
"""
api_version = self._get_api_version('nat_gateways')
if api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import NatGatewaysOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import NatGatewaysOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import NatGatewaysOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import NatGatewaysOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import NatGatewaysOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import NatGatewaysOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import NatGatewaysOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import NatGatewaysOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import NatGatewaysOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import NatGatewaysOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import NatGatewaysOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import NatGatewaysOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import NatGatewaysOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import NatGatewaysOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import NatGatewaysOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import NatGatewaysOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import NatGatewaysOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'nat_gateways'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def nat_rules(self):
"""Instance depends on the API version:
* 2020-08-01: :class:`NatRulesOperations<azure.mgmt.network.v2020_08_01.aio.operations.NatRulesOperations>`
* 2020-11-01: :class:`NatRulesOperations<azure.mgmt.network.v2020_11_01.aio.operations.NatRulesOperations>`
* 2021-02-01: :class:`NatRulesOperations<azure.mgmt.network.v2021_02_01.aio.operations.NatRulesOperations>`
* 2021-05-01: :class:`NatRulesOperations<azure.mgmt.network.v2021_05_01.aio.operations.NatRulesOperations>`
"""
api_version = self._get_api_version('nat_rules')
if api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import NatRulesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import NatRulesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import NatRulesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import NatRulesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'nat_rules'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def network_groups(self):
"""Instance depends on the API version:
* 2021-02-01-preview: :class:`NetworkGroupsOperations<azure.mgmt.network.v2021_02_01_preview.aio.operations.NetworkGroupsOperations>`
"""
api_version = self._get_api_version('network_groups')
if api_version == '2021-02-01-preview':
from ..v2021_02_01_preview.aio.operations import NetworkGroupsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'network_groups'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def network_interface_ip_configurations(self):
"""Instance depends on the API version:
* 2017-06-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2017_06_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
* 2017-10-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2017_10_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
* 2018-01-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2018_01_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
* 2018-02-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2018_02_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
* 2018-04-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2018_04_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
* 2018-06-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2018_06_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
* 2018-07-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2018_07_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
* 2018-08-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2018_08_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
* 2018-10-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2018_10_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
* 2018-11-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2018_11_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
* 2018-12-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2018_12_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
* 2019-02-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2019_02_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
* 2019-04-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2019_04_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
* 2019-06-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2019_06_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
* 2019-07-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2019_07_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
* 2019-08-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2019_08_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
* 2019-09-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2019_09_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
* 2019-11-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2019_11_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
* 2019-12-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2019_12_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
* 2020-03-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2020_03_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
* 2020-04-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2020_04_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
* 2020-05-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2020_05_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
* 2020-06-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2020_06_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
* 2020-07-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2020_07_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
* 2020-08-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2020_08_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
* 2020-11-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2020_11_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
* 2021-02-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2021_02_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
* 2021-05-01: :class:`NetworkInterfaceIPConfigurationsOperations<azure.mgmt.network.v2021_05_01.aio.operations.NetworkInterfaceIPConfigurationsOperations>`
"""
api_version = self._get_api_version('network_interface_ip_configurations')
if api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import NetworkInterfaceIPConfigurationsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'network_interface_ip_configurations'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def network_interface_load_balancers(self):
"""Instance depends on the API version:
* 2017-06-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2017_06_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
* 2017-10-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2017_10_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
* 2018-01-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2018_01_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
* 2018-02-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2018_02_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
* 2018-04-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2018_04_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
* 2018-06-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2018_06_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
* 2018-07-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2018_07_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
* 2018-08-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2018_08_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
* 2018-10-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2018_10_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
* 2018-11-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2018_11_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
* 2018-12-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2018_12_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
* 2019-02-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2019_02_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
* 2019-04-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2019_04_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
* 2019-06-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2019_06_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
* 2019-07-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2019_07_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
* 2019-08-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2019_08_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
* 2019-09-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2019_09_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
* 2019-11-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2019_11_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
* 2019-12-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2019_12_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
* 2020-03-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2020_03_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
* 2020-04-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2020_04_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
* 2020-05-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2020_05_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
* 2020-06-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2020_06_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
* 2020-07-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2020_07_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
* 2020-08-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2020_08_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
* 2020-11-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2020_11_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
* 2021-02-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2021_02_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
* 2021-05-01: :class:`NetworkInterfaceLoadBalancersOperations<azure.mgmt.network.v2021_05_01.aio.operations.NetworkInterfaceLoadBalancersOperations>`
"""
api_version = self._get_api_version('network_interface_load_balancers')
if api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import NetworkInterfaceLoadBalancersOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'network_interface_load_balancers'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def network_interface_tap_configurations(self):
"""Instance depends on the API version:
* 2018-08-01: :class:`NetworkInterfaceTapConfigurationsOperations<azure.mgmt.network.v2018_08_01.aio.operations.NetworkInterfaceTapConfigurationsOperations>`
* 2018-10-01: :class:`NetworkInterfaceTapConfigurationsOperations<azure.mgmt.network.v2018_10_01.aio.operations.NetworkInterfaceTapConfigurationsOperations>`
* 2018-11-01: :class:`NetworkInterfaceTapConfigurationsOperations<azure.mgmt.network.v2018_11_01.aio.operations.NetworkInterfaceTapConfigurationsOperations>`
* 2018-12-01: :class:`NetworkInterfaceTapConfigurationsOperations<azure.mgmt.network.v2018_12_01.aio.operations.NetworkInterfaceTapConfigurationsOperations>`
* 2019-02-01: :class:`NetworkInterfaceTapConfigurationsOperations<azure.mgmt.network.v2019_02_01.aio.operations.NetworkInterfaceTapConfigurationsOperations>`
* 2019-04-01: :class:`NetworkInterfaceTapConfigurationsOperations<azure.mgmt.network.v2019_04_01.aio.operations.NetworkInterfaceTapConfigurationsOperations>`
* 2019-06-01: :class:`NetworkInterfaceTapConfigurationsOperations<azure.mgmt.network.v2019_06_01.aio.operations.NetworkInterfaceTapConfigurationsOperations>`
* 2019-07-01: :class:`NetworkInterfaceTapConfigurationsOperations<azure.mgmt.network.v2019_07_01.aio.operations.NetworkInterfaceTapConfigurationsOperations>`
* 2019-08-01: :class:`NetworkInterfaceTapConfigurationsOperations<azure.mgmt.network.v2019_08_01.aio.operations.NetworkInterfaceTapConfigurationsOperations>`
* 2019-09-01: :class:`NetworkInterfaceTapConfigurationsOperations<azure.mgmt.network.v2019_09_01.aio.operations.NetworkInterfaceTapConfigurationsOperations>`
* 2019-11-01: :class:`NetworkInterfaceTapConfigurationsOperations<azure.mgmt.network.v2019_11_01.aio.operations.NetworkInterfaceTapConfigurationsOperations>`
* 2019-12-01: :class:`NetworkInterfaceTapConfigurationsOperations<azure.mgmt.network.v2019_12_01.aio.operations.NetworkInterfaceTapConfigurationsOperations>`
* 2020-03-01: :class:`NetworkInterfaceTapConfigurationsOperations<azure.mgmt.network.v2020_03_01.aio.operations.NetworkInterfaceTapConfigurationsOperations>`
* 2020-04-01: :class:`NetworkInterfaceTapConfigurationsOperations<azure.mgmt.network.v2020_04_01.aio.operations.NetworkInterfaceTapConfigurationsOperations>`
* 2020-05-01: :class:`NetworkInterfaceTapConfigurationsOperations<azure.mgmt.network.v2020_05_01.aio.operations.NetworkInterfaceTapConfigurationsOperations>`
* 2020-06-01: :class:`NetworkInterfaceTapConfigurationsOperations<azure.mgmt.network.v2020_06_01.aio.operations.NetworkInterfaceTapConfigurationsOperations>`
* 2020-07-01: :class:`NetworkInterfaceTapConfigurationsOperations<azure.mgmt.network.v2020_07_01.aio.operations.NetworkInterfaceTapConfigurationsOperations>`
* 2020-08-01: :class:`NetworkInterfaceTapConfigurationsOperations<azure.mgmt.network.v2020_08_01.aio.operations.NetworkInterfaceTapConfigurationsOperations>`
* 2020-11-01: :class:`NetworkInterfaceTapConfigurationsOperations<azure.mgmt.network.v2020_11_01.aio.operations.NetworkInterfaceTapConfigurationsOperations>`
* 2021-02-01: :class:`NetworkInterfaceTapConfigurationsOperations<azure.mgmt.network.v2021_02_01.aio.operations.NetworkInterfaceTapConfigurationsOperations>`
* 2021-05-01: :class:`NetworkInterfaceTapConfigurationsOperations<azure.mgmt.network.v2021_05_01.aio.operations.NetworkInterfaceTapConfigurationsOperations>`
"""
api_version = self._get_api_version('network_interface_tap_configurations')
if api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import NetworkInterfaceTapConfigurationsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'network_interface_tap_configurations'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def network_interfaces(self):
"""Instance depends on the API version:
* 2015-06-15: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2015_06_15.aio.operations.NetworkInterfacesOperations>`
* 2016-09-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2016_09_01.aio.operations.NetworkInterfacesOperations>`
* 2016-12-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2016_12_01.aio.operations.NetworkInterfacesOperations>`
* 2017-03-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2017_03_01.aio.operations.NetworkInterfacesOperations>`
* 2017-06-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2017_06_01.aio.operations.NetworkInterfacesOperations>`
* 2017-10-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2017_10_01.aio.operations.NetworkInterfacesOperations>`
* 2018-01-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2018_01_01.aio.operations.NetworkInterfacesOperations>`
* 2018-02-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2018_02_01.aio.operations.NetworkInterfacesOperations>`
* 2018-04-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2018_04_01.aio.operations.NetworkInterfacesOperations>`
* 2018-06-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2018_06_01.aio.operations.NetworkInterfacesOperations>`
* 2018-07-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2018_07_01.aio.operations.NetworkInterfacesOperations>`
* 2018-08-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2018_08_01.aio.operations.NetworkInterfacesOperations>`
* 2018-10-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2018_10_01.aio.operations.NetworkInterfacesOperations>`
* 2018-11-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2018_11_01.aio.operations.NetworkInterfacesOperations>`
* 2018-12-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2018_12_01.aio.operations.NetworkInterfacesOperations>`
* 2019-02-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2019_02_01.aio.operations.NetworkInterfacesOperations>`
* 2019-04-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2019_04_01.aio.operations.NetworkInterfacesOperations>`
* 2019-06-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2019_06_01.aio.operations.NetworkInterfacesOperations>`
* 2019-07-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2019_07_01.aio.operations.NetworkInterfacesOperations>`
* 2019-08-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2019_08_01.aio.operations.NetworkInterfacesOperations>`
* 2019-09-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2019_09_01.aio.operations.NetworkInterfacesOperations>`
* 2019-11-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2019_11_01.aio.operations.NetworkInterfacesOperations>`
* 2019-12-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2019_12_01.aio.operations.NetworkInterfacesOperations>`
* 2020-03-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2020_03_01.aio.operations.NetworkInterfacesOperations>`
* 2020-04-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2020_04_01.aio.operations.NetworkInterfacesOperations>`
* 2020-05-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2020_05_01.aio.operations.NetworkInterfacesOperations>`
* 2020-06-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2020_06_01.aio.operations.NetworkInterfacesOperations>`
* 2020-07-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2020_07_01.aio.operations.NetworkInterfacesOperations>`
* 2020-08-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2020_08_01.aio.operations.NetworkInterfacesOperations>`
* 2020-11-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2020_11_01.aio.operations.NetworkInterfacesOperations>`
* 2021-02-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2021_02_01.aio.operations.NetworkInterfacesOperations>`
* 2021-05-01: :class:`NetworkInterfacesOperations<azure.mgmt.network.v2021_05_01.aio.operations.NetworkInterfacesOperations>`
"""
api_version = self._get_api_version('network_interfaces')
if api_version == '2015-06-15':
from ..v2015_06_15.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2016-09-01':
from ..v2016_09_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2016-12-01':
from ..v2016_12_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2017-03-01':
from ..v2017_03_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import NetworkInterfacesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import NetworkInterfacesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'network_interfaces'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def network_manager_commits(self):
"""Instance depends on the API version:
* 2021-02-01-preview: :class:`NetworkManagerCommitsOperations<azure.mgmt.network.v2021_02_01_preview.aio.operations.NetworkManagerCommitsOperations>`
"""
api_version = self._get_api_version('network_manager_commits')
if api_version == '2021-02-01-preview':
from ..v2021_02_01_preview.aio.operations import NetworkManagerCommitsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'network_manager_commits'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def network_manager_deployment_status(self):
"""Instance depends on the API version:
* 2021-02-01-preview: :class:`NetworkManagerDeploymentStatusOperations<azure.mgmt.network.v2021_02_01_preview.aio.operations.NetworkManagerDeploymentStatusOperations>`
"""
api_version = self._get_api_version('network_manager_deployment_status')
if api_version == '2021-02-01-preview':
from ..v2021_02_01_preview.aio.operations import NetworkManagerDeploymentStatusOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'network_manager_deployment_status'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def network_manager_effective_security_admin_rules(self):
"""Instance depends on the API version:
* 2021-02-01-preview: :class:`NetworkManagerEffectiveSecurityAdminRulesOperations<azure.mgmt.network.v2021_02_01_preview.aio.operations.NetworkManagerEffectiveSecurityAdminRulesOperations>`
"""
api_version = self._get_api_version('network_manager_effective_security_admin_rules')
if api_version == '2021-02-01-preview':
from ..v2021_02_01_preview.aio.operations import NetworkManagerEffectiveSecurityAdminRulesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'network_manager_effective_security_admin_rules'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def network_managers(self):
"""Instance depends on the API version:
* 2021-02-01-preview: :class:`NetworkManagersOperations<azure.mgmt.network.v2021_02_01_preview.aio.operations.NetworkManagersOperations>`
"""
api_version = self._get_api_version('network_managers')
if api_version == '2021-02-01-preview':
from ..v2021_02_01_preview.aio.operations import NetworkManagersOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'network_managers'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def network_profiles(self):
"""Instance depends on the API version:
* 2018-08-01: :class:`NetworkProfilesOperations<azure.mgmt.network.v2018_08_01.aio.operations.NetworkProfilesOperations>`
* 2018-10-01: :class:`NetworkProfilesOperations<azure.mgmt.network.v2018_10_01.aio.operations.NetworkProfilesOperations>`
* 2018-11-01: :class:`NetworkProfilesOperations<azure.mgmt.network.v2018_11_01.aio.operations.NetworkProfilesOperations>`
* 2018-12-01: :class:`NetworkProfilesOperations<azure.mgmt.network.v2018_12_01.aio.operations.NetworkProfilesOperations>`
* 2019-02-01: :class:`NetworkProfilesOperations<azure.mgmt.network.v2019_02_01.aio.operations.NetworkProfilesOperations>`
* 2019-04-01: :class:`NetworkProfilesOperations<azure.mgmt.network.v2019_04_01.aio.operations.NetworkProfilesOperations>`
* 2019-06-01: :class:`NetworkProfilesOperations<azure.mgmt.network.v2019_06_01.aio.operations.NetworkProfilesOperations>`
* 2019-07-01: :class:`NetworkProfilesOperations<azure.mgmt.network.v2019_07_01.aio.operations.NetworkProfilesOperations>`
* 2019-08-01: :class:`NetworkProfilesOperations<azure.mgmt.network.v2019_08_01.aio.operations.NetworkProfilesOperations>`
* 2019-09-01: :class:`NetworkProfilesOperations<azure.mgmt.network.v2019_09_01.aio.operations.NetworkProfilesOperations>`
* 2019-11-01: :class:`NetworkProfilesOperations<azure.mgmt.network.v2019_11_01.aio.operations.NetworkProfilesOperations>`
* 2019-12-01: :class:`NetworkProfilesOperations<azure.mgmt.network.v2019_12_01.aio.operations.NetworkProfilesOperations>`
* 2020-03-01: :class:`NetworkProfilesOperations<azure.mgmt.network.v2020_03_01.aio.operations.NetworkProfilesOperations>`
* 2020-04-01: :class:`NetworkProfilesOperations<azure.mgmt.network.v2020_04_01.aio.operations.NetworkProfilesOperations>`
* 2020-05-01: :class:`NetworkProfilesOperations<azure.mgmt.network.v2020_05_01.aio.operations.NetworkProfilesOperations>`
* 2020-06-01: :class:`NetworkProfilesOperations<azure.mgmt.network.v2020_06_01.aio.operations.NetworkProfilesOperations>`
* 2020-07-01: :class:`NetworkProfilesOperations<azure.mgmt.network.v2020_07_01.aio.operations.NetworkProfilesOperations>`
* 2020-08-01: :class:`NetworkProfilesOperations<azure.mgmt.network.v2020_08_01.aio.operations.NetworkProfilesOperations>`
* 2020-11-01: :class:`NetworkProfilesOperations<azure.mgmt.network.v2020_11_01.aio.operations.NetworkProfilesOperations>`
* 2021-02-01: :class:`NetworkProfilesOperations<azure.mgmt.network.v2021_02_01.aio.operations.NetworkProfilesOperations>`
* 2021-05-01: :class:`NetworkProfilesOperations<azure.mgmt.network.v2021_05_01.aio.operations.NetworkProfilesOperations>`
"""
api_version = self._get_api_version('network_profiles')
if api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import NetworkProfilesOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import NetworkProfilesOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import NetworkProfilesOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import NetworkProfilesOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import NetworkProfilesOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import NetworkProfilesOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import NetworkProfilesOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import NetworkProfilesOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import NetworkProfilesOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import NetworkProfilesOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import NetworkProfilesOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import NetworkProfilesOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import NetworkProfilesOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import NetworkProfilesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import NetworkProfilesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import NetworkProfilesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import NetworkProfilesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import NetworkProfilesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import NetworkProfilesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import NetworkProfilesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import NetworkProfilesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'network_profiles'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def network_security_groups(self):
"""Instance depends on the API version:
* 2015-06-15: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2015_06_15.aio.operations.NetworkSecurityGroupsOperations>`
* 2016-09-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2016_09_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2016-12-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2016_12_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2017-03-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2017_03_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2017-06-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2017_06_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2017-10-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2017_10_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2018-01-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2018_01_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2018-02-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2018_02_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2018-04-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2018_04_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2018-06-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2018_06_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2018-07-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2018_07_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2018-08-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2018_08_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2018-10-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2018_10_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2018-11-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2018_11_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2018-12-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2018_12_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2019-02-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2019_02_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2019-04-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2019_04_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2019-06-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2019_06_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2019-07-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2019_07_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2019-08-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2019_08_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2019-09-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2019_09_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2019-11-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2019_11_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2019-12-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2019_12_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2020-03-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2020_03_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2020-04-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2020_04_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2020-05-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2020_05_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2020-06-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2020_06_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2020-07-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2020_07_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2020-08-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2020_08_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2020-11-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2020_11_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2021-02-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2021_02_01.aio.operations.NetworkSecurityGroupsOperations>`
* 2021-05-01: :class:`NetworkSecurityGroupsOperations<azure.mgmt.network.v2021_05_01.aio.operations.NetworkSecurityGroupsOperations>`
"""
api_version = self._get_api_version('network_security_groups')
if api_version == '2015-06-15':
from ..v2015_06_15.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2016-09-01':
from ..v2016_09_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2016-12-01':
from ..v2016_12_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2017-03-01':
from ..v2017_03_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import NetworkSecurityGroupsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'network_security_groups'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def network_security_perimeters(self):
"""Instance depends on the API version:
* 2021-02-01-preview: :class:`NetworkSecurityPerimetersOperations<azure.mgmt.network.v2021_02_01_preview.aio.operations.NetworkSecurityPerimetersOperations>`
"""
api_version = self._get_api_version('network_security_perimeters')
if api_version == '2021-02-01-preview':
from ..v2021_02_01_preview.aio.operations import NetworkSecurityPerimetersOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'network_security_perimeters'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def network_virtual_appliances(self):
"""Instance depends on the API version:
* 2019-12-01: :class:`NetworkVirtualAppliancesOperations<azure.mgmt.network.v2019_12_01.aio.operations.NetworkVirtualAppliancesOperations>`
* 2020-03-01: :class:`NetworkVirtualAppliancesOperations<azure.mgmt.network.v2020_03_01.aio.operations.NetworkVirtualAppliancesOperations>`
* 2020-04-01: :class:`NetworkVirtualAppliancesOperations<azure.mgmt.network.v2020_04_01.aio.operations.NetworkVirtualAppliancesOperations>`
* 2020-05-01: :class:`NetworkVirtualAppliancesOperations<azure.mgmt.network.v2020_05_01.aio.operations.NetworkVirtualAppliancesOperations>`
* 2020-06-01: :class:`NetworkVirtualAppliancesOperations<azure.mgmt.network.v2020_06_01.aio.operations.NetworkVirtualAppliancesOperations>`
* 2020-07-01: :class:`NetworkVirtualAppliancesOperations<azure.mgmt.network.v2020_07_01.aio.operations.NetworkVirtualAppliancesOperations>`
* 2020-08-01: :class:`NetworkVirtualAppliancesOperations<azure.mgmt.network.v2020_08_01.aio.operations.NetworkVirtualAppliancesOperations>`
* 2020-11-01: :class:`NetworkVirtualAppliancesOperations<azure.mgmt.network.v2020_11_01.aio.operations.NetworkVirtualAppliancesOperations>`
* 2021-02-01: :class:`NetworkVirtualAppliancesOperations<azure.mgmt.network.v2021_02_01.aio.operations.NetworkVirtualAppliancesOperations>`
* 2021-05-01: :class:`NetworkVirtualAppliancesOperations<azure.mgmt.network.v2021_05_01.aio.operations.NetworkVirtualAppliancesOperations>`
"""
api_version = self._get_api_version('network_virtual_appliances')
if api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import NetworkVirtualAppliancesOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import NetworkVirtualAppliancesOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import NetworkVirtualAppliancesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import NetworkVirtualAppliancesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import NetworkVirtualAppliancesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import NetworkVirtualAppliancesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import NetworkVirtualAppliancesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import NetworkVirtualAppliancesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import NetworkVirtualAppliancesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import NetworkVirtualAppliancesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'network_virtual_appliances'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def network_watchers(self):
"""Instance depends on the API version:
* 2016-09-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2016_09_01.aio.operations.NetworkWatchersOperations>`
* 2016-12-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2016_12_01.aio.operations.NetworkWatchersOperations>`
* 2017-03-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2017_03_01.aio.operations.NetworkWatchersOperations>`
* 2017-06-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2017_06_01.aio.operations.NetworkWatchersOperations>`
* 2017-10-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2017_10_01.aio.operations.NetworkWatchersOperations>`
* 2018-01-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2018_01_01.aio.operations.NetworkWatchersOperations>`
* 2018-02-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2018_02_01.aio.operations.NetworkWatchersOperations>`
* 2018-04-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2018_04_01.aio.operations.NetworkWatchersOperations>`
* 2018-06-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2018_06_01.aio.operations.NetworkWatchersOperations>`
* 2018-07-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2018_07_01.aio.operations.NetworkWatchersOperations>`
* 2018-08-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2018_08_01.aio.operations.NetworkWatchersOperations>`
* 2018-10-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2018_10_01.aio.operations.NetworkWatchersOperations>`
* 2018-11-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2018_11_01.aio.operations.NetworkWatchersOperations>`
* 2018-12-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2018_12_01.aio.operations.NetworkWatchersOperations>`
* 2019-02-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2019_02_01.aio.operations.NetworkWatchersOperations>`
* 2019-04-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2019_04_01.aio.operations.NetworkWatchersOperations>`
* 2019-06-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2019_06_01.aio.operations.NetworkWatchersOperations>`
* 2019-07-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2019_07_01.aio.operations.NetworkWatchersOperations>`
* 2019-08-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2019_08_01.aio.operations.NetworkWatchersOperations>`
* 2019-09-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2019_09_01.aio.operations.NetworkWatchersOperations>`
* 2019-11-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2019_11_01.aio.operations.NetworkWatchersOperations>`
* 2019-12-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2019_12_01.aio.operations.NetworkWatchersOperations>`
* 2020-03-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2020_03_01.aio.operations.NetworkWatchersOperations>`
* 2020-04-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2020_04_01.aio.operations.NetworkWatchersOperations>`
* 2020-05-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2020_05_01.aio.operations.NetworkWatchersOperations>`
* 2020-06-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2020_06_01.aio.operations.NetworkWatchersOperations>`
* 2020-07-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2020_07_01.aio.operations.NetworkWatchersOperations>`
* 2020-08-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2020_08_01.aio.operations.NetworkWatchersOperations>`
* 2020-11-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2020_11_01.aio.operations.NetworkWatchersOperations>`
* 2021-02-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2021_02_01.aio.operations.NetworkWatchersOperations>`
* 2021-05-01: :class:`NetworkWatchersOperations<azure.mgmt.network.v2021_05_01.aio.operations.NetworkWatchersOperations>`
"""
api_version = self._get_api_version('network_watchers')
if api_version == '2016-09-01':
from ..v2016_09_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2016-12-01':
from ..v2016_12_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2017-03-01':
from ..v2017_03_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import NetworkWatchersOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import NetworkWatchersOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'network_watchers'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def operations(self):
"""Instance depends on the API version:
* 2017-10-01: :class:`Operations<azure.mgmt.network.v2017_10_01.aio.operations.Operations>`
* 2018-01-01: :class:`Operations<azure.mgmt.network.v2018_01_01.aio.operations.Operations>`
* 2018-02-01: :class:`Operations<azure.mgmt.network.v2018_02_01.aio.operations.Operations>`
* 2018-04-01: :class:`Operations<azure.mgmt.network.v2018_04_01.aio.operations.Operations>`
* 2018-06-01: :class:`Operations<azure.mgmt.network.v2018_06_01.aio.operations.Operations>`
* 2018-07-01: :class:`Operations<azure.mgmt.network.v2018_07_01.aio.operations.Operations>`
* 2018-08-01: :class:`Operations<azure.mgmt.network.v2018_08_01.aio.operations.Operations>`
* 2018-10-01: :class:`Operations<azure.mgmt.network.v2018_10_01.aio.operations.Operations>`
* 2018-11-01: :class:`Operations<azure.mgmt.network.v2018_11_01.aio.operations.Operations>`
* 2018-12-01: :class:`Operations<azure.mgmt.network.v2018_12_01.aio.operations.Operations>`
* 2019-02-01: :class:`Operations<azure.mgmt.network.v2019_02_01.aio.operations.Operations>`
* 2019-04-01: :class:`Operations<azure.mgmt.network.v2019_04_01.aio.operations.Operations>`
* 2019-06-01: :class:`Operations<azure.mgmt.network.v2019_06_01.aio.operations.Operations>`
* 2019-07-01: :class:`Operations<azure.mgmt.network.v2019_07_01.aio.operations.Operations>`
* 2019-08-01: :class:`Operations<azure.mgmt.network.v2019_08_01.aio.operations.Operations>`
* 2019-09-01: :class:`Operations<azure.mgmt.network.v2019_09_01.aio.operations.Operations>`
* 2019-11-01: :class:`Operations<azure.mgmt.network.v2019_11_01.aio.operations.Operations>`
* 2019-12-01: :class:`Operations<azure.mgmt.network.v2019_12_01.aio.operations.Operations>`
* 2020-03-01: :class:`Operations<azure.mgmt.network.v2020_03_01.aio.operations.Operations>`
* 2020-04-01: :class:`Operations<azure.mgmt.network.v2020_04_01.aio.operations.Operations>`
* 2020-05-01: :class:`Operations<azure.mgmt.network.v2020_05_01.aio.operations.Operations>`
* 2020-06-01: :class:`Operations<azure.mgmt.network.v2020_06_01.aio.operations.Operations>`
* 2020-07-01: :class:`Operations<azure.mgmt.network.v2020_07_01.aio.operations.Operations>`
* 2020-08-01: :class:`Operations<azure.mgmt.network.v2020_08_01.aio.operations.Operations>`
* 2020-11-01: :class:`Operations<azure.mgmt.network.v2020_11_01.aio.operations.Operations>`
* 2021-02-01: :class:`Operations<azure.mgmt.network.v2021_02_01.aio.operations.Operations>`
* 2021-05-01: :class:`Operations<azure.mgmt.network.v2021_05_01.aio.operations.Operations>`
"""
api_version = self._get_api_version('operations')
if api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import Operations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import Operations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import Operations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import Operations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import Operations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import Operations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import Operations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import Operations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import Operations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import Operations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import Operations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import Operations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import Operations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import Operations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import Operations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import Operations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import Operations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import Operations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import Operations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import Operations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import Operations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import Operations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import Operations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import Operations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import Operations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import Operations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import Operations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'operations'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def p2_svpn_gateways(self):
"""Instance depends on the API version:
* 2018-08-01: :class:`P2SVpnGatewaysOperations<azure.mgmt.network.v2018_08_01.aio.operations.P2SVpnGatewaysOperations>`
* 2018-10-01: :class:`P2SVpnGatewaysOperations<azure.mgmt.network.v2018_10_01.aio.operations.P2SVpnGatewaysOperations>`
* 2018-11-01: :class:`P2SVpnGatewaysOperations<azure.mgmt.network.v2018_11_01.aio.operations.P2SVpnGatewaysOperations>`
* 2018-12-01: :class:`P2SVpnGatewaysOperations<azure.mgmt.network.v2018_12_01.aio.operations.P2SVpnGatewaysOperations>`
* 2019-02-01: :class:`P2SVpnGatewaysOperations<azure.mgmt.network.v2019_02_01.aio.operations.P2SVpnGatewaysOperations>`
* 2019-04-01: :class:`P2SVpnGatewaysOperations<azure.mgmt.network.v2019_04_01.aio.operations.P2SVpnGatewaysOperations>`
* 2019-06-01: :class:`P2SVpnGatewaysOperations<azure.mgmt.network.v2019_06_01.aio.operations.P2SVpnGatewaysOperations>`
* 2019-07-01: :class:`P2SVpnGatewaysOperations<azure.mgmt.network.v2019_07_01.aio.operations.P2SVpnGatewaysOperations>`
* 2019-08-01: :class:`P2SVpnGatewaysOperations<azure.mgmt.network.v2019_08_01.aio.operations.P2SVpnGatewaysOperations>`
* 2019-09-01: :class:`P2SVpnGatewaysOperations<azure.mgmt.network.v2019_09_01.aio.operations.P2SVpnGatewaysOperations>`
* 2019-11-01: :class:`P2SVpnGatewaysOperations<azure.mgmt.network.v2019_11_01.aio.operations.P2SVpnGatewaysOperations>`
* 2019-12-01: :class:`P2SVpnGatewaysOperations<azure.mgmt.network.v2019_12_01.aio.operations.P2SVpnGatewaysOperations>`
* 2020-03-01: :class:`P2SVpnGatewaysOperations<azure.mgmt.network.v2020_03_01.aio.operations.P2SVpnGatewaysOperations>`
* 2020-04-01: :class:`P2SVpnGatewaysOperations<azure.mgmt.network.v2020_04_01.aio.operations.P2SVpnGatewaysOperations>`
* 2020-05-01: :class:`P2SVpnGatewaysOperations<azure.mgmt.network.v2020_05_01.aio.operations.P2SVpnGatewaysOperations>`
* 2020-06-01: :class:`P2SVpnGatewaysOperations<azure.mgmt.network.v2020_06_01.aio.operations.P2SVpnGatewaysOperations>`
* 2020-07-01: :class:`P2SVpnGatewaysOperations<azure.mgmt.network.v2020_07_01.aio.operations.P2SVpnGatewaysOperations>`
* 2020-08-01: :class:`P2SVpnGatewaysOperations<azure.mgmt.network.v2020_08_01.aio.operations.P2SVpnGatewaysOperations>`
* 2020-11-01: :class:`P2SVpnGatewaysOperations<azure.mgmt.network.v2020_11_01.aio.operations.P2SVpnGatewaysOperations>`
* 2021-02-01: :class:`P2SVpnGatewaysOperations<azure.mgmt.network.v2021_02_01.aio.operations.P2SVpnGatewaysOperations>`
* 2021-05-01: :class:`P2SVpnGatewaysOperations<azure.mgmt.network.v2021_05_01.aio.operations.P2SVpnGatewaysOperations>`
"""
api_version = self._get_api_version('p2_svpn_gateways')
if api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import P2SVpnGatewaysOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import P2SVpnGatewaysOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import P2SVpnGatewaysOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import P2SVpnGatewaysOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import P2SVpnGatewaysOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import P2SVpnGatewaysOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import P2SVpnGatewaysOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import P2SVpnGatewaysOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import P2SVpnGatewaysOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import P2SVpnGatewaysOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import P2SVpnGatewaysOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import P2SVpnGatewaysOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import P2SVpnGatewaysOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import P2SVpnGatewaysOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import P2SVpnGatewaysOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import P2SVpnGatewaysOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import P2SVpnGatewaysOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import P2SVpnGatewaysOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import P2SVpnGatewaysOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import P2SVpnGatewaysOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import P2SVpnGatewaysOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'p2_svpn_gateways'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def p2_svpn_server_configurations(self):
"""Instance depends on the API version:
* 2018-08-01: :class:`P2SVpnServerConfigurationsOperations<azure.mgmt.network.v2018_08_01.aio.operations.P2SVpnServerConfigurationsOperations>`
* 2018-10-01: :class:`P2SVpnServerConfigurationsOperations<azure.mgmt.network.v2018_10_01.aio.operations.P2SVpnServerConfigurationsOperations>`
* 2018-11-01: :class:`P2SVpnServerConfigurationsOperations<azure.mgmt.network.v2018_11_01.aio.operations.P2SVpnServerConfigurationsOperations>`
* 2018-12-01: :class:`P2SVpnServerConfigurationsOperations<azure.mgmt.network.v2018_12_01.aio.operations.P2SVpnServerConfigurationsOperations>`
* 2019-02-01: :class:`P2SVpnServerConfigurationsOperations<azure.mgmt.network.v2019_02_01.aio.operations.P2SVpnServerConfigurationsOperations>`
* 2019-04-01: :class:`P2SVpnServerConfigurationsOperations<azure.mgmt.network.v2019_04_01.aio.operations.P2SVpnServerConfigurationsOperations>`
* 2019-06-01: :class:`P2SVpnServerConfigurationsOperations<azure.mgmt.network.v2019_06_01.aio.operations.P2SVpnServerConfigurationsOperations>`
* 2019-07-01: :class:`P2SVpnServerConfigurationsOperations<azure.mgmt.network.v2019_07_01.aio.operations.P2SVpnServerConfigurationsOperations>`
"""
api_version = self._get_api_version('p2_svpn_server_configurations')
if api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import P2SVpnServerConfigurationsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import P2SVpnServerConfigurationsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import P2SVpnServerConfigurationsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import P2SVpnServerConfigurationsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import P2SVpnServerConfigurationsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import P2SVpnServerConfigurationsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import P2SVpnServerConfigurationsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import P2SVpnServerConfigurationsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'p2_svpn_server_configurations'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def packet_captures(self):
"""Instance depends on the API version:
* 2016-09-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2016_09_01.aio.operations.PacketCapturesOperations>`
* 2016-12-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2016_12_01.aio.operations.PacketCapturesOperations>`
* 2017-03-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2017_03_01.aio.operations.PacketCapturesOperations>`
* 2017-06-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2017_06_01.aio.operations.PacketCapturesOperations>`
* 2017-10-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2017_10_01.aio.operations.PacketCapturesOperations>`
* 2018-01-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2018_01_01.aio.operations.PacketCapturesOperations>`
* 2018-02-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2018_02_01.aio.operations.PacketCapturesOperations>`
* 2018-04-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2018_04_01.aio.operations.PacketCapturesOperations>`
* 2018-06-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2018_06_01.aio.operations.PacketCapturesOperations>`
* 2018-07-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2018_07_01.aio.operations.PacketCapturesOperations>`
* 2018-08-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2018_08_01.aio.operations.PacketCapturesOperations>`
* 2018-10-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2018_10_01.aio.operations.PacketCapturesOperations>`
* 2018-11-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2018_11_01.aio.operations.PacketCapturesOperations>`
* 2018-12-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2018_12_01.aio.operations.PacketCapturesOperations>`
* 2019-02-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2019_02_01.aio.operations.PacketCapturesOperations>`
* 2019-04-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2019_04_01.aio.operations.PacketCapturesOperations>`
* 2019-06-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2019_06_01.aio.operations.PacketCapturesOperations>`
* 2019-07-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2019_07_01.aio.operations.PacketCapturesOperations>`
* 2019-08-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2019_08_01.aio.operations.PacketCapturesOperations>`
* 2019-09-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2019_09_01.aio.operations.PacketCapturesOperations>`
* 2019-11-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2019_11_01.aio.operations.PacketCapturesOperations>`
* 2019-12-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2019_12_01.aio.operations.PacketCapturesOperations>`
* 2020-03-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2020_03_01.aio.operations.PacketCapturesOperations>`
* 2020-04-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2020_04_01.aio.operations.PacketCapturesOperations>`
* 2020-05-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2020_05_01.aio.operations.PacketCapturesOperations>`
* 2020-06-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2020_06_01.aio.operations.PacketCapturesOperations>`
* 2020-07-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2020_07_01.aio.operations.PacketCapturesOperations>`
* 2020-08-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2020_08_01.aio.operations.PacketCapturesOperations>`
* 2020-11-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2020_11_01.aio.operations.PacketCapturesOperations>`
* 2021-02-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2021_02_01.aio.operations.PacketCapturesOperations>`
* 2021-05-01: :class:`PacketCapturesOperations<azure.mgmt.network.v2021_05_01.aio.operations.PacketCapturesOperations>`
"""
api_version = self._get_api_version('packet_captures')
if api_version == '2016-09-01':
from ..v2016_09_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2016-12-01':
from ..v2016_12_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2017-03-01':
from ..v2017_03_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import PacketCapturesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import PacketCapturesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'packet_captures'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def peer_express_route_circuit_connections(self):
"""Instance depends on the API version:
* 2018-12-01: :class:`PeerExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2018_12_01.aio.operations.PeerExpressRouteCircuitConnectionsOperations>`
* 2019-02-01: :class:`PeerExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2019_02_01.aio.operations.PeerExpressRouteCircuitConnectionsOperations>`
* 2019-04-01: :class:`PeerExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2019_04_01.aio.operations.PeerExpressRouteCircuitConnectionsOperations>`
* 2019-06-01: :class:`PeerExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2019_06_01.aio.operations.PeerExpressRouteCircuitConnectionsOperations>`
* 2019-07-01: :class:`PeerExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2019_07_01.aio.operations.PeerExpressRouteCircuitConnectionsOperations>`
* 2019-08-01: :class:`PeerExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2019_08_01.aio.operations.PeerExpressRouteCircuitConnectionsOperations>`
* 2019-09-01: :class:`PeerExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2019_09_01.aio.operations.PeerExpressRouteCircuitConnectionsOperations>`
* 2019-11-01: :class:`PeerExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2019_11_01.aio.operations.PeerExpressRouteCircuitConnectionsOperations>`
* 2019-12-01: :class:`PeerExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2019_12_01.aio.operations.PeerExpressRouteCircuitConnectionsOperations>`
* 2020-03-01: :class:`PeerExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2020_03_01.aio.operations.PeerExpressRouteCircuitConnectionsOperations>`
* 2020-04-01: :class:`PeerExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2020_04_01.aio.operations.PeerExpressRouteCircuitConnectionsOperations>`
* 2020-05-01: :class:`PeerExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2020_05_01.aio.operations.PeerExpressRouteCircuitConnectionsOperations>`
* 2020-06-01: :class:`PeerExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2020_06_01.aio.operations.PeerExpressRouteCircuitConnectionsOperations>`
* 2020-07-01: :class:`PeerExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2020_07_01.aio.operations.PeerExpressRouteCircuitConnectionsOperations>`
* 2020-08-01: :class:`PeerExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2020_08_01.aio.operations.PeerExpressRouteCircuitConnectionsOperations>`
* 2020-11-01: :class:`PeerExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2020_11_01.aio.operations.PeerExpressRouteCircuitConnectionsOperations>`
* 2021-02-01: :class:`PeerExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2021_02_01.aio.operations.PeerExpressRouteCircuitConnectionsOperations>`
* 2021-05-01: :class:`PeerExpressRouteCircuitConnectionsOperations<azure.mgmt.network.v2021_05_01.aio.operations.PeerExpressRouteCircuitConnectionsOperations>`
"""
api_version = self._get_api_version('peer_express_route_circuit_connections')
if api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import PeerExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import PeerExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import PeerExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import PeerExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import PeerExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import PeerExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import PeerExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import PeerExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import PeerExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import PeerExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import PeerExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import PeerExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import PeerExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import PeerExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import PeerExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import PeerExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import PeerExpressRouteCircuitConnectionsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import PeerExpressRouteCircuitConnectionsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'peer_express_route_circuit_connections'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def perimeter_associable_resource_types(self):
"""Instance depends on the API version:
* 2021-02-01-preview: :class:`PerimeterAssociableResourceTypesOperations<azure.mgmt.network.v2021_02_01_preview.aio.operations.PerimeterAssociableResourceTypesOperations>`
"""
api_version = self._get_api_version('perimeter_associable_resource_types')
if api_version == '2021-02-01-preview':
from ..v2021_02_01_preview.aio.operations import PerimeterAssociableResourceTypesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'perimeter_associable_resource_types'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def private_dns_zone_groups(self):
"""Instance depends on the API version:
* 2020-03-01: :class:`PrivateDnsZoneGroupsOperations<azure.mgmt.network.v2020_03_01.aio.operations.PrivateDnsZoneGroupsOperations>`
* 2020-04-01: :class:`PrivateDnsZoneGroupsOperations<azure.mgmt.network.v2020_04_01.aio.operations.PrivateDnsZoneGroupsOperations>`
* 2020-05-01: :class:`PrivateDnsZoneGroupsOperations<azure.mgmt.network.v2020_05_01.aio.operations.PrivateDnsZoneGroupsOperations>`
* 2020-06-01: :class:`PrivateDnsZoneGroupsOperations<azure.mgmt.network.v2020_06_01.aio.operations.PrivateDnsZoneGroupsOperations>`
* 2020-07-01: :class:`PrivateDnsZoneGroupsOperations<azure.mgmt.network.v2020_07_01.aio.operations.PrivateDnsZoneGroupsOperations>`
* 2020-08-01: :class:`PrivateDnsZoneGroupsOperations<azure.mgmt.network.v2020_08_01.aio.operations.PrivateDnsZoneGroupsOperations>`
* 2020-11-01: :class:`PrivateDnsZoneGroupsOperations<azure.mgmt.network.v2020_11_01.aio.operations.PrivateDnsZoneGroupsOperations>`
* 2021-02-01: :class:`PrivateDnsZoneGroupsOperations<azure.mgmt.network.v2021_02_01.aio.operations.PrivateDnsZoneGroupsOperations>`
* 2021-05-01: :class:`PrivateDnsZoneGroupsOperations<azure.mgmt.network.v2021_05_01.aio.operations.PrivateDnsZoneGroupsOperations>`
"""
api_version = self._get_api_version('private_dns_zone_groups')
if api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import PrivateDnsZoneGroupsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import PrivateDnsZoneGroupsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import PrivateDnsZoneGroupsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import PrivateDnsZoneGroupsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import PrivateDnsZoneGroupsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import PrivateDnsZoneGroupsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import PrivateDnsZoneGroupsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import PrivateDnsZoneGroupsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import PrivateDnsZoneGroupsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'private_dns_zone_groups'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def private_endpoints(self):
"""Instance depends on the API version:
* 2019-04-01: :class:`PrivateEndpointsOperations<azure.mgmt.network.v2019_04_01.aio.operations.PrivateEndpointsOperations>`
* 2019-06-01: :class:`PrivateEndpointsOperations<azure.mgmt.network.v2019_06_01.aio.operations.PrivateEndpointsOperations>`
* 2019-07-01: :class:`PrivateEndpointsOperations<azure.mgmt.network.v2019_07_01.aio.operations.PrivateEndpointsOperations>`
* 2019-08-01: :class:`PrivateEndpointsOperations<azure.mgmt.network.v2019_08_01.aio.operations.PrivateEndpointsOperations>`
* 2019-09-01: :class:`PrivateEndpointsOperations<azure.mgmt.network.v2019_09_01.aio.operations.PrivateEndpointsOperations>`
* 2019-11-01: :class:`PrivateEndpointsOperations<azure.mgmt.network.v2019_11_01.aio.operations.PrivateEndpointsOperations>`
* 2019-12-01: :class:`PrivateEndpointsOperations<azure.mgmt.network.v2019_12_01.aio.operations.PrivateEndpointsOperations>`
* 2020-03-01: :class:`PrivateEndpointsOperations<azure.mgmt.network.v2020_03_01.aio.operations.PrivateEndpointsOperations>`
* 2020-04-01: :class:`PrivateEndpointsOperations<azure.mgmt.network.v2020_04_01.aio.operations.PrivateEndpointsOperations>`
* 2020-05-01: :class:`PrivateEndpointsOperations<azure.mgmt.network.v2020_05_01.aio.operations.PrivateEndpointsOperations>`
* 2020-06-01: :class:`PrivateEndpointsOperations<azure.mgmt.network.v2020_06_01.aio.operations.PrivateEndpointsOperations>`
* 2020-07-01: :class:`PrivateEndpointsOperations<azure.mgmt.network.v2020_07_01.aio.operations.PrivateEndpointsOperations>`
* 2020-08-01: :class:`PrivateEndpointsOperations<azure.mgmt.network.v2020_08_01.aio.operations.PrivateEndpointsOperations>`
* 2020-11-01: :class:`PrivateEndpointsOperations<azure.mgmt.network.v2020_11_01.aio.operations.PrivateEndpointsOperations>`
* 2021-02-01: :class:`PrivateEndpointsOperations<azure.mgmt.network.v2021_02_01.aio.operations.PrivateEndpointsOperations>`
* 2021-05-01: :class:`PrivateEndpointsOperations<azure.mgmt.network.v2021_05_01.aio.operations.PrivateEndpointsOperations>`
"""
api_version = self._get_api_version('private_endpoints')
if api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import PrivateEndpointsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import PrivateEndpointsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import PrivateEndpointsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import PrivateEndpointsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import PrivateEndpointsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import PrivateEndpointsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import PrivateEndpointsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import PrivateEndpointsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import PrivateEndpointsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import PrivateEndpointsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import PrivateEndpointsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import PrivateEndpointsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import PrivateEndpointsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import PrivateEndpointsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import PrivateEndpointsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import PrivateEndpointsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'private_endpoints'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def private_link_services(self):
"""Instance depends on the API version:
* 2019-04-01: :class:`PrivateLinkServicesOperations<azure.mgmt.network.v2019_04_01.aio.operations.PrivateLinkServicesOperations>`
* 2019-06-01: :class:`PrivateLinkServicesOperations<azure.mgmt.network.v2019_06_01.aio.operations.PrivateLinkServicesOperations>`
* 2019-07-01: :class:`PrivateLinkServicesOperations<azure.mgmt.network.v2019_07_01.aio.operations.PrivateLinkServicesOperations>`
* 2019-08-01: :class:`PrivateLinkServicesOperations<azure.mgmt.network.v2019_08_01.aio.operations.PrivateLinkServicesOperations>`
* 2019-09-01: :class:`PrivateLinkServicesOperations<azure.mgmt.network.v2019_09_01.aio.operations.PrivateLinkServicesOperations>`
* 2019-11-01: :class:`PrivateLinkServicesOperations<azure.mgmt.network.v2019_11_01.aio.operations.PrivateLinkServicesOperations>`
* 2019-12-01: :class:`PrivateLinkServicesOperations<azure.mgmt.network.v2019_12_01.aio.operations.PrivateLinkServicesOperations>`
* 2020-03-01: :class:`PrivateLinkServicesOperations<azure.mgmt.network.v2020_03_01.aio.operations.PrivateLinkServicesOperations>`
* 2020-04-01: :class:`PrivateLinkServicesOperations<azure.mgmt.network.v2020_04_01.aio.operations.PrivateLinkServicesOperations>`
* 2020-05-01: :class:`PrivateLinkServicesOperations<azure.mgmt.network.v2020_05_01.aio.operations.PrivateLinkServicesOperations>`
* 2020-06-01: :class:`PrivateLinkServicesOperations<azure.mgmt.network.v2020_06_01.aio.operations.PrivateLinkServicesOperations>`
* 2020-07-01: :class:`PrivateLinkServicesOperations<azure.mgmt.network.v2020_07_01.aio.operations.PrivateLinkServicesOperations>`
* 2020-08-01: :class:`PrivateLinkServicesOperations<azure.mgmt.network.v2020_08_01.aio.operations.PrivateLinkServicesOperations>`
* 2020-11-01: :class:`PrivateLinkServicesOperations<azure.mgmt.network.v2020_11_01.aio.operations.PrivateLinkServicesOperations>`
* 2021-02-01: :class:`PrivateLinkServicesOperations<azure.mgmt.network.v2021_02_01.aio.operations.PrivateLinkServicesOperations>`
* 2021-05-01: :class:`PrivateLinkServicesOperations<azure.mgmt.network.v2021_05_01.aio.operations.PrivateLinkServicesOperations>`
"""
api_version = self._get_api_version('private_link_services')
if api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import PrivateLinkServicesOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import PrivateLinkServicesOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import PrivateLinkServicesOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import PrivateLinkServicesOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import PrivateLinkServicesOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import PrivateLinkServicesOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import PrivateLinkServicesOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import PrivateLinkServicesOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import PrivateLinkServicesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import PrivateLinkServicesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import PrivateLinkServicesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import PrivateLinkServicesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import PrivateLinkServicesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import PrivateLinkServicesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import PrivateLinkServicesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import PrivateLinkServicesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'private_link_services'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def public_ip_addresses(self):
"""Instance depends on the API version:
* 2015-06-15: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2015_06_15.aio.operations.PublicIPAddressesOperations>`
* 2016-09-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2016_09_01.aio.operations.PublicIPAddressesOperations>`
* 2016-12-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2016_12_01.aio.operations.PublicIPAddressesOperations>`
* 2017-03-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2017_03_01.aio.operations.PublicIPAddressesOperations>`
* 2017-06-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2017_06_01.aio.operations.PublicIPAddressesOperations>`
* 2017-10-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2017_10_01.aio.operations.PublicIPAddressesOperations>`
* 2018-01-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2018_01_01.aio.operations.PublicIPAddressesOperations>`
* 2018-02-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2018_02_01.aio.operations.PublicIPAddressesOperations>`
* 2018-04-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2018_04_01.aio.operations.PublicIPAddressesOperations>`
* 2018-06-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2018_06_01.aio.operations.PublicIPAddressesOperations>`
* 2018-07-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2018_07_01.aio.operations.PublicIPAddressesOperations>`
* 2018-08-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2018_08_01.aio.operations.PublicIPAddressesOperations>`
* 2018-10-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2018_10_01.aio.operations.PublicIPAddressesOperations>`
* 2018-11-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2018_11_01.aio.operations.PublicIPAddressesOperations>`
* 2018-12-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2018_12_01.aio.operations.PublicIPAddressesOperations>`
* 2019-02-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2019_02_01.aio.operations.PublicIPAddressesOperations>`
* 2019-04-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2019_04_01.aio.operations.PublicIPAddressesOperations>`
* 2019-06-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2019_06_01.aio.operations.PublicIPAddressesOperations>`
* 2019-07-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2019_07_01.aio.operations.PublicIPAddressesOperations>`
* 2019-08-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2019_08_01.aio.operations.PublicIPAddressesOperations>`
* 2019-09-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2019_09_01.aio.operations.PublicIPAddressesOperations>`
* 2019-11-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2019_11_01.aio.operations.PublicIPAddressesOperations>`
* 2019-12-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2019_12_01.aio.operations.PublicIPAddressesOperations>`
* 2020-03-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2020_03_01.aio.operations.PublicIPAddressesOperations>`
* 2020-04-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2020_04_01.aio.operations.PublicIPAddressesOperations>`
* 2020-05-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2020_05_01.aio.operations.PublicIPAddressesOperations>`
* 2020-06-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2020_06_01.aio.operations.PublicIPAddressesOperations>`
* 2020-07-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2020_07_01.aio.operations.PublicIPAddressesOperations>`
* 2020-08-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2020_08_01.aio.operations.PublicIPAddressesOperations>`
* 2020-11-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2020_11_01.aio.operations.PublicIPAddressesOperations>`
* 2021-02-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2021_02_01.aio.operations.PublicIPAddressesOperations>`
* 2021-05-01: :class:`PublicIPAddressesOperations<azure.mgmt.network.v2021_05_01.aio.operations.PublicIPAddressesOperations>`
"""
api_version = self._get_api_version('public_ip_addresses')
if api_version == '2015-06-15':
from ..v2015_06_15.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2016-09-01':
from ..v2016_09_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2016-12-01':
from ..v2016_12_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2017-03-01':
from ..v2017_03_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import PublicIPAddressesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import PublicIPAddressesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'public_ip_addresses'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def public_ip_prefixes(self):
"""Instance depends on the API version:
* 2018-07-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2018_07_01.aio.operations.PublicIPPrefixesOperations>`
* 2018-08-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2018_08_01.aio.operations.PublicIPPrefixesOperations>`
* 2018-10-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2018_10_01.aio.operations.PublicIPPrefixesOperations>`
* 2018-11-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2018_11_01.aio.operations.PublicIPPrefixesOperations>`
* 2018-12-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2018_12_01.aio.operations.PublicIPPrefixesOperations>`
* 2019-02-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2019_02_01.aio.operations.PublicIPPrefixesOperations>`
* 2019-04-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2019_04_01.aio.operations.PublicIPPrefixesOperations>`
* 2019-06-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2019_06_01.aio.operations.PublicIPPrefixesOperations>`
* 2019-07-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2019_07_01.aio.operations.PublicIPPrefixesOperations>`
* 2019-08-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2019_08_01.aio.operations.PublicIPPrefixesOperations>`
* 2019-09-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2019_09_01.aio.operations.PublicIPPrefixesOperations>`
* 2019-11-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2019_11_01.aio.operations.PublicIPPrefixesOperations>`
* 2019-12-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2019_12_01.aio.operations.PublicIPPrefixesOperations>`
* 2020-03-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2020_03_01.aio.operations.PublicIPPrefixesOperations>`
* 2020-04-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2020_04_01.aio.operations.PublicIPPrefixesOperations>`
* 2020-05-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2020_05_01.aio.operations.PublicIPPrefixesOperations>`
* 2020-06-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2020_06_01.aio.operations.PublicIPPrefixesOperations>`
* 2020-07-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2020_07_01.aio.operations.PublicIPPrefixesOperations>`
* 2020-08-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2020_08_01.aio.operations.PublicIPPrefixesOperations>`
* 2020-11-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2020_11_01.aio.operations.PublicIPPrefixesOperations>`
* 2021-02-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2021_02_01.aio.operations.PublicIPPrefixesOperations>`
* 2021-05-01: :class:`PublicIPPrefixesOperations<azure.mgmt.network.v2021_05_01.aio.operations.PublicIPPrefixesOperations>`
"""
api_version = self._get_api_version('public_ip_prefixes')
if api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import PublicIPPrefixesOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import PublicIPPrefixesOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import PublicIPPrefixesOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import PublicIPPrefixesOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import PublicIPPrefixesOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import PublicIPPrefixesOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import PublicIPPrefixesOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import PublicIPPrefixesOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import PublicIPPrefixesOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import PublicIPPrefixesOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import PublicIPPrefixesOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import PublicIPPrefixesOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import PublicIPPrefixesOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import PublicIPPrefixesOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import PublicIPPrefixesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import PublicIPPrefixesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import PublicIPPrefixesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import PublicIPPrefixesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import PublicIPPrefixesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import PublicIPPrefixesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import PublicIPPrefixesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import PublicIPPrefixesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'public_ip_prefixes'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def resource_navigation_links(self):
"""Instance depends on the API version:
* 2019-02-01: :class:`ResourceNavigationLinksOperations<azure.mgmt.network.v2019_02_01.aio.operations.ResourceNavigationLinksOperations>`
* 2019-04-01: :class:`ResourceNavigationLinksOperations<azure.mgmt.network.v2019_04_01.aio.operations.ResourceNavigationLinksOperations>`
* 2019-06-01: :class:`ResourceNavigationLinksOperations<azure.mgmt.network.v2019_06_01.aio.operations.ResourceNavigationLinksOperations>`
* 2019-07-01: :class:`ResourceNavigationLinksOperations<azure.mgmt.network.v2019_07_01.aio.operations.ResourceNavigationLinksOperations>`
* 2019-08-01: :class:`ResourceNavigationLinksOperations<azure.mgmt.network.v2019_08_01.aio.operations.ResourceNavigationLinksOperations>`
* 2019-09-01: :class:`ResourceNavigationLinksOperations<azure.mgmt.network.v2019_09_01.aio.operations.ResourceNavigationLinksOperations>`
* 2019-11-01: :class:`ResourceNavigationLinksOperations<azure.mgmt.network.v2019_11_01.aio.operations.ResourceNavigationLinksOperations>`
* 2019-12-01: :class:`ResourceNavigationLinksOperations<azure.mgmt.network.v2019_12_01.aio.operations.ResourceNavigationLinksOperations>`
* 2020-03-01: :class:`ResourceNavigationLinksOperations<azure.mgmt.network.v2020_03_01.aio.operations.ResourceNavigationLinksOperations>`
* 2020-04-01: :class:`ResourceNavigationLinksOperations<azure.mgmt.network.v2020_04_01.aio.operations.ResourceNavigationLinksOperations>`
* 2020-05-01: :class:`ResourceNavigationLinksOperations<azure.mgmt.network.v2020_05_01.aio.operations.ResourceNavigationLinksOperations>`
* 2020-06-01: :class:`ResourceNavigationLinksOperations<azure.mgmt.network.v2020_06_01.aio.operations.ResourceNavigationLinksOperations>`
* 2020-07-01: :class:`ResourceNavigationLinksOperations<azure.mgmt.network.v2020_07_01.aio.operations.ResourceNavigationLinksOperations>`
* 2020-08-01: :class:`ResourceNavigationLinksOperations<azure.mgmt.network.v2020_08_01.aio.operations.ResourceNavigationLinksOperations>`
* 2020-11-01: :class:`ResourceNavigationLinksOperations<azure.mgmt.network.v2020_11_01.aio.operations.ResourceNavigationLinksOperations>`
* 2021-02-01: :class:`ResourceNavigationLinksOperations<azure.mgmt.network.v2021_02_01.aio.operations.ResourceNavigationLinksOperations>`
* 2021-05-01: :class:`ResourceNavigationLinksOperations<azure.mgmt.network.v2021_05_01.aio.operations.ResourceNavigationLinksOperations>`
"""
api_version = self._get_api_version('resource_navigation_links')
if api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import ResourceNavigationLinksOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import ResourceNavigationLinksOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import ResourceNavigationLinksOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import ResourceNavigationLinksOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import ResourceNavigationLinksOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import ResourceNavigationLinksOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import ResourceNavigationLinksOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import ResourceNavigationLinksOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import ResourceNavigationLinksOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import ResourceNavigationLinksOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import ResourceNavigationLinksOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import ResourceNavigationLinksOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import ResourceNavigationLinksOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import ResourceNavigationLinksOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import ResourceNavigationLinksOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import ResourceNavigationLinksOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import ResourceNavigationLinksOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'resource_navigation_links'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def route_filter_rules(self):
"""Instance depends on the API version:
* 2016-12-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2016_12_01.aio.operations.RouteFilterRulesOperations>`
* 2017-03-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2017_03_01.aio.operations.RouteFilterRulesOperations>`
* 2017-06-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2017_06_01.aio.operations.RouteFilterRulesOperations>`
* 2017-10-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2017_10_01.aio.operations.RouteFilterRulesOperations>`
* 2018-01-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2018_01_01.aio.operations.RouteFilterRulesOperations>`
* 2018-02-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2018_02_01.aio.operations.RouteFilterRulesOperations>`
* 2018-04-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2018_04_01.aio.operations.RouteFilterRulesOperations>`
* 2018-06-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2018_06_01.aio.operations.RouteFilterRulesOperations>`
* 2018-07-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2018_07_01.aio.operations.RouteFilterRulesOperations>`
* 2018-08-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2018_08_01.aio.operations.RouteFilterRulesOperations>`
* 2018-10-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2018_10_01.aio.operations.RouteFilterRulesOperations>`
* 2018-11-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2018_11_01.aio.operations.RouteFilterRulesOperations>`
* 2018-12-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2018_12_01.aio.operations.RouteFilterRulesOperations>`
* 2019-02-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2019_02_01.aio.operations.RouteFilterRulesOperations>`
* 2019-04-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2019_04_01.aio.operations.RouteFilterRulesOperations>`
* 2019-06-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2019_06_01.aio.operations.RouteFilterRulesOperations>`
* 2019-07-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2019_07_01.aio.operations.RouteFilterRulesOperations>`
* 2019-08-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2019_08_01.aio.operations.RouteFilterRulesOperations>`
* 2019-09-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2019_09_01.aio.operations.RouteFilterRulesOperations>`
* 2019-11-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2019_11_01.aio.operations.RouteFilterRulesOperations>`
* 2019-12-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2019_12_01.aio.operations.RouteFilterRulesOperations>`
* 2020-03-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2020_03_01.aio.operations.RouteFilterRulesOperations>`
* 2020-04-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2020_04_01.aio.operations.RouteFilterRulesOperations>`
* 2020-05-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2020_05_01.aio.operations.RouteFilterRulesOperations>`
* 2020-06-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2020_06_01.aio.operations.RouteFilterRulesOperations>`
* 2020-07-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2020_07_01.aio.operations.RouteFilterRulesOperations>`
* 2020-08-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2020_08_01.aio.operations.RouteFilterRulesOperations>`
* 2020-11-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2020_11_01.aio.operations.RouteFilterRulesOperations>`
* 2021-02-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2021_02_01.aio.operations.RouteFilterRulesOperations>`
* 2021-05-01: :class:`RouteFilterRulesOperations<azure.mgmt.network.v2021_05_01.aio.operations.RouteFilterRulesOperations>`
"""
api_version = self._get_api_version('route_filter_rules')
if api_version == '2016-12-01':
from ..v2016_12_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2017-03-01':
from ..v2017_03_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import RouteFilterRulesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import RouteFilterRulesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'route_filter_rules'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def route_filters(self):
"""Instance depends on the API version:
* 2016-12-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2016_12_01.aio.operations.RouteFiltersOperations>`
* 2017-03-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2017_03_01.aio.operations.RouteFiltersOperations>`
* 2017-06-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2017_06_01.aio.operations.RouteFiltersOperations>`
* 2017-10-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2017_10_01.aio.operations.RouteFiltersOperations>`
* 2018-01-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2018_01_01.aio.operations.RouteFiltersOperations>`
* 2018-02-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2018_02_01.aio.operations.RouteFiltersOperations>`
* 2018-04-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2018_04_01.aio.operations.RouteFiltersOperations>`
* 2018-06-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2018_06_01.aio.operations.RouteFiltersOperations>`
* 2018-07-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2018_07_01.aio.operations.RouteFiltersOperations>`
* 2018-08-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2018_08_01.aio.operations.RouteFiltersOperations>`
* 2018-10-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2018_10_01.aio.operations.RouteFiltersOperations>`
* 2018-11-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2018_11_01.aio.operations.RouteFiltersOperations>`
* 2018-12-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2018_12_01.aio.operations.RouteFiltersOperations>`
* 2019-02-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2019_02_01.aio.operations.RouteFiltersOperations>`
* 2019-04-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2019_04_01.aio.operations.RouteFiltersOperations>`
* 2019-06-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2019_06_01.aio.operations.RouteFiltersOperations>`
* 2019-07-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2019_07_01.aio.operations.RouteFiltersOperations>`
* 2019-08-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2019_08_01.aio.operations.RouteFiltersOperations>`
* 2019-09-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2019_09_01.aio.operations.RouteFiltersOperations>`
* 2019-11-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2019_11_01.aio.operations.RouteFiltersOperations>`
* 2019-12-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2019_12_01.aio.operations.RouteFiltersOperations>`
* 2020-03-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2020_03_01.aio.operations.RouteFiltersOperations>`
* 2020-04-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2020_04_01.aio.operations.RouteFiltersOperations>`
* 2020-05-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2020_05_01.aio.operations.RouteFiltersOperations>`
* 2020-06-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2020_06_01.aio.operations.RouteFiltersOperations>`
* 2020-07-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2020_07_01.aio.operations.RouteFiltersOperations>`
* 2020-08-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2020_08_01.aio.operations.RouteFiltersOperations>`
* 2020-11-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2020_11_01.aio.operations.RouteFiltersOperations>`
* 2021-02-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2021_02_01.aio.operations.RouteFiltersOperations>`
* 2021-05-01: :class:`RouteFiltersOperations<azure.mgmt.network.v2021_05_01.aio.operations.RouteFiltersOperations>`
"""
api_version = self._get_api_version('route_filters')
if api_version == '2016-12-01':
from ..v2016_12_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2017-03-01':
from ..v2017_03_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import RouteFiltersOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import RouteFiltersOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'route_filters'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def route_tables(self):
"""Instance depends on the API version:
* 2015-06-15: :class:`RouteTablesOperations<azure.mgmt.network.v2015_06_15.aio.operations.RouteTablesOperations>`
* 2016-09-01: :class:`RouteTablesOperations<azure.mgmt.network.v2016_09_01.aio.operations.RouteTablesOperations>`
* 2016-12-01: :class:`RouteTablesOperations<azure.mgmt.network.v2016_12_01.aio.operations.RouteTablesOperations>`
* 2017-03-01: :class:`RouteTablesOperations<azure.mgmt.network.v2017_03_01.aio.operations.RouteTablesOperations>`
* 2017-06-01: :class:`RouteTablesOperations<azure.mgmt.network.v2017_06_01.aio.operations.RouteTablesOperations>`
* 2017-10-01: :class:`RouteTablesOperations<azure.mgmt.network.v2017_10_01.aio.operations.RouteTablesOperations>`
* 2018-01-01: :class:`RouteTablesOperations<azure.mgmt.network.v2018_01_01.aio.operations.RouteTablesOperations>`
* 2018-02-01: :class:`RouteTablesOperations<azure.mgmt.network.v2018_02_01.aio.operations.RouteTablesOperations>`
* 2018-04-01: :class:`RouteTablesOperations<azure.mgmt.network.v2018_04_01.aio.operations.RouteTablesOperations>`
* 2018-06-01: :class:`RouteTablesOperations<azure.mgmt.network.v2018_06_01.aio.operations.RouteTablesOperations>`
* 2018-07-01: :class:`RouteTablesOperations<azure.mgmt.network.v2018_07_01.aio.operations.RouteTablesOperations>`
* 2018-08-01: :class:`RouteTablesOperations<azure.mgmt.network.v2018_08_01.aio.operations.RouteTablesOperations>`
* 2018-10-01: :class:`RouteTablesOperations<azure.mgmt.network.v2018_10_01.aio.operations.RouteTablesOperations>`
* 2018-11-01: :class:`RouteTablesOperations<azure.mgmt.network.v2018_11_01.aio.operations.RouteTablesOperations>`
* 2018-12-01: :class:`RouteTablesOperations<azure.mgmt.network.v2018_12_01.aio.operations.RouteTablesOperations>`
* 2019-02-01: :class:`RouteTablesOperations<azure.mgmt.network.v2019_02_01.aio.operations.RouteTablesOperations>`
* 2019-04-01: :class:`RouteTablesOperations<azure.mgmt.network.v2019_04_01.aio.operations.RouteTablesOperations>`
* 2019-06-01: :class:`RouteTablesOperations<azure.mgmt.network.v2019_06_01.aio.operations.RouteTablesOperations>`
* 2019-07-01: :class:`RouteTablesOperations<azure.mgmt.network.v2019_07_01.aio.operations.RouteTablesOperations>`
* 2019-08-01: :class:`RouteTablesOperations<azure.mgmt.network.v2019_08_01.aio.operations.RouteTablesOperations>`
* 2019-09-01: :class:`RouteTablesOperations<azure.mgmt.network.v2019_09_01.aio.operations.RouteTablesOperations>`
* 2019-11-01: :class:`RouteTablesOperations<azure.mgmt.network.v2019_11_01.aio.operations.RouteTablesOperations>`
* 2019-12-01: :class:`RouteTablesOperations<azure.mgmt.network.v2019_12_01.aio.operations.RouteTablesOperations>`
* 2020-03-01: :class:`RouteTablesOperations<azure.mgmt.network.v2020_03_01.aio.operations.RouteTablesOperations>`
* 2020-04-01: :class:`RouteTablesOperations<azure.mgmt.network.v2020_04_01.aio.operations.RouteTablesOperations>`
* 2020-05-01: :class:`RouteTablesOperations<azure.mgmt.network.v2020_05_01.aio.operations.RouteTablesOperations>`
* 2020-06-01: :class:`RouteTablesOperations<azure.mgmt.network.v2020_06_01.aio.operations.RouteTablesOperations>`
* 2020-07-01: :class:`RouteTablesOperations<azure.mgmt.network.v2020_07_01.aio.operations.RouteTablesOperations>`
* 2020-08-01: :class:`RouteTablesOperations<azure.mgmt.network.v2020_08_01.aio.operations.RouteTablesOperations>`
* 2020-11-01: :class:`RouteTablesOperations<azure.mgmt.network.v2020_11_01.aio.operations.RouteTablesOperations>`
* 2021-02-01: :class:`RouteTablesOperations<azure.mgmt.network.v2021_02_01.aio.operations.RouteTablesOperations>`
* 2021-05-01: :class:`RouteTablesOperations<azure.mgmt.network.v2021_05_01.aio.operations.RouteTablesOperations>`
"""
api_version = self._get_api_version('route_tables')
if api_version == '2015-06-15':
from ..v2015_06_15.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2016-09-01':
from ..v2016_09_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2016-12-01':
from ..v2016_12_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2017-03-01':
from ..v2017_03_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import RouteTablesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import RouteTablesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'route_tables'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def routes(self):
"""Instance depends on the API version:
* 2015-06-15: :class:`RoutesOperations<azure.mgmt.network.v2015_06_15.aio.operations.RoutesOperations>`
* 2016-09-01: :class:`RoutesOperations<azure.mgmt.network.v2016_09_01.aio.operations.RoutesOperations>`
* 2016-12-01: :class:`RoutesOperations<azure.mgmt.network.v2016_12_01.aio.operations.RoutesOperations>`
* 2017-03-01: :class:`RoutesOperations<azure.mgmt.network.v2017_03_01.aio.operations.RoutesOperations>`
* 2017-06-01: :class:`RoutesOperations<azure.mgmt.network.v2017_06_01.aio.operations.RoutesOperations>`
* 2017-10-01: :class:`RoutesOperations<azure.mgmt.network.v2017_10_01.aio.operations.RoutesOperations>`
* 2018-01-01: :class:`RoutesOperations<azure.mgmt.network.v2018_01_01.aio.operations.RoutesOperations>`
* 2018-02-01: :class:`RoutesOperations<azure.mgmt.network.v2018_02_01.aio.operations.RoutesOperations>`
* 2018-04-01: :class:`RoutesOperations<azure.mgmt.network.v2018_04_01.aio.operations.RoutesOperations>`
* 2018-06-01: :class:`RoutesOperations<azure.mgmt.network.v2018_06_01.aio.operations.RoutesOperations>`
* 2018-07-01: :class:`RoutesOperations<azure.mgmt.network.v2018_07_01.aio.operations.RoutesOperations>`
* 2018-08-01: :class:`RoutesOperations<azure.mgmt.network.v2018_08_01.aio.operations.RoutesOperations>`
* 2018-10-01: :class:`RoutesOperations<azure.mgmt.network.v2018_10_01.aio.operations.RoutesOperations>`
* 2018-11-01: :class:`RoutesOperations<azure.mgmt.network.v2018_11_01.aio.operations.RoutesOperations>`
* 2018-12-01: :class:`RoutesOperations<azure.mgmt.network.v2018_12_01.aio.operations.RoutesOperations>`
* 2019-02-01: :class:`RoutesOperations<azure.mgmt.network.v2019_02_01.aio.operations.RoutesOperations>`
* 2019-04-01: :class:`RoutesOperations<azure.mgmt.network.v2019_04_01.aio.operations.RoutesOperations>`
* 2019-06-01: :class:`RoutesOperations<azure.mgmt.network.v2019_06_01.aio.operations.RoutesOperations>`
* 2019-07-01: :class:`RoutesOperations<azure.mgmt.network.v2019_07_01.aio.operations.RoutesOperations>`
* 2019-08-01: :class:`RoutesOperations<azure.mgmt.network.v2019_08_01.aio.operations.RoutesOperations>`
* 2019-09-01: :class:`RoutesOperations<azure.mgmt.network.v2019_09_01.aio.operations.RoutesOperations>`
* 2019-11-01: :class:`RoutesOperations<azure.mgmt.network.v2019_11_01.aio.operations.RoutesOperations>`
* 2019-12-01: :class:`RoutesOperations<azure.mgmt.network.v2019_12_01.aio.operations.RoutesOperations>`
* 2020-03-01: :class:`RoutesOperations<azure.mgmt.network.v2020_03_01.aio.operations.RoutesOperations>`
* 2020-04-01: :class:`RoutesOperations<azure.mgmt.network.v2020_04_01.aio.operations.RoutesOperations>`
* 2020-05-01: :class:`RoutesOperations<azure.mgmt.network.v2020_05_01.aio.operations.RoutesOperations>`
* 2020-06-01: :class:`RoutesOperations<azure.mgmt.network.v2020_06_01.aio.operations.RoutesOperations>`
* 2020-07-01: :class:`RoutesOperations<azure.mgmt.network.v2020_07_01.aio.operations.RoutesOperations>`
* 2020-08-01: :class:`RoutesOperations<azure.mgmt.network.v2020_08_01.aio.operations.RoutesOperations>`
* 2020-11-01: :class:`RoutesOperations<azure.mgmt.network.v2020_11_01.aio.operations.RoutesOperations>`
* 2021-02-01: :class:`RoutesOperations<azure.mgmt.network.v2021_02_01.aio.operations.RoutesOperations>`
* 2021-05-01: :class:`RoutesOperations<azure.mgmt.network.v2021_05_01.aio.operations.RoutesOperations>`
"""
api_version = self._get_api_version('routes')
if api_version == '2015-06-15':
from ..v2015_06_15.aio.operations import RoutesOperations as OperationClass
elif api_version == '2016-09-01':
from ..v2016_09_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2016-12-01':
from ..v2016_12_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2017-03-01':
from ..v2017_03_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import RoutesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import RoutesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'routes'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def routing_intent(self):
"""Instance depends on the API version:
* 2021-05-01: :class:`RoutingIntentOperations<azure.mgmt.network.v2021_05_01.aio.operations.RoutingIntentOperations>`
"""
api_version = self._get_api_version('routing_intent')
if api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import RoutingIntentOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'routing_intent'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def security_admin_configurations(self):
"""Instance depends on the API version:
* 2021-02-01-preview: :class:`SecurityAdminConfigurationsOperations<azure.mgmt.network.v2021_02_01_preview.aio.operations.SecurityAdminConfigurationsOperations>`
"""
api_version = self._get_api_version('security_admin_configurations')
if api_version == '2021-02-01-preview':
from ..v2021_02_01_preview.aio.operations import SecurityAdminConfigurationsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'security_admin_configurations'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def security_partner_providers(self):
"""Instance depends on the API version:
* 2020-03-01: :class:`SecurityPartnerProvidersOperations<azure.mgmt.network.v2020_03_01.aio.operations.SecurityPartnerProvidersOperations>`
* 2020-04-01: :class:`SecurityPartnerProvidersOperations<azure.mgmt.network.v2020_04_01.aio.operations.SecurityPartnerProvidersOperations>`
* 2020-05-01: :class:`SecurityPartnerProvidersOperations<azure.mgmt.network.v2020_05_01.aio.operations.SecurityPartnerProvidersOperations>`
* 2020-06-01: :class:`SecurityPartnerProvidersOperations<azure.mgmt.network.v2020_06_01.aio.operations.SecurityPartnerProvidersOperations>`
* 2020-07-01: :class:`SecurityPartnerProvidersOperations<azure.mgmt.network.v2020_07_01.aio.operations.SecurityPartnerProvidersOperations>`
* 2020-08-01: :class:`SecurityPartnerProvidersOperations<azure.mgmt.network.v2020_08_01.aio.operations.SecurityPartnerProvidersOperations>`
* 2020-11-01: :class:`SecurityPartnerProvidersOperations<azure.mgmt.network.v2020_11_01.aio.operations.SecurityPartnerProvidersOperations>`
* 2021-02-01: :class:`SecurityPartnerProvidersOperations<azure.mgmt.network.v2021_02_01.aio.operations.SecurityPartnerProvidersOperations>`
* 2021-05-01: :class:`SecurityPartnerProvidersOperations<azure.mgmt.network.v2021_05_01.aio.operations.SecurityPartnerProvidersOperations>`
"""
api_version = self._get_api_version('security_partner_providers')
if api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import SecurityPartnerProvidersOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import SecurityPartnerProvidersOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import SecurityPartnerProvidersOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import SecurityPartnerProvidersOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import SecurityPartnerProvidersOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import SecurityPartnerProvidersOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import SecurityPartnerProvidersOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import SecurityPartnerProvidersOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import SecurityPartnerProvidersOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'security_partner_providers'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def security_rules(self):
"""Instance depends on the API version:
* 2015-06-15: :class:`SecurityRulesOperations<azure.mgmt.network.v2015_06_15.aio.operations.SecurityRulesOperations>`
* 2016-09-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2016_09_01.aio.operations.SecurityRulesOperations>`
* 2016-12-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2016_12_01.aio.operations.SecurityRulesOperations>`
* 2017-03-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2017_03_01.aio.operations.SecurityRulesOperations>`
* 2017-06-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2017_06_01.aio.operations.SecurityRulesOperations>`
* 2017-10-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2017_10_01.aio.operations.SecurityRulesOperations>`
* 2018-01-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2018_01_01.aio.operations.SecurityRulesOperations>`
* 2018-02-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2018_02_01.aio.operations.SecurityRulesOperations>`
* 2018-04-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2018_04_01.aio.operations.SecurityRulesOperations>`
* 2018-06-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2018_06_01.aio.operations.SecurityRulesOperations>`
* 2018-07-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2018_07_01.aio.operations.SecurityRulesOperations>`
* 2018-08-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2018_08_01.aio.operations.SecurityRulesOperations>`
* 2018-10-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2018_10_01.aio.operations.SecurityRulesOperations>`
* 2018-11-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2018_11_01.aio.operations.SecurityRulesOperations>`
* 2018-12-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2018_12_01.aio.operations.SecurityRulesOperations>`
* 2019-02-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2019_02_01.aio.operations.SecurityRulesOperations>`
* 2019-04-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2019_04_01.aio.operations.SecurityRulesOperations>`
* 2019-06-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2019_06_01.aio.operations.SecurityRulesOperations>`
* 2019-07-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2019_07_01.aio.operations.SecurityRulesOperations>`
* 2019-08-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2019_08_01.aio.operations.SecurityRulesOperations>`
* 2019-09-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2019_09_01.aio.operations.SecurityRulesOperations>`
* 2019-11-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2019_11_01.aio.operations.SecurityRulesOperations>`
* 2019-12-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2019_12_01.aio.operations.SecurityRulesOperations>`
* 2020-03-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2020_03_01.aio.operations.SecurityRulesOperations>`
* 2020-04-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2020_04_01.aio.operations.SecurityRulesOperations>`
* 2020-05-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2020_05_01.aio.operations.SecurityRulesOperations>`
* 2020-06-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2020_06_01.aio.operations.SecurityRulesOperations>`
* 2020-07-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2020_07_01.aio.operations.SecurityRulesOperations>`
* 2020-08-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2020_08_01.aio.operations.SecurityRulesOperations>`
* 2020-11-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2020_11_01.aio.operations.SecurityRulesOperations>`
* 2021-02-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2021_02_01.aio.operations.SecurityRulesOperations>`
* 2021-05-01: :class:`SecurityRulesOperations<azure.mgmt.network.v2021_05_01.aio.operations.SecurityRulesOperations>`
"""
api_version = self._get_api_version('security_rules')
if api_version == '2015-06-15':
from ..v2015_06_15.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2016-09-01':
from ..v2016_09_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2016-12-01':
from ..v2016_12_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2017-03-01':
from ..v2017_03_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import SecurityRulesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import SecurityRulesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'security_rules'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def security_user_configurations(self):
"""Instance depends on the API version:
* 2021-02-01-preview: :class:`SecurityUserConfigurationsOperations<azure.mgmt.network.v2021_02_01_preview.aio.operations.SecurityUserConfigurationsOperations>`
"""
api_version = self._get_api_version('security_user_configurations')
if api_version == '2021-02-01-preview':
from ..v2021_02_01_preview.aio.operations import SecurityUserConfigurationsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'security_user_configurations'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def service_association_links(self):
"""Instance depends on the API version:
* 2019-02-01: :class:`ServiceAssociationLinksOperations<azure.mgmt.network.v2019_02_01.aio.operations.ServiceAssociationLinksOperations>`
* 2019-04-01: :class:`ServiceAssociationLinksOperations<azure.mgmt.network.v2019_04_01.aio.operations.ServiceAssociationLinksOperations>`
* 2019-06-01: :class:`ServiceAssociationLinksOperations<azure.mgmt.network.v2019_06_01.aio.operations.ServiceAssociationLinksOperations>`
* 2019-07-01: :class:`ServiceAssociationLinksOperations<azure.mgmt.network.v2019_07_01.aio.operations.ServiceAssociationLinksOperations>`
* 2019-08-01: :class:`ServiceAssociationLinksOperations<azure.mgmt.network.v2019_08_01.aio.operations.ServiceAssociationLinksOperations>`
* 2019-09-01: :class:`ServiceAssociationLinksOperations<azure.mgmt.network.v2019_09_01.aio.operations.ServiceAssociationLinksOperations>`
* 2019-11-01: :class:`ServiceAssociationLinksOperations<azure.mgmt.network.v2019_11_01.aio.operations.ServiceAssociationLinksOperations>`
* 2019-12-01: :class:`ServiceAssociationLinksOperations<azure.mgmt.network.v2019_12_01.aio.operations.ServiceAssociationLinksOperations>`
* 2020-03-01: :class:`ServiceAssociationLinksOperations<azure.mgmt.network.v2020_03_01.aio.operations.ServiceAssociationLinksOperations>`
* 2020-04-01: :class:`ServiceAssociationLinksOperations<azure.mgmt.network.v2020_04_01.aio.operations.ServiceAssociationLinksOperations>`
* 2020-05-01: :class:`ServiceAssociationLinksOperations<azure.mgmt.network.v2020_05_01.aio.operations.ServiceAssociationLinksOperations>`
* 2020-06-01: :class:`ServiceAssociationLinksOperations<azure.mgmt.network.v2020_06_01.aio.operations.ServiceAssociationLinksOperations>`
* 2020-07-01: :class:`ServiceAssociationLinksOperations<azure.mgmt.network.v2020_07_01.aio.operations.ServiceAssociationLinksOperations>`
* 2020-08-01: :class:`ServiceAssociationLinksOperations<azure.mgmt.network.v2020_08_01.aio.operations.ServiceAssociationLinksOperations>`
* 2020-11-01: :class:`ServiceAssociationLinksOperations<azure.mgmt.network.v2020_11_01.aio.operations.ServiceAssociationLinksOperations>`
* 2021-02-01: :class:`ServiceAssociationLinksOperations<azure.mgmt.network.v2021_02_01.aio.operations.ServiceAssociationLinksOperations>`
* 2021-05-01: :class:`ServiceAssociationLinksOperations<azure.mgmt.network.v2021_05_01.aio.operations.ServiceAssociationLinksOperations>`
"""
api_version = self._get_api_version('service_association_links')
if api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import ServiceAssociationLinksOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import ServiceAssociationLinksOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import ServiceAssociationLinksOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import ServiceAssociationLinksOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import ServiceAssociationLinksOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import ServiceAssociationLinksOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import ServiceAssociationLinksOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import ServiceAssociationLinksOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import ServiceAssociationLinksOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import ServiceAssociationLinksOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import ServiceAssociationLinksOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import ServiceAssociationLinksOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import ServiceAssociationLinksOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import ServiceAssociationLinksOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import ServiceAssociationLinksOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import ServiceAssociationLinksOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import ServiceAssociationLinksOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'service_association_links'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def service_endpoint_policies(self):
"""Instance depends on the API version:
* 2018-07-01: :class:`ServiceEndpointPoliciesOperations<azure.mgmt.network.v2018_07_01.aio.operations.ServiceEndpointPoliciesOperations>`
* 2018-08-01: :class:`ServiceEndpointPoliciesOperations<azure.mgmt.network.v2018_08_01.aio.operations.ServiceEndpointPoliciesOperations>`
* 2018-10-01: :class:`ServiceEndpointPoliciesOperations<azure.mgmt.network.v2018_10_01.aio.operations.ServiceEndpointPoliciesOperations>`
* 2018-11-01: :class:`ServiceEndpointPoliciesOperations<azure.mgmt.network.v2018_11_01.aio.operations.ServiceEndpointPoliciesOperations>`
* 2018-12-01: :class:`ServiceEndpointPoliciesOperations<azure.mgmt.network.v2018_12_01.aio.operations.ServiceEndpointPoliciesOperations>`
* 2019-02-01: :class:`ServiceEndpointPoliciesOperations<azure.mgmt.network.v2019_02_01.aio.operations.ServiceEndpointPoliciesOperations>`
* 2019-04-01: :class:`ServiceEndpointPoliciesOperations<azure.mgmt.network.v2019_04_01.aio.operations.ServiceEndpointPoliciesOperations>`
* 2019-06-01: :class:`ServiceEndpointPoliciesOperations<azure.mgmt.network.v2019_06_01.aio.operations.ServiceEndpointPoliciesOperations>`
* 2019-07-01: :class:`ServiceEndpointPoliciesOperations<azure.mgmt.network.v2019_07_01.aio.operations.ServiceEndpointPoliciesOperations>`
* 2019-08-01: :class:`ServiceEndpointPoliciesOperations<azure.mgmt.network.v2019_08_01.aio.operations.ServiceEndpointPoliciesOperations>`
* 2019-09-01: :class:`ServiceEndpointPoliciesOperations<azure.mgmt.network.v2019_09_01.aio.operations.ServiceEndpointPoliciesOperations>`
* 2019-11-01: :class:`ServiceEndpointPoliciesOperations<azure.mgmt.network.v2019_11_01.aio.operations.ServiceEndpointPoliciesOperations>`
* 2019-12-01: :class:`ServiceEndpointPoliciesOperations<azure.mgmt.network.v2019_12_01.aio.operations.ServiceEndpointPoliciesOperations>`
* 2020-03-01: :class:`ServiceEndpointPoliciesOperations<azure.mgmt.network.v2020_03_01.aio.operations.ServiceEndpointPoliciesOperations>`
* 2020-04-01: :class:`ServiceEndpointPoliciesOperations<azure.mgmt.network.v2020_04_01.aio.operations.ServiceEndpointPoliciesOperations>`
* 2020-05-01: :class:`ServiceEndpointPoliciesOperations<azure.mgmt.network.v2020_05_01.aio.operations.ServiceEndpointPoliciesOperations>`
* 2020-06-01: :class:`ServiceEndpointPoliciesOperations<azure.mgmt.network.v2020_06_01.aio.operations.ServiceEndpointPoliciesOperations>`
* 2020-07-01: :class:`ServiceEndpointPoliciesOperations<azure.mgmt.network.v2020_07_01.aio.operations.ServiceEndpointPoliciesOperations>`
* 2020-08-01: :class:`ServiceEndpointPoliciesOperations<azure.mgmt.network.v2020_08_01.aio.operations.ServiceEndpointPoliciesOperations>`
* 2020-11-01: :class:`ServiceEndpointPoliciesOperations<azure.mgmt.network.v2020_11_01.aio.operations.ServiceEndpointPoliciesOperations>`
* 2021-02-01: :class:`ServiceEndpointPoliciesOperations<azure.mgmt.network.v2021_02_01.aio.operations.ServiceEndpointPoliciesOperations>`
* 2021-05-01: :class:`ServiceEndpointPoliciesOperations<azure.mgmt.network.v2021_05_01.aio.operations.ServiceEndpointPoliciesOperations>`
"""
api_version = self._get_api_version('service_endpoint_policies')
if api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import ServiceEndpointPoliciesOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import ServiceEndpointPoliciesOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import ServiceEndpointPoliciesOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import ServiceEndpointPoliciesOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import ServiceEndpointPoliciesOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import ServiceEndpointPoliciesOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import ServiceEndpointPoliciesOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import ServiceEndpointPoliciesOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import ServiceEndpointPoliciesOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import ServiceEndpointPoliciesOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import ServiceEndpointPoliciesOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import ServiceEndpointPoliciesOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import ServiceEndpointPoliciesOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import ServiceEndpointPoliciesOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import ServiceEndpointPoliciesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import ServiceEndpointPoliciesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import ServiceEndpointPoliciesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import ServiceEndpointPoliciesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import ServiceEndpointPoliciesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import ServiceEndpointPoliciesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import ServiceEndpointPoliciesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import ServiceEndpointPoliciesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'service_endpoint_policies'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def service_endpoint_policy_definitions(self):
"""Instance depends on the API version:
* 2018-07-01: :class:`ServiceEndpointPolicyDefinitionsOperations<azure.mgmt.network.v2018_07_01.aio.operations.ServiceEndpointPolicyDefinitionsOperations>`
* 2018-08-01: :class:`ServiceEndpointPolicyDefinitionsOperations<azure.mgmt.network.v2018_08_01.aio.operations.ServiceEndpointPolicyDefinitionsOperations>`
* 2018-10-01: :class:`ServiceEndpointPolicyDefinitionsOperations<azure.mgmt.network.v2018_10_01.aio.operations.ServiceEndpointPolicyDefinitionsOperations>`
* 2018-11-01: :class:`ServiceEndpointPolicyDefinitionsOperations<azure.mgmt.network.v2018_11_01.aio.operations.ServiceEndpointPolicyDefinitionsOperations>`
* 2018-12-01: :class:`ServiceEndpointPolicyDefinitionsOperations<azure.mgmt.network.v2018_12_01.aio.operations.ServiceEndpointPolicyDefinitionsOperations>`
* 2019-02-01: :class:`ServiceEndpointPolicyDefinitionsOperations<azure.mgmt.network.v2019_02_01.aio.operations.ServiceEndpointPolicyDefinitionsOperations>`
* 2019-04-01: :class:`ServiceEndpointPolicyDefinitionsOperations<azure.mgmt.network.v2019_04_01.aio.operations.ServiceEndpointPolicyDefinitionsOperations>`
* 2019-06-01: :class:`ServiceEndpointPolicyDefinitionsOperations<azure.mgmt.network.v2019_06_01.aio.operations.ServiceEndpointPolicyDefinitionsOperations>`
* 2019-07-01: :class:`ServiceEndpointPolicyDefinitionsOperations<azure.mgmt.network.v2019_07_01.aio.operations.ServiceEndpointPolicyDefinitionsOperations>`
* 2019-08-01: :class:`ServiceEndpointPolicyDefinitionsOperations<azure.mgmt.network.v2019_08_01.aio.operations.ServiceEndpointPolicyDefinitionsOperations>`
* 2019-09-01: :class:`ServiceEndpointPolicyDefinitionsOperations<azure.mgmt.network.v2019_09_01.aio.operations.ServiceEndpointPolicyDefinitionsOperations>`
* 2019-11-01: :class:`ServiceEndpointPolicyDefinitionsOperations<azure.mgmt.network.v2019_11_01.aio.operations.ServiceEndpointPolicyDefinitionsOperations>`
* 2019-12-01: :class:`ServiceEndpointPolicyDefinitionsOperations<azure.mgmt.network.v2019_12_01.aio.operations.ServiceEndpointPolicyDefinitionsOperations>`
* 2020-03-01: :class:`ServiceEndpointPolicyDefinitionsOperations<azure.mgmt.network.v2020_03_01.aio.operations.ServiceEndpointPolicyDefinitionsOperations>`
* 2020-04-01: :class:`ServiceEndpointPolicyDefinitionsOperations<azure.mgmt.network.v2020_04_01.aio.operations.ServiceEndpointPolicyDefinitionsOperations>`
* 2020-05-01: :class:`ServiceEndpointPolicyDefinitionsOperations<azure.mgmt.network.v2020_05_01.aio.operations.ServiceEndpointPolicyDefinitionsOperations>`
* 2020-06-01: :class:`ServiceEndpointPolicyDefinitionsOperations<azure.mgmt.network.v2020_06_01.aio.operations.ServiceEndpointPolicyDefinitionsOperations>`
* 2020-07-01: :class:`ServiceEndpointPolicyDefinitionsOperations<azure.mgmt.network.v2020_07_01.aio.operations.ServiceEndpointPolicyDefinitionsOperations>`
* 2020-08-01: :class:`ServiceEndpointPolicyDefinitionsOperations<azure.mgmt.network.v2020_08_01.aio.operations.ServiceEndpointPolicyDefinitionsOperations>`
* 2020-11-01: :class:`ServiceEndpointPolicyDefinitionsOperations<azure.mgmt.network.v2020_11_01.aio.operations.ServiceEndpointPolicyDefinitionsOperations>`
* 2021-02-01: :class:`ServiceEndpointPolicyDefinitionsOperations<azure.mgmt.network.v2021_02_01.aio.operations.ServiceEndpointPolicyDefinitionsOperations>`
* 2021-05-01: :class:`ServiceEndpointPolicyDefinitionsOperations<azure.mgmt.network.v2021_05_01.aio.operations.ServiceEndpointPolicyDefinitionsOperations>`
"""
api_version = self._get_api_version('service_endpoint_policy_definitions')
if api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import ServiceEndpointPolicyDefinitionsOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import ServiceEndpointPolicyDefinitionsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import ServiceEndpointPolicyDefinitionsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import ServiceEndpointPolicyDefinitionsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import ServiceEndpointPolicyDefinitionsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import ServiceEndpointPolicyDefinitionsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import ServiceEndpointPolicyDefinitionsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import ServiceEndpointPolicyDefinitionsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import ServiceEndpointPolicyDefinitionsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import ServiceEndpointPolicyDefinitionsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import ServiceEndpointPolicyDefinitionsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import ServiceEndpointPolicyDefinitionsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import ServiceEndpointPolicyDefinitionsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import ServiceEndpointPolicyDefinitionsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import ServiceEndpointPolicyDefinitionsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import ServiceEndpointPolicyDefinitionsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import ServiceEndpointPolicyDefinitionsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import ServiceEndpointPolicyDefinitionsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import ServiceEndpointPolicyDefinitionsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import ServiceEndpointPolicyDefinitionsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import ServiceEndpointPolicyDefinitionsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import ServiceEndpointPolicyDefinitionsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'service_endpoint_policy_definitions'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def service_tag_information(self):
"""Instance depends on the API version:
* 2021-05-01: :class:`ServiceTagInformationOperations<azure.mgmt.network.v2021_05_01.aio.operations.ServiceTagInformationOperations>`
"""
api_version = self._get_api_version('service_tag_information')
if api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import ServiceTagInformationOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'service_tag_information'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def service_tags(self):
"""Instance depends on the API version:
* 2019-04-01: :class:`ServiceTagsOperations<azure.mgmt.network.v2019_04_01.aio.operations.ServiceTagsOperations>`
* 2019-06-01: :class:`ServiceTagsOperations<azure.mgmt.network.v2019_06_01.aio.operations.ServiceTagsOperations>`
* 2019-07-01: :class:`ServiceTagsOperations<azure.mgmt.network.v2019_07_01.aio.operations.ServiceTagsOperations>`
* 2019-08-01: :class:`ServiceTagsOperations<azure.mgmt.network.v2019_08_01.aio.operations.ServiceTagsOperations>`
* 2019-09-01: :class:`ServiceTagsOperations<azure.mgmt.network.v2019_09_01.aio.operations.ServiceTagsOperations>`
* 2019-11-01: :class:`ServiceTagsOperations<azure.mgmt.network.v2019_11_01.aio.operations.ServiceTagsOperations>`
* 2019-12-01: :class:`ServiceTagsOperations<azure.mgmt.network.v2019_12_01.aio.operations.ServiceTagsOperations>`
* 2020-03-01: :class:`ServiceTagsOperations<azure.mgmt.network.v2020_03_01.aio.operations.ServiceTagsOperations>`
* 2020-04-01: :class:`ServiceTagsOperations<azure.mgmt.network.v2020_04_01.aio.operations.ServiceTagsOperations>`
* 2020-05-01: :class:`ServiceTagsOperations<azure.mgmt.network.v2020_05_01.aio.operations.ServiceTagsOperations>`
* 2020-06-01: :class:`ServiceTagsOperations<azure.mgmt.network.v2020_06_01.aio.operations.ServiceTagsOperations>`
* 2020-07-01: :class:`ServiceTagsOperations<azure.mgmt.network.v2020_07_01.aio.operations.ServiceTagsOperations>`
* 2020-08-01: :class:`ServiceTagsOperations<azure.mgmt.network.v2020_08_01.aio.operations.ServiceTagsOperations>`
* 2020-11-01: :class:`ServiceTagsOperations<azure.mgmt.network.v2020_11_01.aio.operations.ServiceTagsOperations>`
* 2021-02-01: :class:`ServiceTagsOperations<azure.mgmt.network.v2021_02_01.aio.operations.ServiceTagsOperations>`
* 2021-05-01: :class:`ServiceTagsOperations<azure.mgmt.network.v2021_05_01.aio.operations.ServiceTagsOperations>`
"""
api_version = self._get_api_version('service_tags')
if api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import ServiceTagsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import ServiceTagsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import ServiceTagsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import ServiceTagsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import ServiceTagsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import ServiceTagsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import ServiceTagsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import ServiceTagsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import ServiceTagsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import ServiceTagsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import ServiceTagsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import ServiceTagsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import ServiceTagsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import ServiceTagsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import ServiceTagsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import ServiceTagsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'service_tags'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def subnets(self):
"""Instance depends on the API version:
* 2015-06-15: :class:`SubnetsOperations<azure.mgmt.network.v2015_06_15.aio.operations.SubnetsOperations>`
* 2016-09-01: :class:`SubnetsOperations<azure.mgmt.network.v2016_09_01.aio.operations.SubnetsOperations>`
* 2016-12-01: :class:`SubnetsOperations<azure.mgmt.network.v2016_12_01.aio.operations.SubnetsOperations>`
* 2017-03-01: :class:`SubnetsOperations<azure.mgmt.network.v2017_03_01.aio.operations.SubnetsOperations>`
* 2017-06-01: :class:`SubnetsOperations<azure.mgmt.network.v2017_06_01.aio.operations.SubnetsOperations>`
* 2017-10-01: :class:`SubnetsOperations<azure.mgmt.network.v2017_10_01.aio.operations.SubnetsOperations>`
* 2018-01-01: :class:`SubnetsOperations<azure.mgmt.network.v2018_01_01.aio.operations.SubnetsOperations>`
* 2018-02-01: :class:`SubnetsOperations<azure.mgmt.network.v2018_02_01.aio.operations.SubnetsOperations>`
* 2018-04-01: :class:`SubnetsOperations<azure.mgmt.network.v2018_04_01.aio.operations.SubnetsOperations>`
* 2018-06-01: :class:`SubnetsOperations<azure.mgmt.network.v2018_06_01.aio.operations.SubnetsOperations>`
* 2018-07-01: :class:`SubnetsOperations<azure.mgmt.network.v2018_07_01.aio.operations.SubnetsOperations>`
* 2018-08-01: :class:`SubnetsOperations<azure.mgmt.network.v2018_08_01.aio.operations.SubnetsOperations>`
* 2018-10-01: :class:`SubnetsOperations<azure.mgmt.network.v2018_10_01.aio.operations.SubnetsOperations>`
* 2018-11-01: :class:`SubnetsOperations<azure.mgmt.network.v2018_11_01.aio.operations.SubnetsOperations>`
* 2018-12-01: :class:`SubnetsOperations<azure.mgmt.network.v2018_12_01.aio.operations.SubnetsOperations>`
* 2019-02-01: :class:`SubnetsOperations<azure.mgmt.network.v2019_02_01.aio.operations.SubnetsOperations>`
* 2019-04-01: :class:`SubnetsOperations<azure.mgmt.network.v2019_04_01.aio.operations.SubnetsOperations>`
* 2019-06-01: :class:`SubnetsOperations<azure.mgmt.network.v2019_06_01.aio.operations.SubnetsOperations>`
* 2019-07-01: :class:`SubnetsOperations<azure.mgmt.network.v2019_07_01.aio.operations.SubnetsOperations>`
* 2019-08-01: :class:`SubnetsOperations<azure.mgmt.network.v2019_08_01.aio.operations.SubnetsOperations>`
* 2019-09-01: :class:`SubnetsOperations<azure.mgmt.network.v2019_09_01.aio.operations.SubnetsOperations>`
* 2019-11-01: :class:`SubnetsOperations<azure.mgmt.network.v2019_11_01.aio.operations.SubnetsOperations>`
* 2019-12-01: :class:`SubnetsOperations<azure.mgmt.network.v2019_12_01.aio.operations.SubnetsOperations>`
* 2020-03-01: :class:`SubnetsOperations<azure.mgmt.network.v2020_03_01.aio.operations.SubnetsOperations>`
* 2020-04-01: :class:`SubnetsOperations<azure.mgmt.network.v2020_04_01.aio.operations.SubnetsOperations>`
* 2020-05-01: :class:`SubnetsOperations<azure.mgmt.network.v2020_05_01.aio.operations.SubnetsOperations>`
* 2020-06-01: :class:`SubnetsOperations<azure.mgmt.network.v2020_06_01.aio.operations.SubnetsOperations>`
* 2020-07-01: :class:`SubnetsOperations<azure.mgmt.network.v2020_07_01.aio.operations.SubnetsOperations>`
* 2020-08-01: :class:`SubnetsOperations<azure.mgmt.network.v2020_08_01.aio.operations.SubnetsOperations>`
* 2020-11-01: :class:`SubnetsOperations<azure.mgmt.network.v2020_11_01.aio.operations.SubnetsOperations>`
* 2021-02-01: :class:`SubnetsOperations<azure.mgmt.network.v2021_02_01.aio.operations.SubnetsOperations>`
* 2021-05-01: :class:`SubnetsOperations<azure.mgmt.network.v2021_05_01.aio.operations.SubnetsOperations>`
"""
api_version = self._get_api_version('subnets')
if api_version == '2015-06-15':
from ..v2015_06_15.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2016-09-01':
from ..v2016_09_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2016-12-01':
from ..v2016_12_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2017-03-01':
from ..v2017_03_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import SubnetsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import SubnetsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'subnets'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def usages(self):
"""Instance depends on the API version:
* 2015-06-15: :class:`UsagesOperations<azure.mgmt.network.v2015_06_15.aio.operations.UsagesOperations>`
* 2016-09-01: :class:`UsagesOperations<azure.mgmt.network.v2016_09_01.aio.operations.UsagesOperations>`
* 2016-12-01: :class:`UsagesOperations<azure.mgmt.network.v2016_12_01.aio.operations.UsagesOperations>`
* 2017-03-01: :class:`UsagesOperations<azure.mgmt.network.v2017_03_01.aio.operations.UsagesOperations>`
* 2017-06-01: :class:`UsagesOperations<azure.mgmt.network.v2017_06_01.aio.operations.UsagesOperations>`
* 2017-10-01: :class:`UsagesOperations<azure.mgmt.network.v2017_10_01.aio.operations.UsagesOperations>`
* 2018-01-01: :class:`UsagesOperations<azure.mgmt.network.v2018_01_01.aio.operations.UsagesOperations>`
* 2018-02-01: :class:`UsagesOperations<azure.mgmt.network.v2018_02_01.aio.operations.UsagesOperations>`
* 2018-04-01: :class:`UsagesOperations<azure.mgmt.network.v2018_04_01.aio.operations.UsagesOperations>`
* 2018-06-01: :class:`UsagesOperations<azure.mgmt.network.v2018_06_01.aio.operations.UsagesOperations>`
* 2018-07-01: :class:`UsagesOperations<azure.mgmt.network.v2018_07_01.aio.operations.UsagesOperations>`
* 2018-08-01: :class:`UsagesOperations<azure.mgmt.network.v2018_08_01.aio.operations.UsagesOperations>`
* 2018-10-01: :class:`UsagesOperations<azure.mgmt.network.v2018_10_01.aio.operations.UsagesOperations>`
* 2018-11-01: :class:`UsagesOperations<azure.mgmt.network.v2018_11_01.aio.operations.UsagesOperations>`
* 2018-12-01: :class:`UsagesOperations<azure.mgmt.network.v2018_12_01.aio.operations.UsagesOperations>`
* 2019-02-01: :class:`UsagesOperations<azure.mgmt.network.v2019_02_01.aio.operations.UsagesOperations>`
* 2019-04-01: :class:`UsagesOperations<azure.mgmt.network.v2019_04_01.aio.operations.UsagesOperations>`
* 2019-06-01: :class:`UsagesOperations<azure.mgmt.network.v2019_06_01.aio.operations.UsagesOperations>`
* 2019-07-01: :class:`UsagesOperations<azure.mgmt.network.v2019_07_01.aio.operations.UsagesOperations>`
* 2019-08-01: :class:`UsagesOperations<azure.mgmt.network.v2019_08_01.aio.operations.UsagesOperations>`
* 2019-09-01: :class:`UsagesOperations<azure.mgmt.network.v2019_09_01.aio.operations.UsagesOperations>`
* 2019-11-01: :class:`UsagesOperations<azure.mgmt.network.v2019_11_01.aio.operations.UsagesOperations>`
* 2019-12-01: :class:`UsagesOperations<azure.mgmt.network.v2019_12_01.aio.operations.UsagesOperations>`
* 2020-03-01: :class:`UsagesOperations<azure.mgmt.network.v2020_03_01.aio.operations.UsagesOperations>`
* 2020-04-01: :class:`UsagesOperations<azure.mgmt.network.v2020_04_01.aio.operations.UsagesOperations>`
* 2020-05-01: :class:`UsagesOperations<azure.mgmt.network.v2020_05_01.aio.operations.UsagesOperations>`
* 2020-06-01: :class:`UsagesOperations<azure.mgmt.network.v2020_06_01.aio.operations.UsagesOperations>`
* 2020-07-01: :class:`UsagesOperations<azure.mgmt.network.v2020_07_01.aio.operations.UsagesOperations>`
* 2020-08-01: :class:`UsagesOperations<azure.mgmt.network.v2020_08_01.aio.operations.UsagesOperations>`
* 2020-11-01: :class:`UsagesOperations<azure.mgmt.network.v2020_11_01.aio.operations.UsagesOperations>`
* 2021-02-01: :class:`UsagesOperations<azure.mgmt.network.v2021_02_01.aio.operations.UsagesOperations>`
* 2021-05-01: :class:`UsagesOperations<azure.mgmt.network.v2021_05_01.aio.operations.UsagesOperations>`
"""
api_version = self._get_api_version('usages')
if api_version == '2015-06-15':
from ..v2015_06_15.aio.operations import UsagesOperations as OperationClass
elif api_version == '2016-09-01':
from ..v2016_09_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2016-12-01':
from ..v2016_12_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2017-03-01':
from ..v2017_03_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import UsagesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import UsagesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'usages'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def user_rule_collections(self):
"""Instance depends on the API version:
* 2021-02-01-preview: :class:`UserRuleCollectionsOperations<azure.mgmt.network.v2021_02_01_preview.aio.operations.UserRuleCollectionsOperations>`
"""
api_version = self._get_api_version('user_rule_collections')
if api_version == '2021-02-01-preview':
from ..v2021_02_01_preview.aio.operations import UserRuleCollectionsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'user_rule_collections'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def user_rules(self):
"""Instance depends on the API version:
* 2021-02-01-preview: :class:`UserRulesOperations<azure.mgmt.network.v2021_02_01_preview.aio.operations.UserRulesOperations>`
"""
api_version = self._get_api_version('user_rules')
if api_version == '2021-02-01-preview':
from ..v2021_02_01_preview.aio.operations import UserRulesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'user_rules'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def virtual_appliance_sites(self):
"""Instance depends on the API version:
* 2020-05-01: :class:`VirtualApplianceSitesOperations<azure.mgmt.network.v2020_05_01.aio.operations.VirtualApplianceSitesOperations>`
* 2020-06-01: :class:`VirtualApplianceSitesOperations<azure.mgmt.network.v2020_06_01.aio.operations.VirtualApplianceSitesOperations>`
* 2020-07-01: :class:`VirtualApplianceSitesOperations<azure.mgmt.network.v2020_07_01.aio.operations.VirtualApplianceSitesOperations>`
* 2020-08-01: :class:`VirtualApplianceSitesOperations<azure.mgmt.network.v2020_08_01.aio.operations.VirtualApplianceSitesOperations>`
* 2020-11-01: :class:`VirtualApplianceSitesOperations<azure.mgmt.network.v2020_11_01.aio.operations.VirtualApplianceSitesOperations>`
* 2021-02-01: :class:`VirtualApplianceSitesOperations<azure.mgmt.network.v2021_02_01.aio.operations.VirtualApplianceSitesOperations>`
* 2021-05-01: :class:`VirtualApplianceSitesOperations<azure.mgmt.network.v2021_05_01.aio.operations.VirtualApplianceSitesOperations>`
"""
api_version = self._get_api_version('virtual_appliance_sites')
if api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import VirtualApplianceSitesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import VirtualApplianceSitesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import VirtualApplianceSitesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import VirtualApplianceSitesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import VirtualApplianceSitesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import VirtualApplianceSitesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import VirtualApplianceSitesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'virtual_appliance_sites'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def virtual_appliance_skus(self):
"""Instance depends on the API version:
* 2020-05-01: :class:`VirtualApplianceSkusOperations<azure.mgmt.network.v2020_05_01.aio.operations.VirtualApplianceSkusOperations>`
* 2020-06-01: :class:`VirtualApplianceSkusOperations<azure.mgmt.network.v2020_06_01.aio.operations.VirtualApplianceSkusOperations>`
* 2020-07-01: :class:`VirtualApplianceSkusOperations<azure.mgmt.network.v2020_07_01.aio.operations.VirtualApplianceSkusOperations>`
* 2020-08-01: :class:`VirtualApplianceSkusOperations<azure.mgmt.network.v2020_08_01.aio.operations.VirtualApplianceSkusOperations>`
* 2020-11-01: :class:`VirtualApplianceSkusOperations<azure.mgmt.network.v2020_11_01.aio.operations.VirtualApplianceSkusOperations>`
* 2021-02-01: :class:`VirtualApplianceSkusOperations<azure.mgmt.network.v2021_02_01.aio.operations.VirtualApplianceSkusOperations>`
* 2021-05-01: :class:`VirtualApplianceSkusOperations<azure.mgmt.network.v2021_05_01.aio.operations.VirtualApplianceSkusOperations>`
"""
api_version = self._get_api_version('virtual_appliance_skus')
if api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import VirtualApplianceSkusOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import VirtualApplianceSkusOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import VirtualApplianceSkusOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import VirtualApplianceSkusOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import VirtualApplianceSkusOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import VirtualApplianceSkusOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import VirtualApplianceSkusOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'virtual_appliance_skus'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def virtual_hub_bgp_connection(self):
"""Instance depends on the API version:
* 2020-05-01: :class:`VirtualHubBgpConnectionOperations<azure.mgmt.network.v2020_05_01.aio.operations.VirtualHubBgpConnectionOperations>`
* 2020-06-01: :class:`VirtualHubBgpConnectionOperations<azure.mgmt.network.v2020_06_01.aio.operations.VirtualHubBgpConnectionOperations>`
* 2020-07-01: :class:`VirtualHubBgpConnectionOperations<azure.mgmt.network.v2020_07_01.aio.operations.VirtualHubBgpConnectionOperations>`
* 2020-08-01: :class:`VirtualHubBgpConnectionOperations<azure.mgmt.network.v2020_08_01.aio.operations.VirtualHubBgpConnectionOperations>`
* 2020-11-01: :class:`VirtualHubBgpConnectionOperations<azure.mgmt.network.v2020_11_01.aio.operations.VirtualHubBgpConnectionOperations>`
* 2021-02-01: :class:`VirtualHubBgpConnectionOperations<azure.mgmt.network.v2021_02_01.aio.operations.VirtualHubBgpConnectionOperations>`
* 2021-05-01: :class:`VirtualHubBgpConnectionOperations<azure.mgmt.network.v2021_05_01.aio.operations.VirtualHubBgpConnectionOperations>`
"""
api_version = self._get_api_version('virtual_hub_bgp_connection')
if api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import VirtualHubBgpConnectionOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import VirtualHubBgpConnectionOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import VirtualHubBgpConnectionOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import VirtualHubBgpConnectionOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import VirtualHubBgpConnectionOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import VirtualHubBgpConnectionOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import VirtualHubBgpConnectionOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'virtual_hub_bgp_connection'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def virtual_hub_bgp_connections(self):
"""Instance depends on the API version:
* 2020-05-01: :class:`VirtualHubBgpConnectionsOperations<azure.mgmt.network.v2020_05_01.aio.operations.VirtualHubBgpConnectionsOperations>`
* 2020-06-01: :class:`VirtualHubBgpConnectionsOperations<azure.mgmt.network.v2020_06_01.aio.operations.VirtualHubBgpConnectionsOperations>`
* 2020-07-01: :class:`VirtualHubBgpConnectionsOperations<azure.mgmt.network.v2020_07_01.aio.operations.VirtualHubBgpConnectionsOperations>`
* 2020-08-01: :class:`VirtualHubBgpConnectionsOperations<azure.mgmt.network.v2020_08_01.aio.operations.VirtualHubBgpConnectionsOperations>`
* 2020-11-01: :class:`VirtualHubBgpConnectionsOperations<azure.mgmt.network.v2020_11_01.aio.operations.VirtualHubBgpConnectionsOperations>`
* 2021-02-01: :class:`VirtualHubBgpConnectionsOperations<azure.mgmt.network.v2021_02_01.aio.operations.VirtualHubBgpConnectionsOperations>`
* 2021-05-01: :class:`VirtualHubBgpConnectionsOperations<azure.mgmt.network.v2021_05_01.aio.operations.VirtualHubBgpConnectionsOperations>`
"""
api_version = self._get_api_version('virtual_hub_bgp_connections')
if api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import VirtualHubBgpConnectionsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import VirtualHubBgpConnectionsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import VirtualHubBgpConnectionsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import VirtualHubBgpConnectionsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import VirtualHubBgpConnectionsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import VirtualHubBgpConnectionsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import VirtualHubBgpConnectionsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'virtual_hub_bgp_connections'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def virtual_hub_ip_configuration(self):
"""Instance depends on the API version:
* 2020-05-01: :class:`VirtualHubIpConfigurationOperations<azure.mgmt.network.v2020_05_01.aio.operations.VirtualHubIpConfigurationOperations>`
* 2020-06-01: :class:`VirtualHubIpConfigurationOperations<azure.mgmt.network.v2020_06_01.aio.operations.VirtualHubIpConfigurationOperations>`
* 2020-07-01: :class:`VirtualHubIpConfigurationOperations<azure.mgmt.network.v2020_07_01.aio.operations.VirtualHubIpConfigurationOperations>`
* 2020-08-01: :class:`VirtualHubIpConfigurationOperations<azure.mgmt.network.v2020_08_01.aio.operations.VirtualHubIpConfigurationOperations>`
* 2020-11-01: :class:`VirtualHubIpConfigurationOperations<azure.mgmt.network.v2020_11_01.aio.operations.VirtualHubIpConfigurationOperations>`
* 2021-02-01: :class:`VirtualHubIpConfigurationOperations<azure.mgmt.network.v2021_02_01.aio.operations.VirtualHubIpConfigurationOperations>`
* 2021-05-01: :class:`VirtualHubIpConfigurationOperations<azure.mgmt.network.v2021_05_01.aio.operations.VirtualHubIpConfigurationOperations>`
"""
api_version = self._get_api_version('virtual_hub_ip_configuration')
if api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import VirtualHubIpConfigurationOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import VirtualHubIpConfigurationOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import VirtualHubIpConfigurationOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import VirtualHubIpConfigurationOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import VirtualHubIpConfigurationOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import VirtualHubIpConfigurationOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import VirtualHubIpConfigurationOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'virtual_hub_ip_configuration'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def virtual_hub_route_table_v2_s(self):
"""Instance depends on the API version:
* 2019-09-01: :class:`VirtualHubRouteTableV2SOperations<azure.mgmt.network.v2019_09_01.aio.operations.VirtualHubRouteTableV2SOperations>`
* 2019-11-01: :class:`VirtualHubRouteTableV2SOperations<azure.mgmt.network.v2019_11_01.aio.operations.VirtualHubRouteTableV2SOperations>`
* 2019-12-01: :class:`VirtualHubRouteTableV2SOperations<azure.mgmt.network.v2019_12_01.aio.operations.VirtualHubRouteTableV2SOperations>`
* 2020-03-01: :class:`VirtualHubRouteTableV2SOperations<azure.mgmt.network.v2020_03_01.aio.operations.VirtualHubRouteTableV2SOperations>`
* 2020-04-01: :class:`VirtualHubRouteTableV2SOperations<azure.mgmt.network.v2020_04_01.aio.operations.VirtualHubRouteTableV2SOperations>`
* 2020-05-01: :class:`VirtualHubRouteTableV2SOperations<azure.mgmt.network.v2020_05_01.aio.operations.VirtualHubRouteTableV2SOperations>`
* 2020-06-01: :class:`VirtualHubRouteTableV2SOperations<azure.mgmt.network.v2020_06_01.aio.operations.VirtualHubRouteTableV2SOperations>`
* 2020-07-01: :class:`VirtualHubRouteTableV2SOperations<azure.mgmt.network.v2020_07_01.aio.operations.VirtualHubRouteTableV2SOperations>`
* 2020-08-01: :class:`VirtualHubRouteTableV2SOperations<azure.mgmt.network.v2020_08_01.aio.operations.VirtualHubRouteTableV2SOperations>`
* 2020-11-01: :class:`VirtualHubRouteTableV2SOperations<azure.mgmt.network.v2020_11_01.aio.operations.VirtualHubRouteTableV2SOperations>`
* 2021-02-01: :class:`VirtualHubRouteTableV2SOperations<azure.mgmt.network.v2021_02_01.aio.operations.VirtualHubRouteTableV2SOperations>`
* 2021-05-01: :class:`VirtualHubRouteTableV2SOperations<azure.mgmt.network.v2021_05_01.aio.operations.VirtualHubRouteTableV2SOperations>`
"""
api_version = self._get_api_version('virtual_hub_route_table_v2_s')
if api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import VirtualHubRouteTableV2SOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import VirtualHubRouteTableV2SOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import VirtualHubRouteTableV2SOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import VirtualHubRouteTableV2SOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import VirtualHubRouteTableV2SOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import VirtualHubRouteTableV2SOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import VirtualHubRouteTableV2SOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import VirtualHubRouteTableV2SOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import VirtualHubRouteTableV2SOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import VirtualHubRouteTableV2SOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import VirtualHubRouteTableV2SOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import VirtualHubRouteTableV2SOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'virtual_hub_route_table_v2_s'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def virtual_hubs(self):
"""Instance depends on the API version:
* 2018-04-01: :class:`VirtualHubsOperations<azure.mgmt.network.v2018_04_01.aio.operations.VirtualHubsOperations>`
* 2018-06-01: :class:`VirtualHubsOperations<azure.mgmt.network.v2018_06_01.aio.operations.VirtualHubsOperations>`
* 2018-07-01: :class:`VirtualHubsOperations<azure.mgmt.network.v2018_07_01.aio.operations.VirtualHubsOperations>`
* 2018-08-01: :class:`VirtualHubsOperations<azure.mgmt.network.v2018_08_01.aio.operations.VirtualHubsOperations>`
* 2018-10-01: :class:`VirtualHubsOperations<azure.mgmt.network.v2018_10_01.aio.operations.VirtualHubsOperations>`
* 2018-11-01: :class:`VirtualHubsOperations<azure.mgmt.network.v2018_11_01.aio.operations.VirtualHubsOperations>`
* 2018-12-01: :class:`VirtualHubsOperations<azure.mgmt.network.v2018_12_01.aio.operations.VirtualHubsOperations>`
* 2019-02-01: :class:`VirtualHubsOperations<azure.mgmt.network.v2019_02_01.aio.operations.VirtualHubsOperations>`
* 2019-04-01: :class:`VirtualHubsOperations<azure.mgmt.network.v2019_04_01.aio.operations.VirtualHubsOperations>`
* 2019-06-01: :class:`VirtualHubsOperations<azure.mgmt.network.v2019_06_01.aio.operations.VirtualHubsOperations>`
* 2019-07-01: :class:`VirtualHubsOperations<azure.mgmt.network.v2019_07_01.aio.operations.VirtualHubsOperations>`
* 2019-08-01: :class:`VirtualHubsOperations<azure.mgmt.network.v2019_08_01.aio.operations.VirtualHubsOperations>`
* 2019-09-01: :class:`VirtualHubsOperations<azure.mgmt.network.v2019_09_01.aio.operations.VirtualHubsOperations>`
* 2019-11-01: :class:`VirtualHubsOperations<azure.mgmt.network.v2019_11_01.aio.operations.VirtualHubsOperations>`
* 2019-12-01: :class:`VirtualHubsOperations<azure.mgmt.network.v2019_12_01.aio.operations.VirtualHubsOperations>`
* 2020-03-01: :class:`VirtualHubsOperations<azure.mgmt.network.v2020_03_01.aio.operations.VirtualHubsOperations>`
* 2020-04-01: :class:`VirtualHubsOperations<azure.mgmt.network.v2020_04_01.aio.operations.VirtualHubsOperations>`
* 2020-05-01: :class:`VirtualHubsOperations<azure.mgmt.network.v2020_05_01.aio.operations.VirtualHubsOperations>`
* 2020-06-01: :class:`VirtualHubsOperations<azure.mgmt.network.v2020_06_01.aio.operations.VirtualHubsOperations>`
* 2020-07-01: :class:`VirtualHubsOperations<azure.mgmt.network.v2020_07_01.aio.operations.VirtualHubsOperations>`
* 2020-08-01: :class:`VirtualHubsOperations<azure.mgmt.network.v2020_08_01.aio.operations.VirtualHubsOperations>`
* 2020-11-01: :class:`VirtualHubsOperations<azure.mgmt.network.v2020_11_01.aio.operations.VirtualHubsOperations>`
* 2021-02-01: :class:`VirtualHubsOperations<azure.mgmt.network.v2021_02_01.aio.operations.VirtualHubsOperations>`
* 2021-05-01: :class:`VirtualHubsOperations<azure.mgmt.network.v2021_05_01.aio.operations.VirtualHubsOperations>`
"""
api_version = self._get_api_version('virtual_hubs')
if api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import VirtualHubsOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import VirtualHubsOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import VirtualHubsOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import VirtualHubsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import VirtualHubsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import VirtualHubsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import VirtualHubsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import VirtualHubsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import VirtualHubsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import VirtualHubsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import VirtualHubsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import VirtualHubsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import VirtualHubsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import VirtualHubsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import VirtualHubsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import VirtualHubsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import VirtualHubsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import VirtualHubsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import VirtualHubsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import VirtualHubsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import VirtualHubsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import VirtualHubsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import VirtualHubsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import VirtualHubsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'virtual_hubs'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def virtual_network_gateway_connections(self):
"""Instance depends on the API version:
* 2015-06-15: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2015_06_15.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2016-09-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2016_09_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2016-12-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2016_12_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2017-03-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2017_03_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2017-06-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2017_06_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2017-10-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2017_10_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2018-01-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2018_01_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2018-02-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2018_02_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2018-04-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2018_04_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2018-06-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2018_06_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2018-07-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2018_07_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2018-08-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2018_08_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2018-10-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2018_10_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2018-11-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2018_11_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2018-12-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2018_12_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2019-02-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2019_02_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2019-04-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2019_04_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2019-06-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2019_06_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2019-07-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2019_07_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2019-08-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2019_08_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2019-09-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2019_09_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2019-11-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2019_11_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2019-12-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2019_12_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2020-03-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2020_03_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2020-04-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2020_04_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2020-05-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2020_05_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2020-06-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2020_06_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2020-07-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2020_07_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2020-08-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2020_08_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2020-11-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2020_11_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2021-02-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2021_02_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
* 2021-05-01: :class:`VirtualNetworkGatewayConnectionsOperations<azure.mgmt.network.v2021_05_01.aio.operations.VirtualNetworkGatewayConnectionsOperations>`
"""
api_version = self._get_api_version('virtual_network_gateway_connections')
if api_version == '2015-06-15':
from ..v2015_06_15.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2016-09-01':
from ..v2016_09_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2016-12-01':
from ..v2016_12_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2017-03-01':
from ..v2017_03_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import VirtualNetworkGatewayConnectionsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'virtual_network_gateway_connections'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def virtual_network_gateway_nat_rules(self):
"""Instance depends on the API version:
* 2021-02-01: :class:`VirtualNetworkGatewayNatRulesOperations<azure.mgmt.network.v2021_02_01.aio.operations.VirtualNetworkGatewayNatRulesOperations>`
* 2021-05-01: :class:`VirtualNetworkGatewayNatRulesOperations<azure.mgmt.network.v2021_05_01.aio.operations.VirtualNetworkGatewayNatRulesOperations>`
"""
api_version = self._get_api_version('virtual_network_gateway_nat_rules')
if api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import VirtualNetworkGatewayNatRulesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import VirtualNetworkGatewayNatRulesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'virtual_network_gateway_nat_rules'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def virtual_network_gateways(self):
"""Instance depends on the API version:
* 2015-06-15: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2015_06_15.aio.operations.VirtualNetworkGatewaysOperations>`
* 2016-09-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2016_09_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2016-12-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2016_12_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2017-03-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2017_03_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2017-06-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2017_06_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2017-10-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2017_10_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2018-01-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2018_01_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2018-02-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2018_02_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2018-04-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2018_04_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2018-06-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2018_06_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2018-07-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2018_07_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2018-08-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2018_08_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2018-10-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2018_10_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2018-11-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2018_11_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2018-12-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2018_12_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2019-02-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2019_02_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2019-04-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2019_04_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2019-06-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2019_06_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2019-07-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2019_07_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2019-08-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2019_08_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2019-09-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2019_09_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2019-11-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2019_11_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2019-12-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2019_12_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2020-03-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2020_03_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2020-04-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2020_04_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2020-05-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2020_05_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2020-06-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2020_06_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2020-07-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2020_07_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2020-08-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2020_08_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2020-11-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2020_11_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2021-02-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2021_02_01.aio.operations.VirtualNetworkGatewaysOperations>`
* 2021-05-01: :class:`VirtualNetworkGatewaysOperations<azure.mgmt.network.v2021_05_01.aio.operations.VirtualNetworkGatewaysOperations>`
"""
api_version = self._get_api_version('virtual_network_gateways')
if api_version == '2015-06-15':
from ..v2015_06_15.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2016-09-01':
from ..v2016_09_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2016-12-01':
from ..v2016_12_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2017-03-01':
from ..v2017_03_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import VirtualNetworkGatewaysOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'virtual_network_gateways'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def virtual_network_peerings(self):
"""Instance depends on the API version:
* 2016-09-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2016_09_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2016-12-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2016_12_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2017-03-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2017_03_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2017-06-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2017_06_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2017-10-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2017_10_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2018-01-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2018_01_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2018-02-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2018_02_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2018-04-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2018_04_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2018-06-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2018_06_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2018-07-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2018_07_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2018-08-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2018_08_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2018-10-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2018_10_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2018-11-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2018_11_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2018-12-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2018_12_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2019-02-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2019_02_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2019-04-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2019_04_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2019-06-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2019_06_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2019-07-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2019_07_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2019-08-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2019_08_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2019-09-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2019_09_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2019-11-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2019_11_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2019-12-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2019_12_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2020-03-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2020_03_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2020-04-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2020_04_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2020-05-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2020_05_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2020-06-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2020_06_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2020-07-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2020_07_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2020-08-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2020_08_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2020-11-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2020_11_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2021-02-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2021_02_01.aio.operations.VirtualNetworkPeeringsOperations>`
* 2021-05-01: :class:`VirtualNetworkPeeringsOperations<azure.mgmt.network.v2021_05_01.aio.operations.VirtualNetworkPeeringsOperations>`
"""
api_version = self._get_api_version('virtual_network_peerings')
if api_version == '2016-09-01':
from ..v2016_09_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2016-12-01':
from ..v2016_12_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2017-03-01':
from ..v2017_03_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import VirtualNetworkPeeringsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'virtual_network_peerings'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def virtual_network_taps(self):
"""Instance depends on the API version:
* 2018-08-01: :class:`VirtualNetworkTapsOperations<azure.mgmt.network.v2018_08_01.aio.operations.VirtualNetworkTapsOperations>`
* 2018-10-01: :class:`VirtualNetworkTapsOperations<azure.mgmt.network.v2018_10_01.aio.operations.VirtualNetworkTapsOperations>`
* 2018-11-01: :class:`VirtualNetworkTapsOperations<azure.mgmt.network.v2018_11_01.aio.operations.VirtualNetworkTapsOperations>`
* 2018-12-01: :class:`VirtualNetworkTapsOperations<azure.mgmt.network.v2018_12_01.aio.operations.VirtualNetworkTapsOperations>`
* 2019-02-01: :class:`VirtualNetworkTapsOperations<azure.mgmt.network.v2019_02_01.aio.operations.VirtualNetworkTapsOperations>`
* 2019-04-01: :class:`VirtualNetworkTapsOperations<azure.mgmt.network.v2019_04_01.aio.operations.VirtualNetworkTapsOperations>`
* 2019-06-01: :class:`VirtualNetworkTapsOperations<azure.mgmt.network.v2019_06_01.aio.operations.VirtualNetworkTapsOperations>`
* 2019-07-01: :class:`VirtualNetworkTapsOperations<azure.mgmt.network.v2019_07_01.aio.operations.VirtualNetworkTapsOperations>`
* 2019-08-01: :class:`VirtualNetworkTapsOperations<azure.mgmt.network.v2019_08_01.aio.operations.VirtualNetworkTapsOperations>`
* 2019-09-01: :class:`VirtualNetworkTapsOperations<azure.mgmt.network.v2019_09_01.aio.operations.VirtualNetworkTapsOperations>`
* 2019-11-01: :class:`VirtualNetworkTapsOperations<azure.mgmt.network.v2019_11_01.aio.operations.VirtualNetworkTapsOperations>`
* 2019-12-01: :class:`VirtualNetworkTapsOperations<azure.mgmt.network.v2019_12_01.aio.operations.VirtualNetworkTapsOperations>`
* 2020-03-01: :class:`VirtualNetworkTapsOperations<azure.mgmt.network.v2020_03_01.aio.operations.VirtualNetworkTapsOperations>`
* 2020-04-01: :class:`VirtualNetworkTapsOperations<azure.mgmt.network.v2020_04_01.aio.operations.VirtualNetworkTapsOperations>`
* 2020-05-01: :class:`VirtualNetworkTapsOperations<azure.mgmt.network.v2020_05_01.aio.operations.VirtualNetworkTapsOperations>`
* 2020-06-01: :class:`VirtualNetworkTapsOperations<azure.mgmt.network.v2020_06_01.aio.operations.VirtualNetworkTapsOperations>`
* 2020-07-01: :class:`VirtualNetworkTapsOperations<azure.mgmt.network.v2020_07_01.aio.operations.VirtualNetworkTapsOperations>`
* 2020-08-01: :class:`VirtualNetworkTapsOperations<azure.mgmt.network.v2020_08_01.aio.operations.VirtualNetworkTapsOperations>`
* 2020-11-01: :class:`VirtualNetworkTapsOperations<azure.mgmt.network.v2020_11_01.aio.operations.VirtualNetworkTapsOperations>`
* 2021-02-01: :class:`VirtualNetworkTapsOperations<azure.mgmt.network.v2021_02_01.aio.operations.VirtualNetworkTapsOperations>`
* 2021-05-01: :class:`VirtualNetworkTapsOperations<azure.mgmt.network.v2021_05_01.aio.operations.VirtualNetworkTapsOperations>`
"""
api_version = self._get_api_version('virtual_network_taps')
if api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import VirtualNetworkTapsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import VirtualNetworkTapsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import VirtualNetworkTapsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import VirtualNetworkTapsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import VirtualNetworkTapsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import VirtualNetworkTapsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import VirtualNetworkTapsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import VirtualNetworkTapsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import VirtualNetworkTapsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import VirtualNetworkTapsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import VirtualNetworkTapsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import VirtualNetworkTapsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import VirtualNetworkTapsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import VirtualNetworkTapsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import VirtualNetworkTapsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import VirtualNetworkTapsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import VirtualNetworkTapsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import VirtualNetworkTapsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import VirtualNetworkTapsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import VirtualNetworkTapsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import VirtualNetworkTapsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'virtual_network_taps'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def virtual_networks(self):
"""Instance depends on the API version:
* 2015-06-15: :class:`VirtualNetworksOperations<azure.mgmt.network.v2015_06_15.aio.operations.VirtualNetworksOperations>`
* 2016-09-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2016_09_01.aio.operations.VirtualNetworksOperations>`
* 2016-12-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2016_12_01.aio.operations.VirtualNetworksOperations>`
* 2017-03-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2017_03_01.aio.operations.VirtualNetworksOperations>`
* 2017-06-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2017_06_01.aio.operations.VirtualNetworksOperations>`
* 2017-10-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2017_10_01.aio.operations.VirtualNetworksOperations>`
* 2018-01-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2018_01_01.aio.operations.VirtualNetworksOperations>`
* 2018-02-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2018_02_01.aio.operations.VirtualNetworksOperations>`
* 2018-04-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2018_04_01.aio.operations.VirtualNetworksOperations>`
* 2018-06-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2018_06_01.aio.operations.VirtualNetworksOperations>`
* 2018-07-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2018_07_01.aio.operations.VirtualNetworksOperations>`
* 2018-08-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2018_08_01.aio.operations.VirtualNetworksOperations>`
* 2018-10-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2018_10_01.aio.operations.VirtualNetworksOperations>`
* 2018-11-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2018_11_01.aio.operations.VirtualNetworksOperations>`
* 2018-12-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2018_12_01.aio.operations.VirtualNetworksOperations>`
* 2019-02-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2019_02_01.aio.operations.VirtualNetworksOperations>`
* 2019-04-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2019_04_01.aio.operations.VirtualNetworksOperations>`
* 2019-06-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2019_06_01.aio.operations.VirtualNetworksOperations>`
* 2019-07-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2019_07_01.aio.operations.VirtualNetworksOperations>`
* 2019-08-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2019_08_01.aio.operations.VirtualNetworksOperations>`
* 2019-09-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2019_09_01.aio.operations.VirtualNetworksOperations>`
* 2019-11-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2019_11_01.aio.operations.VirtualNetworksOperations>`
* 2019-12-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2019_12_01.aio.operations.VirtualNetworksOperations>`
* 2020-03-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2020_03_01.aio.operations.VirtualNetworksOperations>`
* 2020-04-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2020_04_01.aio.operations.VirtualNetworksOperations>`
* 2020-05-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2020_05_01.aio.operations.VirtualNetworksOperations>`
* 2020-06-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2020_06_01.aio.operations.VirtualNetworksOperations>`
* 2020-07-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2020_07_01.aio.operations.VirtualNetworksOperations>`
* 2020-08-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2020_08_01.aio.operations.VirtualNetworksOperations>`
* 2020-11-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2020_11_01.aio.operations.VirtualNetworksOperations>`
* 2021-02-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2021_02_01.aio.operations.VirtualNetworksOperations>`
* 2021-05-01: :class:`VirtualNetworksOperations<azure.mgmt.network.v2021_05_01.aio.operations.VirtualNetworksOperations>`
"""
api_version = self._get_api_version('virtual_networks')
if api_version == '2015-06-15':
from ..v2015_06_15.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2016-09-01':
from ..v2016_09_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2016-12-01':
from ..v2016_12_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2017-03-01':
from ..v2017_03_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2017-06-01':
from ..v2017_06_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2017-10-01':
from ..v2017_10_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2018-01-01':
from ..v2018_01_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2018-02-01':
from ..v2018_02_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import VirtualNetworksOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import VirtualNetworksOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'virtual_networks'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def virtual_router_peerings(self):
"""Instance depends on the API version:
* 2019-07-01: :class:`VirtualRouterPeeringsOperations<azure.mgmt.network.v2019_07_01.aio.operations.VirtualRouterPeeringsOperations>`
* 2019-08-01: :class:`VirtualRouterPeeringsOperations<azure.mgmt.network.v2019_08_01.aio.operations.VirtualRouterPeeringsOperations>`
* 2019-09-01: :class:`VirtualRouterPeeringsOperations<azure.mgmt.network.v2019_09_01.aio.operations.VirtualRouterPeeringsOperations>`
* 2019-11-01: :class:`VirtualRouterPeeringsOperations<azure.mgmt.network.v2019_11_01.aio.operations.VirtualRouterPeeringsOperations>`
* 2019-12-01: :class:`VirtualRouterPeeringsOperations<azure.mgmt.network.v2019_12_01.aio.operations.VirtualRouterPeeringsOperations>`
* 2020-03-01: :class:`VirtualRouterPeeringsOperations<azure.mgmt.network.v2020_03_01.aio.operations.VirtualRouterPeeringsOperations>`
* 2020-04-01: :class:`VirtualRouterPeeringsOperations<azure.mgmt.network.v2020_04_01.aio.operations.VirtualRouterPeeringsOperations>`
* 2020-05-01: :class:`VirtualRouterPeeringsOperations<azure.mgmt.network.v2020_05_01.aio.operations.VirtualRouterPeeringsOperations>`
* 2020-06-01: :class:`VirtualRouterPeeringsOperations<azure.mgmt.network.v2020_06_01.aio.operations.VirtualRouterPeeringsOperations>`
* 2020-07-01: :class:`VirtualRouterPeeringsOperations<azure.mgmt.network.v2020_07_01.aio.operations.VirtualRouterPeeringsOperations>`
* 2020-08-01: :class:`VirtualRouterPeeringsOperations<azure.mgmt.network.v2020_08_01.aio.operations.VirtualRouterPeeringsOperations>`
* 2020-11-01: :class:`VirtualRouterPeeringsOperations<azure.mgmt.network.v2020_11_01.aio.operations.VirtualRouterPeeringsOperations>`
* 2021-02-01: :class:`VirtualRouterPeeringsOperations<azure.mgmt.network.v2021_02_01.aio.operations.VirtualRouterPeeringsOperations>`
* 2021-05-01: :class:`VirtualRouterPeeringsOperations<azure.mgmt.network.v2021_05_01.aio.operations.VirtualRouterPeeringsOperations>`
"""
api_version = self._get_api_version('virtual_router_peerings')
if api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import VirtualRouterPeeringsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import VirtualRouterPeeringsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import VirtualRouterPeeringsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import VirtualRouterPeeringsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import VirtualRouterPeeringsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import VirtualRouterPeeringsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import VirtualRouterPeeringsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import VirtualRouterPeeringsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import VirtualRouterPeeringsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import VirtualRouterPeeringsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import VirtualRouterPeeringsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import VirtualRouterPeeringsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import VirtualRouterPeeringsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import VirtualRouterPeeringsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'virtual_router_peerings'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def virtual_routers(self):
"""Instance depends on the API version:
* 2019-07-01: :class:`VirtualRoutersOperations<azure.mgmt.network.v2019_07_01.aio.operations.VirtualRoutersOperations>`
* 2019-08-01: :class:`VirtualRoutersOperations<azure.mgmt.network.v2019_08_01.aio.operations.VirtualRoutersOperations>`
* 2019-09-01: :class:`VirtualRoutersOperations<azure.mgmt.network.v2019_09_01.aio.operations.VirtualRoutersOperations>`
* 2019-11-01: :class:`VirtualRoutersOperations<azure.mgmt.network.v2019_11_01.aio.operations.VirtualRoutersOperations>`
* 2019-12-01: :class:`VirtualRoutersOperations<azure.mgmt.network.v2019_12_01.aio.operations.VirtualRoutersOperations>`
* 2020-03-01: :class:`VirtualRoutersOperations<azure.mgmt.network.v2020_03_01.aio.operations.VirtualRoutersOperations>`
* 2020-04-01: :class:`VirtualRoutersOperations<azure.mgmt.network.v2020_04_01.aio.operations.VirtualRoutersOperations>`
* 2020-05-01: :class:`VirtualRoutersOperations<azure.mgmt.network.v2020_05_01.aio.operations.VirtualRoutersOperations>`
* 2020-06-01: :class:`VirtualRoutersOperations<azure.mgmt.network.v2020_06_01.aio.operations.VirtualRoutersOperations>`
* 2020-07-01: :class:`VirtualRoutersOperations<azure.mgmt.network.v2020_07_01.aio.operations.VirtualRoutersOperations>`
* 2020-08-01: :class:`VirtualRoutersOperations<azure.mgmt.network.v2020_08_01.aio.operations.VirtualRoutersOperations>`
* 2020-11-01: :class:`VirtualRoutersOperations<azure.mgmt.network.v2020_11_01.aio.operations.VirtualRoutersOperations>`
* 2021-02-01: :class:`VirtualRoutersOperations<azure.mgmt.network.v2021_02_01.aio.operations.VirtualRoutersOperations>`
* 2021-05-01: :class:`VirtualRoutersOperations<azure.mgmt.network.v2021_05_01.aio.operations.VirtualRoutersOperations>`
"""
api_version = self._get_api_version('virtual_routers')
if api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import VirtualRoutersOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import VirtualRoutersOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import VirtualRoutersOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import VirtualRoutersOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import VirtualRoutersOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import VirtualRoutersOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import VirtualRoutersOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import VirtualRoutersOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import VirtualRoutersOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import VirtualRoutersOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import VirtualRoutersOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import VirtualRoutersOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import VirtualRoutersOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import VirtualRoutersOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'virtual_routers'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def virtual_wans(self):
"""Instance depends on the API version:
* 2018-04-01: :class:`VirtualWANsOperations<azure.mgmt.network.v2018_04_01.aio.operations.VirtualWANsOperations>`
* 2018-06-01: :class:`VirtualWANsOperations<azure.mgmt.network.v2018_06_01.aio.operations.VirtualWANsOperations>`
* 2018-07-01: :class:`VirtualWANsOperations<azure.mgmt.network.v2018_07_01.aio.operations.VirtualWANsOperations>`
* 2018-08-01: :class:`VirtualWansOperations<azure.mgmt.network.v2018_08_01.aio.operations.VirtualWansOperations>`
* 2018-10-01: :class:`VirtualWansOperations<azure.mgmt.network.v2018_10_01.aio.operations.VirtualWansOperations>`
* 2018-11-01: :class:`VirtualWansOperations<azure.mgmt.network.v2018_11_01.aio.operations.VirtualWansOperations>`
* 2018-12-01: :class:`VirtualWansOperations<azure.mgmt.network.v2018_12_01.aio.operations.VirtualWansOperations>`
* 2019-02-01: :class:`VirtualWansOperations<azure.mgmt.network.v2019_02_01.aio.operations.VirtualWansOperations>`
* 2019-04-01: :class:`VirtualWansOperations<azure.mgmt.network.v2019_04_01.aio.operations.VirtualWansOperations>`
* 2019-06-01: :class:`VirtualWansOperations<azure.mgmt.network.v2019_06_01.aio.operations.VirtualWansOperations>`
* 2019-07-01: :class:`VirtualWansOperations<azure.mgmt.network.v2019_07_01.aio.operations.VirtualWansOperations>`
* 2019-08-01: :class:`VirtualWansOperations<azure.mgmt.network.v2019_08_01.aio.operations.VirtualWansOperations>`
* 2019-09-01: :class:`VirtualWansOperations<azure.mgmt.network.v2019_09_01.aio.operations.VirtualWansOperations>`
* 2019-11-01: :class:`VirtualWansOperations<azure.mgmt.network.v2019_11_01.aio.operations.VirtualWansOperations>`
* 2019-12-01: :class:`VirtualWansOperations<azure.mgmt.network.v2019_12_01.aio.operations.VirtualWansOperations>`
* 2020-03-01: :class:`VirtualWansOperations<azure.mgmt.network.v2020_03_01.aio.operations.VirtualWansOperations>`
* 2020-04-01: :class:`VirtualWansOperations<azure.mgmt.network.v2020_04_01.aio.operations.VirtualWansOperations>`
* 2020-05-01: :class:`VirtualWansOperations<azure.mgmt.network.v2020_05_01.aio.operations.VirtualWansOperations>`
* 2020-06-01: :class:`VirtualWansOperations<azure.mgmt.network.v2020_06_01.aio.operations.VirtualWansOperations>`
* 2020-07-01: :class:`VirtualWansOperations<azure.mgmt.network.v2020_07_01.aio.operations.VirtualWansOperations>`
* 2020-08-01: :class:`VirtualWansOperations<azure.mgmt.network.v2020_08_01.aio.operations.VirtualWansOperations>`
* 2020-11-01: :class:`VirtualWansOperations<azure.mgmt.network.v2020_11_01.aio.operations.VirtualWansOperations>`
* 2021-02-01: :class:`VirtualWansOperations<azure.mgmt.network.v2021_02_01.aio.operations.VirtualWansOperations>`
* 2021-05-01: :class:`VirtualWansOperations<azure.mgmt.network.v2021_05_01.aio.operations.VirtualWansOperations>`
"""
api_version = self._get_api_version('virtual_wans')
if api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import VirtualWANsOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import VirtualWANsOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import VirtualWANsOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import VirtualWansOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import VirtualWansOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import VirtualWansOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import VirtualWansOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import VirtualWansOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import VirtualWansOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import VirtualWansOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import VirtualWansOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import VirtualWansOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import VirtualWansOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import VirtualWansOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import VirtualWansOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import VirtualWansOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import VirtualWansOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import VirtualWansOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import VirtualWansOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import VirtualWansOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import VirtualWansOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import VirtualWansOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import VirtualWansOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import VirtualWansOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'virtual_wans'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def vpn_connections(self):
"""Instance depends on the API version:
* 2018-04-01: :class:`VpnConnectionsOperations<azure.mgmt.network.v2018_04_01.aio.operations.VpnConnectionsOperations>`
* 2018-06-01: :class:`VpnConnectionsOperations<azure.mgmt.network.v2018_06_01.aio.operations.VpnConnectionsOperations>`
* 2018-07-01: :class:`VpnConnectionsOperations<azure.mgmt.network.v2018_07_01.aio.operations.VpnConnectionsOperations>`
* 2018-08-01: :class:`VpnConnectionsOperations<azure.mgmt.network.v2018_08_01.aio.operations.VpnConnectionsOperations>`
* 2018-10-01: :class:`VpnConnectionsOperations<azure.mgmt.network.v2018_10_01.aio.operations.VpnConnectionsOperations>`
* 2018-11-01: :class:`VpnConnectionsOperations<azure.mgmt.network.v2018_11_01.aio.operations.VpnConnectionsOperations>`
* 2018-12-01: :class:`VpnConnectionsOperations<azure.mgmt.network.v2018_12_01.aio.operations.VpnConnectionsOperations>`
* 2019-02-01: :class:`VpnConnectionsOperations<azure.mgmt.network.v2019_02_01.aio.operations.VpnConnectionsOperations>`
* 2019-04-01: :class:`VpnConnectionsOperations<azure.mgmt.network.v2019_04_01.aio.operations.VpnConnectionsOperations>`
* 2019-06-01: :class:`VpnConnectionsOperations<azure.mgmt.network.v2019_06_01.aio.operations.VpnConnectionsOperations>`
* 2019-07-01: :class:`VpnConnectionsOperations<azure.mgmt.network.v2019_07_01.aio.operations.VpnConnectionsOperations>`
* 2019-08-01: :class:`VpnConnectionsOperations<azure.mgmt.network.v2019_08_01.aio.operations.VpnConnectionsOperations>`
* 2019-09-01: :class:`VpnConnectionsOperations<azure.mgmt.network.v2019_09_01.aio.operations.VpnConnectionsOperations>`
* 2019-11-01: :class:`VpnConnectionsOperations<azure.mgmt.network.v2019_11_01.aio.operations.VpnConnectionsOperations>`
* 2019-12-01: :class:`VpnConnectionsOperations<azure.mgmt.network.v2019_12_01.aio.operations.VpnConnectionsOperations>`
* 2020-03-01: :class:`VpnConnectionsOperations<azure.mgmt.network.v2020_03_01.aio.operations.VpnConnectionsOperations>`
* 2020-04-01: :class:`VpnConnectionsOperations<azure.mgmt.network.v2020_04_01.aio.operations.VpnConnectionsOperations>`
* 2020-05-01: :class:`VpnConnectionsOperations<azure.mgmt.network.v2020_05_01.aio.operations.VpnConnectionsOperations>`
* 2020-06-01: :class:`VpnConnectionsOperations<azure.mgmt.network.v2020_06_01.aio.operations.VpnConnectionsOperations>`
* 2020-07-01: :class:`VpnConnectionsOperations<azure.mgmt.network.v2020_07_01.aio.operations.VpnConnectionsOperations>`
* 2020-08-01: :class:`VpnConnectionsOperations<azure.mgmt.network.v2020_08_01.aio.operations.VpnConnectionsOperations>`
* 2020-11-01: :class:`VpnConnectionsOperations<azure.mgmt.network.v2020_11_01.aio.operations.VpnConnectionsOperations>`
* 2021-02-01: :class:`VpnConnectionsOperations<azure.mgmt.network.v2021_02_01.aio.operations.VpnConnectionsOperations>`
* 2021-05-01: :class:`VpnConnectionsOperations<azure.mgmt.network.v2021_05_01.aio.operations.VpnConnectionsOperations>`
"""
api_version = self._get_api_version('vpn_connections')
if api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import VpnConnectionsOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import VpnConnectionsOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import VpnConnectionsOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import VpnConnectionsOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import VpnConnectionsOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import VpnConnectionsOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import VpnConnectionsOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import VpnConnectionsOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import VpnConnectionsOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import VpnConnectionsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import VpnConnectionsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import VpnConnectionsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import VpnConnectionsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import VpnConnectionsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import VpnConnectionsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import VpnConnectionsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import VpnConnectionsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import VpnConnectionsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import VpnConnectionsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import VpnConnectionsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import VpnConnectionsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import VpnConnectionsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import VpnConnectionsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import VpnConnectionsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'vpn_connections'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def vpn_gateways(self):
"""Instance depends on the API version:
* 2018-04-01: :class:`VpnGatewaysOperations<azure.mgmt.network.v2018_04_01.aio.operations.VpnGatewaysOperations>`
* 2018-06-01: :class:`VpnGatewaysOperations<azure.mgmt.network.v2018_06_01.aio.operations.VpnGatewaysOperations>`
* 2018-07-01: :class:`VpnGatewaysOperations<azure.mgmt.network.v2018_07_01.aio.operations.VpnGatewaysOperations>`
* 2018-08-01: :class:`VpnGatewaysOperations<azure.mgmt.network.v2018_08_01.aio.operations.VpnGatewaysOperations>`
* 2018-10-01: :class:`VpnGatewaysOperations<azure.mgmt.network.v2018_10_01.aio.operations.VpnGatewaysOperations>`
* 2018-11-01: :class:`VpnGatewaysOperations<azure.mgmt.network.v2018_11_01.aio.operations.VpnGatewaysOperations>`
* 2018-12-01: :class:`VpnGatewaysOperations<azure.mgmt.network.v2018_12_01.aio.operations.VpnGatewaysOperations>`
* 2019-02-01: :class:`VpnGatewaysOperations<azure.mgmt.network.v2019_02_01.aio.operations.VpnGatewaysOperations>`
* 2019-04-01: :class:`VpnGatewaysOperations<azure.mgmt.network.v2019_04_01.aio.operations.VpnGatewaysOperations>`
* 2019-06-01: :class:`VpnGatewaysOperations<azure.mgmt.network.v2019_06_01.aio.operations.VpnGatewaysOperations>`
* 2019-07-01: :class:`VpnGatewaysOperations<azure.mgmt.network.v2019_07_01.aio.operations.VpnGatewaysOperations>`
* 2019-08-01: :class:`VpnGatewaysOperations<azure.mgmt.network.v2019_08_01.aio.operations.VpnGatewaysOperations>`
* 2019-09-01: :class:`VpnGatewaysOperations<azure.mgmt.network.v2019_09_01.aio.operations.VpnGatewaysOperations>`
* 2019-11-01: :class:`VpnGatewaysOperations<azure.mgmt.network.v2019_11_01.aio.operations.VpnGatewaysOperations>`
* 2019-12-01: :class:`VpnGatewaysOperations<azure.mgmt.network.v2019_12_01.aio.operations.VpnGatewaysOperations>`
* 2020-03-01: :class:`VpnGatewaysOperations<azure.mgmt.network.v2020_03_01.aio.operations.VpnGatewaysOperations>`
* 2020-04-01: :class:`VpnGatewaysOperations<azure.mgmt.network.v2020_04_01.aio.operations.VpnGatewaysOperations>`
* 2020-05-01: :class:`VpnGatewaysOperations<azure.mgmt.network.v2020_05_01.aio.operations.VpnGatewaysOperations>`
* 2020-06-01: :class:`VpnGatewaysOperations<azure.mgmt.network.v2020_06_01.aio.operations.VpnGatewaysOperations>`
* 2020-07-01: :class:`VpnGatewaysOperations<azure.mgmt.network.v2020_07_01.aio.operations.VpnGatewaysOperations>`
* 2020-08-01: :class:`VpnGatewaysOperations<azure.mgmt.network.v2020_08_01.aio.operations.VpnGatewaysOperations>`
* 2020-11-01: :class:`VpnGatewaysOperations<azure.mgmt.network.v2020_11_01.aio.operations.VpnGatewaysOperations>`
* 2021-02-01: :class:`VpnGatewaysOperations<azure.mgmt.network.v2021_02_01.aio.operations.VpnGatewaysOperations>`
* 2021-05-01: :class:`VpnGatewaysOperations<azure.mgmt.network.v2021_05_01.aio.operations.VpnGatewaysOperations>`
"""
api_version = self._get_api_version('vpn_gateways')
if api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import VpnGatewaysOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import VpnGatewaysOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import VpnGatewaysOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import VpnGatewaysOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import VpnGatewaysOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import VpnGatewaysOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import VpnGatewaysOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import VpnGatewaysOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import VpnGatewaysOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import VpnGatewaysOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import VpnGatewaysOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import VpnGatewaysOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import VpnGatewaysOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import VpnGatewaysOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import VpnGatewaysOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import VpnGatewaysOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import VpnGatewaysOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import VpnGatewaysOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import VpnGatewaysOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import VpnGatewaysOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import VpnGatewaysOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import VpnGatewaysOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import VpnGatewaysOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import VpnGatewaysOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'vpn_gateways'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def vpn_link_connections(self):
"""Instance depends on the API version:
* 2019-06-01: :class:`VpnLinkConnectionsOperations<azure.mgmt.network.v2019_06_01.aio.operations.VpnLinkConnectionsOperations>`
* 2019-07-01: :class:`VpnLinkConnectionsOperations<azure.mgmt.network.v2019_07_01.aio.operations.VpnLinkConnectionsOperations>`
* 2019-08-01: :class:`VpnLinkConnectionsOperations<azure.mgmt.network.v2019_08_01.aio.operations.VpnLinkConnectionsOperations>`
* 2019-09-01: :class:`VpnLinkConnectionsOperations<azure.mgmt.network.v2019_09_01.aio.operations.VpnLinkConnectionsOperations>`
* 2019-11-01: :class:`VpnLinkConnectionsOperations<azure.mgmt.network.v2019_11_01.aio.operations.VpnLinkConnectionsOperations>`
* 2019-12-01: :class:`VpnLinkConnectionsOperations<azure.mgmt.network.v2019_12_01.aio.operations.VpnLinkConnectionsOperations>`
* 2020-03-01: :class:`VpnLinkConnectionsOperations<azure.mgmt.network.v2020_03_01.aio.operations.VpnLinkConnectionsOperations>`
* 2020-04-01: :class:`VpnLinkConnectionsOperations<azure.mgmt.network.v2020_04_01.aio.operations.VpnLinkConnectionsOperations>`
* 2020-05-01: :class:`VpnLinkConnectionsOperations<azure.mgmt.network.v2020_05_01.aio.operations.VpnLinkConnectionsOperations>`
* 2020-06-01: :class:`VpnLinkConnectionsOperations<azure.mgmt.network.v2020_06_01.aio.operations.VpnLinkConnectionsOperations>`
* 2020-07-01: :class:`VpnLinkConnectionsOperations<azure.mgmt.network.v2020_07_01.aio.operations.VpnLinkConnectionsOperations>`
* 2020-08-01: :class:`VpnLinkConnectionsOperations<azure.mgmt.network.v2020_08_01.aio.operations.VpnLinkConnectionsOperations>`
* 2020-11-01: :class:`VpnLinkConnectionsOperations<azure.mgmt.network.v2020_11_01.aio.operations.VpnLinkConnectionsOperations>`
* 2021-02-01: :class:`VpnLinkConnectionsOperations<azure.mgmt.network.v2021_02_01.aio.operations.VpnLinkConnectionsOperations>`
* 2021-05-01: :class:`VpnLinkConnectionsOperations<azure.mgmt.network.v2021_05_01.aio.operations.VpnLinkConnectionsOperations>`
"""
api_version = self._get_api_version('vpn_link_connections')
if api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import VpnLinkConnectionsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import VpnLinkConnectionsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import VpnLinkConnectionsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import VpnLinkConnectionsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import VpnLinkConnectionsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import VpnLinkConnectionsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import VpnLinkConnectionsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import VpnLinkConnectionsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import VpnLinkConnectionsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import VpnLinkConnectionsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import VpnLinkConnectionsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import VpnLinkConnectionsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import VpnLinkConnectionsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import VpnLinkConnectionsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import VpnLinkConnectionsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'vpn_link_connections'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def vpn_server_configurations(self):
"""Instance depends on the API version:
* 2019-08-01: :class:`VpnServerConfigurationsOperations<azure.mgmt.network.v2019_08_01.aio.operations.VpnServerConfigurationsOperations>`
* 2019-09-01: :class:`VpnServerConfigurationsOperations<azure.mgmt.network.v2019_09_01.aio.operations.VpnServerConfigurationsOperations>`
* 2019-11-01: :class:`VpnServerConfigurationsOperations<azure.mgmt.network.v2019_11_01.aio.operations.VpnServerConfigurationsOperations>`
* 2019-12-01: :class:`VpnServerConfigurationsOperations<azure.mgmt.network.v2019_12_01.aio.operations.VpnServerConfigurationsOperations>`
* 2020-03-01: :class:`VpnServerConfigurationsOperations<azure.mgmt.network.v2020_03_01.aio.operations.VpnServerConfigurationsOperations>`
* 2020-04-01: :class:`VpnServerConfigurationsOperations<azure.mgmt.network.v2020_04_01.aio.operations.VpnServerConfigurationsOperations>`
* 2020-05-01: :class:`VpnServerConfigurationsOperations<azure.mgmt.network.v2020_05_01.aio.operations.VpnServerConfigurationsOperations>`
* 2020-06-01: :class:`VpnServerConfigurationsOperations<azure.mgmt.network.v2020_06_01.aio.operations.VpnServerConfigurationsOperations>`
* 2020-07-01: :class:`VpnServerConfigurationsOperations<azure.mgmt.network.v2020_07_01.aio.operations.VpnServerConfigurationsOperations>`
* 2020-08-01: :class:`VpnServerConfigurationsOperations<azure.mgmt.network.v2020_08_01.aio.operations.VpnServerConfigurationsOperations>`
* 2020-11-01: :class:`VpnServerConfigurationsOperations<azure.mgmt.network.v2020_11_01.aio.operations.VpnServerConfigurationsOperations>`
* 2021-02-01: :class:`VpnServerConfigurationsOperations<azure.mgmt.network.v2021_02_01.aio.operations.VpnServerConfigurationsOperations>`
* 2021-05-01: :class:`VpnServerConfigurationsOperations<azure.mgmt.network.v2021_05_01.aio.operations.VpnServerConfigurationsOperations>`
"""
api_version = self._get_api_version('vpn_server_configurations')
if api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import VpnServerConfigurationsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import VpnServerConfigurationsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import VpnServerConfigurationsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import VpnServerConfigurationsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import VpnServerConfigurationsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import VpnServerConfigurationsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import VpnServerConfigurationsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import VpnServerConfigurationsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import VpnServerConfigurationsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import VpnServerConfigurationsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import VpnServerConfigurationsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import VpnServerConfigurationsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import VpnServerConfigurationsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'vpn_server_configurations'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def vpn_server_configurations_associated_with_virtual_wan(self):
"""Instance depends on the API version:
* 2019-08-01: :class:`VpnServerConfigurationsAssociatedWithVirtualWanOperations<azure.mgmt.network.v2019_08_01.aio.operations.VpnServerConfigurationsAssociatedWithVirtualWanOperations>`
* 2019-09-01: :class:`VpnServerConfigurationsAssociatedWithVirtualWanOperations<azure.mgmt.network.v2019_09_01.aio.operations.VpnServerConfigurationsAssociatedWithVirtualWanOperations>`
* 2019-11-01: :class:`VpnServerConfigurationsAssociatedWithVirtualWanOperations<azure.mgmt.network.v2019_11_01.aio.operations.VpnServerConfigurationsAssociatedWithVirtualWanOperations>`
* 2019-12-01: :class:`VpnServerConfigurationsAssociatedWithVirtualWanOperations<azure.mgmt.network.v2019_12_01.aio.operations.VpnServerConfigurationsAssociatedWithVirtualWanOperations>`
* 2020-03-01: :class:`VpnServerConfigurationsAssociatedWithVirtualWanOperations<azure.mgmt.network.v2020_03_01.aio.operations.VpnServerConfigurationsAssociatedWithVirtualWanOperations>`
* 2020-04-01: :class:`VpnServerConfigurationsAssociatedWithVirtualWanOperations<azure.mgmt.network.v2020_04_01.aio.operations.VpnServerConfigurationsAssociatedWithVirtualWanOperations>`
* 2020-05-01: :class:`VpnServerConfigurationsAssociatedWithVirtualWanOperations<azure.mgmt.network.v2020_05_01.aio.operations.VpnServerConfigurationsAssociatedWithVirtualWanOperations>`
* 2020-06-01: :class:`VpnServerConfigurationsAssociatedWithVirtualWanOperations<azure.mgmt.network.v2020_06_01.aio.operations.VpnServerConfigurationsAssociatedWithVirtualWanOperations>`
* 2020-07-01: :class:`VpnServerConfigurationsAssociatedWithVirtualWanOperations<azure.mgmt.network.v2020_07_01.aio.operations.VpnServerConfigurationsAssociatedWithVirtualWanOperations>`
* 2020-08-01: :class:`VpnServerConfigurationsAssociatedWithVirtualWanOperations<azure.mgmt.network.v2020_08_01.aio.operations.VpnServerConfigurationsAssociatedWithVirtualWanOperations>`
* 2020-11-01: :class:`VpnServerConfigurationsAssociatedWithVirtualWanOperations<azure.mgmt.network.v2020_11_01.aio.operations.VpnServerConfigurationsAssociatedWithVirtualWanOperations>`
* 2021-02-01: :class:`VpnServerConfigurationsAssociatedWithVirtualWanOperations<azure.mgmt.network.v2021_02_01.aio.operations.VpnServerConfigurationsAssociatedWithVirtualWanOperations>`
* 2021-05-01: :class:`VpnServerConfigurationsAssociatedWithVirtualWanOperations<azure.mgmt.network.v2021_05_01.aio.operations.VpnServerConfigurationsAssociatedWithVirtualWanOperations>`
"""
api_version = self._get_api_version('vpn_server_configurations_associated_with_virtual_wan')
if api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import VpnServerConfigurationsAssociatedWithVirtualWanOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import VpnServerConfigurationsAssociatedWithVirtualWanOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import VpnServerConfigurationsAssociatedWithVirtualWanOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import VpnServerConfigurationsAssociatedWithVirtualWanOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import VpnServerConfigurationsAssociatedWithVirtualWanOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import VpnServerConfigurationsAssociatedWithVirtualWanOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import VpnServerConfigurationsAssociatedWithVirtualWanOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import VpnServerConfigurationsAssociatedWithVirtualWanOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import VpnServerConfigurationsAssociatedWithVirtualWanOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import VpnServerConfigurationsAssociatedWithVirtualWanOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import VpnServerConfigurationsAssociatedWithVirtualWanOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import VpnServerConfigurationsAssociatedWithVirtualWanOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import VpnServerConfigurationsAssociatedWithVirtualWanOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'vpn_server_configurations_associated_with_virtual_wan'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def vpn_site_link_connections(self):
"""Instance depends on the API version:
* 2019-06-01: :class:`VpnSiteLinkConnectionsOperations<azure.mgmt.network.v2019_06_01.aio.operations.VpnSiteLinkConnectionsOperations>`
* 2019-07-01: :class:`VpnSiteLinkConnectionsOperations<azure.mgmt.network.v2019_07_01.aio.operations.VpnSiteLinkConnectionsOperations>`
* 2019-08-01: :class:`VpnSiteLinkConnectionsOperations<azure.mgmt.network.v2019_08_01.aio.operations.VpnSiteLinkConnectionsOperations>`
* 2019-09-01: :class:`VpnSiteLinkConnectionsOperations<azure.mgmt.network.v2019_09_01.aio.operations.VpnSiteLinkConnectionsOperations>`
* 2019-11-01: :class:`VpnSiteLinkConnectionsOperations<azure.mgmt.network.v2019_11_01.aio.operations.VpnSiteLinkConnectionsOperations>`
* 2019-12-01: :class:`VpnSiteLinkConnectionsOperations<azure.mgmt.network.v2019_12_01.aio.operations.VpnSiteLinkConnectionsOperations>`
* 2020-03-01: :class:`VpnSiteLinkConnectionsOperations<azure.mgmt.network.v2020_03_01.aio.operations.VpnSiteLinkConnectionsOperations>`
* 2020-04-01: :class:`VpnSiteLinkConnectionsOperations<azure.mgmt.network.v2020_04_01.aio.operations.VpnSiteLinkConnectionsOperations>`
* 2020-05-01: :class:`VpnSiteLinkConnectionsOperations<azure.mgmt.network.v2020_05_01.aio.operations.VpnSiteLinkConnectionsOperations>`
* 2020-06-01: :class:`VpnSiteLinkConnectionsOperations<azure.mgmt.network.v2020_06_01.aio.operations.VpnSiteLinkConnectionsOperations>`
* 2020-07-01: :class:`VpnSiteLinkConnectionsOperations<azure.mgmt.network.v2020_07_01.aio.operations.VpnSiteLinkConnectionsOperations>`
* 2020-08-01: :class:`VpnSiteLinkConnectionsOperations<azure.mgmt.network.v2020_08_01.aio.operations.VpnSiteLinkConnectionsOperations>`
* 2020-11-01: :class:`VpnSiteLinkConnectionsOperations<azure.mgmt.network.v2020_11_01.aio.operations.VpnSiteLinkConnectionsOperations>`
* 2021-02-01: :class:`VpnSiteLinkConnectionsOperations<azure.mgmt.network.v2021_02_01.aio.operations.VpnSiteLinkConnectionsOperations>`
* 2021-05-01: :class:`VpnSiteLinkConnectionsOperations<azure.mgmt.network.v2021_05_01.aio.operations.VpnSiteLinkConnectionsOperations>`
"""
api_version = self._get_api_version('vpn_site_link_connections')
if api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import VpnSiteLinkConnectionsOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import VpnSiteLinkConnectionsOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import VpnSiteLinkConnectionsOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import VpnSiteLinkConnectionsOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import VpnSiteLinkConnectionsOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import VpnSiteLinkConnectionsOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import VpnSiteLinkConnectionsOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import VpnSiteLinkConnectionsOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import VpnSiteLinkConnectionsOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import VpnSiteLinkConnectionsOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import VpnSiteLinkConnectionsOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import VpnSiteLinkConnectionsOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import VpnSiteLinkConnectionsOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import VpnSiteLinkConnectionsOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import VpnSiteLinkConnectionsOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'vpn_site_link_connections'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def vpn_site_links(self):
"""Instance depends on the API version:
* 2019-06-01: :class:`VpnSiteLinksOperations<azure.mgmt.network.v2019_06_01.aio.operations.VpnSiteLinksOperations>`
* 2019-07-01: :class:`VpnSiteLinksOperations<azure.mgmt.network.v2019_07_01.aio.operations.VpnSiteLinksOperations>`
* 2019-08-01: :class:`VpnSiteLinksOperations<azure.mgmt.network.v2019_08_01.aio.operations.VpnSiteLinksOperations>`
* 2019-09-01: :class:`VpnSiteLinksOperations<azure.mgmt.network.v2019_09_01.aio.operations.VpnSiteLinksOperations>`
* 2019-11-01: :class:`VpnSiteLinksOperations<azure.mgmt.network.v2019_11_01.aio.operations.VpnSiteLinksOperations>`
* 2019-12-01: :class:`VpnSiteLinksOperations<azure.mgmt.network.v2019_12_01.aio.operations.VpnSiteLinksOperations>`
* 2020-03-01: :class:`VpnSiteLinksOperations<azure.mgmt.network.v2020_03_01.aio.operations.VpnSiteLinksOperations>`
* 2020-04-01: :class:`VpnSiteLinksOperations<azure.mgmt.network.v2020_04_01.aio.operations.VpnSiteLinksOperations>`
* 2020-05-01: :class:`VpnSiteLinksOperations<azure.mgmt.network.v2020_05_01.aio.operations.VpnSiteLinksOperations>`
* 2020-06-01: :class:`VpnSiteLinksOperations<azure.mgmt.network.v2020_06_01.aio.operations.VpnSiteLinksOperations>`
* 2020-07-01: :class:`VpnSiteLinksOperations<azure.mgmt.network.v2020_07_01.aio.operations.VpnSiteLinksOperations>`
* 2020-08-01: :class:`VpnSiteLinksOperations<azure.mgmt.network.v2020_08_01.aio.operations.VpnSiteLinksOperations>`
* 2020-11-01: :class:`VpnSiteLinksOperations<azure.mgmt.network.v2020_11_01.aio.operations.VpnSiteLinksOperations>`
* 2021-02-01: :class:`VpnSiteLinksOperations<azure.mgmt.network.v2021_02_01.aio.operations.VpnSiteLinksOperations>`
* 2021-05-01: :class:`VpnSiteLinksOperations<azure.mgmt.network.v2021_05_01.aio.operations.VpnSiteLinksOperations>`
"""
api_version = self._get_api_version('vpn_site_links')
if api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import VpnSiteLinksOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import VpnSiteLinksOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import VpnSiteLinksOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import VpnSiteLinksOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import VpnSiteLinksOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import VpnSiteLinksOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import VpnSiteLinksOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import VpnSiteLinksOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import VpnSiteLinksOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import VpnSiteLinksOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import VpnSiteLinksOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import VpnSiteLinksOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import VpnSiteLinksOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import VpnSiteLinksOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import VpnSiteLinksOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'vpn_site_links'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def vpn_sites(self):
"""Instance depends on the API version:
* 2018-04-01: :class:`VpnSitesOperations<azure.mgmt.network.v2018_04_01.aio.operations.VpnSitesOperations>`
* 2018-06-01: :class:`VpnSitesOperations<azure.mgmt.network.v2018_06_01.aio.operations.VpnSitesOperations>`
* 2018-07-01: :class:`VpnSitesOperations<azure.mgmt.network.v2018_07_01.aio.operations.VpnSitesOperations>`
* 2018-08-01: :class:`VpnSitesOperations<azure.mgmt.network.v2018_08_01.aio.operations.VpnSitesOperations>`
* 2018-10-01: :class:`VpnSitesOperations<azure.mgmt.network.v2018_10_01.aio.operations.VpnSitesOperations>`
* 2018-11-01: :class:`VpnSitesOperations<azure.mgmt.network.v2018_11_01.aio.operations.VpnSitesOperations>`
* 2018-12-01: :class:`VpnSitesOperations<azure.mgmt.network.v2018_12_01.aio.operations.VpnSitesOperations>`
* 2019-02-01: :class:`VpnSitesOperations<azure.mgmt.network.v2019_02_01.aio.operations.VpnSitesOperations>`
* 2019-04-01: :class:`VpnSitesOperations<azure.mgmt.network.v2019_04_01.aio.operations.VpnSitesOperations>`
* 2019-06-01: :class:`VpnSitesOperations<azure.mgmt.network.v2019_06_01.aio.operations.VpnSitesOperations>`
* 2019-07-01: :class:`VpnSitesOperations<azure.mgmt.network.v2019_07_01.aio.operations.VpnSitesOperations>`
* 2019-08-01: :class:`VpnSitesOperations<azure.mgmt.network.v2019_08_01.aio.operations.VpnSitesOperations>`
* 2019-09-01: :class:`VpnSitesOperations<azure.mgmt.network.v2019_09_01.aio.operations.VpnSitesOperations>`
* 2019-11-01: :class:`VpnSitesOperations<azure.mgmt.network.v2019_11_01.aio.operations.VpnSitesOperations>`
* 2019-12-01: :class:`VpnSitesOperations<azure.mgmt.network.v2019_12_01.aio.operations.VpnSitesOperations>`
* 2020-03-01: :class:`VpnSitesOperations<azure.mgmt.network.v2020_03_01.aio.operations.VpnSitesOperations>`
* 2020-04-01: :class:`VpnSitesOperations<azure.mgmt.network.v2020_04_01.aio.operations.VpnSitesOperations>`
* 2020-05-01: :class:`VpnSitesOperations<azure.mgmt.network.v2020_05_01.aio.operations.VpnSitesOperations>`
* 2020-06-01: :class:`VpnSitesOperations<azure.mgmt.network.v2020_06_01.aio.operations.VpnSitesOperations>`
* 2020-07-01: :class:`VpnSitesOperations<azure.mgmt.network.v2020_07_01.aio.operations.VpnSitesOperations>`
* 2020-08-01: :class:`VpnSitesOperations<azure.mgmt.network.v2020_08_01.aio.operations.VpnSitesOperations>`
* 2020-11-01: :class:`VpnSitesOperations<azure.mgmt.network.v2020_11_01.aio.operations.VpnSitesOperations>`
* 2021-02-01: :class:`VpnSitesOperations<azure.mgmt.network.v2021_02_01.aio.operations.VpnSitesOperations>`
* 2021-05-01: :class:`VpnSitesOperations<azure.mgmt.network.v2021_05_01.aio.operations.VpnSitesOperations>`
"""
api_version = self._get_api_version('vpn_sites')
if api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import VpnSitesOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import VpnSitesOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import VpnSitesOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import VpnSitesOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import VpnSitesOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import VpnSitesOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import VpnSitesOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import VpnSitesOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import VpnSitesOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import VpnSitesOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import VpnSitesOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import VpnSitesOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import VpnSitesOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import VpnSitesOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import VpnSitesOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import VpnSitesOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import VpnSitesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import VpnSitesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import VpnSitesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import VpnSitesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import VpnSitesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import VpnSitesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import VpnSitesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import VpnSitesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'vpn_sites'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def vpn_sites_configuration(self):
"""Instance depends on the API version:
* 2018-04-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2018_04_01.aio.operations.VpnSitesConfigurationOperations>`
* 2018-06-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2018_06_01.aio.operations.VpnSitesConfigurationOperations>`
* 2018-07-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2018_07_01.aio.operations.VpnSitesConfigurationOperations>`
* 2018-08-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2018_08_01.aio.operations.VpnSitesConfigurationOperations>`
* 2018-10-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2018_10_01.aio.operations.VpnSitesConfigurationOperations>`
* 2018-11-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2018_11_01.aio.operations.VpnSitesConfigurationOperations>`
* 2018-12-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2018_12_01.aio.operations.VpnSitesConfigurationOperations>`
* 2019-02-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2019_02_01.aio.operations.VpnSitesConfigurationOperations>`
* 2019-04-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2019_04_01.aio.operations.VpnSitesConfigurationOperations>`
* 2019-06-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2019_06_01.aio.operations.VpnSitesConfigurationOperations>`
* 2019-07-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2019_07_01.aio.operations.VpnSitesConfigurationOperations>`
* 2019-08-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2019_08_01.aio.operations.VpnSitesConfigurationOperations>`
* 2019-09-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2019_09_01.aio.operations.VpnSitesConfigurationOperations>`
* 2019-11-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2019_11_01.aio.operations.VpnSitesConfigurationOperations>`
* 2019-12-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2019_12_01.aio.operations.VpnSitesConfigurationOperations>`
* 2020-03-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2020_03_01.aio.operations.VpnSitesConfigurationOperations>`
* 2020-04-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2020_04_01.aio.operations.VpnSitesConfigurationOperations>`
* 2020-05-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2020_05_01.aio.operations.VpnSitesConfigurationOperations>`
* 2020-06-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2020_06_01.aio.operations.VpnSitesConfigurationOperations>`
* 2020-07-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2020_07_01.aio.operations.VpnSitesConfigurationOperations>`
* 2020-08-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2020_08_01.aio.operations.VpnSitesConfigurationOperations>`
* 2020-11-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2020_11_01.aio.operations.VpnSitesConfigurationOperations>`
* 2021-02-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2021_02_01.aio.operations.VpnSitesConfigurationOperations>`
* 2021-05-01: :class:`VpnSitesConfigurationOperations<azure.mgmt.network.v2021_05_01.aio.operations.VpnSitesConfigurationOperations>`
"""
api_version = self._get_api_version('vpn_sites_configuration')
if api_version == '2018-04-01':
from ..v2018_04_01.aio.operations import VpnSitesConfigurationOperations as OperationClass
elif api_version == '2018-06-01':
from ..v2018_06_01.aio.operations import VpnSitesConfigurationOperations as OperationClass
elif api_version == '2018-07-01':
from ..v2018_07_01.aio.operations import VpnSitesConfigurationOperations as OperationClass
elif api_version == '2018-08-01':
from ..v2018_08_01.aio.operations import VpnSitesConfigurationOperations as OperationClass
elif api_version == '2018-10-01':
from ..v2018_10_01.aio.operations import VpnSitesConfigurationOperations as OperationClass
elif api_version == '2018-11-01':
from ..v2018_11_01.aio.operations import VpnSitesConfigurationOperations as OperationClass
elif api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import VpnSitesConfigurationOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import VpnSitesConfigurationOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import VpnSitesConfigurationOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import VpnSitesConfigurationOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import VpnSitesConfigurationOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import VpnSitesConfigurationOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import VpnSitesConfigurationOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import VpnSitesConfigurationOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import VpnSitesConfigurationOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import VpnSitesConfigurationOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import VpnSitesConfigurationOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import VpnSitesConfigurationOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import VpnSitesConfigurationOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import VpnSitesConfigurationOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import VpnSitesConfigurationOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import VpnSitesConfigurationOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import VpnSitesConfigurationOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import VpnSitesConfigurationOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'vpn_sites_configuration'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def web_application_firewall_policies(self):
"""Instance depends on the API version:
* 2018-12-01: :class:`WebApplicationFirewallPoliciesOperations<azure.mgmt.network.v2018_12_01.aio.operations.WebApplicationFirewallPoliciesOperations>`
* 2019-02-01: :class:`WebApplicationFirewallPoliciesOperations<azure.mgmt.network.v2019_02_01.aio.operations.WebApplicationFirewallPoliciesOperations>`
* 2019-04-01: :class:`WebApplicationFirewallPoliciesOperations<azure.mgmt.network.v2019_04_01.aio.operations.WebApplicationFirewallPoliciesOperations>`
* 2019-06-01: :class:`WebApplicationFirewallPoliciesOperations<azure.mgmt.network.v2019_06_01.aio.operations.WebApplicationFirewallPoliciesOperations>`
* 2019-07-01: :class:`WebApplicationFirewallPoliciesOperations<azure.mgmt.network.v2019_07_01.aio.operations.WebApplicationFirewallPoliciesOperations>`
* 2019-08-01: :class:`WebApplicationFirewallPoliciesOperations<azure.mgmt.network.v2019_08_01.aio.operations.WebApplicationFirewallPoliciesOperations>`
* 2019-09-01: :class:`WebApplicationFirewallPoliciesOperations<azure.mgmt.network.v2019_09_01.aio.operations.WebApplicationFirewallPoliciesOperations>`
* 2019-11-01: :class:`WebApplicationFirewallPoliciesOperations<azure.mgmt.network.v2019_11_01.aio.operations.WebApplicationFirewallPoliciesOperations>`
* 2019-12-01: :class:`WebApplicationFirewallPoliciesOperations<azure.mgmt.network.v2019_12_01.aio.operations.WebApplicationFirewallPoliciesOperations>`
* 2020-03-01: :class:`WebApplicationFirewallPoliciesOperations<azure.mgmt.network.v2020_03_01.aio.operations.WebApplicationFirewallPoliciesOperations>`
* 2020-04-01: :class:`WebApplicationFirewallPoliciesOperations<azure.mgmt.network.v2020_04_01.aio.operations.WebApplicationFirewallPoliciesOperations>`
* 2020-05-01: :class:`WebApplicationFirewallPoliciesOperations<azure.mgmt.network.v2020_05_01.aio.operations.WebApplicationFirewallPoliciesOperations>`
* 2020-06-01: :class:`WebApplicationFirewallPoliciesOperations<azure.mgmt.network.v2020_06_01.aio.operations.WebApplicationFirewallPoliciesOperations>`
* 2020-07-01: :class:`WebApplicationFirewallPoliciesOperations<azure.mgmt.network.v2020_07_01.aio.operations.WebApplicationFirewallPoliciesOperations>`
* 2020-08-01: :class:`WebApplicationFirewallPoliciesOperations<azure.mgmt.network.v2020_08_01.aio.operations.WebApplicationFirewallPoliciesOperations>`
* 2020-11-01: :class:`WebApplicationFirewallPoliciesOperations<azure.mgmt.network.v2020_11_01.aio.operations.WebApplicationFirewallPoliciesOperations>`
* 2021-02-01: :class:`WebApplicationFirewallPoliciesOperations<azure.mgmt.network.v2021_02_01.aio.operations.WebApplicationFirewallPoliciesOperations>`
* 2021-05-01: :class:`WebApplicationFirewallPoliciesOperations<azure.mgmt.network.v2021_05_01.aio.operations.WebApplicationFirewallPoliciesOperations>`
"""
api_version = self._get_api_version('web_application_firewall_policies')
if api_version == '2018-12-01':
from ..v2018_12_01.aio.operations import WebApplicationFirewallPoliciesOperations as OperationClass
elif api_version == '2019-02-01':
from ..v2019_02_01.aio.operations import WebApplicationFirewallPoliciesOperations as OperationClass
elif api_version == '2019-04-01':
from ..v2019_04_01.aio.operations import WebApplicationFirewallPoliciesOperations as OperationClass
elif api_version == '2019-06-01':
from ..v2019_06_01.aio.operations import WebApplicationFirewallPoliciesOperations as OperationClass
elif api_version == '2019-07-01':
from ..v2019_07_01.aio.operations import WebApplicationFirewallPoliciesOperations as OperationClass
elif api_version == '2019-08-01':
from ..v2019_08_01.aio.operations import WebApplicationFirewallPoliciesOperations as OperationClass
elif api_version == '2019-09-01':
from ..v2019_09_01.aio.operations import WebApplicationFirewallPoliciesOperations as OperationClass
elif api_version == '2019-11-01':
from ..v2019_11_01.aio.operations import WebApplicationFirewallPoliciesOperations as OperationClass
elif api_version == '2019-12-01':
from ..v2019_12_01.aio.operations import WebApplicationFirewallPoliciesOperations as OperationClass
elif api_version == '2020-03-01':
from ..v2020_03_01.aio.operations import WebApplicationFirewallPoliciesOperations as OperationClass
elif api_version == '2020-04-01':
from ..v2020_04_01.aio.operations import WebApplicationFirewallPoliciesOperations as OperationClass
elif api_version == '2020-05-01':
from ..v2020_05_01.aio.operations import WebApplicationFirewallPoliciesOperations as OperationClass
elif api_version == '2020-06-01':
from ..v2020_06_01.aio.operations import WebApplicationFirewallPoliciesOperations as OperationClass
elif api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import WebApplicationFirewallPoliciesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import WebApplicationFirewallPoliciesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import WebApplicationFirewallPoliciesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import WebApplicationFirewallPoliciesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import WebApplicationFirewallPoliciesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'web_application_firewall_policies'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
@property
def web_categories(self):
"""Instance depends on the API version:
* 2020-07-01: :class:`WebCategoriesOperations<azure.mgmt.network.v2020_07_01.aio.operations.WebCategoriesOperations>`
* 2020-08-01: :class:`WebCategoriesOperations<azure.mgmt.network.v2020_08_01.aio.operations.WebCategoriesOperations>`
* 2020-11-01: :class:`WebCategoriesOperations<azure.mgmt.network.v2020_11_01.aio.operations.WebCategoriesOperations>`
* 2021-02-01: :class:`WebCategoriesOperations<azure.mgmt.network.v2021_02_01.aio.operations.WebCategoriesOperations>`
* 2021-05-01: :class:`WebCategoriesOperations<azure.mgmt.network.v2021_05_01.aio.operations.WebCategoriesOperations>`
"""
api_version = self._get_api_version('web_categories')
if api_version == '2020-07-01':
from ..v2020_07_01.aio.operations import WebCategoriesOperations as OperationClass
elif api_version == '2020-08-01':
from ..v2020_08_01.aio.operations import WebCategoriesOperations as OperationClass
elif api_version == '2020-11-01':
from ..v2020_11_01.aio.operations import WebCategoriesOperations as OperationClass
elif api_version == '2021-02-01':
from ..v2021_02_01.aio.operations import WebCategoriesOperations as OperationClass
elif api_version == '2021-05-01':
from ..v2021_05_01.aio.operations import WebCategoriesOperations as OperationClass
else:
raise ValueError("API version {} does not have operation group 'web_categories'".format(api_version))
return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
async def close(self):
await self._client.close()
async def __aenter__(self):
await self._client.__aenter__()
return self
async def __aexit__(self, *exc_details):
await self._client.__aexit__(*exc_details)
| Azure/azure-sdk-for-python | sdk/network/azure-mgmt-network/azure/mgmt/network/aio/_network_management_client.py | Python | mit | 731,138 |
from __future__ import absolute_import, division, print_function
import os.path
import sys
from Cython.Build import cythonize
from Cython.Distutils import extension
from echomesh.base import Path
from echomesh.base import Platform
_DEBUG_FLAG = '--debug'
DEBUG = _DEBUG_FLAG in sys.argv
if DEBUG:
sys.argv.remove(_DEBUG_FLAG)
VERBOSE = True
class Config(object):
def __init__(self):
self.debug = DEBUG
self.verbose = VERBOSE
self.module_name = 'cechomesh'
self.library_name = '%s.so' % self.module_name
pyx_files = ['cechomesh.pyx']
libraries = ['echomesh', 'pthread', 'glog']
extra_compile_args = (
'-I. -fmessage-length=0 -std=c++11 '
' -IJuceLibraryCode -Ibuild/include -Wno-unused-function ')
if DEBUG:
extra_args = {'cython_gdb': True, 'pyrex_gdb': True}
extra_compile_args += '-O0 -g -D_DEBUG=1 -DDEBUG=1 '
extra_link_args = '-g '
else:
extra_args = {}
extra_compile_args += '-O2 '
extra_link_args = '-flto '
if Platform.PLATFORM == Platform.MAC:
extra_link_args += (
'-framework Cocoa -framework WebKit -framework CoreMidi ')
extra_compile_args += '-stdlib=libc++ -x c++ -arch x86_64 '
if DEBUG:
echomesh_lib = 'Builds/MacOSX/build/Debug'
else:
echomesh_lib = 'Builds/MacOSX/build/Release'
elif Platform.PLATFORM == Platform.UBUNTU:
extra_link_args += (
'-lc++ -L/usr/X11R6/lib/ -lX11 -lXext -lXinerama -lasound '
'-ldl -lfreetype -lrt -lechomesh')
extra_compile_args += '-stdlib=libc++ -arch x86_64 -x c++ '
if DEBUG:
echomesh_lib = 'Builds/Linux/build/Debug'
else:
echomesh_lib = 'Builds/Linux/build'
elif Platform.PLATFORM == Platform.RASPBERRY_PI:
extra_link_args += (
'-L/usr/X11R6/lib/ -lX11 -lXext -lXinerama -lasound '
'-ldl -lfreetype -lrt -lechomesh')
echomesh_lib = 'Builds/Linux/build'
else:
raise Exception("Don't understand platform %s" % Platform.PLATFORM)
extra_compile_args = extra_compile_args.split()
extra_link_args = extra_link_args.split()
self.bin_dir = Path.LIBRARY_PATH
lib_dirs = ['build/lib', echomesh_lib]
ext = extension.Extension(
self.module_name,
pyx_files,
library_dirs=lib_dirs,
libraries=libraries,
extra_compile_args=extra_compile_args,
extra_link_args=extra_link_args,
**extra_args)
self.modules = cythonize([ext], **extra_args)
self.c_library = os.path.join(echomesh_lib, 'libechomesh.a')
CONFIG = Config()
| rec/echomesh | code/python/echomesh/build/BuildConfig.py | Python | mit | 2,875 |
""" Rumors script for x/84. """
# https://github.com/x84-extras/rumors
__author__ = u'haliphax <https://github.com/haliphax>'
# std imports
import collections
import os
# local
from x84.bbs import getsession, getterminal, DBProxy
from x84.bbs.ini import get_ini
from x84.bbs.output import echo
MYDIR = os.path.dirname(__file__)
# settings - configured in default.ini [rumors] section
DEFAULT_RUMOR = get_ini('rumors', 'default_rumor') or \
u'No rumors; why not add one yourself?'
ART_FILE = get_ini('rumors', 'art_file') or \
(u'art/rumors.ans' \
if not (os.path.isdir(os.path.join(MYDIR, '.git')) \
or os.path.isdir(os.path.join(MYDIR, '_git'))) \
else os.path.join(MYDIR, 'art', 'rumors.ans'))
SHOW_MENU_ENTRIES = get_ini('rumors', 'show_menu_entries',
getter='getboolean')
MENU_HIGHLIGHT_COLOR = get_ini('rumors', 'menu_highlight_color') or \
u'bold_green'
MENU_LOWLIGHT_COLOR = get_ini('rumors', 'menu_lowlight_color') or \
u'bold_black'
MENU_COMMAND_TEXT = get_ini('rumors', 'menu_command_text') or \
u'command'
MENU_COMMAND_COLOR = get_ini('rumors', 'menu_command_color') or \
u'bold_green'
MENU_PROMPT_COLOR = get_ini('rumors', 'menu_prompt_color') or \
u'black_on_green'
LIST_BORDER_COLOR = get_ini('rumors', 'list_border_color') or \
u'bold_black'
LIST_HIGHLIGHT_COLOR = get_ini('rumors', 'list_highlight_color') or \
u'bold_white_on_green'
ADD_PROMPT_COLOR = get_ini('rumors', 'add_prompt_color') or \
u'bold_white_on_green'
DELETE_PROMPT_COLOR = get_ini('rumors', 'delete_prompt_color') or \
u'bold_white_on_green'
# namedtuple for our menu entries (to be used in render_menu_entries)
MenuItem = collections.namedtuple('MenuItem', ['inp_key', 'text'])
def get_rumor():
""" Pull a rumor from the database (or default if none are found). """
import random
rumordb = DBProxy('rumors')
rumor = DEFAULT_RUMOR
keys = rumordb.keys()
if keys:
rumor = rumordb[random.choice(keys)]
return rumor
def add_rumor():
""" Add a new rumor to the database. """
from x84.bbs.editor import ScrollingEditor
term = getterminal()
led = ScrollingEditor(width=term.width + 1, xloc=-1,
yloc=term.height, max_length=128,
colors={'highlight':
getattr(term, ADD_PROMPT_COLOR)})
echo(led.refresh())
rumor = led.read()
echo(term.normal)
if rumor:
rumordb = DBProxy('rumors')
with rumordb:
key = 1
if len(rumordb):
key = int(max(rumordb.keys())) + 1
rumordb['%d' % key] = rumor
def view_rumors():
""" View list of rumors. """
from x84.bbs.lightbar import Lightbar
session, term = getsession(), getterminal()
rumordb = DBProxy('rumors')
lbar = Lightbar(width=term.width - 1, height=term.height, xloc=0, yloc=0,
colors={'border': getattr(term, LIST_BORDER_COLOR),
'highlight': getattr(term, LIST_HIGHLIGHT_COLOR)},
glyphs={'top-left': u'+', 'top-right': u'+',
'top-horiz': u'-', 'bot-horiz': u'-',
'bot-left': u'+', 'bot-right': u'+',
'left-vert': u'|', 'right-vert': u'|'})
def refresh():
""" Refresh the lightbar. """
if not len(rumordb):
return False
contents = [(key, '{key}) {rumor}'.format(key=key, rumor=rumordb[key]))
for key in sorted(map(int, rumordb.keys()))]
lbar.update(contents)
echo(u''.join([lbar.border(), lbar.refresh()]))
refresh()
while not lbar.quit:
event, data = session.read_events(['refresh', 'input'])
if event == 'refresh':
refresh()
elif event == 'input':
session.buffer_input(data, pushback=True)
echo(lbar.process_keystroke(term.inkey()))
def del_rumor():
""" Delete a rumor from the database. """
from x84.bbs.editor import LineEditor
session, term = getsession(), getterminal()
rumordb = DBProxy('rumors')
echo(u'\r\n\r\n')
if not session.user.is_sysop:
echo(u'Only SysOps can do that!')
term.inkey()
return
led = LineEditor(width=len(str(max([int(k) for k in rumordb.keys()]))),
colors={'highlight':
getattr(term, DELETE_PROMPT_COLOR)})
echo(u''.join([term.move_x(max(term.width / 2 - 40, 0)), 'Delete rumor: ',
led.refresh()]))
try:
rumor = int(led.read())
except (ValueError, TypeError):
rumor = None
echo(term.normal)
if rumor:
rumordb = DBProxy('rumors')
with rumordb:
del rumordb['%d' % rumor]
def main():
""" x/84 script launch point. """
from x84.bbs.editor import LineEditor
from common import (display_banner, # pylint: disable=W0403
render_menu_entries)
session, term = getsession(), getterminal()
session.activity = u'Browsing rumors'
def refresh():
""" Refresh the menu. """
echo(term.clear)
top_margin = display_banner(ART_FILE) + 1
echo(u'\r\n')
if SHOW_MENU_ENTRIES:
colors = {'highlight': getattr(term, MENU_HIGHLIGHT_COLOR),
'lowlight': getattr(term, MENU_LOWLIGHT_COLOR)}
entries = [
MenuItem(inp_key=u'v', text=u'view rumors'),
MenuItem(inp_key=u'a', text=u'add a rumor'),
MenuItem(inp_key=u'q', text=u'quit to main'),
]
if session.user.is_sysop:
entries.append(MenuItem(inp_key=u'd', text=u'delete a rumor'))
echo(render_menu_entries(term, top_margin, entries, colors))
echo(u'{0}[{1}]: {2}'.format(term.move_x(max(term.width / 2 - 40,
0))
if term.width > 80 else u'',
getattr(term, MENU_COMMAND_COLOR)
(MENU_COMMAND_TEXT),
led.refresh()))
led = LineEditor(width=1, colors={'highlight':
getattr(term, MENU_PROMPT_COLOR)})
dirty = True
event = None
# input loop
while True:
if dirty or event == 'refresh':
dirty = False
refresh()
event, data = session.read_events(['input', 'refresh'])
if event == 'input':
session.buffer_input(data, pushback=True)
echo(led.process_keystroke(term.inkey(0)))
if not led.carriage_returned:
continue
dirty = True
echo(term.normal)
inp = led.content
led.content = u''
led._carriage_returned = False
if inp:
inp = inp.lower()
if inp == u'a':
add_rumor()
elif inp == u'v':
view_rumors()
elif inp == u'd':
del_rumor()
elif inp == u'q':
return
| x84-extras/rumors | rumors.py | Python | mit | 7,299 |
from random import randrange as rand
import pygame, sys
cell_size = 18
cols = 10
rows = 22
maxfps = 30
colors = [
(0, 0, 0 ),
(255, 85, 85),
(100, 200, 115),
(120, 108, 245),
(255, 140, 50 ),
(50, 120, 52 ),
(146, 202, 73 ),
(150, 161, 218 ),
(35, 35, 35)
]
tetris_shapes = [
[[1, 1, 1],
[0, 1, 0]],
[[0, 2, 2],
[2, 2, 0]],
[[3, 3, 0],
[0, 3, 3]],
[[4, 0, 0],
[4, 4, 4]],
[[0, 0, 5],
[5, 5, 5]],
[[6, 6, 6, 6]],
[[7, 7],
[7, 7]]
]
def rotate_clockwise(shape):
return [ [ shape[y][x]
for y in range(len(shape)) ]
for x in range(len(shape[0]) - 1, -1, -1) ]
def check_collision(board, shape, offset):
off_x, off_y = offset
for cy, row in enumerate(shape):
for cx, cell in enumerate(row):
try:
if cell and board[ cy + off_y ][ cx + off_x ]:
return True
except IndexError:
return True
return False
def remove_row(board, row):
del board[row]
return [[0 for i in range(cols)]] + board
def join_matrixes(mat1, mat2, mat2_off):
off_x, off_y = mat2_off
for cy, row in enumerate(mat2):
for cx, val in enumerate(row):
mat1[cy+off_y-1 ][cx+off_x] += val
return mat1
def new_board():
board = [ [ 0 for x in range(cols) ]
for y in range(rows) ]
board += [[ 1 for x in range(cols)]]
return board
class TetrisApp(object):
def __init__(self):
pygame.init()
pygame.key.set_repeat(250,25)
self.width = cell_size*(cols+6)
self.height = cell_size*rows
self.rlim = cell_size*cols
self.bground_grid = [[ 8 if x%2==y%2 else 0 for x in range(cols)] for y in range(rows)]
self.default_font = pygame.font.Font(
pygame.font.get_default_font(), 12)
self.screen = pygame.display.set_mode((self.width, self.height))
pygame.event.set_blocked(pygame.MOUSEMOTION)
self.next_stone = tetris_shapes[rand(len(tetris_shapes))]
self.init_game()
def new_stone(self):
self.stone = self.next_stone[:]
self.next_stone = tetris_shapes[rand(len(tetris_shapes))]
self.stone_x = int(cols / 2 - len(self.stone[0])/2)
self.stone_y = 0
if check_collision(self.board,
self.stone,
(self.stone_x, self.stone_y)):
self.gameover = True
def init_game(self):
self.board = new_board()
self.new_stone()
self.level = 1
self.score = 0
self.lines = 0
pygame.time.set_timer(pygame.USEREVENT+1, 1000)
def disp_msg(self, msg, topleft):
x,y = topleft
for line in msg.splitlines():
self.screen.blit(
self.default_font.render(
line,
False,
(255,255,255),
(0,0,0)),
(x,y))
y+=14
def center_msg(self, msg):
for i, line in enumerate(msg.splitlines()):
msg_image = self.default_font.render(line, False,
(255,255,255), (0,0,0))
msgim_center_x, msgim_center_y = msg_image.get_size()
msgim_center_x //= 2
msgim_center_y //= 2
self.screen.blit(msg_image, (
self.width // 2-msgim_center_x,
self.height // 2-msgim_center_y+i*22))
def draw_matrix(self, matrix, offset):
off_x, off_y = offset
for y, row in enumerate(matrix):
for x, val in enumerate(row):
if val:
pygame.draw.rect(
self.screen,
colors[val],
pygame.Rect(
(off_x+x) *
cell_size,
(off_y+y) *
cell_size,
cell_size,
cell_size),0)
def add_cl_lines(self, n):
linescores = [0, 40, 100, 300, 1200]
self.lines += n
self.score += linescores[n] * self.level
if self.lines >= self.level*6:
self.level += 1
newdelay = 1000-50*(self.level-1)
newdelay = 100 if newdelay < 100 else newdelay
pygame.time.set_timer(pygame.USEREVENT+1, newdelay)
def move(self, delta_x):
if not self.gameover and not self.paused:
new_x = self.stone_x + delta_x
if new_x < 0:
new_x = 0
if new_x > cols - len(self.stone[0]):
new_x = cols - len(self.stone[0])
if not check_collision(self.board,
self.stone,
(new_x, self.stone_y)):
self.stone_x = new_x
def quit(self):
self.center_msg("Exiting...")
pygame.display.update()
sys.exit()
def drop(self, manual):
if not self.gameover and not self.paused:
self.score += 1 if manual else 0
self.stone_y += 1
if check_collision(self.board,
self.stone,
(self.stone_x, self.stone_y)):
self.board = join_matrixes(
self.board,
self.stone,
(self.stone_x, self.stone_y))
self.new_stone()
cleared_rows = 0
while True:
for i, row in enumerate(self.board[:-1]):
if 0 not in row:
self.board = remove_row(
self.board, i)
cleared_rows += 1
break
else:
break
self.add_cl_lines(cleared_rows)
return True
return False
def insta_drop(self):
if not self.gameover and not self.paused:
while(not self.drop(True)):
pass
def rotate_stone(self):
if not self.gameover and not self.paused:
new_stone = rotate_clockwise(self.stone)
if not check_collision(self.board,
new_stone,
(self.stone_x, self.stone_y)):
self.stone = new_stone
def toggle_pause(self):
self.paused = not self.paused
def start_game(self):
if self.gameover:
self.init_game()
self.gameover = False
def run(self):
key_actions = {
'ESCAPE': self.quit,
'LEFT': lambda:self.move(-1),
'RIGHT': lambda:self.move(+1),
'DOWN': lambda:self.drop(True),
'UP': self.rotate_stone,
'p': self.toggle_pause,
'SPACE': self.start_game,
'RETURN': self.insta_drop
}
self.gameover = False
self.paused = False
dont_burn_my_cpu = pygame.time.Clock()
while 1:
self.screen.fill((0,0,0))
if self.gameover:
self.center_msg("""Game Over!\nYour score: %d
Press space to continue""" % self.score)
else:
if self.paused:
self.center_msg("Paused")
else:
pygame.draw.line(self.screen,
(255,255,255),
(self.rlim+1, 0),
(self.rlim+1, self.height-1))
self.disp_msg("Next:", (
self.rlim+cell_size,
2))
self.disp_msg("Score: %d\n\nLevel: %d\
\nLines: %d" % (self.score, self.level, self.lines),
(self.rlim+cell_size, cell_size*5))
self.draw_matrix(self.bground_grid, (0,0))
self.draw_matrix(self.board, (0,0))
self.draw_matrix(self.stone,
(self.stone_x, self.stone_y))
self.draw_matrix(self.next_stone,
(cols+1,2))
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.USEREVENT+1:
self.drop(False)
elif event.type == pygame.QUIT:
self.quit()
elif event.type == pygame.KEYDOWN:
for key in key_actions:
if event.key == eval("pygame.K_"
+key):
key_actions[key]()
dont_burn_my_cpu.tick(maxfps)
if __name__ == '__main__':
App = TetrisApp()
App.run() | saintdragon2/python-3-lecture-2015 | sinsojael_final/1st_presentation/5조/5wh.py | Python | mit | 6,784 |
"""Lea 128-bit cipher."""
import itertools
from arxpy.bitvector.core import Constant
from arxpy.bitvector.operation import RotateLeft as ROL
from arxpy.bitvector.operation import RotateRight as ROR
from arxpy.primitives.primitives import KeySchedule, Encryption, Cipher
class LeaKeySchedule(KeySchedule):
"""Key schedule function."""
rounds = 24
input_widths = [32, 32, 32, 32]
output_widths = [32 for i in range(24 * 6)]
@classmethod
def set_rounds(cls, new_rounds):
cls.rounds = new_rounds
cls.output_widths = [32 for _ in range(new_rounds * 6)]
# noinspection PyPep8Naming
@classmethod
def eval(cls, k0, k1, k2, k3):
round_keys = [None for _ in range(cls.rounds)]
T0, T1, T2, T3 = k0, k1, k2, k3
delta = [
Constant(0xc3efe9db, 32), Constant(0x44626b02, 32),
Constant(0x79e27c8a, 32), Constant(0x78df30ec, 32),
]
for i in range(cls.rounds):
T0 = ROL(T0 + ROL(delta[i % 4], i), 1)
T1 = ROL(T1 + ROL(delta[i % 4], (i + 1)), 3)
T2 = ROL(T2 + ROL(delta[i % 4], (i + 2)), 6)
T3 = ROL(T3 + ROL(delta[i % 4], (i + 3)), 11)
round_keys[i] = T0, T1, T2, T1, T3, T1
return tuple(itertools.chain(*round_keys)) # flatten
class LeaEncryption(Encryption):
"""Encryption function."""
rounds = 24
input_widths = [32, 32, 32, 32]
output_widths = [32, 32, 32, 32]
round_keys = None
@classmethod
def set_rounds(cls, new_rounds):
cls.rounds = new_rounds
@classmethod
def eval(cls, p0, p1, p2, p3):
x0, x1, x2, x3 = p0, p1, p2, p3
rk = [[None for _ in range(6)] for _ in range(cls.rounds)]
for i, k in enumerate(cls.round_keys):
rk[i // 6][i % 6] = k
for i in range(cls.rounds):
k0, k1, k2, k3, k4, k5 = rk[i]
tmp = x0
x0 = ROL((x0 ^ k0) + (x1 ^ k1), 9)
x1 = ROR((x1 ^ k2) + (x2 ^ k3), 5)
x2 = ROR((x2 ^ k4) + (x3 ^ k5), 3)
x3 = tmp
return x0, x1, x2, x3
class LeaCipher(Cipher):
key_schedule = LeaKeySchedule
encryption = LeaEncryption
rounds = 24
@classmethod
def set_rounds(cls, new_rounds):
cls.rounds = new_rounds
cls.key_schedule.set_rounds(new_rounds)
cls.encryption.set_rounds(new_rounds)
@classmethod
def test(cls):
old_rounds = cls.rounds
cls.set_rounds(24)
key = [
Constant(0x3c2d1e0f, 32),
Constant(0x78695a4b, 32),
Constant(0xb4a59687, 32),
Constant(0xf0e1d2c3, 32)
]
pt = [
Constant(0x13121110, 32),
Constant(0x17161514, 32),
Constant(0x1b1a1918, 32),
Constant(0x1f1e1d1c, 32)
]
ct = [
Constant(0x354ec89f, 32),
Constant(0x18c6c628, 32),
Constant(0xa7c73255, 32),
Constant(0xfd8b6404, 32)
]
assert cls(pt, key) == tuple(ct)
cls.set_rounds(old_rounds)
| ranea/ArxPy | arxpy/primitives/lea.py | Python | mit | 3,096 |
# -*- coding: utf-8 -*-
from distutils.core import setup
import py2exe
option = {
"compressed" : 1,
"optimize" : 2,
"bundle_files" : 1
}
setup(
options = {
"py2exe" : option
},
console = [
{ "script" : "main.py" }
],
zipfile = None
) | IBCCW/plen2__ble_motion_installer_python | make.py | Python | mit | 257 |
import sys, os
#sudo pip install prettytable
from prettytable import PrettyTable
sys.path.append(os.path.abspath("../login/"))
from azureADUserLogin import *
resource_client = azure_ad_user_login()
def list_resource_group(resource_group_name=""):
rgTable = PrettyTable(['Name','Location'])
if resource_group_name == "":
for item in resource_client.resource_groups.list():
rgTable.add_row([item.name,item.location])
print(rgTable);
else:
if resource_client.resource_groups.check_existence(resource_group_name):
rg = resource_client.resource_groups.get(resource_group_name)
rgTable.add_row([rg.name,rg.location])
print(rgTable);
else:
print ("There is no resource group named " + resource_group_name);
def create_resource_group(resource_group_name, location):
if resource_client.resource_groups.check_existence(resource_group_name):
print (resource_group_name + " is already existing.\ntry other name.")
return;
else:
resource_client.resource_groups.create_or_update(resource_group_name, {'location':location})
print ("Successfully created {0} Resoure Group\nregion :{1}".format(resource_group_name, location));
def delete_resource_group(resource_group_name):
if resource_client.resource_groups.check_existence(resource_group_name):
resource_client.resource_groups.delete(resource_group_name)
print ("Successfully deleted {0} Resoure Group".format(resource_group_name));
else:
print ("Resource group '" + resource_group_name + "' does not exist.\ncheck the name.")
return;
| jiyongseong/AzureCommon | azure_resource_manager/python/resourceGroup/manage_resource_group.py | Python | mit | 1,672 |
import os
import shutil
import six
from tempfile import mkdtemp
from ..exceptions import UnknownMethod, ShellError
from .utils import ShellParser
from .image import Parser as TesseractParser
from distutils.spawn import find_executable
class Parser(ShellParser):
"""Extract text from pdf files using either the ``pdftotext`` method
(default) or the ``pdfminer`` method.
"""
def extract(self, filename, method='', **kwargs):
if method == '' or method == 'pdftotext':
try:
return self.extract_pdftotext(filename, **kwargs)
except ShellError as ex:
# If pdftotext isn't installed and the pdftotext method
# wasn't specified, then gracefully fallback to using
# pdfminer instead.
if method == '' and ex.is_not_installed():
return self.extract_pdfminer(filename, **kwargs)
else:
raise ex
elif method == 'pdfminer':
return self.extract_pdfminer(filename, **kwargs)
elif method == 'tesseract':
return self.extract_tesseract(filename, **kwargs)
else:
raise UnknownMethod(method)
def extract_pdftotext(self, filename, **kwargs):
"""Extract text from pdfs using the pdftotext command line utility."""
if 'layout' in kwargs:
args = ['pdftotext', '-layout', filename, '-']
else:
args = ['pdftotext', filename, '-']
stdout, _ = self.run(args)
return stdout
def extract_pdfminer(self, filename, **kwargs):
"""Extract text from pdfs using pdfminer."""
#Nested try/except loops? Not great
#Try the normal pdf2txt, if that fails try the python3
# pdf2txt, if that fails try the python2 pdf2txt
pdf2txt_path = find_executable('pdf2txt.py')
try:
stdout, _ = self.run(['pdf2txt.py', filename])
except OSError:
try:
stdout, _ = self.run(['python3',pdf2txt_path, filename])
except ShellError:
stdout, _ = self.run(['python2',pdf2txt_path, filename])
return stdout
def extract_tesseract(self, filename, **kwargs):
"""Extract text from pdfs using tesseract (per-page OCR)."""
temp_dir = mkdtemp()
base = os.path.join(temp_dir, 'conv')
contents = []
try:
stdout, _ = self.run(['pdftoppm', filename, base])
for page in sorted(os.listdir(temp_dir)):
page_path = os.path.join(temp_dir, page)
page_content = TesseractParser().extract(page_path, **kwargs)
contents.append(page_content)
return six.b('').join(contents)
finally:
shutil.rmtree(temp_dir)
| deanmalmgren/textract | textract/parsers/pdf_parser.py | Python | mit | 2,826 |
import argparse
import glob
import features
import cv2
import pickle
ap = argparse.ArgumentParser()
ap.add_argument("-i", "--images", required = True,
help = "Path to the directory that contains the images representing model categories.")
ap.add_argument("-m", "--models", required = True,
help = "Path to location of generated model file.")
args = vars(ap.parse_args())
histograms = {}
print ('Reading images...')
for imagePath in glob.glob(args["images"] + "/*.JPG"):
k = imagePath[imagePath.rfind("/") + 1:]
print('image_key',k)
image = cv2.imread(imagePath)
histogram = features.describe(image)
histograms[k] = histogram
print ('Image histograms created.')
print ('Loading models...')
# load the models
#models = pickle.loads(open(args["models"]).read())
models = pickle.load(open(args["models"], "rb"))
for image, image_histogram in histograms.items():
print ('Evaluating:', image)
#print image_histogram
candidates = {}
for model_key, model_histogram in models.items():
diff = features.chi2_distance(image_histogram, model_histogram)
candidates[model_key] = diff
# http://stackoverflow.com/questions/3282823/get-key-with-the-least-value-from-a-dictionary
# http://stackoverflow.com/a/3282904
#print min(candidates, key=candidates.get)
min_value = min(candidates.values())
min_keys = {}
# http://stackoverflow.com/questions/9944963/python-get-key-with-the-least-value-from-a-dictionary-but-multiple-minimum-valu
#min_keys = [k for k in candidates if candidates[k] == min_value]
for k, v in candidates.items():
if candidates[k] == min_value:
min_keys[k] = v
print (min_keys)
| jbest/digitization_tools | analyze/categorize.py | Python | mit | 1,699 |
# coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for license information.
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is regenerated.
# --------------------------------------------------------------------------
from typing import Any, AsyncIterable, Callable, Dict, Generic, Optional, TypeVar, Union
import warnings
from azure.core.async_paging import AsyncItemPaged, AsyncList
from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error
from azure.core.pipeline import PipelineResponse
from azure.core.pipeline.transport import AsyncHttpResponse, HttpRequest
from azure.mgmt.core.exceptions import ARMErrorFormat
from ... import models as _models
T = TypeVar('T')
ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]]
class ApplicationsOperations:
"""ApplicationsOperations async operations.
You should not instantiate this class directly. Instead, you should create a Client instance that
instantiates it for you and attaches it as an attribute.
:ivar models: Alias to model classes used in this operation group.
:type models: ~desktop_virtualization_api_client.models
:param client: Client for service requests.
:param config: Configuration of service client.
:param serializer: An object model serializer.
:param deserializer: An object model deserializer.
"""
models = _models
def __init__(self, client, config, serializer, deserializer) -> None:
self._client = client
self._serialize = serializer
self._deserialize = deserializer
self._config = config
async def get(
self,
resource_group_name: str,
application_group_name: str,
application_name: str,
**kwargs: Any
) -> "_models.Application":
"""Get an application.
:param resource_group_name: The name of the resource group. The name is case insensitive.
:type resource_group_name: str
:param application_group_name: The name of the application group.
:type application_group_name: str
:param application_name: The name of the application within the specified application group.
:type application_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: Application, or the result of cls(response)
:rtype: ~desktop_virtualization_api_client.models.Application
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["_models.Application"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2021-09-03-preview"
accept = "application/json"
# Construct URL
url = self.get.metadata['url'] # type: ignore
path_format_arguments = {
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str', min_length=1),
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1),
'applicationGroupName': self._serialize.url("application_group_name", application_group_name, 'str', max_length=64, min_length=3),
'applicationName': self._serialize.url("application_name", application_name, 'str', max_length=24, min_length=3),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
request = self._client.get(url, query_parameters, header_parameters)
pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs)
response = pipeline_response.http_response
if response.status_code not in [200]:
map_error(status_code=response.status_code, response=response, error_map=error_map)
raise HttpResponseError(response=response, error_format=ARMErrorFormat)
deserialized = self._deserialize('Application', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
get.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DesktopVirtualization/applicationGroups/{applicationGroupName}/applications/{applicationName}'} # type: ignore
async def create_or_update(
self,
resource_group_name: str,
application_group_name: str,
application_name: str,
application: "_models.Application",
**kwargs: Any
) -> "_models.Application":
"""Create or update an application.
:param resource_group_name: The name of the resource group. The name is case insensitive.
:type resource_group_name: str
:param application_group_name: The name of the application group.
:type application_group_name: str
:param application_name: The name of the application within the specified application group.
:type application_name: str
:param application: Object containing Application definitions.
:type application: ~desktop_virtualization_api_client.models.Application
:keyword callable cls: A custom type or function that will be passed the direct response
:return: Application, or the result of cls(response)
:rtype: ~desktop_virtualization_api_client.models.Application
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["_models.Application"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2021-09-03-preview"
content_type = kwargs.pop("content_type", "application/json")
accept = "application/json"
# Construct URL
url = self.create_or_update.metadata['url'] # type: ignore
path_format_arguments = {
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str', min_length=1),
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1),
'applicationGroupName': self._serialize.url("application_group_name", application_group_name, 'str', max_length=64, min_length=3),
'applicationName': self._serialize.url("application_name", application_name, 'str', max_length=24, min_length=3),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str')
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
body_content_kwargs = {} # type: Dict[str, Any]
body_content = self._serialize.body(application, 'Application')
body_content_kwargs['content'] = body_content
request = self._client.put(url, query_parameters, header_parameters, **body_content_kwargs)
pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs)
response = pipeline_response.http_response
if response.status_code not in [200, 201]:
map_error(status_code=response.status_code, response=response, error_map=error_map)
raise HttpResponseError(response=response, error_format=ARMErrorFormat)
if response.status_code == 200:
deserialized = self._deserialize('Application', pipeline_response)
if response.status_code == 201:
deserialized = self._deserialize('Application', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
create_or_update.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DesktopVirtualization/applicationGroups/{applicationGroupName}/applications/{applicationName}'} # type: ignore
async def delete(
self,
resource_group_name: str,
application_group_name: str,
application_name: str,
**kwargs: Any
) -> None:
"""Remove an application.
:param resource_group_name: The name of the resource group. The name is case insensitive.
:type resource_group_name: str
:param application_group_name: The name of the application group.
:type application_group_name: str
:param application_name: The name of the application within the specified application group.
:type application_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: None, or the result of cls(response)
:rtype: None
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType[None]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2021-09-03-preview"
accept = "application/json"
# Construct URL
url = self.delete.metadata['url'] # type: ignore
path_format_arguments = {
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str', min_length=1),
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1),
'applicationGroupName': self._serialize.url("application_group_name", application_group_name, 'str', max_length=64, min_length=3),
'applicationName': self._serialize.url("application_name", application_name, 'str', max_length=24, min_length=3),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
request = self._client.delete(url, query_parameters, header_parameters)
pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs)
response = pipeline_response.http_response
if response.status_code not in [200, 204]:
map_error(status_code=response.status_code, response=response, error_map=error_map)
raise HttpResponseError(response=response, error_format=ARMErrorFormat)
if cls:
return cls(pipeline_response, None, {})
delete.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DesktopVirtualization/applicationGroups/{applicationGroupName}/applications/{applicationName}'} # type: ignore
async def update(
self,
resource_group_name: str,
application_group_name: str,
application_name: str,
application: Optional["_models.ApplicationPatch"] = None,
**kwargs: Any
) -> "_models.Application":
"""Update an application.
:param resource_group_name: The name of the resource group. The name is case insensitive.
:type resource_group_name: str
:param application_group_name: The name of the application group.
:type application_group_name: str
:param application_name: The name of the application within the specified application group.
:type application_name: str
:param application: Object containing Application definitions.
:type application: ~desktop_virtualization_api_client.models.ApplicationPatch
:keyword callable cls: A custom type or function that will be passed the direct response
:return: Application, or the result of cls(response)
:rtype: ~desktop_virtualization_api_client.models.Application
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["_models.Application"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2021-09-03-preview"
content_type = kwargs.pop("content_type", "application/json")
accept = "application/json"
# Construct URL
url = self.update.metadata['url'] # type: ignore
path_format_arguments = {
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str', min_length=1),
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1),
'applicationGroupName': self._serialize.url("application_group_name", application_group_name, 'str', max_length=64, min_length=3),
'applicationName': self._serialize.url("application_name", application_name, 'str', max_length=24, min_length=3),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str')
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
body_content_kwargs = {} # type: Dict[str, Any]
if application is not None:
body_content = self._serialize.body(application, 'ApplicationPatch')
else:
body_content = None
body_content_kwargs['content'] = body_content
request = self._client.patch(url, query_parameters, header_parameters, **body_content_kwargs)
pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs)
response = pipeline_response.http_response
if response.status_code not in [200]:
map_error(status_code=response.status_code, response=response, error_map=error_map)
raise HttpResponseError(response=response, error_format=ARMErrorFormat)
deserialized = self._deserialize('Application', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
update.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DesktopVirtualization/applicationGroups/{applicationGroupName}/applications/{applicationName}'} # type: ignore
def list(
self,
resource_group_name: str,
application_group_name: str,
**kwargs: Any
) -> AsyncIterable["_models.ApplicationList"]:
"""List applications.
:param resource_group_name: The name of the resource group. The name is case insensitive.
:type resource_group_name: str
:param application_group_name: The name of the application group.
:type application_group_name: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either ApplicationList or the result of cls(response)
:rtype: ~azure.core.async_paging.AsyncItemPaged[~desktop_virtualization_api_client.models.ApplicationList]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["_models.ApplicationList"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
api_version = "2021-09-03-preview"
accept = "application/json"
def prepare_request(next_link=None):
# Construct headers
header_parameters = {} # type: Dict[str, Any]
header_parameters['Accept'] = self._serialize.header("accept", accept, 'str')
if not next_link:
# Construct URL
url = self.list.metadata['url'] # type: ignore
path_format_arguments = {
'subscriptionId': self._serialize.url("self._config.subscription_id", self._config.subscription_id, 'str', min_length=1),
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1),
'applicationGroupName': self._serialize.url("application_group_name", application_group_name, 'str', max_length=64, min_length=3),
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {} # type: Dict[str, Any]
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
request = self._client.get(url, query_parameters, header_parameters)
else:
url = next_link
query_parameters = {} # type: Dict[str, Any]
request = self._client.get(url, query_parameters, header_parameters)
return request
async def extract_data(pipeline_response):
deserialized = self._deserialize('ApplicationList', pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, AsyncList(list_of_elem)
async def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs)
response = pipeline_response.http_response
if response.status_code not in [200]:
map_error(status_code=response.status_code, response=response, error_map=error_map)
raise HttpResponseError(response=response, error_format=ARMErrorFormat)
return pipeline_response
return AsyncItemPaged(
get_next, extract_data
)
list.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DesktopVirtualization/applicationGroups/{applicationGroupName}/applications'} # type: ignore
| Azure/azure-sdk-for-python | sdk/desktopvirtualization/azure-mgmt-desktopvirtualization/azure/mgmt/desktopvirtualization/aio/operations/_applications_operations.py | Python | mit | 19,785 |
'''
The MIT License (MIT)
Copyright (c) 2016 WavyCloud
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.
'''
def associate_drt_log_bucket(LogBucket=None):
"""
Authorizes the DDoS Response team (DRT) to access the specified Amazon S3 bucket containing your AWS WAF logs. You can associate up to 10 Amazon S3 buckets with your subscription.
To use the services of the DRT and make an AssociateDRTLogBucket request, you must be subscribed to the Business Support plan or the Enterprise Support plan .
See also: AWS API Documentation
Exceptions
:example: response = client.associate_drt_log_bucket(
LogBucket='string'
)
:type LogBucket: string
:param LogBucket: [REQUIRED]\nThe Amazon S3 bucket that contains your AWS WAF logs.\n
:rtype: dict
ReturnsResponse Syntax{}
Response Structure
(dict) --
Exceptions
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.InvalidOperationException
Shield.Client.exceptions.NoAssociatedRoleException
Shield.Client.exceptions.LimitsExceededException
Shield.Client.exceptions.InvalidParameterException
Shield.Client.exceptions.AccessDeniedForDependencyException
Shield.Client.exceptions.OptimisticLockException
Shield.Client.exceptions.ResourceNotFoundException
:return: {}
:returns:
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.InvalidOperationException
Shield.Client.exceptions.NoAssociatedRoleException
Shield.Client.exceptions.LimitsExceededException
Shield.Client.exceptions.InvalidParameterException
Shield.Client.exceptions.AccessDeniedForDependencyException
Shield.Client.exceptions.OptimisticLockException
Shield.Client.exceptions.ResourceNotFoundException
"""
pass
def associate_drt_role(RoleArn=None):
"""
Authorizes the DDoS Response team (DRT), using the specified role, to access your AWS account to assist with DDoS attack mitigation during potential attacks. This enables the DRT to inspect your AWS WAF configuration and create or update AWS WAF rules and web ACLs.
You can associate only one RoleArn with your subscription. If you submit an AssociateDRTRole request for an account that already has an associated role, the new RoleArn will replace the existing RoleArn .
Prior to making the AssociateDRTRole request, you must attach the AWSShieldDRTAccessPolicy managed policy to the role you will specify in the request. For more information see `Attaching and Detaching IAM Policies < https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html>`__ . The role must also trust the service principal drt.shield.amazonaws.com . For more information, see IAM JSON Policy Elements: Principal .
The DRT will have access only to your AWS WAF and Shield resources. By submitting this request, you authorize the DRT to inspect your AWS WAF and Shield configuration and create and update AWS WAF rules and web ACLs on your behalf. The DRT takes these actions only if explicitly authorized by you.
You must have the iam:PassRole permission to make an AssociateDRTRole request. For more information, see Granting a User Permissions to Pass a Role to an AWS Service .
To use the services of the DRT and make an AssociateDRTRole request, you must be subscribed to the Business Support plan or the Enterprise Support plan .
See also: AWS API Documentation
Exceptions
:example: response = client.associate_drt_role(
RoleArn='string'
)
:type RoleArn: string
:param RoleArn: [REQUIRED]\nThe Amazon Resource Name (ARN) of the role the DRT will use to access your AWS account.\nPrior to making the AssociateDRTRole request, you must attach the AWSShieldDRTAccessPolicy managed policy to this role. For more information see `Attaching and Detaching IAM Policies < https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html>`__ .\n
:rtype: dict
ReturnsResponse Syntax{}
Response Structure
(dict) --
Exceptions
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.InvalidOperationException
Shield.Client.exceptions.InvalidParameterException
Shield.Client.exceptions.AccessDeniedForDependencyException
Shield.Client.exceptions.OptimisticLockException
Shield.Client.exceptions.ResourceNotFoundException
:return: {}
:returns:
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.InvalidOperationException
Shield.Client.exceptions.InvalidParameterException
Shield.Client.exceptions.AccessDeniedForDependencyException
Shield.Client.exceptions.OptimisticLockException
Shield.Client.exceptions.ResourceNotFoundException
"""
pass
def associate_health_check(ProtectionId=None, HealthCheckArn=None):
"""
Adds health-based detection to the Shield Advanced protection for a resource. Shield Advanced health-based detection uses the health of your AWS resource to improve responsiveness and accuracy in attack detection and mitigation.
You define the health check in Route 53 and then associate it with your Shield Advanced protection. For more information, see Shield Advanced Health-Based Detection in the AWS WAF and AWS Shield Developer Guide .
See also: AWS API Documentation
Exceptions
:example: response = client.associate_health_check(
ProtectionId='string',
HealthCheckArn='string'
)
:type ProtectionId: string
:param ProtectionId: [REQUIRED]\nThe unique identifier (ID) for the Protection object to add the health check association to.\n
:type HealthCheckArn: string
:param HealthCheckArn: [REQUIRED]\nThe Amazon Resource Name (ARN) of the health check to associate with the protection.\n
:rtype: dict
ReturnsResponse Syntax
{}
Response Structure
(dict) --
Exceptions
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.LimitsExceededException
Shield.Client.exceptions.ResourceNotFoundException
Shield.Client.exceptions.InvalidParameterException
Shield.Client.exceptions.OptimisticLockException
:return: {}
:returns:
(dict) --
"""
pass
def can_paginate(operation_name=None):
"""
Check if an operation can be paginated.
:type operation_name: string
:param operation_name: The operation name. This is the same name\nas the method name on the client. For example, if the\nmethod name is create_foo, and you\'d normally invoke the\noperation as client.create_foo(**kwargs), if the\ncreate_foo operation can be paginated, you can use the\ncall client.get_paginator('create_foo').
"""
pass
def create_protection(Name=None, ResourceArn=None):
"""
Enables AWS Shield Advanced for a specific AWS resource. The resource can be an Amazon CloudFront distribution, Elastic Load Balancing load balancer, AWS Global Accelerator accelerator, Elastic IP Address, or an Amazon Route 53 hosted zone.
You can add protection to only a single resource with each CreateProtection request. If you want to add protection to multiple resources at once, use the AWS WAF console . For more information see Getting Started with AWS Shield Advanced and Add AWS Shield Advanced Protection to more AWS Resources .
See also: AWS API Documentation
Exceptions
:example: response = client.create_protection(
Name='string',
ResourceArn='string'
)
:type Name: string
:param Name: [REQUIRED]\nFriendly name for the Protection you are creating.\n
:type ResourceArn: string
:param ResourceArn: [REQUIRED]\nThe ARN (Amazon Resource Name) of the resource to be protected.\nThe ARN should be in one of the following formats:\n\nFor an Application Load Balancer: ``arn:aws:elasticloadbalancing:region :account-id :loadbalancer/app/load-balancer-name /load-balancer-id ``\nFor an Elastic Load Balancer (Classic Load Balancer): ``arn:aws:elasticloadbalancing:region :account-id :loadbalancer/load-balancer-name ``\nFor an AWS CloudFront distribution: ``arn:aws:cloudfront::account-id :distribution/distribution-id ``\nFor an AWS Global Accelerator accelerator: ``arn:aws:globalaccelerator::account-id :accelerator/accelerator-id ``\nFor Amazon Route 53: ``arn:aws:route53:::hostedzone/hosted-zone-id ``\nFor an Elastic IP address: ``arn:aws:ec2:region :account-id :eip-allocation/allocation-id ``\n\n
:rtype: dict
ReturnsResponse Syntax
{
'ProtectionId': 'string'
}
Response Structure
(dict) --
ProtectionId (string) --
The unique identifier (ID) for the Protection object that is created.
Exceptions
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.InvalidResourceException
Shield.Client.exceptions.InvalidOperationException
Shield.Client.exceptions.LimitsExceededException
Shield.Client.exceptions.ResourceAlreadyExistsException
Shield.Client.exceptions.OptimisticLockException
Shield.Client.exceptions.ResourceNotFoundException
:return: {
'ProtectionId': 'string'
}
:returns:
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.InvalidResourceException
Shield.Client.exceptions.InvalidOperationException
Shield.Client.exceptions.LimitsExceededException
Shield.Client.exceptions.ResourceAlreadyExistsException
Shield.Client.exceptions.OptimisticLockException
Shield.Client.exceptions.ResourceNotFoundException
"""
pass
def create_subscription():
"""
Activates AWS Shield Advanced for an account.
As part of this request you can specify EmergencySettings that automaticaly grant the DDoS response team (DRT) needed permissions to assist you during a suspected DDoS attack. For more information see Authorize the DDoS Response Team to Create Rules and Web ACLs on Your Behalf .
To use the services of the DRT, you must be subscribed to the Business Support plan or the Enterprise Support plan .
When you initally create a subscription, your subscription is set to be automatically renewed at the end of the existing subscription period. You can change this by submitting an UpdateSubscription request.
See also: AWS API Documentation
Exceptions
:example: response = client.create_subscription()
:rtype: dict
ReturnsResponse Syntax{}
Response Structure
(dict) --
Exceptions
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.ResourceAlreadyExistsException
:return: {}
:returns:
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.ResourceAlreadyExistsException
"""
pass
def delete_protection(ProtectionId=None):
"""
Deletes an AWS Shield Advanced Protection .
See also: AWS API Documentation
Exceptions
:example: response = client.delete_protection(
ProtectionId='string'
)
:type ProtectionId: string
:param ProtectionId: [REQUIRED]\nThe unique identifier (ID) for the Protection object to be deleted.\n
:rtype: dict
ReturnsResponse Syntax{}
Response Structure
(dict) --
Exceptions
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.ResourceNotFoundException
Shield.Client.exceptions.OptimisticLockException
:return: {}
:returns:
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.ResourceNotFoundException
Shield.Client.exceptions.OptimisticLockException
"""
pass
def delete_subscription():
"""
Removes AWS Shield Advanced from an account. AWS Shield Advanced requires a 1-year subscription commitment. You cannot delete a subscription prior to the completion of that commitment.
See also: AWS API Documentation
Exceptions
:example: response = client.delete_subscription()
:rtype: dict
ReturnsResponse Syntax{}
Response Structure
(dict) --
Exceptions
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.LockedSubscriptionException
Shield.Client.exceptions.ResourceNotFoundException
:return: {}
:returns:
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.LockedSubscriptionException
Shield.Client.exceptions.ResourceNotFoundException
"""
pass
def describe_attack(AttackId=None):
"""
Describes the details of a DDoS attack.
See also: AWS API Documentation
Exceptions
:example: response = client.describe_attack(
AttackId='string'
)
:type AttackId: string
:param AttackId: [REQUIRED]\nThe unique identifier (ID) for the attack that to be described.\n
:rtype: dict
ReturnsResponse Syntax{
'Attack': {
'AttackId': 'string',
'ResourceArn': 'string',
'SubResources': [
{
'Type': 'IP'|'URL',
'Id': 'string',
'AttackVectors': [
{
'VectorType': 'string',
'VectorCounters': [
{
'Name': 'string',
'Max': 123.0,
'Average': 123.0,
'Sum': 123.0,
'N': 123,
'Unit': 'string'
},
]
},
],
'Counters': [
{
'Name': 'string',
'Max': 123.0,
'Average': 123.0,
'Sum': 123.0,
'N': 123,
'Unit': 'string'
},
]
},
],
'StartTime': datetime(2015, 1, 1),
'EndTime': datetime(2015, 1, 1),
'AttackCounters': [
{
'Name': 'string',
'Max': 123.0,
'Average': 123.0,
'Sum': 123.0,
'N': 123,
'Unit': 'string'
},
],
'AttackProperties': [
{
'AttackLayer': 'NETWORK'|'APPLICATION',
'AttackPropertyIdentifier': 'DESTINATION_URL'|'REFERRER'|'SOURCE_ASN'|'SOURCE_COUNTRY'|'SOURCE_IP_ADDRESS'|'SOURCE_USER_AGENT'|'WORDPRESS_PINGBACK_REFLECTOR'|'WORDPRESS_PINGBACK_SOURCE',
'TopContributors': [
{
'Name': 'string',
'Value': 123
},
],
'Unit': 'BITS'|'BYTES'|'PACKETS'|'REQUESTS',
'Total': 123
},
],
'Mitigations': [
{
'MitigationName': 'string'
},
]
}
}
Response Structure
(dict) --
Attack (dict) --The attack that is described.
AttackId (string) --The unique identifier (ID) of the attack.
ResourceArn (string) --The ARN (Amazon Resource Name) of the resource that was attacked.
SubResources (list) --If applicable, additional detail about the resource being attacked, for example, IP address or URL.
(dict) --The attack information for the specified SubResource.
Type (string) --The SubResource type.
Id (string) --The unique identifier (ID) of the SubResource .
AttackVectors (list) --The list of attack types and associated counters.
(dict) --A summary of information about the attack.
VectorType (string) --The attack type, for example, SNMP reflection or SYN flood.
VectorCounters (list) --The list of counters that describe the details of the attack.
(dict) --The counter that describes a DDoS attack.
Name (string) --The counter name.
Max (float) --The maximum value of the counter for a specified time period.
Average (float) --The average value of the counter for a specified time period.
Sum (float) --The total of counter values for a specified time period.
N (integer) --The number of counters for a specified time period.
Unit (string) --The unit of the counters.
Counters (list) --The counters that describe the details of the attack.
(dict) --The counter that describes a DDoS attack.
Name (string) --The counter name.
Max (float) --The maximum value of the counter for a specified time period.
Average (float) --The average value of the counter for a specified time period.
Sum (float) --The total of counter values for a specified time period.
N (integer) --The number of counters for a specified time period.
Unit (string) --The unit of the counters.
StartTime (datetime) --The time the attack started, in Unix time in seconds. For more information see timestamp .
EndTime (datetime) --The time the attack ended, in Unix time in seconds. For more information see timestamp .
AttackCounters (list) --List of counters that describe the attack for the specified time period.
(dict) --The counter that describes a DDoS attack.
Name (string) --The counter name.
Max (float) --The maximum value of the counter for a specified time period.
Average (float) --The average value of the counter for a specified time period.
Sum (float) --The total of counter values for a specified time period.
N (integer) --The number of counters for a specified time period.
Unit (string) --The unit of the counters.
AttackProperties (list) --The array of AttackProperty objects.
(dict) --Details of the described attack.
AttackLayer (string) --The type of distributed denial of service (DDoS) event that was observed. NETWORK indicates layer 3 and layer 4 events and APPLICATION indicates layer 7 events.
AttackPropertyIdentifier (string) --Defines the DDoS attack property information that is provided. The WORDPRESS_PINGBACK_REFLECTOR and WORDPRESS_PINGBACK_SOURCE values are valid only for WordPress reflective pingback DDoS attacks.
TopContributors (list) --The array of Contributor objects that includes the top five contributors to an attack.
(dict) --A contributor to the attack and their contribution.
Name (string) --The name of the contributor. This is dependent on the AttackPropertyIdentifier . For example, if the AttackPropertyIdentifier is SOURCE_COUNTRY , the Name could be United States .
Value (integer) --The contribution of this contributor expressed in Protection units. For example 10,000 .
Unit (string) --The unit of the Value of the contributions.
Total (integer) --The total contributions made to this attack by all contributors, not just the five listed in the TopContributors list.
Mitigations (list) --List of mitigation actions taken for the attack.
(dict) --The mitigation applied to a DDoS attack.
MitigationName (string) --The name of the mitigation taken for this attack.
Exceptions
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.AccessDeniedException
:return: {
'Attack': {
'AttackId': 'string',
'ResourceArn': 'string',
'SubResources': [
{
'Type': 'IP'|'URL',
'Id': 'string',
'AttackVectors': [
{
'VectorType': 'string',
'VectorCounters': [
{
'Name': 'string',
'Max': 123.0,
'Average': 123.0,
'Sum': 123.0,
'N': 123,
'Unit': 'string'
},
]
},
],
'Counters': [
{
'Name': 'string',
'Max': 123.0,
'Average': 123.0,
'Sum': 123.0,
'N': 123,
'Unit': 'string'
},
]
},
],
'StartTime': datetime(2015, 1, 1),
'EndTime': datetime(2015, 1, 1),
'AttackCounters': [
{
'Name': 'string',
'Max': 123.0,
'Average': 123.0,
'Sum': 123.0,
'N': 123,
'Unit': 'string'
},
],
'AttackProperties': [
{
'AttackLayer': 'NETWORK'|'APPLICATION',
'AttackPropertyIdentifier': 'DESTINATION_URL'|'REFERRER'|'SOURCE_ASN'|'SOURCE_COUNTRY'|'SOURCE_IP_ADDRESS'|'SOURCE_USER_AGENT'|'WORDPRESS_PINGBACK_REFLECTOR'|'WORDPRESS_PINGBACK_SOURCE',
'TopContributors': [
{
'Name': 'string',
'Value': 123
},
],
'Unit': 'BITS'|'BYTES'|'PACKETS'|'REQUESTS',
'Total': 123
},
],
'Mitigations': [
{
'MitigationName': 'string'
},
]
}
}
"""
pass
def describe_drt_access():
"""
Returns the current role and list of Amazon S3 log buckets used by the DDoS Response team (DRT) to access your AWS account while assisting with attack mitigation.
See also: AWS API Documentation
Exceptions
:example: response = client.describe_drt_access()
:rtype: dict
ReturnsResponse Syntax{
'RoleArn': 'string',
'LogBucketList': [
'string',
]
}
Response Structure
(dict) --
RoleArn (string) --The Amazon Resource Name (ARN) of the role the DRT used to access your AWS account.
LogBucketList (list) --The list of Amazon S3 buckets accessed by the DRT.
(string) --
Exceptions
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.ResourceNotFoundException
:return: {
'RoleArn': 'string',
'LogBucketList': [
'string',
]
}
:returns:
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.ResourceNotFoundException
"""
pass
def describe_emergency_contact_settings():
"""
Lists the email addresses that the DRT can use to contact you during a suspected attack.
See also: AWS API Documentation
Exceptions
:example: response = client.describe_emergency_contact_settings()
:rtype: dict
ReturnsResponse Syntax{
'EmergencyContactList': [
{
'EmailAddress': 'string'
},
]
}
Response Structure
(dict) --
EmergencyContactList (list) --A list of email addresses that the DRT can use to contact you during a suspected attack.
(dict) --Contact information that the DRT can use to contact you during a suspected attack.
EmailAddress (string) --An email address that the DRT can use to contact you during a suspected attack.
Exceptions
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.ResourceNotFoundException
:return: {
'EmergencyContactList': [
{
'EmailAddress': 'string'
},
]
}
"""
pass
def describe_protection(ProtectionId=None, ResourceArn=None):
"""
Lists the details of a Protection object.
See also: AWS API Documentation
Exceptions
:example: response = client.describe_protection(
ProtectionId='string',
ResourceArn='string'
)
:type ProtectionId: string
:param ProtectionId: The unique identifier (ID) for the Protection object that is described. When submitting the DescribeProtection request you must provide either the ResourceArn or the ProtectionID , but not both.
:type ResourceArn: string
:param ResourceArn: The ARN (Amazon Resource Name) of the AWS resource for the Protection object that is described. When submitting the DescribeProtection request you must provide either the ResourceArn or the ProtectionID , but not both.
:rtype: dict
ReturnsResponse Syntax
{
'Protection': {
'Id': 'string',
'Name': 'string',
'ResourceArn': 'string',
'HealthCheckIds': [
'string',
]
}
}
Response Structure
(dict) --
Protection (dict) --
The Protection object that is described.
Id (string) --
The unique identifier (ID) of the protection.
Name (string) --
The friendly name of the protection. For example, My CloudFront distributions .
ResourceArn (string) --
The ARN (Amazon Resource Name) of the AWS resource that is protected.
HealthCheckIds (list) --
The unique identifier (ID) for the Route 53 health check that\'s associated with the protection.
(string) --
Exceptions
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.InvalidParameterException
Shield.Client.exceptions.ResourceNotFoundException
:return: {
'Protection': {
'Id': 'string',
'Name': 'string',
'ResourceArn': 'string',
'HealthCheckIds': [
'string',
]
}
}
:returns:
(string) --
"""
pass
def describe_subscription():
"""
Provides details about the AWS Shield Advanced subscription for an account.
See also: AWS API Documentation
Exceptions
:example: response = client.describe_subscription()
:rtype: dict
ReturnsResponse Syntax{
'Subscription': {
'StartTime': datetime(2015, 1, 1),
'EndTime': datetime(2015, 1, 1),
'TimeCommitmentInSeconds': 123,
'AutoRenew': 'ENABLED'|'DISABLED',
'Limits': [
{
'Type': 'string',
'Max': 123
},
]
}
}
Response Structure
(dict) --
Subscription (dict) --The AWS Shield Advanced subscription details for an account.
StartTime (datetime) --The start time of the subscription, in Unix time in seconds. For more information see timestamp .
EndTime (datetime) --The date and time your subscription will end.
TimeCommitmentInSeconds (integer) --The length, in seconds, of the AWS Shield Advanced subscription for the account.
AutoRenew (string) --If ENABLED , the subscription will be automatically renewed at the end of the existing subscription period.
When you initally create a subscription, AutoRenew is set to ENABLED . You can change this by submitting an UpdateSubscription request. If the UpdateSubscription request does not included a value for AutoRenew , the existing value for AutoRenew remains unchanged.
Limits (list) --Specifies how many protections of a given type you can create.
(dict) --Specifies how many protections of a given type you can create.
Type (string) --The type of protection.
Max (integer) --The maximum number of protections that can be created for the specified Type .
Exceptions
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.ResourceNotFoundException
:return: {
'Subscription': {
'StartTime': datetime(2015, 1, 1),
'EndTime': datetime(2015, 1, 1),
'TimeCommitmentInSeconds': 123,
'AutoRenew': 'ENABLED'|'DISABLED',
'Limits': [
{
'Type': 'string',
'Max': 123
},
]
}
}
"""
pass
def disassociate_drt_log_bucket(LogBucket=None):
"""
Removes the DDoS Response team\'s (DRT) access to the specified Amazon S3 bucket containing your AWS WAF logs.
To make a DisassociateDRTLogBucket request, you must be subscribed to the Business Support plan or the Enterprise Support plan . However, if you are not subscribed to one of these support plans, but had been previously and had granted the DRT access to your account, you can submit a DisassociateDRTLogBucket request to remove this access.
See also: AWS API Documentation
Exceptions
:example: response = client.disassociate_drt_log_bucket(
LogBucket='string'
)
:type LogBucket: string
:param LogBucket: [REQUIRED]\nThe Amazon S3 bucket that contains your AWS WAF logs.\n
:rtype: dict
ReturnsResponse Syntax{}
Response Structure
(dict) --
Exceptions
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.InvalidOperationException
Shield.Client.exceptions.NoAssociatedRoleException
Shield.Client.exceptions.AccessDeniedForDependencyException
Shield.Client.exceptions.OptimisticLockException
Shield.Client.exceptions.ResourceNotFoundException
:return: {}
:returns:
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.InvalidOperationException
Shield.Client.exceptions.NoAssociatedRoleException
Shield.Client.exceptions.AccessDeniedForDependencyException
Shield.Client.exceptions.OptimisticLockException
Shield.Client.exceptions.ResourceNotFoundException
"""
pass
def disassociate_drt_role():
"""
Removes the DDoS Response team\'s (DRT) access to your AWS account.
To make a DisassociateDRTRole request, you must be subscribed to the Business Support plan or the Enterprise Support plan . However, if you are not subscribed to one of these support plans, but had been previously and had granted the DRT access to your account, you can submit a DisassociateDRTRole request to remove this access.
See also: AWS API Documentation
Exceptions
:example: response = client.disassociate_drt_role()
:rtype: dict
ReturnsResponse Syntax{}
Response Structure
(dict) --
Exceptions
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.InvalidOperationException
Shield.Client.exceptions.OptimisticLockException
Shield.Client.exceptions.ResourceNotFoundException
:return: {}
:returns:
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.InvalidOperationException
Shield.Client.exceptions.OptimisticLockException
Shield.Client.exceptions.ResourceNotFoundException
"""
pass
def disassociate_health_check(ProtectionId=None, HealthCheckArn=None):
"""
Removes health-based detection from the Shield Advanced protection for a resource. Shield Advanced health-based detection uses the health of your AWS resource to improve responsiveness and accuracy in attack detection and mitigation.
You define the health check in Route 53 and then associate or disassociate it with your Shield Advanced protection. For more information, see Shield Advanced Health-Based Detection in the AWS WAF and AWS Shield Developer Guide .
See also: AWS API Documentation
Exceptions
:example: response = client.disassociate_health_check(
ProtectionId='string',
HealthCheckArn='string'
)
:type ProtectionId: string
:param ProtectionId: [REQUIRED]\nThe unique identifier (ID) for the Protection object to remove the health check association from.\n
:type HealthCheckArn: string
:param HealthCheckArn: [REQUIRED]\nThe Amazon Resource Name (ARN) of the health check that is associated with the protection.\n
:rtype: dict
ReturnsResponse Syntax
{}
Response Structure
(dict) --
Exceptions
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.InvalidParameterException
Shield.Client.exceptions.ResourceNotFoundException
Shield.Client.exceptions.OptimisticLockException
:return: {}
:returns:
(dict) --
"""
pass
def generate_presigned_url(ClientMethod=None, Params=None, ExpiresIn=None, HttpMethod=None):
"""
Generate a presigned url given a client, its method, and arguments
:type ClientMethod: string
:param ClientMethod: The client method to presign for
:type Params: dict
:param Params: The parameters normally passed to\nClientMethod.
:type ExpiresIn: int
:param ExpiresIn: The number of seconds the presigned url is valid\nfor. By default it expires in an hour (3600 seconds)
:type HttpMethod: string
:param HttpMethod: The http method to use on the generated url. By\ndefault, the http method is whatever is used in the method\'s model.
"""
pass
def get_paginator(operation_name=None):
"""
Create a paginator for an operation.
:type operation_name: string
:param operation_name: The operation name. This is the same name\nas the method name on the client. For example, if the\nmethod name is create_foo, and you\'d normally invoke the\noperation as client.create_foo(**kwargs), if the\ncreate_foo operation can be paginated, you can use the\ncall client.get_paginator('create_foo').
:rtype: L{botocore.paginate.Paginator}
ReturnsA paginator object.
"""
pass
def get_subscription_state():
"""
Returns the SubscriptionState , either Active or Inactive .
See also: AWS API Documentation
Exceptions
:example: response = client.get_subscription_state()
:rtype: dict
ReturnsResponse Syntax{
'SubscriptionState': 'ACTIVE'|'INACTIVE'
}
Response Structure
(dict) --
SubscriptionState (string) --The status of the subscription.
Exceptions
Shield.Client.exceptions.InternalErrorException
:return: {
'SubscriptionState': 'ACTIVE'|'INACTIVE'
}
"""
pass
def get_waiter(waiter_name=None):
"""
Returns an object that can wait for some condition.
:type waiter_name: str
:param waiter_name: The name of the waiter to get. See the waiters\nsection of the service docs for a list of available waiters.
:rtype: botocore.waiter.Waiter
"""
pass
def list_attacks(ResourceArns=None, StartTime=None, EndTime=None, NextToken=None, MaxResults=None):
"""
Returns all ongoing DDoS attacks or all DDoS attacks during a specified time period.
See also: AWS API Documentation
Exceptions
:example: response = client.list_attacks(
ResourceArns=[
'string',
],
StartTime={
'FromInclusive': datetime(2015, 1, 1),
'ToExclusive': datetime(2015, 1, 1)
},
EndTime={
'FromInclusive': datetime(2015, 1, 1),
'ToExclusive': datetime(2015, 1, 1)
},
NextToken='string',
MaxResults=123
)
:type ResourceArns: list
:param ResourceArns: The ARN (Amazon Resource Name) of the resource that was attacked. If this is left blank, all applicable resources for this account will be included.\n\n(string) --\n\n
:type StartTime: dict
:param StartTime: The start of the time period for the attacks. This is a timestamp type. The sample request above indicates a number type because the default used by WAF is Unix time in seconds. However any valid timestamp format is allowed.\n\nFromInclusive (datetime) --The start time, in Unix time in seconds. For more information see timestamp .\n\nToExclusive (datetime) --The end time, in Unix time in seconds. For more information see timestamp .\n\n\n
:type EndTime: dict
:param EndTime: The end of the time period for the attacks. This is a timestamp type. The sample request above indicates a number type because the default used by WAF is Unix time in seconds. However any valid timestamp format is allowed.\n\nFromInclusive (datetime) --The start time, in Unix time in seconds. For more information see timestamp .\n\nToExclusive (datetime) --The end time, in Unix time in seconds. For more information see timestamp .\n\n\n
:type NextToken: string
:param NextToken: The ListAttacksRequest.NextMarker value from a previous call to ListAttacksRequest . Pass null if this is the first call.
:type MaxResults: integer
:param MaxResults: The maximum number of AttackSummary objects to be returned. If this is left blank, the first 20 results will be returned.\nThis is a maximum value; it is possible that AWS WAF will return the results in smaller batches. That is, the number of AttackSummary objects returned could be less than MaxResults , even if there are still more AttackSummary objects yet to return. If there are more AttackSummary objects to return, AWS WAF will always also return a NextToken .\n
:rtype: dict
ReturnsResponse Syntax
{
'AttackSummaries': [
{
'AttackId': 'string',
'ResourceArn': 'string',
'StartTime': datetime(2015, 1, 1),
'EndTime': datetime(2015, 1, 1),
'AttackVectors': [
{
'VectorType': 'string'
},
]
},
],
'NextToken': 'string'
}
Response Structure
(dict) --
AttackSummaries (list) --
The attack information for the specified time range.
(dict) --
Summarizes all DDoS attacks for a specified time period.
AttackId (string) --
The unique identifier (ID) of the attack.
ResourceArn (string) --
The ARN (Amazon Resource Name) of the resource that was attacked.
StartTime (datetime) --
The start time of the attack, in Unix time in seconds. For more information see timestamp .
EndTime (datetime) --
The end time of the attack, in Unix time in seconds. For more information see timestamp .
AttackVectors (list) --
The list of attacks for a specified time period.
(dict) --
Describes the attack.
VectorType (string) --
The attack type. Valid values:
UDP_TRAFFIC
UDP_FRAGMENT
GENERIC_UDP_REFLECTION
DNS_REFLECTION
NTP_REFLECTION
CHARGEN_REFLECTION
SSDP_REFLECTION
PORT_MAPPER
RIP_REFLECTION
SNMP_REFLECTION
MSSQL_REFLECTION
NET_BIOS_REFLECTION
SYN_FLOOD
ACK_FLOOD
REQUEST_FLOOD
HTTP_REFLECTION
UDS_REFLECTION
MEMCACHED_REFLECTION
NextToken (string) --
The token returned by a previous call to indicate that there is more data available. If not null, more results are available. Pass this value for the NextMarker parameter in a subsequent call to ListAttacks to retrieve the next set of items.
AWS WAF might return the list of AttackSummary objects in batches smaller than the number specified by MaxResults. If there are more AttackSummary objects to return, AWS WAF will always also return a NextToken .
Exceptions
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.InvalidParameterException
Shield.Client.exceptions.InvalidOperationException
:return: {
'AttackSummaries': [
{
'AttackId': 'string',
'ResourceArn': 'string',
'StartTime': datetime(2015, 1, 1),
'EndTime': datetime(2015, 1, 1),
'AttackVectors': [
{
'VectorType': 'string'
},
]
},
],
'NextToken': 'string'
}
:returns:
UDP_TRAFFIC
UDP_FRAGMENT
GENERIC_UDP_REFLECTION
DNS_REFLECTION
NTP_REFLECTION
CHARGEN_REFLECTION
SSDP_REFLECTION
PORT_MAPPER
RIP_REFLECTION
SNMP_REFLECTION
MSSQL_REFLECTION
NET_BIOS_REFLECTION
SYN_FLOOD
ACK_FLOOD
REQUEST_FLOOD
HTTP_REFLECTION
UDS_REFLECTION
MEMCACHED_REFLECTION
"""
pass
def list_protections(NextToken=None, MaxResults=None):
"""
Lists all Protection objects for the account.
See also: AWS API Documentation
Exceptions
:example: response = client.list_protections(
NextToken='string',
MaxResults=123
)
:type NextToken: string
:param NextToken: The ListProtectionsRequest.NextToken value from a previous call to ListProtections . Pass null if this is the first call.
:type MaxResults: integer
:param MaxResults: The maximum number of Protection objects to be returned. If this is left blank the first 20 results will be returned.\nThis is a maximum value; it is possible that AWS WAF will return the results in smaller batches. That is, the number of Protection objects returned could be less than MaxResults , even if there are still more Protection objects yet to return. If there are more Protection objects to return, AWS WAF will always also return a NextToken .\n
:rtype: dict
ReturnsResponse Syntax
{
'Protections': [
{
'Id': 'string',
'Name': 'string',
'ResourceArn': 'string',
'HealthCheckIds': [
'string',
]
},
],
'NextToken': 'string'
}
Response Structure
(dict) --
Protections (list) --
The array of enabled Protection objects.
(dict) --
An object that represents a resource that is under DDoS protection.
Id (string) --
The unique identifier (ID) of the protection.
Name (string) --
The friendly name of the protection. For example, My CloudFront distributions .
ResourceArn (string) --
The ARN (Amazon Resource Name) of the AWS resource that is protected.
HealthCheckIds (list) --
The unique identifier (ID) for the Route 53 health check that\'s associated with the protection.
(string) --
NextToken (string) --
If you specify a value for MaxResults and you have more Protections than the value of MaxResults, AWS Shield Advanced returns a NextToken value in the response that allows you to list another group of Protections. For the second and subsequent ListProtections requests, specify the value of NextToken from the previous response to get information about another batch of Protections.
AWS WAF might return the list of Protection objects in batches smaller than the number specified by MaxResults. If there are more Protection objects to return, AWS WAF will always also return a NextToken .
Exceptions
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.ResourceNotFoundException
Shield.Client.exceptions.InvalidPaginationTokenException
:return: {
'Protections': [
{
'Id': 'string',
'Name': 'string',
'ResourceArn': 'string',
'HealthCheckIds': [
'string',
]
},
],
'NextToken': 'string'
}
:returns:
(string) --
"""
pass
def update_emergency_contact_settings(EmergencyContactList=None):
"""
Updates the details of the list of email addresses that the DRT can use to contact you during a suspected attack.
See also: AWS API Documentation
Exceptions
:example: response = client.update_emergency_contact_settings(
EmergencyContactList=[
{
'EmailAddress': 'string'
},
]
)
:type EmergencyContactList: list
:param EmergencyContactList: A list of email addresses that the DRT can use to contact you during a suspected attack.\n\n(dict) --Contact information that the DRT can use to contact you during a suspected attack.\n\nEmailAddress (string) -- [REQUIRED]An email address that the DRT can use to contact you during a suspected attack.\n\n\n\n\n
:rtype: dict
ReturnsResponse Syntax{}
Response Structure
(dict) --
Exceptions
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.InvalidParameterException
Shield.Client.exceptions.OptimisticLockException
Shield.Client.exceptions.ResourceNotFoundException
:return: {}
:returns:
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.InvalidParameterException
Shield.Client.exceptions.OptimisticLockException
Shield.Client.exceptions.ResourceNotFoundException
"""
pass
def update_subscription(AutoRenew=None):
"""
Updates the details of an existing subscription. Only enter values for parameters you want to change. Empty parameters are not updated.
See also: AWS API Documentation
Exceptions
:example: response = client.update_subscription(
AutoRenew='ENABLED'|'DISABLED'
)
:type AutoRenew: string
:param AutoRenew: When you initally create a subscription, AutoRenew is set to ENABLED . If ENABLED , the subscription will be automatically renewed at the end of the existing subscription period. You can change this by submitting an UpdateSubscription request. If the UpdateSubscription request does not included a value for AutoRenew , the existing value for AutoRenew remains unchanged.
:rtype: dict
ReturnsResponse Syntax{}
Response Structure
(dict) --
Exceptions
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.LockedSubscriptionException
Shield.Client.exceptions.ResourceNotFoundException
Shield.Client.exceptions.InvalidParameterException
Shield.Client.exceptions.OptimisticLockException
:return: {}
:returns:
Shield.Client.exceptions.InternalErrorException
Shield.Client.exceptions.LockedSubscriptionException
Shield.Client.exceptions.ResourceNotFoundException
Shield.Client.exceptions.InvalidParameterException
Shield.Client.exceptions.OptimisticLockException
"""
pass
| wavycloud/pyboto3 | pyboto3/shield.py | Python | mit | 46,532 |
#!/usr/bin/python
# coding: utf-8
# waveform modification based on spectrum differencial
import json
import numpy as np
import sys
import sptk
from pylab import plot, show, legend
from scipy.io import wavfile
if __name__ == "__main__":
import argparse
parser = argparse.ArgumentParser(description="Synthsis")
parser.add_argument("--input", dest="input", type=str, required=True)
parser.add_argument("--mcep", dest="mcep", type=str, required=True)
parser.add_argument("--output", dest="output", type=str,
default="converted.wav")
parser.set_defaults(trajectory=False)
args = parser.parse_args()
# input audio
fs, data = wavfile.read(args.input)
# setup mcep
f = open(args.mcep)
src = json.load(f)
f.close()
mcep = np.array(src['Data'])
# remove power coef.
mcep[:, 0] = 0.0
# waveform modification based on spectrum differencial
order = len(mcep[0]) - 1
mlsa = sptk.MLSASynthesizer(order)
synthesized = mlsa.synthesis(data, mcep, alpha=0.35)
synthesized = np.array(synthesized, dtype=np.int16)
plot(synthesized, label="converted")
plot(data, label="original")
legend()
show()
wavfile.write(args.output, fs, synthesized)
| r9y9/stav | diff_synthesis.py | Python | mit | 1,259 |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('cc', '0010_remove_numericdata_qualifiers'),
]
operations = [
migrations.AlterField(
model_name='numericexpressionresponse',
name='assignment_id',
field=models.CharField(unique=True, max_length=1024),
),
]
| arunchaganty/contextual-comparatives | applesoranges/cc/migrations/0011_auto_20160221_0120.py | Python | mit | 449 |
import unittest
from katas.kyu_7.finding_remainder_without_using_modulo import remainder
class RemainderTestCase(unittest.TestCase):
def test_equals(self):
self.assertEqual(remainder(3, 2), 1)
def test_equals_2(self):
self.assertEqual(remainder(19, 2), 1)
def test_equals_3(self):
self.assertEqual(remainder(10, 2), 0)
def test_equals_4(self):
self.assertEqual(remainder(34, 7), 6)
def test_equals_5(self):
self.assertEqual(remainder(27, 5), 2)
| the-zebulan/CodeWars | tests/kyu_7_tests/test_finding_remainder_without_using_modulo.py | Python | mit | 512 |
"""
Test the ffi wrapper for libgroove
"""
from __future__ import absolute_import, unicode_literals
from groove._groove import ffi, lib
def setup_module(module):
lib.groove_init()
lib.groove_set_logging(32)
def teardown_module(module):
lib.groove_finish()
def test_channel_layouts():
# TODO: replace these numbers with values from groove.constants
assert lib.groove_channel_layout_count(1) == 1
assert lib.groove_channel_layout_count(3) == 2
assert lib.groove_channel_layout_count(7) == 3
assert lib.groove_channel_layout_default(1) == 4
assert lib.groove_channel_layout_default(2) == 3
assert lib.groove_channel_layout_default(3) == 11
| kalhartt/python-groove | tests/test_groove_ffi.py | Python | mit | 684 |
# -*- coding: utf-8 -*-
__author__ = 'peter'
from handlers.avatar import AvatarRequestHandler
class BotsHandler(AvatarRequestHandler):
def get(self):
pass
| motord/tardis | dashboard/bot.py | Python | mit | 170 |
import re
import copy
import os
import tempfile
import logging
import subprocess
import shlex
import time
from threading import Timer
from pycparser import parse_file, c_generator
from pycparser.c_ast import Break
_ENV_ORIG_SRC = 'MUTATE_ORIG_SRC'
_ENV_MODIFIED_SRC = 'MUTATE_MODIFIED_SRC'
def _node_to_str(node):
'''Produce a string representation of an AST node.'''
gen = c_generator.CGenerator()
return gen.visit(node)
def _find_nodes(node, nodetype):
'''Find nodes of a given type in a given subtree.'''
nodes = []
if isinstance(node, nodetype):
nodes.append(node)
for _, c in node.children():
nodes.extend(_find_nodes(c, nodetype))
return nodes
def _get_op_swaps(op, swaps):
'''Find the set of mutations to perform on a given op.'''
ops = set()
for s in swaps:
if op in s:
ops |= s - set(op)
return ops
def _run_process(cmd, env_vars=None, timeout_sec=0, log_filename=None):
def timeout(p):
p.kill()
raise TimeoutError()
env = os.environ.copy()
if env_vars is not None:
env.update(env_vars)
if log_filename is not None:
log_file = open(log_filename, 'w')
p = subprocess.Popen(shlex.split(cmd),
env=env,
stdout=log_file,
stderr=log_file)
else:
p = subprocess.Popen(shlex.split(cmd), env=env)
timer = Timer(timeout_sec, timeout, [p])
try:
if timeout_sec > 0:
timer.start()
p.wait()
finally:
timer.cancel()
if log_filename is not None:
log_file.close()
return p.returncode
class MutationGenerator(c_generator.CGenerator):
def __init__(self, swap_nodes=None):
self.swap_nodes = swap_nodes
super(MutationGenerator, self).__init__()
def visit(self, node):
if node is self.swap_nodes[0]:
if self.swap_nodes[1] is not None:
return super(MutationGenerator, self).visit(self.swap_nodes[1])
else:
return ''
else:
return super(MutationGenerator, self).visit(node)
class Mutator:
_MIN_RUN_TIME = 5
_TIMEOUT_MULTIPLIER = 4
def __init__(self, build_cmd, test_exe, mutate_file, inject_path, log_dir,
exclude_patterns=None):
self._build_cmd = build_cmd
self._test_exe = test_exe
self._orig_filename = mutate_file
self._ast = parse_file(self._orig_filename, use_cpp=True)
self._inject_path = inject_path
self._iteration = 0
self._log_dir = log_dir
self._run_timeout = 0
self.build_failed = 0
self.crashed = 0
self.timed_out = 0
self.caught = 0
self.missed = 0
self._gen_orig_filename = '{}/{}.orig'.format(
self._log_dir, os.path.basename(self._orig_filename))
if exclude_patterns is None:
self._exclude_patterns = []
else:
self._exclude_patterns = [re.compile(p) for p in exclude_patterns]
@property
def runs(self):
return self.caught + self.missed + self.build_failed + self.crashed
def __call__(self):
if self._initial_run():
self._visit(self._ast, None)
def _visit(self, node, parent):
# Skip nodes that aren't in the original file (i.e. are in headers)
if node.coord is not None and node.coord.file != self._orig_filename:
return
method = getattr(self,
'_visit_' + node.__class__.__name__,
self._generic_visit)
descend = method(node, parent)
# Visit the children, unless the visit callback for this node
# indicated we should stop.
if descend:
for _, c in node.children():
self._visit(c, node)
def _generic_visit(self, node, parent):
return True
def _visit_Case(self, node, parent):
# Find any breaks, and remove them.
for b in _find_nodes(node, Break):
self._test((b, None))
return True
def _visit_BinaryOp(self, node, parent):
new_node = copy.copy(node)
ops = _get_op_swaps(node.op,
[{'+', '-'},
{'<', '>', '<=', '>='},
{'<<', '>>'},
{'!=', '=='},
{'&', '&&'},
{'&', '|'},
{'&&', '||'},
{'<<', '>>'},
{'|=', '&='}])
for op in ops:
new_node.op = op
self._test((node, new_node))
return True
def _visit_FuncDef(self, node, parent):
# Skip all of this function if its name matches one of the exclusion
# patterns.
for p in self._exclude_patterns:
if p.search(node.decl.name):
return False
return True
def _visit_UnaryOp(self, node, parent):
if node.op == '!':
self._test((node, node.expr))
else:
ops = _get_op_swaps(node.op,
[{'p++', 'p--', '++', '--'}])
new_node = copy.copy(node)
for op in ops:
new_node.op = op
self._test((node, new_node))
return True
def _iter_log_dirname(self):
'''Return the log directory name for the current iteration.'''
return self._log_dir + '/run{}'.format(self._iteration)
def _write_mutation(self, swap_nodes):
ext = os.path.splitext(self._orig_filename)[1]
with tempfile.NamedTemporaryFile(
mode='w', suffix=ext, delete=False) as f:
gen = MutationGenerator(swap_nodes)
f.write(gen.visit(self._ast))
return f.name
def _build_mutation(self, mutation_filename):
'''Build the test executable, with the mutated file subbed in.'''
env_vars = {
'LD_PRELOAD': self._inject_path,
_ENV_ORIG_SRC: self._orig_filename,
_ENV_MODIFIED_SRC: mutation_filename
}
rc = _run_process(cmd=self._build_cmd,
env_vars=env_vars,
log_filename=self._iter_log_dirname() + '/build.log')
return rc == 0
def _write_diff(self, mutation_filename):
# TODO: Check if the diff executable exists etc?
os.system('diff -c {} {} > {}/{}.diff'.format(
self._gen_orig_filename,
mutation_filename,
self._iter_log_dirname(),
os.path.basename(self._orig_filename)))
def _run_mutation(self, mutation_str, coord):
# TODO: Build the exe path correctly
# TODO: Check for crashes
try:
run_log = '{}/{}.log'.format(self._iter_log_dirname(),
os.path.basename(self._test_exe))
rc = _run_process(cmd='./' + self._test_exe,
log_filename=run_log,
timeout_sec=self._run_timeout)
except TimeoutError:
self.timed_out += 1
result_str = 'timed out'
log_fn = logging.error
else:
if rc == 0:
self.missed += 1
result_str = 'missed'
log_fn = logging.error
else:
self.caught += 1
result_str = 'caught'
log_fn = logging.info
log_fn('Run {}: {} {}, test output {} - {}'.format(
self._iteration,
coord,
mutation_str,
rc,
result_str))
def _test(self, swap_nodes, mutation_str=''):
if mutation_str == '':
if swap_nodes[1] is None:
mutation_str = 'Remove {}'.format(_node_to_str(swap_nodes[0]))
else:
mutation_str = '"{}" -> "{}"'.format(
_node_to_str(swap_nodes[0]),
_node_to_str(swap_nodes[1]))
# Create the log directory for this iteration, the calls below will
# assume it exists.
os.mkdir(self._iter_log_dirname())
# Write the mutated AST to disk.
mutation_filename = self._write_mutation(swap_nodes)
# Build the test with the mutated file.
build_success = self._build_mutation(mutation_filename)
# Write out the diff before deleting the mutated file.
self._write_diff(mutation_filename)
os.system('rm {}'.format(mutation_filename))
if not build_success:
self.build_failed += 1
logging.error('Run {}: {} {} - build failed'.format(
self._iteration,
swap_nodes[0].coord,
mutation_str))
else:
self._run_mutation(mutation_str, swap_nodes[0].coord)
self._iteration += 1
def _initial_run(self):
# Dump the unmutated C file from the AST so that we can diff the
# mutations against it. If we just diffed against the file we parsed,
# the diffs would contain layout changes between the original file
# and the layout that the generator produces.
with open(self._gen_orig_filename, 'w') as f:
gen = c_generator.CGenerator()
f.write(gen.visit(self._ast))
build_log = self._log_dir + '/build.log.orig'
rc = _run_process(cmd=self._build_cmd, log_filename=build_log)
if rc == 0:
# Time the unmutated run so that we can time out mutated runs that
# have got stuck (e.g. a mutation leads to an infinite loop or
# deadlock).
start = time.time()
# TODO: Build the exe path correctly
run_log = '{}/{}.log.orig'.format(
self._log_dir, os.path.basename(self._test_exe))
rc = _run_process(cmd='./' + self._test_exe, log_filename=run_log)
end = time.time()
# Use a min run time - if a process runs very quickly we don't
# mind waiting a bit longer.
self._run_timeout = (Mutator._TIMEOUT_MULTIPLIER *
max(Mutator._MIN_RUN_TIME, int(end - start)))
return rc == 0
| Juzley/Fawkes | mutate/mutator.py | Python | mit | 10,400 |
"""
Integration tests for singletask vector feature models.
"""
import os
import deepchem as dc
import numpy as np
from sklearn.ensemble import RandomForestRegressor
def test_singletask_sklearn_rf_ECFP_regression_API():
"""Test of singletask RF ECFP regression API."""
X = np.random.rand(100, 5)
y = np.random.rand(100,)
dataset = dc.data.NumpyDataset(X, y)
splitter = dc.splits.RandomSplitter()
train_dataset, test_dataset = splitter.train_test_split(dataset)
transformer = dc.trans.NormalizationTransformer(
transform_y=True, dataset=train_dataset)
train_dataset = transformer.transform(train_dataset)
test_dataset = transformer.transform(test_dataset)
regression_metrics = [
dc.metrics.Metric(dc.metrics.r2_score),
dc.metrics.Metric(dc.metrics.mean_squared_error),
dc.metrics.Metric(dc.metrics.mean_absolute_error)
]
sklearn_model = RandomForestRegressor()
model = dc.models.SklearnModel(sklearn_model)
# Fit trained model
model.fit(train_dataset)
model.save()
# Eval model on train
_ = model.evaluate(train_dataset, regression_metrics, [transformer])
_ = model.evaluate(test_dataset, regression_metrics, [transformer])
def test_singletask_sklearn_rf_user_specified_regression_API():
"""Test of singletask RF USF regression API."""
featurizer = dc.feat.UserDefinedFeaturizer(
["user-specified1", "user-specified2"])
tasks = ["log-solubility"]
current_dir = os.path.dirname(os.path.abspath(__file__))
input_file = os.path.join(current_dir, "user_specified_example.csv")
loader = dc.data.UserCSVLoader(
tasks=tasks, feature_field="smiles", featurizer=featurizer)
dataset = loader.create_dataset(input_file)
splitter = dc.splits.RandomSplitter()
train_dataset, test_dataset = splitter.train_test_split(dataset)
transformers = [
dc.trans.NormalizationTransformer(
transform_y=True, dataset=train_dataset)
]
for dataset in [train_dataset, test_dataset]:
for transformer in transformers:
dataset = transformer.transform(dataset)
regression_metrics = [
dc.metrics.Metric(dc.metrics.r2_score),
dc.metrics.Metric(dc.metrics.mean_squared_error),
dc.metrics.Metric(dc.metrics.mean_absolute_error)
]
sklearn_model = RandomForestRegressor()
model = dc.models.SklearnModel(sklearn_model)
# Fit trained model
model.fit(train_dataset)
model.save()
# Eval model on train/test
_ = model.evaluate(train_dataset, regression_metrics, transformers)
_ = model.evaluate(test_dataset, regression_metrics, transformers)
def test_singletask_sklearn_rf_RDKIT_descriptor_regression_API():
"""Test of singletask RF RDKIT-descriptor regression API."""
splittype = "scaffold"
featurizer = dc.feat.RDKitDescriptors()
tasks = ["log-solubility"]
current_dir = os.path.dirname(os.path.abspath(__file__))
input_file = os.path.join(current_dir, "example.csv")
loader = dc.data.CSVLoader(
tasks=tasks, feature_field="smiles", featurizer=featurizer)
dataset = loader.create_dataset(input_file)
splitter = dc.splits.ScaffoldSplitter()
train_dataset, test_dataset = splitter.train_test_split(dataset)
transformers = [
dc.trans.NormalizationTransformer(
transform_X=True, dataset=train_dataset),
dc.trans.ClippingTransformer(transform_X=True, dataset=train_dataset),
dc.trans.NormalizationTransformer(
transform_y=True, dataset=train_dataset)
]
for dataset in [train_dataset, test_dataset]:
for transformer in transformers:
dataset = transformer.transform(dataset)
regression_metrics = [
dc.metrics.Metric(dc.metrics.r2_score),
dc.metrics.Metric(dc.metrics.mean_squared_error),
dc.metrics.Metric(dc.metrics.mean_absolute_error)
]
sklearn_model = RandomForestRegressor()
model = dc.models.SklearnModel(sklearn_model)
# Fit trained model
model.fit(train_dataset)
model.save()
# Eval model on train/test
_ = model.evaluate(train_dataset, regression_metrics, transformers)
_ = model.evaluate(test_dataset, regression_metrics, transformers)
def test_singletask_mlp_ECFP_classification_API():
"""Test of singletask MLP classification API."""
np.random.seed(123)
X = np.random.rand(100, 5)
y = np.random.randint(2, size=(100,))
dataset = dc.data.NumpyDataset(X, y)
splitter = dc.splits.RandomSplitter()
train_dataset, test_dataset = splitter.train_test_split(dataset)
transformers = []
classification_metrics = [
dc.metrics.Metric(dc.metrics.roc_auc_score),
dc.metrics.Metric(dc.metrics.prc_auc_score),
dc.metrics.Metric(dc.metrics.matthews_corrcoef),
dc.metrics.Metric(dc.metrics.recall_score),
dc.metrics.Metric(dc.metrics.accuracy_score),
dc.metrics.Metric(dc.metrics.balanced_accuracy_score),
dc.metrics.Metric(dc.metrics.jaccard_score),
dc.metrics.Metric(dc.metrics.f1_score),
dc.metrics.Metric(dc.metrics.pixel_error),
dc.metrics.Metric(dc.metrics.kappa_score),
dc.metrics.Metric(dc.metrics.bedroc_score),
]
model = dc.models.MultitaskClassifier(1, 5)
# Fit trained model
model.fit(train_dataset)
# Eval model on train/test
_ = model.evaluate(train_dataset, classification_metrics, transformers)
_ = model.evaluate(test_dataset, classification_metrics, transformers)
| lilleswing/deepchem | deepchem/models/tests/test_api.py | Python | mit | 5,338 |
"""
WSGI config for todo_lab project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/1.8/howto/deployment/wsgi/
"""
import os
from django.core.wsgi import get_wsgi_application
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "todo_lab.settings")
application = get_wsgi_application()
| pauloromeira/todo_lab | todo_lab/wsgi.py | Python | mit | 393 |
from django.shortcuts import render
from django.views.generic import View
from django.contrib.auth.decorators import login_required
from django.core.urlresolvers import reverse
from django.http import HttpResponseRedirect, JsonResponse
from django.utils import timezone
from .forms import PhotoForm, DeleteForm
from .models import PhotoModel
import os
import shutil
from .effects import double, nigeria, france, usa, kenya, russia
from django.contrib import messages
# Mixins
class LoginRequiredMixin(object):
@classmethod
def as_view(cls, **initkwargs):
view = super(LoginRequiredMixin, cls).as_view(**initkwargs)
return login_required(view)
# helper functions
def get_photos(user):
'''returns all photos of a user'''
photos = PhotoModel.objects.filter(owner=user)
return photos
def create_duplicate_file(image_file_path, image_file_url):
'''creates a duplicate file for editting'''
# create temporary file path
root, ext = os.path.splitext(image_file_path)
root = root + '_temp'
temp_file_path = root + ext
# create temporary file url
root, ext = os.path.splitext(image_file_url)
root = root + '_temp'
temp_file_url = root + ext
# create a duplicate of the image file
shutil.copy2(image_file_path, temp_file_path)
return temp_file_path, temp_file_url
def photo_effect(effect, temp_file_path, temp_file_url):
'''applies a photo effect on a temporary file'''
if effect == 'double':
double(temp_file_path)
return_value = temp_file_url
elif effect == 'france':
france(temp_file_path)
return_value = temp_file_url
elif effect == 'kenya':
kenya(temp_file_path)
return_value = temp_file_url
elif effect == 'nigeria':
nigeria(temp_file_path)
return_value = temp_file_url
elif effect == 'russia':
russia(temp_file_path)
return_value = temp_file_url
elif effect == 'usa':
usa(temp_file_path)
return_value = temp_file_url
else:
return_value = None
return return_value
# Views
class HomePageView(View):
'''handles homepage requests'''
template_name = 'photo/index.html'
def get(self, request):
# redirect to user dashboard if user is logged in
if request.user and not request.user.is_anonymous:
return HttpResponseRedirect(reverse('photo:user_home'))
else:
return render(request, self.template_name)
class DashboardView(LoginRequiredMixin, View):
'''displays dashboard'''
template_name = 'photo/dashboard.html'
def get(self, request):
# get the user's social details
social_user = request.user.social_auth.filter(provider='facebook').first()
message = {}
# check if any photo is to be editted
staged_photo = None
if 'photo' in request.GET:
# get object of the photo to be editted
staged_photo = PhotoModel.objects.get(id=request.GET['photo'])
# set original image as image to be displayed
staged_photo.display_image = staged_photo.photo.url
if 'effect' in request.GET:
# create a temporary image to use for editting
staged_photo.temp_file_path, staged_photo.temp_file_url = create_duplicate_file(staged_photo.photo.path, staged_photo.photo.url)
staged_photo.temp_file_url = photo_effect(request.GET['effect'], staged_photo.temp_file_path, staged_photo.temp_file_url)
# set temporary image as image to be displayed
staged_photo.display_image = staged_photo.temp_file_url
message = {'staged_photo': staged_photo.display_image + '? %s' % (timezone.now())}
return JsonResponse(message)
photos = get_photos(request.user)
context = {'social_user': social_user,
'photos': photos,
'staged_photo': staged_photo}
return render(request, self.template_name, context)
class ImageUploadView(LoginRequiredMixin, View):
'''handles image upload'''
def post(self, request):
form = PhotoForm(request.POST, request.FILES)
if form.is_valid():
# set the current user as the owner of the photo before saving the photo
photo = form.save(commit=False)
photo.owner = request.user
photo.save()
return HttpResponseRedirect(reverse('photo:user_home'))
else:
message = 'Error! Both Photo Caption and Select Photo are required'
messages.add_message(request, messages.WARNING, message)
return HttpResponseRedirect(reverse('photo:user_home'))
class DeleteImageView(LoginRequiredMixin, View):
''' handle deletion of images'''
def post(self, request):
form = DeleteForm(request.POST)
if form.is_valid():
photo_id = request.POST['photo_id']
original_photo_path = request.POST['orig']
temporary_photo_path = request.POST['temp']
# delete image from database
photo = PhotoModel.objects.get(pk=photo_id)
photo.delete()
# delete original and temporary images
os.remove(original_photo_path)
# first check if a temporary image exists
if temporary_photo_path != 'None':
os.remove(temporary_photo_path)
message = {'content': 'Photo was deleted successfully', 'status': True}
return JsonResponse(message)
else:
message = {'content': 'Error deleting file', 'status': False}
return JsonResponse(message)
| andela-tadesanya/django-photo-application | django_photo/photo/views.py | Python | mit | 5,672 |
"""Review Board feature checkers."""
from __future__ import unicode_literals
from djblets.features.checkers import SiteConfigFeatureChecker
class RBFeatureChecker(SiteConfigFeatureChecker):
"""Feature checker that checks against a LocalSite's configuration.
Features can be enabled/disabled on a per-LocalSite basis by setting
the specified feature ID to either ``True`` or ``False`` in the
``enabled_features`` key in that LocalSite's
:py:attr:`~reviewboard.sites.models.LocalSite.extra_data`` field.
If the key is absent, this checker will check against the site
configuration (and then the Django settings) to see if it is enabled or
disabled globally.
"""
EXTRA_DATA_KEY = SiteConfigFeatureChecker.siteconfig_key
def is_feature_enabled(self, feature_id, **kwargs):
"""Return whether a feature is enabled for a given ID.
Args:
feature_id (unicode):
The unique identifier of the feature whose status is to be
determined.
**kwargs (dict):
Additional keyword arguments.
Keyword Args:
request (django.http.HttpRequest):
An optional request. If this request is made against a
LocalSite, that LocalSite will be used to look up the feature.
Either this argument or ``local_site`` must be provided to
enable checking against a LocalSite.
local_site (reviewboard.site.models.LocalSite):
An optional local site. If provided, this LocalSite will be
used to look up the status of the requested feature.
Either this argument or ``request`` must be provided to enable
checking against a LocalSite.
Returns:
bool:
Whether or not the feature is enabled.
"""
local_site = kwargs.get('local_site')
request = kwargs.get('request')
if (local_site is None and
request is not None and
hasattr(request, 'local_site')):
local_site = request.local_site
if local_site and local_site.extra_data:
try:
return local_site.extra_data[self.EXTRA_DATA_KEY][feature_id]
except KeyError:
pass
return super(RBFeatureChecker, self).is_feature_enabled(feature_id,
**kwargs)
| brennie/reviewboard | reviewboard/features/checkers.py | Python | mit | 2,485 |
from numpy import array
from numpy import *
import knn
import matplotlib.pyplot as plot
datingMat, datingLabels = knn.readDataFile("../inaction/Ch02/datingTestSet2.txt")
fig = plot.figure()
ax = fig.add_subplot(111)
datingMat2 = {}
handles = []
distinctLabels = []
size = len(datingLabels)
for index in range(size):
label = datingLabels[index];
labelMatrix = datingMat2.get(label);
if labelMatrix is None :
labelMatrix = []
datingMat2[label] = labelMatrix
labelMatrix.append(datingMat[index, :])
a=mat(datingMat2.get(1))
b=mat(datingMat2.get(2))
c=mat(datingMat2.get(3))
print a[:,1][0]
print b[:,1][0]
print c[:,1][0]
handles.append(ax.scatter(a[:, 0], a[:, 1], tile(15,(a.shape[0])), tile(15,(a.shape[0]))))
handles.append(ax.scatter(b[:, 0], b[:, 1], tile(20,(b.shape[0])), tile(20,(b.shape[0]))))
handles.append(ax.scatter(c[:, 0], c[:, 1], tile(30,(c.shape[0])), tile(30,(c.shape[0]))))
#ax.axis([0, 100000, -2, 25])
#ax.axis([0, 100000, -2, 25])
#ax.axis([0, 100000, -2, 25])
plot.ylabel('Percentage of Time Spent Playing Video Games')
plot.xlabel('Liters of Ice Cream Consumed Per Week')
plot.legend(handles, ["I do not like it", "b", "c"])
plot.show()
| lxzhu/ehow | src/testFirstPlot.py | Python | mit | 1,200 |
import bpy
import copy # オブジェクトをコピーするためのモジュールcopyをインポート
def move(box,l,stack,s,t): # 図形をコピーして移動する操作
box_2 =copy.deepcopy(box) # boxをbox_2にコピー
n=len(box_2)
for i in range(n):
for j in range(8):
box_2[i][j][s]+=l # s方向に l だけ移動
box_2[i][j][t]+=l # t方向に l だけ移動
stack.extend(box_2) # スタックにコピー
########################################
# 立方体の頂点座標と辺・頂点の接続関係
verts=[[[0,0,0], [1,0,0], [1,1,0], [0,1,0],
[0,0,1], [1,0,1], [1,1,1], [0,1,1]]]
faces=[[0, 1, 2, 3], [4, 5, 6, 7], [0, 4, 5, 1],
[1, 2, 6, 5], [3, 2, 6, 7], [0, 3, 7, 4]]
stack=[] # 立方体を保存するためのスタックの初期化
l=1 # 立方体を移動する量の初期値
########################################
#フラクタル図形の生成，初期値では3回繰り返し
for i in range(3):
move(verts,l,stack,1,2)
move(verts,l,stack,0,1)
move(verts,l,stack,0,2)
verts.extend(stack)
stack=[]
l=l*2
# 変数の初期化
m_d=[]
c_m_d=[]
c_o=[]
C_O=[]
n=len(verts)
#blnder上に図形を描画するための設定
for i in range(n):
m_d.append("mesh_data_"+str(i))
c_m_d.append("cube_mesh_data_"+str(i))
c_o.append("cube_object"+str(i))
C_O.append("Cube_Object"+str(i))
m_d[i] = bpy.data.meshes.new(c_m_d[i])
m_d[i].from_pydata(verts[i], [], faces)
m_d[i].update()
c_o[i] = bpy.data.objects.new(C_O[i], m_d[i])
scene = bpy.context.scene
for i in range(n):
scene.objects.link(c_o[i]) | o-kei/design-computing-aij | ch2_5/blender04.py | Python | mit | 1,701 |
from maka.data.Field import String
from maka.data.Observation import Observation
from FieldTests import FieldTests, fieldTestClass
@fieldTestClass
class StringFieldTests(FieldTests):
fieldClass = String
validValue = 'bobo'
invalidValue = 0
defaultTypeName = 'string'
def testStringFieldWithRestrictedValues(self):
class Obs(Observation):
s = String(values=['One', 'Two'])
self.assertEqual(Obs.s.range, '{"One", "Two"}')
obs = Obs()
self.assertIsNone(obs.s)
obs.s = 'One'
self.assertEqual(obs.s, 'One')
self._assertRaises(ValueError, setattr, obs, 's', 'Three')
def testValueTypeError(self):
self._assertRaises(TypeError, String, **{'values': ['One', 2]})
def testDefaultTypeError(self):
self._assertRaises(ValueError, String, **{'values': ['One', 'Two'], 'default': 'Three'})
def testTranslations(self):
class TranslatedString(String):
TRANSLATIONS = {'1': 'one', '2': 'two'}
class Obs(Observation):
s = String(translations={'0': 'zero', '1': 'one'})
t = TranslatedString
obs = Obs()
obs.s = '0'
self.assertEqual(obs.s, 'zero')
obs.s = '1'
self.assertEqual(obs.s, 'one')
obs.s = '2'
self.assertEqual(obs.s, '2')
obs.t = '0'
self.assertEqual(obs.t, '0')
obs.t = '1'
self.assertEqual(obs.t, 'one')
obs.t = '2'
self.assertEqual(obs.t, 'two')
obs = Obs(s='0', t='0')
self.assertEqual(obs.s, 'zero')
self.assertEqual(obs.t, '0')
def testTranslationValueError(self):
self._assertRaises(ValueError, String, **{'values': ['One'], 'translations': {'2': 'Two'}})
| HaroldMills/Maka | test/StringFieldTests.py | Python | mit | 2,021 |
# coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for
# license information.
#
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is
# regenerated.
# --------------------------------------------------------------------------
from msrest.serialization import Model
class NameIdentifier(Model):
"""Identifies an object.
:param name: Name of the object.
:type name: str
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
}
def __init__(self, name=None):
super(NameIdentifier, self).__init__()
self.name = name
| lmazuel/azure-sdk-for-python | azure-mgmt-web/azure/mgmt/web/models/name_identifier.py | Python | mit | 825 |
#!/usr/bin/env python3
# Copyright (c) 2015-2019 The Bitcoin Core developers
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
"""Test decoding scripts via decodescript RPC command."""
from test_framework.messages import CTransaction, sha256
from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import assert_equal, hex_str_to_bytes
from io import BytesIO
class DecodeScriptTest(BitcoinTestFramework):
def set_test_params(self):
self.setup_clean_chain = True
self.num_nodes = 1
def decodescript_script_sig(self):
signature = '304502207fa7a6d1e0ee81132a269ad84e68d695483745cde8b541e3bf630749894e342a022100c1f7ab20e13e22fb95281a870f3dcf38d782e53023ee313d741ad0cfbc0c509001'
push_signature = '48' + signature
public_key = '03b0da749730dc9b4b1f4a14d6902877a92541f5368778853d9c4a0cb7802dcfb2'
push_public_key = '21' + public_key
# below are test cases for all of the standard transaction types
# 1) P2PK scriptSig
# the scriptSig of a public key scriptPubKey simply pushes a signature onto the stack
rpc_result = self.nodes[0].decodescript(push_signature)
assert_equal(signature, rpc_result['asm'])
# 2) P2PKH scriptSig
rpc_result = self.nodes[0].decodescript(push_signature + push_public_key)
assert_equal(signature + ' ' + public_key, rpc_result['asm'])
# 3) multisig scriptSig
# this also tests the leading portion of a P2SH multisig scriptSig
# OP_0 <A sig> <B sig>
rpc_result = self.nodes[0].decodescript('00' + push_signature + push_signature)
assert_equal('0 ' + signature + ' ' + signature, rpc_result['asm'])
# 4) P2SH scriptSig
# an empty P2SH redeemScript is valid and makes for a very simple test case.
# thus, such a spending scriptSig would just need to pass the outer redeemScript
# hash test and leave true on the top of the stack.
rpc_result = self.nodes[0].decodescript('5100')
assert_equal('OP_NAME_NEW 0', rpc_result['asm'])
# 5) null data scriptSig - no such thing because null data scripts can not be spent.
# thus, no test case for that standard transaction type is here.
def decodescript_script_pub_key(self):
public_key = '03b0da749730dc9b4b1f4a14d6902877a92541f5368778853d9c4a0cb7802dcfb2'
push_public_key = '21' + public_key
public_key_hash = '5dd1d3a048119c27b28293056724d9522f26d945'
push_public_key_hash = '14' + public_key_hash
uncompressed_public_key = '04b0da749730dc9b4b1f4a14d6902877a92541f5368778853d9c4a0cb7802dcfb25e01fc8fde47c96c98a4f3a8123e33a38a50cf9025cc8c4494a518f991792bb7'
push_uncompressed_public_key = '41' + uncompressed_public_key
p2wsh_p2pk_script_hash = 'd8590cf8ea0674cf3d49fd7ca249b85ef7485dea62c138468bddeb20cd6519f7'
# below are test cases for all of the standard transaction types
# 1) P2PK scriptPubKey
# <pubkey> OP_CHECKSIG
rpc_result = self.nodes[0].decodescript(push_public_key + 'ac')
assert_equal(public_key + ' OP_CHECKSIG', rpc_result['asm'])
# P2PK is translated to P2WPKH
assert_equal('0 ' + public_key_hash, rpc_result['segwit']['asm'])
# 2) P2PKH scriptPubKey
# OP_DUP OP_HASH160 <PubKeyHash> OP_EQUALVERIFY OP_CHECKSIG
rpc_result = self.nodes[0].decodescript('76a9' + push_public_key_hash + '88ac')
assert_equal('OP_DUP OP_HASH160 ' + public_key_hash + ' OP_EQUALVERIFY OP_CHECKSIG', rpc_result['asm'])
# P2PKH is translated to P2WPKH
assert_equal('0 ' + public_key_hash, rpc_result['segwit']['asm'])
# 3) multisig scriptPubKey
# <m> <A pubkey> <B pubkey> <C pubkey> <n> OP_CHECKMULTISIG
# just imagine that the pub keys used below are different.
# for our purposes here it does not matter that they are the same even though it is unrealistic.
multisig_script = '52' + push_public_key + push_public_key + push_public_key + '53ae'
rpc_result = self.nodes[0].decodescript(multisig_script)
assert_equal('OP_NAME_FIRSTUPDATE ' + public_key + ' ' + public_key + ' ' + public_key + ' OP_NAME_UPDATE OP_CHECKMULTISIG', rpc_result['asm'])
# multisig in P2WSH
multisig_script_hash = sha256(hex_str_to_bytes(multisig_script)).hex()
assert_equal('0 ' + multisig_script_hash, rpc_result['segwit']['asm'])
# 4) P2SH scriptPubKey
# OP_HASH160 <Hash160(redeemScript)> OP_EQUAL.
# push_public_key_hash here should actually be the hash of a redeem script.
# but this works the same for purposes of this test.
rpc_result = self.nodes[0].decodescript('a9' + push_public_key_hash + '87')
assert_equal('OP_HASH160 ' + public_key_hash + ' OP_EQUAL', rpc_result['asm'])
# P2SH does not work in segwit secripts. decodescript should not return a result for it.
assert 'segwit' not in rpc_result
# 5) null data scriptPubKey
# use a signature look-alike here to make sure that we do not decode random data as a signature.
# this matters if/when signature sighash decoding comes along.
# would want to make sure that no such decoding takes place in this case.
signature_imposter = '48304502207fa7a6d1e0ee81132a269ad84e68d695483745cde8b541e3bf630749894e342a022100c1f7ab20e13e22fb95281a870f3dcf38d782e53023ee313d741ad0cfbc0c509001'
# OP_RETURN <data>
rpc_result = self.nodes[0].decodescript('6a' + signature_imposter)
assert_equal('OP_RETURN ' + signature_imposter[2:], rpc_result['asm'])
# 6) a CLTV redeem script. redeem scripts are in-effect scriptPubKey scripts, so adding a test here.
# OP_NOP2 is also known as OP_CHECKLOCKTIMEVERIFY.
# just imagine that the pub keys used below are different.
# for our purposes here it does not matter that they are the same even though it is unrealistic.
#
# OP_IF
# <receiver-pubkey> OP_CHECKSIGVERIFY
# OP_ELSE
# <lock-until> OP_CHECKLOCKTIMEVERIFY OP_DROP
# OP_ENDIF
# <sender-pubkey> OP_CHECKSIG
#
# lock until block 500,000
cltv_script = '63' + push_public_key + 'ad670320a107b17568' + push_public_key + 'ac'
rpc_result = self.nodes[0].decodescript(cltv_script)
assert_equal('OP_IF ' + public_key + ' OP_CHECKSIGVERIFY OP_ELSE 500000 OP_CHECKLOCKTIMEVERIFY OP_DROP OP_ENDIF ' + public_key + ' OP_CHECKSIG', rpc_result['asm'])
# CLTV script in P2WSH
cltv_script_hash = sha256(hex_str_to_bytes(cltv_script)).hex()
assert_equal('0 ' + cltv_script_hash, rpc_result['segwit']['asm'])
# 7) P2PK scriptPubKey
# <pubkey> OP_CHECKSIG
rpc_result = self.nodes[0].decodescript(push_uncompressed_public_key + 'ac')
assert_equal(uncompressed_public_key + ' OP_CHECKSIG', rpc_result['asm'])
# uncompressed pubkeys are invalid for checksigs in segwit scripts.
# decodescript should not return a P2WPKH equivalent.
assert 'segwit' not in rpc_result
# 8) multisig scriptPubKey with an uncompressed pubkey
# <m> <A pubkey> <B pubkey> <n> OP_CHECKMULTISIG
# just imagine that the pub keys used below are different.
# the purpose of this test is to check that a segwit script is not returned for bare multisig scripts
# with an uncompressed pubkey in them.
rpc_result = self.nodes[0].decodescript('52' + push_public_key + push_uncompressed_public_key +'52ae')
assert_equal('OP_NAME_FIRSTUPDATE ' + public_key + ' ' + uncompressed_public_key + ' OP_NAME_FIRSTUPDATE OP_CHECKMULTISIG', rpc_result['asm'])
# uncompressed pubkeys are invalid for checksigs in segwit scripts.
# decodescript should not return a P2WPKH equivalent.
assert 'segwit' not in rpc_result
# 9) P2WPKH scriptpubkey
# 0 <PubKeyHash>
rpc_result = self.nodes[0].decodescript('00' + push_public_key_hash)
assert_equal('0 ' + public_key_hash, rpc_result['asm'])
# segwit scripts do not work nested into each other.
# a nested segwit script should not be returned in the results.
assert 'segwit' not in rpc_result
# 10) P2WSH scriptpubkey
# 0 <ScriptHash>
# even though this hash is of a P2PK script which is better used as bare P2WPKH, it should not matter
# for the purpose of this test.
rpc_result = self.nodes[0].decodescript('0020' + p2wsh_p2pk_script_hash)
assert_equal('0 ' + p2wsh_p2pk_script_hash, rpc_result['asm'])
# segwit scripts do not work nested into each other.
# a nested segwit script should not be returned in the results.
assert 'segwit' not in rpc_result
def decoderawtransaction_asm_sighashtype(self):
"""Test decoding scripts via RPC command "decoderawtransaction".
This test is in with the "decodescript" tests because they are testing the same "asm" script decodes.
"""
# this test case uses a random plain vanilla mainnet transaction with a single P2PKH input and output
tx = '0100000001696a20784a2c70143f634e95227dbdfdf0ecd51647052e70854512235f5986ca010000008a47304402207174775824bec6c2700023309a168231ec80b82c6069282f5133e6f11cbb04460220570edc55c7c5da2ca687ebd0372d3546ebc3f810516a002350cac72dfe192dfb014104d3f898e6487787910a690410b7a917ef198905c27fb9d3b0a42da12aceae0544fc7088d239d9a48f2828a15a09e84043001f27cc80d162cb95404e1210161536ffffffff0100e1f505000000001976a914eb6c6e0cdb2d256a32d97b8df1fc75d1920d9bca88ac00000000'
rpc_result = self.nodes[0].decoderawtransaction(tx)
assert_equal('304402207174775824bec6c2700023309a168231ec80b82c6069282f5133e6f11cbb04460220570edc55c7c5da2ca687ebd0372d3546ebc3f810516a002350cac72dfe192dfb[ALL] 04d3f898e6487787910a690410b7a917ef198905c27fb9d3b0a42da12aceae0544fc7088d239d9a48f2828a15a09e84043001f27cc80d162cb95404e1210161536', rpc_result['vin'][0]['scriptSig']['asm'])
# this test case uses a mainnet transaction that has a P2SH input and both P2PKH and P2SH outputs.
# it's from James D'Angelo's awesome introductory videos about multisig: https://www.youtube.com/watch?v=zIbUSaZBJgU and https://www.youtube.com/watch?v=OSA1pwlaypc
# verify that we have not altered scriptPubKey decoding.
tx = '01000000018d1f5635abd06e2c7e2ddf58dc85b3de111e4ad6e0ab51bb0dcf5e84126d927300000000fdfe0000483045022100ae3b4e589dfc9d48cb82d41008dc5fa6a86f94d5c54f9935531924602730ab8002202f88cf464414c4ed9fa11b773c5ee944f66e9b05cc1e51d97abc22ce098937ea01483045022100b44883be035600e9328a01b66c7d8439b74db64187e76b99a68f7893b701d5380220225bf286493e4c4adcf928c40f785422572eb232f84a0b83b0dea823c3a19c75014c695221020743d44be989540d27b1b4bbbcfd17721c337cb6bc9af20eb8a32520b393532f2102c0120a1dda9e51a938d39ddd9fe0ebc45ea97e1d27a7cbd671d5431416d3dd87210213820eb3d5f509d7438c9eeecb4157b2f595105e7cd564b3cdbb9ead3da41eed53aeffffffff02611e0000000000001976a914dc863734a218bfe83ef770ee9d41a27f824a6e5688acee2a02000000000017a9142a5edea39971049a540474c6a99edf0aa4074c588700000000'
rpc_result = self.nodes[0].decoderawtransaction(tx)
assert_equal('8e3730608c3b0bb5df54f09076e196bc292a8e39a78e73b44b6ba08c78f5cbb0', rpc_result['txid'])
assert_equal('0 3045022100ae3b4e589dfc9d48cb82d41008dc5fa6a86f94d5c54f9935531924602730ab8002202f88cf464414c4ed9fa11b773c5ee944f66e9b05cc1e51d97abc22ce098937ea[ALL] 3045022100b44883be035600e9328a01b66c7d8439b74db64187e76b99a68f7893b701d5380220225bf286493e4c4adcf928c40f785422572eb232f84a0b83b0dea823c3a19c75[ALL] 5221020743d44be989540d27b1b4bbbcfd17721c337cb6bc9af20eb8a32520b393532f2102c0120a1dda9e51a938d39ddd9fe0ebc45ea97e1d27a7cbd671d5431416d3dd87210213820eb3d5f509d7438c9eeecb4157b2f595105e7cd564b3cdbb9ead3da41eed53ae', rpc_result['vin'][0]['scriptSig']['asm'])
assert_equal('OP_DUP OP_HASH160 dc863734a218bfe83ef770ee9d41a27f824a6e56 OP_EQUALVERIFY OP_CHECKSIG', rpc_result['vout'][0]['scriptPubKey']['asm'])
assert_equal('OP_HASH160 2a5edea39971049a540474c6a99edf0aa4074c58 OP_EQUAL', rpc_result['vout'][1]['scriptPubKey']['asm'])
txSave = CTransaction()
txSave.deserialize(BytesIO(hex_str_to_bytes(tx)))
# make sure that a specifically crafted op_return value will not pass all the IsDERSignature checks and then get decoded as a sighash type
tx = '01000000015ded05872fdbda629c7d3d02b194763ce3b9b1535ea884e3c8e765d42e316724020000006b48304502204c10d4064885c42638cbff3585915b322de33762598321145ba033fc796971e2022100bb153ad3baa8b757e30a2175bd32852d2e1cb9080f84d7e32fcdfd667934ef1b012103163c0ff73511ea1743fb5b98384a2ff09dd06949488028fd819f4d83f56264efffffffff0200000000000000000b6a0930060201000201000180380100000000001976a9141cabd296e753837c086da7a45a6c2fe0d49d7b7b88ac00000000'
rpc_result = self.nodes[0].decoderawtransaction(tx)
assert_equal('OP_RETURN 300602010002010001', rpc_result['vout'][0]['scriptPubKey']['asm'])
# verify that we have not altered scriptPubKey processing even of a specially crafted P2PKH pubkeyhash and P2SH redeem script hash that is made to pass the der signature checks
tx = '01000000018d1f5635abd06e2c7e2ddf58dc85b3de111e4ad6e0ab51bb0dcf5e84126d927300000000fdfe0000483045022100ae3b4e589dfc9d48cb82d41008dc5fa6a86f94d5c54f9935531924602730ab8002202f88cf464414c4ed9fa11b773c5ee944f66e9b05cc1e51d97abc22ce098937ea01483045022100b44883be035600e9328a01b66c7d8439b74db64187e76b99a68f7893b701d5380220225bf286493e4c4adcf928c40f785422572eb232f84a0b83b0dea823c3a19c75014c695221020743d44be989540d27b1b4bbbcfd17721c337cb6bc9af20eb8a32520b393532f2102c0120a1dda9e51a938d39ddd9fe0ebc45ea97e1d27a7cbd671d5431416d3dd87210213820eb3d5f509d7438c9eeecb4157b2f595105e7cd564b3cdbb9ead3da41eed53aeffffffff02611e0000000000001976a914301102070101010101010102060101010101010188acee2a02000000000017a91430110207010101010101010206010101010101018700000000'
rpc_result = self.nodes[0].decoderawtransaction(tx)
assert_equal('OP_DUP OP_HASH160 3011020701010101010101020601010101010101 OP_EQUALVERIFY OP_CHECKSIG', rpc_result['vout'][0]['scriptPubKey']['asm'])
assert_equal('OP_HASH160 3011020701010101010101020601010101010101 OP_EQUAL', rpc_result['vout'][1]['scriptPubKey']['asm'])
# verify that names shorter than 5 bytes aren't interpreted into asm as integers (issue #140)
tx = '0071000002c323b5df3dbd501ef8e26683749fd13f785eac6d4f4c2083196a33262605e6ec010000008b48304502207cc397996cf41a4be7ce229226c2e3862557256e372dd325dfefaba26a4a44a20221008e71fc315563d04d7d92d6e2b0ef9c5e095df50777664819623156dcf3ec1c1e0141045bc24b6e33ecbe341e8195b4e8fcb3f8c7937ca6f671f799644968dc00e82d0160c5e14b687cba83840381dda04711939a225588eb0e2401d4f14dc9d3a5ccdaffffffff882be8eb700e1c6eaef2682839293ae9d5bfacf82cee80510d4dee6eed359c98000000004847304402206c6115eb47b4f3010a6c0e79ea5ee7f036fc1da22af172c4bd39a460758bb34402204cc40302837a3a61d9b1e12a99e73572f95da7b5005e5ce842a7b8b4ba90d7f901ffffffff02e007646300000000434104fb090d04c8f110012a9f4545b6cb1f93a6f22db1b35bef7e1545a4a0aef0124cd25c522851ba2120f12b124785adc6f09b13f8eaa294cfe54a601dc75f11df29ac40420f00000000005a5303662f6a394269746d65737361676520616464726573733a20424d2d3263554755687335436a6973526975514756574447334a514a47717a5967713134356d7576a9147368feca713f2a9d7780343b74007e26a4fcfcea88ac00000000'
rpc_result = self.nodes[0].decoderawtransaction(tx)
assert_equal('OP_NAME_UPDATE 662f6a 4269746d65737361676520616464726573733a20424d2d3263554755687335436a6973526975514756574447334a514a47717a596771313435 OP_2DROP OP_DROP OP_DUP OP_HASH160 7368feca713f2a9d7780343b74007e26a4fcfcea OP_EQUALVERIFY OP_CHECKSIG', rpc_result['vout'][1]['scriptPubKey']['asm'])
# some more full transaction tests of varying specific scriptSigs. used instead of
# tests in decodescript_script_sig because the decodescript RPC is specifically
# for working on scriptPubKeys (argh!).
push_signature = txSave.vin[0].scriptSig.hex()[2:(0x48*2+4)]
signature = push_signature[2:]
der_signature = signature[:-2]
signature_sighash_decoded = der_signature + '[ALL]'
signature_2 = der_signature + '82'
push_signature_2 = '48' + signature_2
signature_2_sighash_decoded = der_signature + '[NONE|ANYONECANPAY]'
# 1) P2PK scriptSig
txSave.vin[0].scriptSig = hex_str_to_bytes(push_signature)
rpc_result = self.nodes[0].decoderawtransaction(txSave.serialize().hex())
assert_equal(signature_sighash_decoded, rpc_result['vin'][0]['scriptSig']['asm'])
# make sure that the sighash decodes come out correctly for a more complex / lesser used case.
txSave.vin[0].scriptSig = hex_str_to_bytes(push_signature_2)
rpc_result = self.nodes[0].decoderawtransaction(txSave.serialize().hex())
assert_equal(signature_2_sighash_decoded, rpc_result['vin'][0]['scriptSig']['asm'])
# 2) multisig scriptSig
txSave.vin[0].scriptSig = hex_str_to_bytes('00' + push_signature + push_signature_2)
rpc_result = self.nodes[0].decoderawtransaction(txSave.serialize().hex())
assert_equal('0 ' + signature_sighash_decoded + ' ' + signature_2_sighash_decoded, rpc_result['vin'][0]['scriptSig']['asm'])
# 3) test a scriptSig that contains more than push operations.
# in fact, it contains an OP_RETURN with data specially crafted to cause improper decode if the code does not catch it.
txSave.vin[0].scriptSig = hex_str_to_bytes('6a143011020701010101010101020601010101010101')
rpc_result = self.nodes[0].decoderawtransaction(txSave.serialize().hex())
assert_equal('OP_RETURN 3011020701010101010101020601010101010101', rpc_result['vin'][0]['scriptSig']['asm'])
def run_test(self):
self.decodescript_script_sig()
self.decodescript_script_pub_key()
self.decoderawtransaction_asm_sighashtype()
if __name__ == '__main__':
DecodeScriptTest().main()
| namecoin/namecore | test/functional/rpc_decodescript.py | Python | mit | 18,174 |
# -*- coding: utf-8 -*-
"""
Zipline bundle for Poloniex exchange
"""
import logging
from datetime import time, timedelta, datetime
from pytz import timezone
import numpy as np
import pandas as pd
from pandas.tseries.offsets import CustomBusinessDay
from zipline.utils.calendars import (
TradingCalendar, register_calendar, register_calendar_alias,
deregister_calendar)
from zipline.data.bundles import register
from zipline.utils.memoize import lazyval
from .api import get_currencies, get_trade_hist_alias
__author__ = "Florian Wilhelm"
__copyright__ = "Florian Wilhelm"
__license__ = "mit"
_logger = logging.getLogger(__name__)
class Pairs(object):
"""Record object holding most common US-$ / crypto-currency pairs
"""
usdt_btc = 'USDT_BTC'
usdt_bch = 'USDT_BCH'
usdt_eth = 'USDT_ETH'
usdt_dash = 'USDT_DASH'
usdt_etc = 'USDT_ETC'
usdt_xmr = 'USDT_XMR'
usdt_zec = 'USDT_ZEC'
usdt_xrp = 'USDT_XRP'
usdt_ltc = 'USDT_LTC'
usdt_rep = 'USDT_REP'
usdt_nxt = 'USDT_NXT'
usdt_str = 'USDT_STR'
def fetch_assets(asset_pairs):
"""Fetch given asset pairs
Args:
asset_pairs (list): list of asset pairs
Returns:
pandas.DataFrame: dataframe of asset pairs
"""
asset_pair_map = {pair.split("_")[1]: pair for pair in asset_pairs}
all_assets = get_currencies()
asset_df = all_assets.ix[asset_pair_map.keys()].reset_index()
asset_df = asset_df[['index', 'name']].rename(
columns={'index': 'symbol', 'name': 'asset_name'})
asset_df['exchange'] = 'Poloniex' # needed despite documented as optional
return asset_df
def make_candle_stick(trades, freq='1T'):
"""Make a candle stick like chart
Check [1] for resample rules:
[1]: http://pandas.pydata.org/pandas-docs/stable/timeseries.html#offset-aliases
Args:
trades (pandas.DataFrame): dataframe containing trades
freq (str): frequency for resampling (default 1 minute)
Returns:
pandas.DataFrame: chart data
"""
volume = trades['amount'].resample(freq).sum()
volume = volume.fillna(0)
high = trades['rate'].resample(freq).max()
low = trades['rate'].resample(freq).min()
open = trades['rate'].resample(freq).first()
close = trades['rate'].resample(freq).last()
return pd.DataFrame(
dict(open=open, high=high, low=low, close=close, volume=volume))
def fetch_trades(asset_pair, start, end):
"""Helper function to fetch trades for a single asset pair
Does all necessary conversions, sets `date` as index and assures
that `start` and `end` are in the index.
Args:
asset_pair: name of the asset pair
start (pandas.Timestamp): start of period
end (pandas.Timestamp): end of period
Returns:
pandas.DataFrame: dataframe containing trades of asset
"""
df = get_trade_hist_alias(asset_pair, start, end)
df['date'] = df['date'].apply(lambda x: datetime.strptime(
x, '%Y-%m-%d %H:%M:%S').replace(tzinfo=timezone('UTC')))
for col in ('total', 'rate', 'amount'):
df[col] = df[col].astype(np.float32)
df = df.set_index('date')
if start not in df.index:
df.loc[start] = np.nan
if end not in df.index:
df.loc[end] = np.nan
return df
def prepare_data(start, end, sid_map, cache):
"""Retrieve and prepare trade data for ingestion
Args:
start (pandas.Timestamp): start of period
end (pandas.Timestamp): end of period
sid_map (dict): mapping from symbol id to asset pair name
cache: cache object as provided by zipline
Returns:
generator of symbol id and dataframe tuples
"""
def get_key(sid, day):
return "{}_{}".format(sid, day.strftime("%Y-%m-%d"))
for sid, asset_pair in sid_map.items():
for start_day in pd.date_range(start, end, freq='D', closed='left', tz='utc'):
key = get_key(sid, start_day)
if key not in cache:
end_day = start_day + timedelta(days=1, seconds=-1)
trades = fetch_trades(asset_pair, start_day, end_day)
cache[key] = make_candle_stick(trades)
_logger.debug("Fetched trades from {} to {}".format(start_day, end_day))
yield sid, cache[key]
def create_bundle(asset_pairs, start=None, end=None):
"""Create a bundle ingest function
Args:
asset_pairs (list): list of asset pairs
start (pandas.Timestamp): start of trading period
end (pandas.Timestamp): end of trading period
Returns:
ingest function needed by zipline's register.
"""
def ingest(environ,
asset_db_writer,
minute_bar_writer,
daily_bar_writer,
adjustment_writer,
calendar,
start_session,
end_session,
cache,
show_progress,
output_dir,
# pass these as defaults to make them 'nonlocal' in py2
start=start,
end=end):
if start is None:
start = start_session
if end is None:
end = end_session
adjustment_writer.write()
asset_df = fetch_assets(asset_pairs)
asset_db_writer.write(equities=asset_df)
# generate the mapping between sid and symbol name
asset_map = asset_df['symbol'].to_dict()
asset_pair_map = {pair.split("_")[1]: pair for pair in asset_pairs}
sid_map = {k: asset_pair_map[v] for k, v in asset_map.items()}
data = prepare_data(start, end, sid_map, cache)
minute_bar_writer.write(data, show_progress=show_progress)
return ingest
class PoloniexCalendar(TradingCalendar):
"""Trading Calender of Poloniex Exchange
"""
@property
def name(self):
return "POLONIEX"
@property
def tz(self):
return timezone('UTC')
@property
def open_times(self):
return ((None, time(0, 0)),)
@property
def close_times(self):
return ((None, time(23, 59)),)
@lazyval
def day(self):
return CustomBusinessDay(
weekmask='Mon Tue Wed Thu Fri Sat Sun'
)
register_calendar('POLONIEX', PoloniexCalendar())
# The following is necessary because zipline's developer hard-coded NYSE
# everywhere in run_algo._run, *DOH*!!!
deregister_calendar('NYSE')
register_calendar_alias('NYSE', 'POLONIEX', force=False)
register(
'.test_poloniex',
create_bundle(
[Pairs.usdt_eth],
pd.Timestamp('2016-01-01', tz='utc'),
pd.Timestamp('2016-01-31', tz='utc'),
),
calendar_name='POLONIEX',
minutes_per_day=24*60
)
| FlorianWilhelm/zipline-poloniex | zipline_poloniex/bundle.py | Python | mit | 6,718 |
import datetime
import numpy as np
from hyperopt import hp, fmin, tpe
import os
import sys
from sklearn.ensemble import RandomForestClassifier
sys.path.insert(0, os.getcwd())
import qml_workdir.classes.config
from qml.cv import QCV
from qml.models import QXgb, QXgb2, QNN1, QNN2
from qml_workdir.classes.models import qm
if __name__ == "__main__":
CV_SCORE_TO_STOP = 0.548
DATAS = [266, 269]
EVALS_ROUNDS = 4000
rounds = EVALS_ROUNDS
cv = QCV(qm)
counter = 0
def fn(params):
global counter
counter +=1
params['epochs'] = int(1.3 ** params['epochs'])
model_id = qm.add_by_params(
QNN2(
middle_dim=int(params['middle_dim']),
epochs=int(params['epochs'])
),
'hyperopt nn1'
)
res = cv.cross_val(model_id, params['data_id'], seed=1000, early_stop_cv=lambda x: x>CV_SCORE_TO_STOP)
res = np.float64(res)
res_arr = [res]
# if res < CV_SCORE_TO_STOP:
# for i in range(7):
# res = cv.cross_val(model_id, data_id, seed=1001 + i, force=True)
# res = np.float64(res)
# res_arr.append(res)
print(params['data_id'], model_id, "{}/{}".format(counter, rounds), res_arr, datetime.datetime.now(), params)
return np.mean(res_arr)
space = {
'middle_dim': hp.quniform('middle_dim', 50, 250, 1),
'epochs': hp.quniform('epochs', 18, 23, 1),
}
counter = 0
space['data_id'] = hp.choice('data_id', DATAS)
rounds = EVALS_ROUNDS
fmin(fn, space, algo=tpe.suggest, max_evals=rounds)
| quantum13/mlbootcamp5 | qml_workdir/ensembling/level1_models_nn02.py | Python | mit | 1,653 |
#!/usr/bin/python
# ex:set fileencoding=utf-8:
from __future__ import unicode_literals
from django.apps import AppConfig
class Config(AppConfig):
name = 'useraccounts'
label = 'useraccounts'
verbose_name = "Accounts"
| glomium/elmnt.de | useraccounts/apps.py | Python | mit | 233 |
import contextlib
import io
import re
import os
import subprocess
import sys
import pexpect
import pytest
@pytest.fixture(scope='session')
def lldb_session(tmpdir_factory):
"""Starts LLDB in the background with Python as the target process.
LLDB is started via pexpect.spawn; bidirectional communication with the child process is
performed via pipes attached to its stdin/stdout/stderr.
This fixture has the session scope, so that LLDB is only launched once and reused across
different tests. That is managed via a separate, function-scoped fixture -- lldb.
"""
session = pexpect.spawn(
'lldb',
args=['-O', 'settings set use-color 0', sys.executable],
cwd=tmpdir_factory.mktemp('lldb').strpath,
encoding='utf-8',
timeout=6,
maxread=65536,
env={
'PYTHONPATH': os.environ.get('PYTHONPATH', ''),
'PYTHONHASHSEED': os.environ.get('PYTHONHASHSEED', '1'),
'LANG': os.environ.get('LANG'),
},
)
session.expect('Current executable set to')
yield session
@pytest.fixture(scope='session')
def lldb_no_symbols_session(tmpdir_factory):
"""Starts LLDB in the background with Python as the target process.
Same as lldb_session, but also creates a copy of libpython w/o debugging symbols and updates
LD_LIBRARY_PATH to point to it.
"""
tmpdir = tmpdir_factory.mktemp('lldb')
with tmpdir.as_cwd():
libpython = subprocess.check_output("ldd %s | grep libpython | awk '{print $3}'" % (sys.executable), shell=True).decode("utf-8").strip()
libpython_copy = tmpdir.join(os.path.basename(libpython)).strpath
subprocess.check_call(['cp', libpython, libpython_copy])
subprocess.check_call(['strip', '-S', libpython_copy])
session = pexpect.spawn(
'lldb',
args=['-O', 'settings set use-color 0', sys.executable],
cwd=tmpdir.strpath,
encoding='utf-8',
timeout=6,
maxread=65536,
env={
'PYTHONPATH': os.environ.get('PYTHONPATH', ''),
'PYTHONHASHSEED': os.environ.get('PYTHONHASHSEED', '1'),
'LD_LIBRARY_PATH': '.',
'LANG': os.environ.get('LANG'),
},
)
session.expect('Current executable set to')
yield session
@contextlib.contextmanager
def _lldb_manager(lldb_session):
prev_cwd = os.getcwd()
os.chdir(lldb_session.cwd)
try:
yield lldb_session
finally:
os.chdir(prev_cwd)
lldb_session.sendline('kill')
lldb_session.expect(re.compile(r'Process \d+ exited'))
lldb_session.expect(re.escape('(lldb) '))
lldb_session.sendline('breakpoint delete --force')
lldb_session.expect('All breakpoints removed. ')
lldb_session.expect(re.escape('(lldb) '))
@pytest.fixture
def lldb(lldb_session):
"""Re-usable LLDB session.
Returns a context manager that can be used to retrieve a pexpect.spawn handle controlling an
LLDB instance running in the background. The context manager will automatically clean up the
state (such as breakpoints) and terminate the Python process under debug, so that another
session can be created w/o restarting LLDB.
As a side effect, the context manager will temporarily change the current working directory
created for this LLDB instance.
"""
return lambda: _lldb_manager(lldb_session)
@pytest.fixture
def lldb_no_symbols(lldb_no_symbols_session):
"""Same as lldb, but uses a copy of libpython with stripped debugging symbols."""
return lambda: _lldb_manager(lldb_no_symbols_session)
def normalize_stacktrace(trace):
"""Replace absolute paths in a stacktrace to make them consistent between runs."""
return re.sub('File "(.*)test.py"', 'File "test.py"', trace)
def run_lldb(lldb_manager, code, breakpoint, commands):
"""Run arbitrary LLDB commands after the given Python snippets hits a specified breakpoint.
Returns a list that contains an output each command has produced. As a side effect, absolute
paths in the stacktraces are automatically truncated to the final (i.e. file name) part.
"""
outputs = []
with lldb_manager() as lldb:
with io.open('test.py', 'wb') as fp:
if isinstance(code, str):
code = code.encode('utf-8')
fp.write(code)
lldb.sendline('breakpoint set -r %s' % breakpoint)
lldb.expect(r'Breakpoint \d+')
lldb.expect(re.escape('(lldb) '))
lldb.sendline('run test.py')
lldb.expect(r'Process \d+ stopped')
lldb.expect(re.escape('(lldb) '))
for command in commands:
lldb.sendline(command)
lldb.expect(re.escape('%s\r\n' % command))
lldb.expect(re.escape('(lldb) '))
outputs.append(normalize_stacktrace(lldb.before.replace('\r\n', '\n')))
return outputs
| malor/cpython-lldb | tests/conftest.py | Python | mit | 4,928 |
###ENUM CONSTANTS
XI_BINNING = 0
XI_SKIPPING = 1
# xiApi parameters
XI_PRM_DEVICE_NAME = "device_name" # Return device name
XI_PRM_DEVICE_TYPE = "device_type" # Return device type
XI_PRM_DEVICE_MODEL_ID = "device_model_id" # Return device model id
XI_PRM_DEVICE_SN = "device_sn" # Return device serial number
XI_PRM_DEVICE_SENS_SN = "device_sens_sn" # Return sensor serial number
XI_PRM_DEVICE_INSTANCE_PATH = "device_inst_path" # Return device system instance path.
XI_PRM_DEVICE_USER_ID = "device_user_id" # Return custom ID of camera.
#
XI_PRM_EXPOSURE = "exposure" # Exposure time in microseconds
XI_PRM_GAIN = "gain" # Gain in dB
XI_PRM_DOWNSAMPLING = "downsampling" # Change image resolution by binning or skipping.
XI_PRM_DOWNSAMPLING_TYPE = "downsampling_type" # Change image downsampling type. XI_DOWNSAMPL_TYPE
XI_PRM_SHUTTER_TYPE = "shutter_type" # Change sensor shutter type(CMOS sensor). XI_SHUTTER_TYPE
XI_PRM_IMAGE_DATA_FORMAT = "imgdataformat" # Output data format. XI_IMG_FORMAT
XI_PRM_TRANSPORT_PIXEL_FORMAT = "transport_pixel_format" # Current format of pixels on transport layer. XI_GenTL_Image_Format_e
XI_PRM_SENSOR_TAPS = "sensor_taps" # Number of taps
XI_PRM_SENSOR_PIXEL_CLOCK_FREQ_HZ = "sensor_pixel_clock_freq_hz"# Sensor pixel clock frequency in Hz.
XI_PRM_SENSOR_PIXEL_CLOCK_FREQ_INDEX = "sensor_pixel_clock_freq_index"# Sensor pixel clock frequency. Selects frequency index for getter of XI_PRM_SENSOR_PIXEL_CLOCK_FREQ_HZ parameter.
XI_PRM_SENSOR_DATA_BIT_DEPTH = "sensor_bit_depth" # Sensor output data bit depth.
XI_PRM_OUTPUT_DATA_BIT_DEPTH = "output_bit_depth" # Device output data bit depth.
XI_PRM_OUTPUT_DATA_PACKING = "output_bit_packing" # Device output data packing (or grouping) enabled. Packing could be enabled if output_data_bit_depth > 8 and packing is available. XI_SWITCH
XI_PRM_FRAMERATE = "framerate" # Define framerate in Hz
XI_PRM_ACQ_TIMING_MODE = "acq_timing_mode" # Type of sensor frames timing. XI_ACQ_TIM_MODE
XI_PRM_AVAILABLE_BANDWIDTH = "available_bandwidth" # Calculate and return available interface bandwidth(int Megabits)
XI_PRM_LIMIT_BANDWIDTH = "limit_bandwidth" # Set/get bandwidth(datarate)(in Megabits)
XI_PRM_BUFFER_POLICY = "buffer_policy" # Data move policy XI_BP
XI_PRM_WIDTH = "width" # Width of the Image provided by the device (in pixels).
XI_PRM_HEIGHT = "height" # Height of the Image provided by the device (in pixels).
XI_PRM_OFFSET_X = "offsetX" # Horizontal offset from the origin to the area of interest (in pixels).
XI_PRM_OFFSET_Y = "offsetY" # Vertical offset from the origin to the area of interest (in pixels).
XI_PRM_LUT_EN = "LUTEnable" # Activates LUT. XI_SWITCH
XI_PRM_LUT_EX = "LUTIndex" # Control the index (offset) of the coefficient to access in the LUT.
XI_PRM_LUT_VALUE = "LUTValue" # Value at entry LUTIndex of the LUT
XI_PRM_TRG_SOURCE = "trigger_source" # Defines source of trigger. XI_TRG_SOURCE
XI_PRM_TRG_SELECTOR = "trigger_selector" # Selects the type of trigger. XI_TRG_SELECTOR
XI_PRM_TRG_SOFTWARE = "trigger_software" # Generates an internal trigger. XI_PRM_TRG_SOURCE must be set to TRG_SOFTWARE.
XI_PRM_TRG_DELAY = "trigger_delay" # Specifies the delay in microseconds (us) to apply after the trigger reception before activating it.
XI_PRM_GPI_SELECTOR = "gpi_selector" # Selects GPI
XI_PRM_GPI_MODE = "gpi_mode" # Defines GPI functionality XI_GPI_MODE
XI_PRM_GPI_LEVEL = "gpi_level" # GPI level
XI_PRM_GPO_SELECTOR = "gpo_selector" # Selects GPO
XI_PRM_GPO_MODE = "gpo_mode" # Defines GPO functionality XI_GPO_MODE
XI_PRM_LED_SELECTOR = "led_selector" # Selects LED
XI_PRM_LED_MODE = "led_mode" # Defines LED functionality XI_LED_MODE
XI_PRM_ACQ_FRAME_BURST_COUNT = "acq_frame_burst_count" # Sets number of frames acquired by burst. This burst is used only if trigger is set to FrameBurstStart
#
XI_PRM_IS_DEVICE_EXIST = "isexist" # Returns 1 if camera connected and works properly. XI_SWITCH
XI_PRM_ACQ_BUFFER_SIZE = "acq_buffer_size" # Acquisition buffer size in bytes
XI_PRM_ACQ_TRANSPORT_BUFFER_SIZE = "acq_transport_buffer_size"# Acquisition transport buffer size in bytes
XI_PRM_BUFFERS_QUEUE_SIZE = "buffers_queue_size" # Queue of field/frame buffers
XI_PRM_RECENT_FRAME = "recent_frame" # GetImage returns most recent frame XI_SWITCH
#
XI_PRM_CMS = "cms" # Mode of color management system. XI_CMS_MODE
XI_PRM_APPLY_CMS = "apply_cms" # Enable applying of CMS profiles to xiGetImage (see XI_PRM_UT_CMS_PROFILE, XI_PRM_UT_CMS_PROFILE). XI_SWITCH
XI_PRM_INPUT_CMS_PROFILE = "input_cms_profile" # Filename for input cms profile (e.g. input.icc)
XI_PRM_OUTPUT_CMS_PROFILE = "output_cms_profile" # Filename for output cms profile (e.g. input.icc)
XI_PRM_IMAGE_IS_COLOR = "iscolor" # Returns 1 for color cameras. XI_SWITCH
XI_PRM_COLOR_FILTER_ARRAY = "cfa" # Returns color filter array type of RAW data. XI_COLOR_FILTER_ARRAY
XI_PRM_WB_KR = "wb_kr" # White balance red coefficient
XI_PRM_WB_KG = "wb_kg" # White balance green coefficient
XI_PRM_WB_KB = "wb_kb" # White balance blue coefficient
XI_PRM_MANUAL_WB = "manual_wb" # Calculates White Balance(xiGetImage function must be called)
XI_PRM_AUTO_WB = "auto_wb" # Automatic white balance XI_SWITCH
XI_PRM_GAMMAY = "gammaY" # Luminosity gamma
XI_PRM_GAMMAC = "gammaC" # Chromaticity gamma
XI_PRM_SHARPNESS = "sharpness" # Sharpness Strenght
XI_PRM_CC_MATRIX_00 = "ccMTX00" # Color Correction Matrix element [0][0]
XI_PRM_CC_MATRIX_01 = "ccMTX01" # Color Correction Matrix element [0][1]
XI_PRM_CC_MATRIX_02 = "ccMTX02" # Color Correction Matrix element [0][2]
XI_PRM_CC_MATRIX_03 = "ccMTX03" # Color Correction Matrix element [0][3]
XI_PRM_CC_MATRIX_10 = "ccMTX10" # Color Correction Matrix element [1][0]
XI_PRM_CC_MATRIX_11 = "ccMTX11" # Color Correction Matrix element [1][1]
XI_PRM_CC_MATRIX_12 = "ccMTX12" # Color Correction Matrix element [1][2]
XI_PRM_CC_MATRIX_13 = "ccMTX13" # Color Correction Matrix element [1][3]
XI_PRM_CC_MATRIX_20 = "ccMTX20" # Color Correction Matrix element [2][0]
XI_PRM_CC_MATRIX_21 = "ccMTX21" # Color Correction Matrix element [2][1]
XI_PRM_CC_MATRIX_22 = "ccMTX22" # Color Correction Matrix element [2][2]
XI_PRM_CC_MATRIX_23 = "ccMTX23" # Color Correction Matrix element [2][3]
XI_PRM_CC_MATRIX_30 = "ccMTX30" # Color Correction Matrix element [3][0]
XI_PRM_CC_MATRIX_31 = "ccMTX31" # Color Correction Matrix element [3][1]
XI_PRM_CC_MATRIX_32 = "ccMTX32" # Color Correction Matrix element [3][2]
XI_PRM_CC_MATRIX_33 = "ccMTX33" # Color Correction Matrix element [3][3]
XI_PRM_DEFAULT_CC_MATRIX = "defccMTX" # Set default Color Correction Matrix
#
XI_PRM_AEAG = "aeag" # Automatic exposure/gain XI_SWITCH
XI_PRM_AEAG_ROI_OFFSET_X = "aeag_roi_offset_x" # Automatic exposure/gain ROI offset X
XI_PRM_AEAG_ROI_OFFSET_Y = "aeag_roi_offset_y" # Automatic exposure/gain ROI offset Y
XI_PRM_AEAG_ROI_WIDTH = "aeag_roi_width" # Automatic exposure/gain ROI Width
XI_PRM_AEAG_ROI_HEIGHT = "aeag_roi_height" # Automatic exposure/gain ROI Height
XI_PRM_EXP_PRIORITY = "exp_priority" # Exposure priority (0.5 - exposure 50%, gain 50%).
XI_PRM_AE_MAX_LIMIT = "ae_max_limit" # Maximum limit of exposure in AEAG procedure
XI_PRM_AG_MAX_LIMIT = "ag_max_limit" # Maximum limit of gain in AEAG procedure
XI_PRM_AEAG_LEVEL = "aeag_level" # Average intensity of output signal AEAG should achieve(in %)
#
XI_PRM_BPC = "bpc" # Correction of bad pixels XI_SWITCH
#
XI_PRM_DEBOUNCE_EN = "dbnc_en" # Enable/Disable debounce to selected GPI XI_SWITCH
XI_PRM_DEBOUNCE_T0 = "dbnc_t0" # Debounce time (x * 10us)
XI_PRM_DEBOUNCE_T1 = "dbnc_t1" # Debounce time (x * 10us)
XI_PRM_DEBOUNCE_POL = "dbnc_pol" # Debounce polarity (pol = 1 t0 - falling edge, t1 - rising edge)
#
XI_PRM_IS_COOLED = "iscooled" # Returns 1 for cameras that support cooling.
XI_PRM_COOLING = "cooling" # Start camera cooling. XI_SWITCH
XI_PRM_TARGET_TEMP = "target_temp" # Set sensor target temperature for cooling.
XI_PRM_CHIP_TEMP = "chip_temp" # Camera sensor temperature
XI_PRM_HOUS_TEMP = "hous_temp" # Camera housing tepmerature
#
XI_PRM_SENSOR_MODE = "sensor_mode" # Current sensor mode. Allows to select sensor mode by one integer. Setting of this parameter affects: image dimensions and downsampling.
XI_PRM_HDR = "hdr" # Enable High Dynamic Range feature. XI_SWITCH
XI_PRM_HDR_KNEEPOINT_COUNT = "hdr_kneepoint_count" # The number of kneepoints in the PWLR.
XI_PRM_HDR_T1 = "hdr_t1" # position of first kneepoint(in % of XI_PRM_EXPOSURE)
XI_PRM_HDR_T2 = "hdr_t2" # position of second kneepoint (in % of XI_PRM_EXPOSURE)
XI_PRM_KNEEPOINT1 = "hdr_kneepoint1" # value of first kneepoint (% of sensor saturation)
XI_PRM_KNEEPOINT2 = "hdr_kneepoint2" # value of second kneepoint (% of sensor saturation)
XI_PRM_IMAGE_BLACK_LEVEL = "image_black_level" # Last image black level counts. Can be used for Offline processing to recall it.
#
XI_PRM_API_VERSION = "api_version" # Returns version of API.
XI_PRM_DRV_VERSION = "drv_version" # Returns version of current device driver.
XI_PRM_MCU1_VERSION = "version_mcu1" # Returns version of MCU1 firmware.
XI_PRM_MCU2_VERSION = "version_mcu2" # Returns version of MCU2 firmware.
XI_PRM_FPGA1_VERSION = "version_fpga1" # Returns version of FPGA1 firmware.
#
XI_PRM_DEBUG_LEVEL = "debug_level" # Set debug level XI_DEBUG_LEVEL
XI_PRM_AUTO_BANDWIDTH_CALCULATION = "auto_bandwidth_calculation"# Automatic bandwidth calculation, XI_SWITCH
#
XI_PRM_READ_FILE_FFS = "read_file_ffs" # Read file from camera flash filesystem.
XI_PRM_WRITE_FILE_FFS = "write_file_ffs" # Write file to camera flash filesystem.
XI_PRM_FFS_FILE_NAME = "ffs_file_name" # Set name of file to be written/read from camera FFS.
XI_PRM_FREE_FFS_SIZE = "free_ffs_size" # Size of free camera FFS.
XI_PRM_USED_FFS_SIZE = "used_ffs_size" # Size of used camera FFS.
#
XI_PRM_API_CONTEXT_LIST = "xiapi_context_list" # List of current parameters settings context - parameters with values. Used for offline processing.
#-------------------------------------------------------------------------------------------------------------------
# Global definitions
SIZE_XI_IMG_V1 = 28 # structure size default
SIZE_XI_IMG_V2 = 40 # structure size with timestamp and GPI level information
SIZE_XI_IMG_V3 = 44 # structure size with black level information
SIZE_XI_IMG_V4 = 48 # structure size with horizontal buffer padding information
XI_PRM_INFO_MIN = ":min" # Parameter minimum
XI_PRM_INFO_MAX = ":max" # Parameter maximum
XI_PRM_INFO_INCREMENT = ":inc" # Parameter increment
XI_PRM_INFO = ":info" # Parameter value
XI_PRMM_DIRECT_UPDATE = ":direct_update" # Parameter modifier for direct update without stopping the streaming. E.g. XI_PRM_EXPOSURE XI_PRMM_DIRECT_UPDATE can be used with this modifier
XI_MQ_LED_STATUS1 = 1 # MQ Status 1 LED selection value.
XI_MQ_LED_STATUS2 = 2 # MQ Status 2 LED selection value.
XI_MQ_LED_POWER = 3 # MQ Power LED selection value.
XI_MS_LED_STATUS1 = 1 # CURRERA-R LED 1 selection value.
XI_MS_LED_STATUS2 = 2 # CURRERA-R LED 2 selection value.
###ENUM strings:
logger_levels = {
'Detail' :0,
'Trace' :1,
'Warning' :2,
'Error' :3,
'Fatal' :4,
'Disabled':100
}
###ERROR CODES:
error_codes = {
0 : ("XI_OK","Function call succeeded"),
1 : ("XI_INVALID_HANDLE","Invalid handle"),
2 : ("XI_READREG","Register read error"),
3 : ("XI_WRITEREG","Register write error"),
4 : ("XI_FREE_RESOURCES","Freeing resiurces error"),
5 : ("XI_FREE_CHANNEL","Freeing channel error"),
6 : ("XI_FREE_BANDWIDTH","Freeing bandwith error"),
7 : ("XI_READBLK","Read block error"),
8 : ("XI_WRITEBLK","Write block error"),
9 : ("XI_NO_IMAGE","No image"),
10 : ("XI_TIMEOUT","Timeout"),
11 : ("XI_INVALID_ARG","Invalid arguments supplied"),
12 : ("XI_NOT_SUPPORTED","Not supported"),
13 : ("XI_ISOCH_ATTACH_BUFFERS","Attach buffers error"),
14 : ("XI_GET_OVERLAPPED_RESULT","Overlapped result"),
15 : ("XI_MEMORY_ALLOCATION","Memory allocation error"),
16 : ("XI_DLLCONTEXTISNULL","DLL context is NULL"),
17 : ("XI_DLLCONTEXTISNONZERO","DLL context is non zero"),
18 : ("XI_DLLCONTEXTEXIST","DLL context exists"),
19 : ("XI_TOOMANYDEVICES","Too many devices connected"),
20 : ("XI_ERRORCAMCONTEXT","Camera context error"),
21 : ("XI_UNKNOWN_HARDWARE","Unknown hardware"),
22 : ("XI_INVALID_TM_FILE","Invalid TM file"),
23 : ("XI_INVALID_TM_TAG","Invalid TM tag"),
24 : ("XI_INCOMPLETE_TM","Incomplete TM"),
25 : ("XI_BUS_RESET_FAILED","Bus reset error"),
26 : ("XI_NOT_IMPLEMENTED","Not implemented"),
27 : ("XI_SHADING_TOOBRIGHT","Shading too bright"),
28 : ("XI_SHADING_TOODARK","Shading too dark"),
29 : ("XI_TOO_LOW_GAIN","Gain is too low"),
30 : ("XI_INVALID_BPL","Invalid bad pixel list"),
31 : ("XI_BPL_REALLOC","Bad pixel list realloc error"),
32 : ("XI_INVALID_PIXEL_LIST","Invalid pixel list"),
33 : ("XI_INVALID_FFS","Invalid Flash File System"),
34 : ("XI_INVALID_PROFILE","Invalid profile"),
35 : ("XI_INVALID_CALIBRATION","Invalid calibration"),
36 : ("XI_INVALID_BUFFER","Invalid buffer"),
38 : ("XI_INVALID_DATA","Invalid data"),
39 : ("XI_TGBUSY","Timing generator is busy"),
40 : ("XI_IO_WRONG","Wrong operation open/write/read/close"),
41 : ("XI_ACQUISITION_ALREADY_UP","Acquisition already started"),
42 : ("XI_OLD_DRIVER_VERSION","Old version of device driver installed to the system."),
43 : ("XI_GET_LAST_ERROR","To get error code please call GetLastError function."),
44 : ("XI_CANT_PROCESS","Data can't be processed"),
45 : ("XI_ACQUISITION_STOPED","Acquisition has been stopped. It should be started before GetImage."),
46 : ("XI_ACQUISITION_STOPED_WERR","Acquisition has been stoped with error."),
47 : ("XI_INVALID_INPUT_ICC_PROFILE","Input ICC profile missed or corrupted"),
48 : ("XI_INVALID_OUTPUT_ICC_PROFILE","Output ICC profile missed or corrupted"),
49 : ("XI_DEVICE_NOT_READY","Device not ready to operate"),
50 : ("XI_SHADING_TOOCONTRAST","Shading too contrast"),
51 : ("XI_ALREADY_INITIALIZED","Modile already initialized"),
52 : ("XI_NOT_ENOUGH_PRIVILEGES","Application doesn't enough privileges(one or more app"),
53 : ("XI_NOT_COMPATIBLE_DRIVER","Installed driver not compatible with current software"),
54 : ("XI_TM_INVALID_RESOURCE","TM file was not loaded successfully from resources"),
55 : ("XI_DEVICE_HAS_BEEN_RESETED","Device has been reseted, abnormal initial state"),
56 : ("XI_NO_DEVICES_FOUND","No Devices Found"),
57 : ("XI_RESOURCE_OR_FUNCTION_LOCKED","Resource(device) or function locked by mutex"),
58 : ("XI_BUFFER_SIZE_TOO_SMALL","Buffer provided by user is too small"),
100 :("XI_UNKNOWN_PARAM","Unknown parameter"),
101 :("XI_WRONG_PARAM_VALUE","Wrong parameter value"),
103 :("XI_WRONG_PARAM_TYPE","Wrong parameter type"),
104 :("XI_WRONG_PARAM_SIZE","Wrong parameter size"),
105 :("XI_BUFFER_TOO_SMALL","Input buffer too small"),
106 :("XI_NOT_SUPPORTED_PARAM","Parameter info not supported"),
107 :("XI_NOT_SUPPORTED_PARAM_INFO","Parameter info not supported"),
108 :("XI_NOT_SUPPORTED_DATA_FORMAT","Data format not supported"),
109 :("XI_READ_ONLY_PARAM","Read only parameter"),
111 :("XI_BANDWIDTH_NOT_SUPPORTED","This camera does not support currently available bandwidth"),
112 :("XI_INVALID_FFS_FILE_NAME","FFS file selector is invalid or NULL"),
113 :("XI_FFS_FILE_NOT_FOUND","FFS file not found"),
201 :("XI_PROC_OTHER_ERROR","Processing error - other"),
202 :("XI_PROC_PROCESSING_ERROR","Error while image processing."),
203 :("XI_PROC_INPUT_FORMAT_UNSUPPORTED","Input format is not supported for processing."),
204 :("XI_PROC_OUTPUT_FORMAT_UNSUPPORTED","Output format is not supported for processing.")
}
| pupil-labs/pyximea | constants.py | Python | mit | 19,557 |
from django.conf import settings
from django.core.mail import send_mail
from django.shortcuts import render
# Create your views here.
from products.models import Product, ProductFeatured
from .forms import ContactForm, SignUpForm
from .models import SignUp
def home(request):
title = 'Sign Up Now'
featured_product = ProductFeatured.objects.filter(active=True).order_by('-timestamp').first()
products = Product.objects.all().order_by('?')[:4]
form = SignUpForm(request.POST or None)
context = {
'title': title,
'form': form,
'featured_product': featured_product,
'products': products,
}
if form.is_valid():
instance = form.save(commit=False)
full_name = form.cleaned_data.get('full_name')
if not full_name:
full_name = 'New full name'
instance.full_name = full_name
# if not instance.full_name:
# instance.full_name = 'Justin'
instance.save()
context = {
'title': 'Thank you',
}
return render(request, 'home.html', context)
def contact(request):
title = 'Contact Us'
title_align_center = True
form = ContactForm(request.POST or None)
if form.is_valid():
form_email = form.cleaned_data.get('email')
form_message = form.cleaned_data.get('message')
form_full_name = form.cleaned_data.get('full_name')
# print email, message, full_name
subject = 'Site contact form'
from_email = settings.EMAIL_HOST_USER
to_email = [from_email, '[email protected]']
contact_message = '%s: %s via %s' %(
form_full_name,
form_message,
form_email)
some_html_message = """
<h1>hello</h1>
"""
send_mail(subject,
contact_message,
from_email,
to_email,
html_message=some_html_message,
fail_silently=True)
context = {
'form': form,
'title': title,
'title_align_center': title_align_center,
}
return render(request, 'forms.html', context)
| loafbaker/django_ecommerce2 | newsletter/views.py | Python | mit | 2,151 |
# -*- coding: utf-8 -*-
import logging
from django import forms
from django.core.urlresolvers import reverse
from crispy_forms.bootstrap import FormActions, InlineCheckboxes
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Field, HTML, Layout, Submit
from .models import Mocker
logger = logging.getLogger(__name__)
class MockerForm(forms.ModelForm):
class Meta:
model = Mocker
fields = [
'destination_address',
'allowed_http_method',
'allowed_content_type',
'callback_address',
'callback_content_type',
]
def __init__(self, *args, **kwargs):
super(MockerForm, self).__init__(*args, **kwargs)
self.helper = FormHelper(self)
self.helper.form_method = 'POST'
self.helper.form_action = reverse('process_mock_form_view')
self.helper.layout = Layout(
Field('destination_address', autocomplete='off'),
Field('allowed_content_type', autocomplete='off'),
InlineCheckboxes('allowed_http_method'),
Field('callback_address', autocomplete='off'),
Field('callback_content_type', autocomplete='off'),
FormActions(
HTML("""<a role="button" class="btn btn-default" href="{% url "home" %}">Cancel</a>"""),
Submit('save', 'Submit'),
)
)
| paveu/api_mocker | apimocker/mocker/forms.py | Python | mit | 1,407 |
# -*- coding: utf-8 -*-
"""
Модели
"""
from django.db import models
from django.contrib.auth.models import User
from decimal import Decimal
# Create your models here.
class Booking(models.Model):
"""Модель заказа"""
class Meta:
"""
Права по-умолчанию обнулены.
Добавлено право на исполнение заказа.
"""
permissions = (
("perform_perm", u"Ability to perform created booking"),
)
PENDING = "pending"
WAITING_FOR_APPROVAL = "waiting_for_approval"
RUNNING = "running"
COMPLETED = "completed"
STATUS_CHOICES = (
(PENDING, u"Ожидает исполнителя"),
(WAITING_FOR_APPROVAL, u"Ожидает подтверждения заказчиком"),
(RUNNING, u"Взят на исполнение"),
(COMPLETED, u"Завершен"),
)
title = models.CharField(max_length=100)
text = models.TextField(max_length=4000)
price = models.DecimalField(max_digits=8, decimal_places=2, default=100)
status = models.CharField(
db_index=True,
choices=STATUS_CHOICES,
default=PENDING,
max_length=30
)
customer = models.ForeignKey(User, related_name='customer_booking')
performer = models.ForeignKey(
User, null=True, blank=True, related_name='performer_booking')
possible_performers = models.ManyToManyField(User)
date = models.DateTimeField(db_index=True, auto_now_add=True)
def set_performer(self, performer):
"""
Установка исполнителя для заказа. Установка выполняющегося статуса
для заказа.
"""
self.performer = performer
self.save()
def set_customer(self, customer):
"""
Установка заказчика для заказа.
"""
self.customer = customer
self.save()
def get_customer(self):
"""
Получение модели исполнителя
"""
return self.customer
def get_performer(self):
"""
Получение модели исполнителя
"""
return self.performer
def complete(self):
"""
Перевод средств со счета заказчика на счет исполнителя.
Установка завершающего статуса для заказа.
"""
system_account = SystemAccount.objects.all()[0]
comission = system_account.get_comission()
cash_for_system = self.price * comission
cash_for_performer = self.price * (1 - comission)
system_account.transfer_cash(cash_for_system)
system_account.save()
self.performer.profile.increase_cash(cash_for_performer)
self.performer.profile.save()
self.status = self.COMPLETED
self.save()
return cash_for_system, cash_for_performer
def get_status(self):
"""
Получение текущего статуса заказа
"""
return self.status
def set_status(self, status):
"""
Установка статуса для заказа.
"""
self.status = status
self.save()
class UserProfile(models.Model):
"""
Расширенный профиль пользователя
"""
user = models.OneToOneField(User, related_name='profile')
cash = models.DecimalField(
max_digits=6, decimal_places=2, default=Decimal('0.0'))
def __unicode__(self):
return self.user.username
def increase_cash(self, _cash):
"""
Увеличение денег на счету пользователя.
"""
self.cash += _cash
def decrease_cash(self, _cash):
"""
Уменьшение денег на счету пользователя.
"""
self.cash -= _cash
def has_enough_cash_for_booking(self, price):
"""
Цена введенного заказа должна быть меньше (либо равна) сумме,
которая заказчика есть на счету, для того, чтобы он мог оплатить заказ.
Проверяется при взятии заказа исполнителем.
"""
if self.cash >= price:
return True
else:
return False
class SystemAccount(models.Model):
"""
Счет системы, на который происходит перевод процента-комиссии цены заказа
со счета заказа после его завершения.
"""
account = models.DecimalField(max_digits=6, decimal_places=2,
default=Decimal('0.00'))
commission = models.DecimalField(max_digits=3, decimal_places=2,
default=Decimal('0.03'))
def transfer_cash(self, _cash):
"""
Пополнение средств на счету
"""
self.account += _cash
def get_comission(self):
"""
Комиссия системы
"""
return self.commission
class Comment(models.Model):
booking = models.ForeignKey(Booking, related_name='booking_comments')
text = models.TextField(max_length=1000)
date = models.DateTimeField(db_index=True, auto_now_add=True)
creator = models.ForeignKey(User, related_name='creator_comments')
| bo858585/AbstractBooking | Booking/booking/models.py | Python | mit | 5,669 |
#--coding:utf8--
from BeautifulSoup import BeautifulSoup
import urllib2
start_url = 'http://bbs.tianya.cn/post-stocks-1062591-%s.shtml'
saved_file = "content.txt"
def spider(url, f):
r = urllib2.urlopen(url)
h = r.read()
txt = extract(h)
f.write(txt.encode('utf8'))
f.write('\r\n=============================\r\n')
return fetch_next_url(h)
def extract(html):
soup = BeautifulSoup(html)
txt = []
blocks = soup.findAll(name = "div",
attrs = {'class': 'atl-item'})
for block in blocks:
arthur = block.find("a", attrs={"class": "js-vip-check"}).text
content = block.find(name = "div",
attrs = {'class' : "bbs-content"}).text
txt.append('%s :\r\n%s' % (arthur, content))
return '\r\n--------------------\r\n'.join(txt)
def fetch_next_url(html):
return None
def main():
with open(saved_file, 'w+') as f:
for i in range(1, 88):
spider(start_url % i, f)
if __name__ == '__main__':
main()
| largetalk/tenbagger | gather/blog/fetch_tianya.py | Python | mit | 1,048 |
import sys
from importlib import import_module
sys.path.insert(0, ".") # Necessary for working in other modules
def import_from_path(path):
try:
module = import_module(path)
return module
except ImportError:
parts = path.split(".")
module_path = ".".join(parts[:-1])
attribute_name = parts[-1]
module = import_module(module_path)
attribute = getattr(module, attribute_name)
return attribute
def encode(val, none_val="NULL"):
if val is None:
return none_val
elif isinstance(val, bytes):
val = str(val, 'utf-8', "replace")
else:
val = str(val)
return val.replace("\t", "\\t").replace("\n", "\\n")
| ToAruShiroiNeko/revscoring | revscoring/utilities/util.py | Python | mit | 717 |
import psycopg2
import datetime
from .db_controller import DbController
from logic import user
class Event:
def __init__(self, id_, title, description, photo, date, time, shortdescription):
self._id = id_
self.title = title
self.description = description
self.shortdescription = shortdescription
self.photo = photo
#self.date = datetime(*[int(i) for i in date.split('.')])
#self.time = datetime.time(*[int(i) for i in time.split(':')])
self.date = date
self.time = time
self.__db = DbController(table='Event')
@staticmethod
def create_event(title, description, photo, date, time, shortdescription):
try:
db = DbController(table='Event')
id_ = db.create(name=title, description=description, photo=photo, date=date, time=time, shortdescription=shortdescription)
return Event(id_, title, description, shortdescription, photo, date, time)
except psycopg2.Error as e:
print(e)
return None
@staticmethod
def get_event(param_name, param_value):
try:
db = DbController(table='Event')
data = db.get(param_name, param_value)
return Event(data['id'], data['name'], data['description'], data['photo'], data['date'], data['time'], data['shortdescription'])
except psycopg2.Error as e:
print(e)
return None
@staticmethod
def all_event(hashtag_name=None):
try:
db = DbController(table='Event')
command = 'SELECT * FROM "Event";'
if hashtag_name:
command = f'{command[:-1]} JOIN "EventToHashtag" ON "Event"."id" = "EventToHashtag"."event_id" ' \
f'WHERE "hashtag_id" = \'{hashtag_name.lower()}\';'
events = db.query(command)
event_list = []
for data in events:
event_list.append(Event(data[0], data[1], data[2], data[3], data[4], data[5], data[6]))
return event_list
except psycopg2.Error as e:
print(e)
return None
def update(self):
try:
self.__db.update(self._id, name=self.title, description=self.description, photo=self.photo, date=self.date,
time=self.time, shortdescription=self.shortdescription)
return True
except psycopg2.Error as e:
print(e)
return False
def get_users(self):
try:
users = self.__db.query(f'SELECT * from User JOIN EventToUser ON User.id = EventToUser.user_id WHERE '
f'EventToUser.event_id={self._id};')
user_list = []
for data in users:
is_staff = 'True' is data['is_staff']
user_list.append(user.User(data['id'], data['first_name'], data['last_name'],
data['phone'], data['chat_id'], data['username'], is_staff))
return user_list
except psycopg2.Error as e:
print(e)
return None
def delete_event(self):
try:
self.__db.delete(self._id)
return True
except psycopg2.Error as e:
print(e)
return False
| lubchenko05/belka.system | belkaBot/logic/event.py | Python | mit | 3,392 |
"""Main initialization for the WeGovNow extension."""
VERSION = (3, 2, 1)
__version__ = '.'.join(map(str, VERSION))
try:
from geokey.extensions.base import register
register(
'geokey_wegovnow',
'WeGovNow',
display_admin=False,
superuser=False,
version=__version__
)
except BaseException:
print 'Please install GeoKey first'
| ExCiteS/geokey-wegovnow | geokey_wegovnow/__init__.py | Python | mit | 384 |
# -*- coding: utf8 -*-
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
from __future__ import generators
from markdown.preprocessors import Preprocessor
from markdown.extensions import Extension
import re
class WorkSyntaxPreprocessor(Preprocessor):
def run(self, lines):
new_lines = ['''<form action="" method="post">''']
task = re.compile('^::task (.+)$')
date = re.compile('^::date (.+)$')
op = re.compile('^::open')
num = re.compile('^::number (.+)$')
lb_f = re.compile('^:- (.+)$')
lb_t = re.compile('^:\+ (.+)$')
for line in lines:
match_task = task.search(line)
match_date = date.search(line)
match_op = op.search(line)
match_number = num.search(line)
match_false = lb_f.search(line)
match_true = lb_t.search(line)
if match_task:
new_lines.append('<h2>{0}</h2>'
.format(match_task.group(1)))
elif match_date:
new_lines.append('<h5>{0}</h5>'
.format(match_date.group(1)))
elif match_op:
new_lines.append('''<br><textarea name="text" cols="40"
rows="4"></textarea>''')
elif match_number:
new_lines.append('''<br><input type="text"
name="number" value="">
<span style="color: red">
{0}</span>'''
.format(match_number.group(1)))
elif match_false:
new_lines.append('''<br><input type="radio" name="choice"
value="{0}"> {0}'''
.format(match_false.group(1)))
elif match_true:
new_lines.append('''<br><span style="color: red"><input type="radio" name="choice"
value="{0}"> {0}</span>'''
.format(match_true.group(1)))
else:
new_lines.append(line)
new_lines.append('''<br><input type="submit"
value ="Odeslat">
</form>''')
return new_lines
class WorkSyntax(Extension):
def extendMarkdown(self, md, md_globals):
md.preprocessors.add('urlify', WorkSyntaxPreprocessor(md), '_end')
| Lokky007/flask_testing_web | work_syntax_admin.py | Python | mit | 2,519 |
from django.conf.urls.defaults import patterns, include, url
from django.contrib import admin
admin.autodiscover()
urlpatterns = patterns('pollio.views',
url(r'^$', 'index'),
url(r'^initialize/$', 'initialize'),
url(r'^new_poll/$', 'new_poll'),
url(r'^request_poll/$', 'request_poll'),
url(r'^request_results/$', 'request_results'),
url(r'^submit_vote/$', 'submit_vote'),
)
| army-of-dumbledore/pennappsF13 | django/django_server/pollio/urls.py | Python | mit | 400 |
# encoding: UTF-8
"""
# Gender variable
#
# Copyright (c) 2015, Translation Exchange, Inc.
# 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.
"""
from __future__ import absolute_import
import six
from _ctypes import ArgumentError
from tml.strings import to_string
__author__ = '[email protected]'
class Gender(object):
""" Gender data """
key = 'gender'
GENDERS = MALE, FEMALE, OTHER = ('male', 'female', 'other')
def __init__(self, gender, value):
self.value = value
self.gender = Gender.supported_gender(gender)
@classmethod
def male(cls, value):
""" Male factory
Args:
value (string): wrapped value
Returns:
Gender
"""
return cls(Gender.MALE, value)
@classmethod
def female(cls, value):
""" Female factory
Args:
value (string): wrapped value
Returns:
Gender
"""
return cls(Gender.FEMALE, value)
@classmethod
def other(cls, value):
""" Other factory
Args:
value (string): wrapped value
Returns:
Gender
"""
return cls(Gender.OTHER, value)
def __unicode__(self):
return to_string(self.value)
@classmethod
def supported_gender(cls, gender):
""" Check is gender string is valid gender """
if gender in Gender.GENDERS:
return gender
raise ArgumentError('Gender unsupported: %s' % gender)
@classmethod
def match(cls, data):
""" Check is object string is valid gender """
try:
if isinstance(data, six.string_types):
# String:
return Gender.supported_gender(data)
if (isinstance(data, Gender)):
# Object is Gender instance:
gender = data.gender
elif (isinstance(data, dict)):
# {'gender':'male'}
gender = data['gender']
elif (isinstance(data, object)):
# check gender property:
gender = data.gender
except Exception as e:
raise ArgumentError('Fault to detect gender for %s' % object, e)
if not gender:
raise ArgumentError('No gender at %s' % type(gender))
return Gender.supported_gender(gender)
| translationexchange/tml-python | tml/rules/contexts/gender.py | Python | mit | 3,404 |
import asyncio
import unittest
from aiounittest import async_test
async def add(x, y):
await asyncio.sleep(0.1)
return x + y
class MyAsyncTestDecorator(unittest.TestCase):
@async_test
async def test_async_add(self):
ret = await add(5, 6)
self.assertEqual(ret, 11)
@unittest.expectedFailure
@async_test
async def test_async_add(self):
ret = await add(5, 6)
self.assertEqual(ret, 44)
def test_async_test_with_custom_loop(self):
async def some_func():
ret = await add(5, 6)
assert ret == 11
return 'OK'
loop = asyncio.get_event_loop()
wrapped = async_test(some_func, loop=loop)
res = wrapped()
self.assertEqual(res, 'OK')
# decorator should not change the state (eg close) of the loop if it's custom
self.assertFalse(loop.is_closed())
| kwarunek/aiounittest | tests/test_async_test.py | Python | mit | 899 |
from flask import render_template, flash, redirect, url_for, jsonify, session
from .forms import WebsiteForm
from . import main
from ..scraper import scraper
from datetime import datetime
@main.route('/', methods=['GET', 'POST'])
def index():
# Load Form
form = WebsiteForm()
# Scrape Function
def scrape(form):
try:
scrp = scraper.Scraper(form.website.data)
session['element_data'] = scrp.scrape()
except:
flash("This website cannot be scraped: %s" % (form.website.data))
form.website.data = "https://www.google.com"
scrp = scraper.Scraper(form.website.data)
session['element_data'] = scrp.scrape()
return redirect(url_for('.index'))
# Scrape Submitted site
if form.validate_on_submit():
scrape(form)
# Scrape Default site
else:
form.website.data = "https://www.google.com"
scrape(form)
return render_template('index.html', form=form,
elements=session['element_data']['list'],
totalCount=session['element_data']['totalCount'],
uniqueCount=session['element_data']['uniqueCount'])
@main.route('/getchartdata', methods=['GET', 'POST'])
def getchartdata():
try:
data = session['element_data']
except:
redirect(url_for('.index'))
return jsonify(data)
| znoland3/zachdemo | app/main/views.py | Python | mit | 1,428 |
#/usr/bin/env pypy
import subprocess
import tempfile
import argparse
import os
seqtk = "seqtk"
def parse_args():
"Pass command line arguments"
parser = argparse.ArgumentParser(description='Process input files')
#input files
parser.add_argument('-s','--sequences',
help='number of sequences to take for testing, useful for debugging')
parser.add_argument('--forward',
help='forward reads fastq')
parser.add_argument('--reverse',
help='reverse reads fastq')
parser.add_argument('-t','--tmpdir',
help='tmp directory',default='/tmp')
parser.add_argument('--threads',
help='Number of threads to used where multithreading is possible')
parser.add_argument('--outputdir',
help='Optional: output directory')
parser.add_argument('--log',
help='log of output operation')
args = parser.parse_args()
if args.outputdir:
if not os.path.exists(args.outputdir):
try:
os.mkdir(args.outputdir)
except OSError:
raise
args.log = os.path.join(args.outputdir,'merge_reads.log')
return args
def run_subprocess(cmd,args,log_message):
"Run subprocess under standardized settings"
#force the cmds to be a string.
if len(cmd) != 1:
cmd = [" ".join(cmd)]
with open(args.log,'a') as log:
log.write("now starting:\t%s\n"%log_message)
log.write('running:\t%s\n'%(' '.join(cmd)))
log.flush()
p = subprocess.Popen(cmd,stdout=subprocess.PIPE,stderr=subprocess.PIPE,shell=True,executable='bash')
stdout, stderr = p.communicate()
stdout = stdout.replace('\r','\n')
stderr = stderr.replace('\r','\n')
if stdout:
log.write('stdout:\n%s\n'%stdout)
if stderr:
log.write('stderr:\n%s\n'%stderr)
log.write('finished:\t%s\n\n'%log_message)
return 0
def merge_reads(args):
"Unzip / Merge Watson and crick reads using pear"
#TODO: run only once for both watson and crick at same time
out_files = {}
for strand in ['watson','crick']:
fwd_out = tempfile.NamedTemporaryFile(suffix=".fastq.gz",prefix=strand,dir=args.tmpdir)
rev_out = tempfile.NamedTemporaryFile(suffix=".fastq.gz",prefix=strand,dir=args.tmpdir)
join_out = tempfile.NamedTemporaryFile(prefix="join_%s"%strand,dir=args.tmpdir)
if args.sequences:
head = '|head -n %s'%(int(args.sequences)*4)
else:
head = ''
if args.forward.endswith('.gz'):
cat = 'pigz -p %s -cd '%args.threads
else:
cat = 'cat '
if strand == 'watson':
grep_watson = "|grep 'Watson\|watson' -A 3 |sed '/^--$/d'"
cmd1 = [ cat + args.forward + head + grep_watson + '|pigz -p %s -c >'%(args.threads)+fwd_out.name]
cmd2 = [ cat + args.reverse + head + grep_watson + '|pigz -p %s -c >'%(args.threads)+rev_out.name]
else:
grep_crick = "|grep 'Crick\|crick' -A 3 |sed '/^--$/d'"
cmd1 = [cat + args.forward + head + grep_crick + '|pigz -p %s -c >'%(args.threads)+fwd_out.name]
cmd2 = [cat + args.reverse + head + grep_crick + '|pigz -p %s -c >'%(args.threads)+rev_out.name]
log = "Write input files to tmpdir using gzcat"
run_subprocess(cmd1,args,log)
run_subprocess(cmd2,args,log)
#todo: check if pear is on path
cmd = ['pear']
#set reads
cmd+=['-f',fwd_out.name]
cmd+=['-r',rev_out.name]
#set number of threads for pear
cmd+=['-j','%s'%args.threads]
cmd+=['-p','0.001']
#set minimum overlap
cmd+=['-v','10']
#set minimum assembly length to 0
cmd+=['-n','0']
#specify output
cmd+=['-o',join_out.name]
log = "run pear for merging reads"
run_subprocess(cmd,args,log)
#Delete input files and output file name that are no longer needed??
fwd_out.close()
rev_out.close()
fwd_out.close()
#append output files as dictionary
out_files[strand] = {'merged':join_out.name+".assembled.fastq",
'single_R1':join_out.name+".unassembled.forward.fastq",
'single_R2':join_out.name+".unassembled.reverse.fastq"}
return out_files
def trim_and_zip(in_files,args):
"""Trim fastq files and return using pigz"""
in_files['trimmed'] = {}
log = 'Zip single watson reads: '
file_in = in_files['watson']['single_R1']
if args.outputdir:
file_out = os.path.join(args.outputdir, 'Unassembled.R1.watson.fq.gz')
else:
file_out = '_'.join(args.watson_forward.split('_')[:-1])+'.Unassembled.watson.R1.fq.gz'
in_files['trimmed']['watson_R1'] = file_out
cmd = [seqtk + ' seq %s |pigz -p %s -c > %s'%(file_in, args.threads, file_out)]
run_subprocess(cmd,args,log)
log = 'Process single watson reads: reverse complement required for R2 '
file_in = in_files['watson']['single_R2']
if args.outputdir:
file_out = os.path.join(args.outputdir, 'Unassembled.R2.crick.fq.gz')
else:
file_out = '_'.join(args.watson_reverse.split('_')[:-1])+'.Unassembled.watson.R2.fq.gz'
in_files['trimmed']['watson_R2'] = file_out
#Take reverse complement as pear outputs R2 in reverse complement
cmd = [seqtk + ' seq -r %s |pigz -p %s -c > %s'%(file_in, args.threads, file_out)]
run_subprocess(cmd,args,log)
log = 'Process single crick reads: no trimming required for R1'
file_in = in_files['crick']['single_R1']
if args.outputdir:
file_out = os.path.join(args.outputdir, 'Unassembled.R1.watson.fq.gz')
else:
file_out = '_'.join(args.crick_forward.split('_')[:-1])+'.Unassembled.crick.R1.fq.gz'
in_files['trimmed']['crick_R1'] = file_out
cmd = [seqtk + ' seq %s |pigz -p %s -c >> %s'%(file_in, args.threads, file_out)]
run_subprocess(cmd,args,log)
log = 'Process single crick reads: reverse complement for R2'
file_in = in_files['crick']['single_R2']
if args.outputdir:
file_out = os.path.join(args.outputdir, 'Unassembled.R2.crick.fq.gz')
else:
file_out = '_'.join(args.crick_reverse.split('_')[:-1])+'.Unassembled.crick.R2.fq.gz'
in_files['trimmed']['crick_R2'] = file_out
#Take reverse complement as pear outputs R2 in reverse complement
cmd = [seqtk + ' seq -r %s |pigz -p %s -c >> %s'%(file_in, args.threads, file_out)]
run_subprocess(cmd,args,log)
#Process merged files
log = 'Process merged watson reads:'
file_in = in_files['watson']['merged']
if args.outputdir:
file_out = os.path.join(args.outputdir, 'Assembled.fq.gz')
else:
file_out = '_'.join(args.watson_forward.split('_')[:-1])+'.Assembled.R1.fq.gz'
in_files['trimmed']['watson_merged'] = file_out
cmd = [seqtk + ' seq %s |pigz -p %s -c > %s'%(file_in, args.threads, file_out)]
run_subprocess(cmd,args,log)
log = 'Process merged crick reads:'
file_in = in_files['crick']['merged']
if args.outputdir:
file_out = os.path.join(args.outputdir, 'Assembled.fq.gz')
else:
file_out = '_'.join(args.crick_forward.split('_')[:-1])+'.Assembled.fq.gz'
in_files['trimmed']['crick_merged'] = file_out
cmd = [seqtk + ' seq %s |pigz -p %s -c >> %s'%(file_in, args.threads, file_out)]
run_subprocess(cmd,args,log)
return in_files
def clear_tmp(file_dict):
"""clear tmp files"""
purge_list = []
for v in file_dict.keys():
for key,value in file_dict[v].items():
try:
if value.startswith('/tmp'):
purge_list.append(value)
except AttributeError:
if type(value) == type([]):
purge_list.append(value[0])
for item in purge_list:
print "removing %s" % item
os.remove(item)
return 0
def main():
"Main function loop"
#Check if os is windows, if so, throw error and tell the user that the software cannot run on windows.
if os.name == 'nt':
raise OSError("This pipeline relies on unix/linux with a bash shell.")
args = parse_args()
#Make sure log is empty at start
if not args.log:
return 0
if os.path.isfile(args.log):
os.remove(args.log)
#Step 1: Merge Watson and crick reads returns dictionary
files = merge_reads(args)
files = trim_and_zip(files, args)
clear_tmp(files)
if __name__ == '__main__':
main() | thomasvangurp/epiGBS | mapping_varcall/merge_pear.py | Python | mit | 8,665 |
# coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for license information.
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is regenerated.
# --------------------------------------------------------------------------
import functools
from typing import Any, Callable, Dict, Generic, Iterable, Optional, TypeVar, Union
import warnings
from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error
from azure.core.paging import ItemPaged
from azure.core.pipeline import PipelineResponse
from azure.core.pipeline.transport import HttpResponse
from azure.core.polling import LROPoller, NoPolling, PollingMethod
from azure.core.rest import HttpRequest
from azure.core.tracing.decorator import distributed_trace
from azure.mgmt.core.exceptions import ARMErrorFormat
from azure.mgmt.core.polling.arm_polling import ARMPolling
from msrest import Serializer
from .. import models as _models
from .._vendor import _convert_request, _format_url_section
T = TypeVar('T')
JSONType = Any
ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]]
_SERIALIZER = Serializer()
_SERIALIZER.client_side_validation = False
def build_list_request(
subscription_id: str,
resource_group_name: str,
registry_name: str,
*,
filter: Optional[str] = None,
top: Optional[int] = None,
**kwargs: Any
) -> HttpRequest:
api_version = "2019-04-01"
accept = "application/json"
# Construct URL
url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/runs')
path_format_arguments = {
"subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
"resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', min_length=1),
"registryName": _SERIALIZER.url("registry_name", registry_name, 'str', max_length=50, min_length=5, pattern=r'^[a-zA-Z0-9]*$'),
}
url = _format_url_section(url, **path_format_arguments)
# Construct parameters
query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any]
query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
if filter is not None:
query_parameters['$filter'] = _SERIALIZER.query("filter", filter, 'str')
if top is not None:
query_parameters['$top'] = _SERIALIZER.query("top", top, 'int')
# Construct headers
header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any]
header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
return HttpRequest(
method="GET",
url=url,
params=query_parameters,
headers=header_parameters,
**kwargs
)
def build_get_request(
subscription_id: str,
resource_group_name: str,
registry_name: str,
run_id: str,
**kwargs: Any
) -> HttpRequest:
api_version = "2019-04-01"
accept = "application/json"
# Construct URL
url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/runs/{runId}')
path_format_arguments = {
"subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
"resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', min_length=1),
"registryName": _SERIALIZER.url("registry_name", registry_name, 'str', max_length=50, min_length=5, pattern=r'^[a-zA-Z0-9]*$'),
"runId": _SERIALIZER.url("run_id", run_id, 'str'),
}
url = _format_url_section(url, **path_format_arguments)
# Construct parameters
query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any]
query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
# Construct headers
header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any]
header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
return HttpRequest(
method="GET",
url=url,
params=query_parameters,
headers=header_parameters,
**kwargs
)
def build_update_request_initial(
subscription_id: str,
resource_group_name: str,
registry_name: str,
run_id: str,
*,
json: JSONType = None,
content: Any = None,
**kwargs: Any
) -> HttpRequest:
content_type = kwargs.pop('content_type', None) # type: Optional[str]
api_version = "2019-04-01"
accept = "application/json"
# Construct URL
url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/runs/{runId}')
path_format_arguments = {
"subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
"resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', min_length=1),
"registryName": _SERIALIZER.url("registry_name", registry_name, 'str', max_length=50, min_length=5, pattern=r'^[a-zA-Z0-9]*$'),
"runId": _SERIALIZER.url("run_id", run_id, 'str'),
}
url = _format_url_section(url, **path_format_arguments)
# Construct parameters
query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any]
query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
# Construct headers
header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any]
if content_type is not None:
header_parameters['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str')
header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
return HttpRequest(
method="PATCH",
url=url,
params=query_parameters,
headers=header_parameters,
json=json,
content=content,
**kwargs
)
def build_get_log_sas_url_request(
subscription_id: str,
resource_group_name: str,
registry_name: str,
run_id: str,
**kwargs: Any
) -> HttpRequest:
api_version = "2019-04-01"
accept = "application/json"
# Construct URL
url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/runs/{runId}/listLogSasUrl')
path_format_arguments = {
"subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
"resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', min_length=1),
"registryName": _SERIALIZER.url("registry_name", registry_name, 'str', max_length=50, min_length=5, pattern=r'^[a-zA-Z0-9]*$'),
"runId": _SERIALIZER.url("run_id", run_id, 'str'),
}
url = _format_url_section(url, **path_format_arguments)
# Construct parameters
query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any]
query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
# Construct headers
header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any]
header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str')
return HttpRequest(
method="POST",
url=url,
params=query_parameters,
headers=header_parameters,
**kwargs
)
def build_cancel_request_initial(
subscription_id: str,
resource_group_name: str,
registry_name: str,
run_id: str,
**kwargs: Any
) -> HttpRequest:
api_version = "2019-04-01"
# Construct URL
url = kwargs.pop("template_url", '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/runs/{runId}/cancel')
path_format_arguments = {
"subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, 'str'),
"resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, 'str', min_length=1),
"registryName": _SERIALIZER.url("registry_name", registry_name, 'str', max_length=50, min_length=5, pattern=r'^[a-zA-Z0-9]*$'),
"runId": _SERIALIZER.url("run_id", run_id, 'str'),
}
url = _format_url_section(url, **path_format_arguments)
# Construct parameters
query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any]
query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str')
return HttpRequest(
method="POST",
url=url,
params=query_parameters,
**kwargs
)
class RunsOperations(object):
"""RunsOperations operations.
You should not instantiate this class directly. Instead, you should create a Client instance that
instantiates it for you and attaches it as an attribute.
:ivar models: Alias to model classes used in this operation group.
:type models: ~azure.mgmt.containerregistry.v2019_04_01.models
:param client: Client for service requests.
:param config: Configuration of service client.
:param serializer: An object model serializer.
:param deserializer: An object model deserializer.
"""
models = _models
def __init__(self, client, config, serializer, deserializer):
self._client = client
self._serialize = serializer
self._deserialize = deserializer
self._config = config
@distributed_trace
def list(
self,
resource_group_name: str,
registry_name: str,
filter: Optional[str] = None,
top: Optional[int] = None,
**kwargs: Any
) -> Iterable["_models.RunListResult"]:
"""Gets all the runs for a registry.
:param resource_group_name: The name of the resource group to which the container registry
belongs.
:type resource_group_name: str
:param registry_name: The name of the container registry.
:type registry_name: str
:param filter: The runs filter to apply on the operation. Arithmetic operators are not
supported. The allowed string function is 'contains'. All logical operators except 'Not',
'Has', 'All' are allowed.
:type filter: str
:param top: $top is supported for get list of runs, which limits the maximum number of runs to
return.
:type top: int
:keyword callable cls: A custom type or function that will be passed the direct response
:return: An iterator like instance of either RunListResult or the result of cls(response)
:rtype:
~azure.core.paging.ItemPaged[~azure.mgmt.containerregistry.v2019_04_01.models.RunListResult]
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["_models.RunListResult"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
def prepare_request(next_link=None):
if not next_link:
request = build_list_request(
subscription_id=self._config.subscription_id,
resource_group_name=resource_group_name,
registry_name=registry_name,
filter=filter,
top=top,
template_url=self.list.metadata['url'],
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
else:
request = build_list_request(
subscription_id=self._config.subscription_id,
resource_group_name=resource_group_name,
registry_name=registry_name,
filter=filter,
top=top,
template_url=next_link,
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
request.method = "GET"
return request
def extract_data(pipeline_response):
deserialized = self._deserialize("RunListResult", pipeline_response)
list_of_elem = deserialized.value
if cls:
list_of_elem = cls(list_of_elem)
return deserialized.next_link or None, iter(list_of_elem)
def get_next(next_link=None):
request = prepare_request(next_link)
pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
response = pipeline_response.http_response
if response.status_code not in [200]:
map_error(status_code=response.status_code, response=response, error_map=error_map)
raise HttpResponseError(response=response, error_format=ARMErrorFormat)
return pipeline_response
return ItemPaged(
get_next, extract_data
)
list.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/runs'} # type: ignore
@distributed_trace
def get(
self,
resource_group_name: str,
registry_name: str,
run_id: str,
**kwargs: Any
) -> "_models.Run":
"""Gets the detailed information for a given run.
:param resource_group_name: The name of the resource group to which the container registry
belongs.
:type resource_group_name: str
:param registry_name: The name of the container registry.
:type registry_name: str
:param run_id: The run ID.
:type run_id: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: Run, or the result of cls(response)
:rtype: ~azure.mgmt.containerregistry.v2019_04_01.models.Run
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["_models.Run"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
request = build_get_request(
subscription_id=self._config.subscription_id,
resource_group_name=resource_group_name,
registry_name=registry_name,
run_id=run_id,
template_url=self.get.metadata['url'],
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
response = pipeline_response.http_response
if response.status_code not in [200]:
map_error(status_code=response.status_code, response=response, error_map=error_map)
raise HttpResponseError(response=response, error_format=ARMErrorFormat)
deserialized = self._deserialize('Run', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
get.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/runs/{runId}'} # type: ignore
def _update_initial(
self,
resource_group_name: str,
registry_name: str,
run_id: str,
run_update_parameters: "_models.RunUpdateParameters",
**kwargs: Any
) -> "_models.Run":
cls = kwargs.pop('cls', None) # type: ClsType["_models.Run"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
content_type = kwargs.pop('content_type', "application/json") # type: Optional[str]
_json = self._serialize.body(run_update_parameters, 'RunUpdateParameters')
request = build_update_request_initial(
subscription_id=self._config.subscription_id,
resource_group_name=resource_group_name,
registry_name=registry_name,
run_id=run_id,
content_type=content_type,
json=_json,
template_url=self._update_initial.metadata['url'],
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
response = pipeline_response.http_response
if response.status_code not in [200, 201]:
map_error(status_code=response.status_code, response=response, error_map=error_map)
raise HttpResponseError(response=response, error_format=ARMErrorFormat)
if response.status_code == 200:
deserialized = self._deserialize('Run', pipeline_response)
if response.status_code == 201:
deserialized = self._deserialize('Run', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
_update_initial.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/runs/{runId}'} # type: ignore
@distributed_trace
def begin_update(
self,
resource_group_name: str,
registry_name: str,
run_id: str,
run_update_parameters: "_models.RunUpdateParameters",
**kwargs: Any
) -> LROPoller["_models.Run"]:
"""Patch the run properties.
:param resource_group_name: The name of the resource group to which the container registry
belongs.
:type resource_group_name: str
:param registry_name: The name of the container registry.
:type registry_name: str
:param run_id: The run ID.
:type run_id: str
:param run_update_parameters: The run update properties.
:type run_update_parameters:
~azure.mgmt.containerregistry.v2019_04_01.models.RunUpdateParameters
:keyword callable cls: A custom type or function that will be passed the direct response
:keyword str continuation_token: A continuation token to restart a poller from a saved state.
:keyword polling: By default, your polling method will be ARMPolling. Pass in False for this
operation to not poll, or pass in your own initialized polling object for a personal polling
strategy.
:paramtype polling: bool or ~azure.core.polling.PollingMethod
:keyword int polling_interval: Default waiting time between two polls for LRO operations if no
Retry-After header is present.
:return: An instance of LROPoller that returns either Run or the result of cls(response)
:rtype: ~azure.core.polling.LROPoller[~azure.mgmt.containerregistry.v2019_04_01.models.Run]
:raises: ~azure.core.exceptions.HttpResponseError
"""
content_type = kwargs.pop('content_type', "application/json") # type: Optional[str]
polling = kwargs.pop('polling', True) # type: Union[bool, azure.core.polling.PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType["_models.Run"]
lro_delay = kwargs.pop(
'polling_interval',
self._config.polling_interval
)
cont_token = kwargs.pop('continuation_token', None) # type: Optional[str]
if cont_token is None:
raw_result = self._update_initial(
resource_group_name=resource_group_name,
registry_name=registry_name,
run_id=run_id,
run_update_parameters=run_update_parameters,
content_type=content_type,
cls=lambda x,y,z: x,
**kwargs
)
kwargs.pop('error_map', None)
def get_long_running_output(pipeline_response):
response = pipeline_response.http_response
deserialized = self._deserialize('Run', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
if polling is True: polling_method = ARMPolling(lro_delay, **kwargs)
elif polling is False: polling_method = NoPolling()
else: polling_method = polling
if cont_token:
return LROPoller.from_continuation_token(
polling_method=polling_method,
continuation_token=cont_token,
client=self._client,
deserialization_callback=get_long_running_output
)
else:
return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
begin_update.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/runs/{runId}'} # type: ignore
@distributed_trace
def get_log_sas_url(
self,
resource_group_name: str,
registry_name: str,
run_id: str,
**kwargs: Any
) -> "_models.RunGetLogResult":
"""Gets a link to download the run logs.
:param resource_group_name: The name of the resource group to which the container registry
belongs.
:type resource_group_name: str
:param registry_name: The name of the container registry.
:type registry_name: str
:param run_id: The run ID.
:type run_id: str
:keyword callable cls: A custom type or function that will be passed the direct response
:return: RunGetLogResult, or the result of cls(response)
:rtype: ~azure.mgmt.containerregistry.v2019_04_01.models.RunGetLogResult
:raises: ~azure.core.exceptions.HttpResponseError
"""
cls = kwargs.pop('cls', None) # type: ClsType["_models.RunGetLogResult"]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
request = build_get_log_sas_url_request(
subscription_id=self._config.subscription_id,
resource_group_name=resource_group_name,
registry_name=registry_name,
run_id=run_id,
template_url=self.get_log_sas_url.metadata['url'],
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
response = pipeline_response.http_response
if response.status_code not in [200]:
map_error(status_code=response.status_code, response=response, error_map=error_map)
raise HttpResponseError(response=response, error_format=ARMErrorFormat)
deserialized = self._deserialize('RunGetLogResult', pipeline_response)
if cls:
return cls(pipeline_response, deserialized, {})
return deserialized
get_log_sas_url.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/runs/{runId}/listLogSasUrl'} # type: ignore
def _cancel_initial(
self,
resource_group_name: str,
registry_name: str,
run_id: str,
**kwargs: Any
) -> None:
cls = kwargs.pop('cls', None) # type: ClsType[None]
error_map = {
401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError
}
error_map.update(kwargs.pop('error_map', {}))
request = build_cancel_request_initial(
subscription_id=self._config.subscription_id,
resource_group_name=resource_group_name,
registry_name=registry_name,
run_id=run_id,
template_url=self._cancel_initial.metadata['url'],
)
request = _convert_request(request)
request.url = self._client.format_url(request.url)
pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs)
response = pipeline_response.http_response
if response.status_code not in [200, 202]:
map_error(status_code=response.status_code, response=response, error_map=error_map)
raise HttpResponseError(response=response, error_format=ARMErrorFormat)
if cls:
return cls(pipeline_response, None, {})
_cancel_initial.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/runs/{runId}/cancel'} # type: ignore
@distributed_trace
def begin_cancel(
self,
resource_group_name: str,
registry_name: str,
run_id: str,
**kwargs: Any
) -> LROPoller[None]:
"""Cancel an existing run.
:param resource_group_name: The name of the resource group to which the container registry
belongs.
:type resource_group_name: str
:param registry_name: The name of the container registry.
:type registry_name: str
:param run_id: The run ID.
:type run_id: str
:keyword callable cls: A custom type or function that will be passed the direct response
:keyword str continuation_token: A continuation token to restart a poller from a saved state.
:keyword polling: By default, your polling method will be ARMPolling. Pass in False for this
operation to not poll, or pass in your own initialized polling object for a personal polling
strategy.
:paramtype polling: bool or ~azure.core.polling.PollingMethod
:keyword int polling_interval: Default waiting time between two polls for LRO operations if no
Retry-After header is present.
:return: An instance of LROPoller that returns either None or the result of cls(response)
:rtype: ~azure.core.polling.LROPoller[None]
:raises: ~azure.core.exceptions.HttpResponseError
"""
polling = kwargs.pop('polling', True) # type: Union[bool, azure.core.polling.PollingMethod]
cls = kwargs.pop('cls', None) # type: ClsType[None]
lro_delay = kwargs.pop(
'polling_interval',
self._config.polling_interval
)
cont_token = kwargs.pop('continuation_token', None) # type: Optional[str]
if cont_token is None:
raw_result = self._cancel_initial(
resource_group_name=resource_group_name,
registry_name=registry_name,
run_id=run_id,
cls=lambda x,y,z: x,
**kwargs
)
kwargs.pop('error_map', None)
def get_long_running_output(pipeline_response):
if cls:
return cls(pipeline_response, None, {})
if polling is True: polling_method = ARMPolling(lro_delay, **kwargs)
elif polling is False: polling_method = NoPolling()
else: polling_method = polling
if cont_token:
return LROPoller.from_continuation_token(
polling_method=polling_method,
continuation_token=cont_token,
client=self._client,
deserialization_callback=get_long_running_output
)
else:
return LROPoller(self._client, raw_result, get_long_running_output, polling_method)
begin_cancel.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/runs/{runId}/cancel'} # type: ignore
| Azure/azure-sdk-for-python | sdk/containerregistry/azure-mgmt-containerregistry/azure/mgmt/containerregistry/v2019_04_01/operations/_runs_operations.py | Python | mit | 28,323 |
from ._base import FunctionBase
class Function(FunctionBase):
name = 'import'
doc = 'Imports arg[0] module as arg[1] name'
methods_subclass = {}
def do_import(self, tglobals, elocal, import_module, import_as):
text_mod = 'import %s as %s' % (import_module, import_as)
try:
exec(text_mod, globals(), elocal)
ret = 'Imported %s as %s' % (import_module, import_as)
except Exception as e:
ret = 'Failed to import %s\n%s' % (import_module, str(e))
return ret
def handle_input(self, term_system, term_globals, exec_locals, text):
args = text.split(' ')[1:]
return self.do_import(term_globals, exec_locals, *args)
| Bakterija/mmplayer | mmplayer/kivy_soil/terminal_widget/functions/import.py | Python | mit | 715 |
import unittest
from twisted.internet import defer
from arena.local_arena import LocalIOArena
class GameExampleTests(unittest.TestCase):
"""Tests of situations encountered in games that broke the bot"""
AIG_BOT = "pokeher/theaigame_bot.py"
def __run_test(self, actions):
with LocalIOArena(silent=True) as arena:
arena.print_bot_output = False
arena.load_bot(self.AIG_BOT)
self.assertEqual(arena.bot_count(), 1)
for a in actions:
arena.tell_bots([a])
def callback(action):
self.assertTrue(action)
d = defer.Deferred()
d.addCallback(callback)
arena.get_action("bot_0", d)
def test_timeout_after_flop(self):
"""Something goes bump in the night. This also explodes if extra logging gets added"""
actions = [
"Settings your_bot bot_0",
"Settings timebank 10000",
"Settings time_per_move 500",
"Match round 1",
"Match small_blind 10",
"Match big_blind 20",
"Match on_button player2",
"bot_0 stack 2000",
"player2 stack 2000",
"player2 post 10",
"bot_0 post 20",
"bot_0 hand [Td,Ac]",
"player2 call 10",
"Match max_win_pot 40",
"Match amount_to_call 0",
"bot_0 raise 28",
"player2 call 28",
"Match table [9d,6d,5h]",
"Match max_win_pot 96",
"Match amount_to_call 0",
]
self.__run_test(actions)
def test_main_loop_exception(self):
"""Seeing 'main loop exception' errors during test games"""
actions = [
"Settings your_bot bot_0",
"Settings timebank 10000",
"Settings time_per_move 500",
"Match round 15",
"Match small_blind 15",
"Match big_blind 30",
"Match on_button player2",
"bot_0 stack 2290",
"player2 stack 1710",
"player2 post 15",
"bot_0 post 30",
"bot_0 hand [Ts,3h]",
"player2 raise 60",
"Match max_win_pot 120",
"Match amount_to_call 60",
]
self.__run_test(actions)
| gnmerritt/poker | test/test_game_situations.py | Python | mit | 2,316 |
#!/usr/bin/env python
## path configuration
caffe_root = './caffe'
script_path = '.'
caffe_model = script_path + '/soccer_make_inference.prototxt'
caffe_weight = script_path + '/snapshot/superlatefusion_iter_last.caffemodel'
caffe_inference_weight = script_path + '/superlatefusion_inference.caffemodel'
### start generate caffemodel
print 'start generating BN-testable caffemodel'
print 'caffe_root: %s' % caffe_root
print 'script_path: %s' % script_path
print 'caffe_model: %s' % caffe_model
print 'caffe_weight: %s' % caffe_weight
print 'caffe_inference_weight: %s' % caffe_inference_weight
import numpy as np
import sys
sys.path.append(caffe_root+'/python')
import caffe
from caffe.proto import caffe_pb2
import cv2
net = caffe.Net(caffe_model, caffe_weight)
net.set_mode_cpu()
net.set_phase_test()
def forward_once(net):
start_ind = 0
end_ind = len(net.layers) - 1
net._forward(start_ind, end_ind)
return {out: net.blobs[out].data for out in net.outputs}
print net.params.keys()
res = forward_once(net)
layers = ['data', 'data2', 'seg-label', 'input', 'conv1', 'conv2', 'conv3', 'seg-score']
# debug output
for name in layers:
blob = net.blobs[name]
for b in range(0, 16):
for c in range(0, blob.data[b].shape[0]):
cv2.imwrite('debug/%s/%d-%d.png' %(name, b, c), np.squeeze(blob.data[b][c]))
print 'done'
| xionluhnis/decnet-scripts | training/super_late_fusion/test.py | Python | mit | 1,383 |
from django.conf.urls import patterns, include, url
# Uncomment the next two lines to enable the admin:
# from django.contrib import admin
# admin.autodiscover()
urlpatterns = patterns('',
# Examples:
# url(r'^$', 'manuelalvarez.views.home', name='home'),
# url(r'^manuelalvarez/', include('manuelalvarez.foo.urls')),
# Uncomment the admin/doc line below to enable admin documentation:
# url(r'^admin/doc/', include('django.contrib.admindocs.urls')),
# Uncomment the next line to enable the admin:
# url(r'^admin/', include(admin.site.urls)),
)
| manuel-alvarez/manuelalvarez | manuelalvarez/urls.py | Python | mit | 594 |
import sys
from copy import deepcopy
if sys.stdout.isatty():
RED_FONT_ESC = "\033[1;31m"
GREEN_FONT_ESC = "\033[1;32m"
DEFAULT_FONT_ESC = "\033[0;0m"
else:
RED_FONT_ESC = ""
GREEN_FONT_ESC = ""
DEFAULT_FONT_ESC = ""
class DictWrapper:
@classmethod
def from_dict(cls, source):
ret = cls()
ret.__dict__.update(source)
return ret
def as_dict(self) -> dict:
return deepcopy(self.__dict__)
def cprint(*args, **kwargs):
line = (RED_FONT_ESC, '-=>' + GREEN_FONT_ESC) + args + (DEFAULT_FONT_ESC,)
print(*line, **kwargs)
| pkubik/setags | setags/utils.py | Python | mit | 595 |
from . import node
from . import visitor
| Sibert-Aerts/c2p | src/c2p/grammar/ast/__init__.py | Python | mit | 41 |
import os
from sys import exit
import pygame
import time
#import pywapi
import requests
import string
import logging
import datetime
import calendar
#import threading
import random
# *** Not to be used for commercial use without permission!
# if you want to buy the icons for commercial use please send me a note - http://vclouds.deviantart.com/ ***
#
# Credit goes to Karol Tomala for Python GUI in Linux frame buffer: http://www.karoltomala.com/blog/?p=679
# Credit goes to Jamie Jackson http://blog.jacobean.net/?p=1016 for his nice Tutorial and great Parts of his Code, which i re-use.
# Credit goes to Merlin the Red for his great pictures: http://vclouds.deviantart.com/art/plain-weather-icons-157162192 , which i use.
# ^-> I use his svg files and bring them to ~ 328x328 px
#
# I modify the original code for my 4 inch display and that it work in two 'screens'. First shows the currentday, Secound shows the forecast.
# Further I add some Code and play around with this and that.
# Now there are two img sizes big and small in seperate folders.
# Playing around with the original Code and adding my own Stuff, so I recycled/changed the code mostly.
# If you want to use forecast.io or darksky maybe better using this API: https://github.com/Detrous/darksky
# openweaterdata.org is also a nice API.
#
# This application have the goal to show weathergraphics with SDL Library under it.
# Using Pygame as a Wrapper for SDL Lib. Usage is with X-Server (for testing) and with framebuffer /dev/fbcon.
# With a LCD Display as main display the framebuffer is used as graphic driver.
# installPath is like "/home/username/installfolder/img/big" ... ".../small"
installPathImgBig = "img/big/"
installPathImgSmall = "img/small/"
class PyLcd :
screen = None;
colorBlack = (0, 0, 0)
def init_framebuffer_screen(self):
"Ininitializes a new pygame screen using the framebuffer"
# Based on "Python GUI in Linux frame buffer"
# http://www.karoltomala.com/blog/?p=679
disp_no = os.getenv("DISPLAY")
if disp_no:
print("I'm running under X display = {0}".format(disp_no))
os.putenv('SDL_FBDEV', '/dev/fb1')
# Select frame buffer driver
# Make sure that SDL_VIDEODRIVER is set
driver = 'fbcon'
if not os.getenv('SDL_VIDEODRIVER'):
os.putenv('SDL_VIDEODRIVER', driver)
try:
pygame.display.init()
except Exception as e:
print("exception: {}".format(e))
except pygame.error:
print('Driver: {0} failed.'.format(driver))
exit(0)
size = (pygame.display.Info().current_w, pygame.display.Info().current_h)
self.screen = pygame.display.set_mode(size, pygame.FULLSCREEN)
# Clear the screen to start
self.screen.fill((0, 0, 0))
# Initialise font support
pygame.font.init()
# Render the screen
pygame.display.update()
logging.debug("pygame runs with fbcon support.")
def init_xserver_screen(self):
try:
pygame.init()
#pygame.display.init()
# Create a screen
#size = (pygame.display.Info().current_w, pygame.display.Info().current_h)
#self.screen = pygame.display.set_mode(size, pygame.FULLSCREEN)
self.screen = pygame.display.set_mode((656,415))
pygame.display.set_caption("WeatherScreen")
# Clear the screen to start
self.screen.fill((0, 0, 0))
# Initialise font support
pygame.font.init()
# Render the screen
pygame.display.update()
logging.debug("pygame runs with X-Server support.")
except Exception as e:
logging.error("Error creating pygame Screen for X-Server: {}".format(e))
def __init__(self):
# chose
#disp_no = os.getenv("DISPLAY")
#if disp_no:
# run X
#else
# run under fbcon
self.init_xserver_screen()
logging.debug("pygame screen succesful created.")
print("pygame screen succesful created.")
def __del__(self):
logging.info("pygame screen destructor called -> QUIT now.")
pygame.display.quit()
#print("Destructor pygame display shuts down.")
# Create an instance of the PyLcd class
lcd = PyLcd()
# Constants
pygame.mouse.set_visible(False)
# colours
colorWhite = (255, 255, 255)
colorBlack = (0, 0, 0)
colorYellow = (255,255,0)
colorGreen = (0,255,0)
colorOrange = (255,100,10)
colorRed = (255,0,0)
colorPurple = (240,0,255)
# font
fontpath = pygame.font.match_font('dejavusansmono')
# set up 3 sizes
font = pygame.font.Font(fontpath, 32)
fontS2 = pygame.font.Font(fontpath, 28)
fontSm = pygame.font.Font(fontpath, 18)
# Constants
class PygameWeather(object):
"""This class uses pygame and show on [ X-Server | Framebuffer ] graphic Weatherinformation"""
# class variable
downloadTime = 21600000 # miliseconds
rotationTime = 20000 # miliseconds, for switching between screens
updateRate = 7200 # seconds, for server call # update interval
betweenTime = 20 # seconds, befor screen switching (pause time)
screenTimeOffset = 20 # same Time like betweenTime, was intentionally the time the screens are show
# more vars
app_states = ["initial", "screen1", "screen2", "screen3", "network"] #obsolete
lcd_states = [0,1,2]
state = 0
weather_data = {}
h = 0
w = 0
# today variables
today = ""
windSpeed = ""
currWind = ""
currTemp = ""
currTempFeeling = ""
currPress = ""
uv = ""
todayDesc = ""
humid = ""
# forecast variables
forecastDesc = ""
# forecast data
forecastDays = {}
forecaseHighs = {}
forecaseLows = {}
forecastPrecips = {}
forecastPrecipProps = {}
forecastWinds = {}
forecastIcons = {}
forecastUVs = {}
forecastOzones = {}
forecastHums = {}
forecastSummary = {}
# pygame user events
download_data_event = pygame.USEREVENT + 51
auto_screen_event = pygame.USEREVENT + 50
screen3_event = pygame.USEREVENT + 3
screen2_event = pygame.USEREVENT + 2
screen1_event = pygame.USEREVENT + 1
# set timer for the user events (milliseconds), fires the event every
#pygame.time.set_timer(screen1_event, rotationTime)
#pygame.time.set_timer(screen2_event, rotationTime)
#pygame.time.set_timer(screen3_event, rotationTime)
def getWeekday(self, number):
d_today = datetime.datetime.today()
d_weekday = d_today + datetime.timedelta(days=+number)
dt = d_weekday.weekday()
#d_strs = list(calendar.day_name)
d_strs = list(calendar.day_abbr)
return d_strs[dt]
# create a new event in event queue for state_number
def raise_event(self, state_number):
if state_number == 0:
ee = pygame.event.Event(self.screen1_event)
elif state_number == 1:
ee = pygame.event.Event(self.screen2_event)
elif state_number == 2:
ee = pygame.event.Event(self.screen3_event)
else:
return # state is not known
#pygame.event.post(ee)
pygame.fastevent.post(ee) # enqueue new event
# enabled the timer; timer fires the event every given time milliseconds
def enable_event_timer(self):
#todo: make it generic: betweenTime * n-Screennumber
#pygame.time.set_timer(self.screen1_event, self.rotationTime)
#pygame.time.set_timer(self.screen2_event, self.rotationTime*2)
#pygame.time.set_timer(self.screen3_event, self.rotationTime*3)
pygame.time.set_timer(self.auto_screen_event, self.rotationTime)
# disables the timer for event firing
def disable_event_timer(self):
#pygame.time.set_timer(self.screen1_event, 0)
#pygame.time.set_timer(self.screen2_event, 0)
#pygame.time.set_timer(self.screen3_event, 0)
pygame.time.set_timer(self.auto_screen_event, 0)
# shows the next screen, ring rotation style
def showNext(self):
self.rotate_right()
self.show_screens()
def create_download_event_timer(self):
# jitter: 6h + 0 milisecs [..] 10 mins
every_time = self.downloadTime + random.randint(0, 600000)
pygame.time.set_timer(self.download_data_event, every_time)
def progressScreen(self):
try:
# do this in thread
# while self.updateing_data == True:
picture = installPathImgBig + "wlan.png"
logo = pygame.image.load(picture).convert()
self.w = logo.get_width() / 10.0
self.h = logo.get_height() / 10.0
logo = pygame.transform.scale(logo, (self.w,self.h))
textAnchorY = 360
textAnchorX = 440
self.lcd.screen.blit(logo, (textAnchorX, textAnchorY))
#textYoffset = 40
text_surface = self.font.render("Downloading ...", True, self.colorWhite)
lcd.screen.blit(text_surface, (textAnchorX, textAnchorY+40))
#todo: draw a graphics or use fancy circle something
pygame.display.update()
#pass
except Exception as e:
logging.error("Something wrong with show progress: {}".format(e))
# call weather server, if no connection or error return old data
def callServer( self, mydict ):
"""
returns dictionary with response from weather API Server
if response HTTP Status != 200 returns None
"""
try:
old_values = mydict.copy()
url = 'https://api.forecast.io/forecast/500e8abf656226b5076cd1886f87f8b2/51.0475,13.7404?units=si&lang=de'
params = {}
# params = dict(foo='', foo2='')
resp = requests.get(url=url, params=params)
if (resp.status_code == 200):
data = resp.json()
#pp.pprint(data)
return data
if mydict == {}:
# todo: logging
return None
if resp.status_code != 200:
logging.warning("Using old data from callServer()! Code != 200 error is: {}".format(resp.status_code))
return old_values
# todo add dict return
except Exception as e:
logging.error("Something wrong with callServer: {}".format(e))
# see a clock with secounds
def showClock(self):
# clear screen and update
lcd.screen.fill(colorBlack)
pygame.display.update()
# show the clock @ (10,260), uodate the screen and wait 1 second
updated = time.strftime("%H:%M:%S")
text_surface = fontS2.render(updated, True, colorWhite)
lcd.screen.blit(text_surface, (10, 260))
pygame.display.update()
time.sleep(1)
# format text based on value and return it for blit on text surface
def showUVcolored(self):
uv = self.weather_data['currently']['uvIndex']
if uv >= 0 and uv <= 2:
colored_text_surface = font.render('{} niedrig'.format(self.uv), True, colorGreen)
elif uv >= 3 and uv <= 5:
colored_text_surface = font.render('{} mäßig'.format(self.uv), True, colorYellow)
elif uv >= 6 and uv <= 7:
colored_text_surface = font.render('{} hoch'.format(self.uv), True, colorOrange)
elif uv >= 8 and uv <= 10:
colored_text_surface = font.render('{} Gefahr!'.format(self.uv), True, colorRed)
elif uv >= 11:
colored_text_surface = font.render('{} Extrem!'.format(self.uv), True, colorPurple)
else:
colored_text_surface = None
return colored_text_surface
def showScreen1(self):
# blank the screen
lcd.screen.fill(colorBlack)
# Render the weather logo at 0,0
icon = installPathImgBig + (self.weather_data['currently']['icon']) + ".png"
try:
logo = pygame.image.load(icon).convert()
except e:
logging.error("Error while loading screen1 icon: {}".format(e))
self.w = logo.get_width() - 50
self.h = logo.get_height() - 50
logo = pygame.transform.scale(logo, (self.w,self.h))
lcd.screen.blit(logo, (0, 0))
# set the anchor for the current weather data text
textAnchorX = 260 # 310 war ok bei 328 Bild
textAnchorY = 5
textYoffset = 40
# add current weather data text artifacts to the screen
text_surface = font.render(self.todayDesc, True, colorWhite)
lcd.screen.blit(text_surface, (textAnchorX, textAnchorY))
textAnchorY+=textYoffset
textAnchorY+=textYoffset
text_surface = font.render(self.currTemp, True, colorWhite)
lcd.screen.blit(text_surface, (textAnchorX, textAnchorY))
textAnchorY+=textYoffset
text_surface = font.render(self.currTempFeeling, True, colorWhite)
lcd.screen.blit(text_surface, (textAnchorX, textAnchorY))
textAnchorY+=textYoffset
textAnchorY+=textYoffset
text_surface = font.render(self.currWind, True, colorWhite)
lcd.screen.blit(text_surface, (textAnchorX, textAnchorY))
textAnchorY+=textYoffset
#text_surface = font.render(self.currPress, True, colorWhite)
#lcd.screen.blit(text_surface, (textAnchorX, textAnchorY))
#textAnchorY+=textYoffset
text_surface = self.showUVcolored()
lcd.screen.blit(text_surface, (textAnchorX, textAnchorY))
textAnchorY+=textYoffset
text_surface = font.render(self.humid, True, colorWhite)
lcd.screen.blit(text_surface, (textAnchorX, textAnchorY))
# wait between screen changes screenTimeOffset alias first betweenTime
pygame.display.update()
# wait
def showScreen2(self):
# blank the screen
lcd.screen.fill(colorBlack)
pygame.display.update()
# set X axis text anchor for the forecast text
textAnchorX = 0
textAnchorY = 10
textXoffset = 100 #75
textYoffset = 40
#pygame.draw.line(lcd.screen.get_surface(), colorWhite, (50,10), (450,10),4)
# add summy of the values in one row
for i in range(0,6):
text_surface = fontS2.render(self.forecastDesc[i], True, colorWhite)
lcd.screen.blit(text_surface, (textAnchorX, textAnchorY))
textAnchorY+=textYoffset
textAnchorX+=120
textXoffset = 100
# add each days forecast text + icon
for i in range(1, 5):
try:
textAnchorY = 10
text_surface = fontS2.render(self.forecastDays[i], True, colorWhite)
lcd.screen.blit(text_surface, (textAnchorX, textAnchorY))
textAnchorY+=textYoffset
text_surface = fontS2.render(self.forecaseHighs[i], True, colorWhite)
lcd.screen.blit(text_surface, (textAnchorX, textAnchorY))
textAnchorY+=textYoffset
text_surface = fontS2.render(self.forecaseLows[i], True, colorWhite)
lcd.screen.blit(text_surface, (textAnchorX, textAnchorY))
textAnchorY+=textYoffset
text_surface = fontS2.render(self.forecastHums[i], True, colorWhite)
lcd.screen.blit(text_surface, (textAnchorX, textAnchorY))
textAnchorY+=textYoffset
text_surface = fontS2.render(self.forecastWinds[i], True, colorWhite)
lcd.screen.blit(text_surface, (textAnchorX, textAnchorY))
textAnchorY+=textYoffset
text_surface = fontS2.render(self.forecastUVs[i], True, colorWhite)
lcd.screen.blit(text_surface, (textAnchorX, textAnchorY))
textAnchorY+=textYoffset
#text_surface = fontS2.render(self.forecastPrecips[i], True, colorWhite) # Niederschlag
#lcd.screen.blit(text_surface, (textAnchorX, textAnchorY))
#textAnchorY+=textYoffset
except pygame.error as message:
logging.warning("showscreen2 text at position i: {}, {}".format(i, message))
try:
logo = pygame.image.load(self.forecastIcons[i]).convert()
self.w = logo.get_width()
self.h = logo.get_height()
logo = pygame.transform.scale(logo, (self.w,self.h))
lcd.screen.blit(logo, (textAnchorX, textAnchorY))
textAnchorX+=textXoffset
except FileNotFoundError:
logging.warning("showscreen2: cannot found a picture at position i: {}, {}".format(i, self.forecastIcons[i]))
self.forecastIcons[i] = installPathImgSmall + "na.png"
logo = pygame.image.load(self.forecastIcons[i]).convert()
self.w = logo.get_width()
self.h = logo.get_height()
logo = pygame.transform.scale(logo, (self.w,self.h))
lcd.screen.blit(logo, (textAnchorX, textAnchorY))
textAnchorX+=textXoffset
except pygame.error as message:
logging.warning("showscreen2 icons: {}".format(message))
# today desc under the table
textAnchorY = 330
textAnchorX = 440
updated = time.strftime("%H:%M")
text_surface = fontS2.render('{}'.format(updated) , True, colorWhite)
lcd.screen.blit(text_surface, (textAnchorX, textAnchorY))
# update when information
#textAnchorY+=textYoffset
#updated = time.strftime("%A %H:%M") #time.strftime("%H:%M:%S"), time.strftime("%H:%M"), time.strftime("%c"), time.strftime("%A %H:%M")
#text_surface = fontS2.render(updated, True, colorWhite)
#lcd.screen.blit(text_surface, (textAnchorX, textAnchorY))
# update screen with forecast text
pygame.display.update()
# wait
def showScreen3(self):
# screen3 siesta beginns
if (time.strftime("%H:%M") >= '11:00' and time.strftime("%H:%M") <= '15:00') or self.weather_data['currently']['uvIndex'] >= 6:
lcd.screen.fill(colorBlack)
icon = installPathImgBig + "siesta.jpeg"
logo = pygame.image.load(icon).convert()
self.w = logo.get_width() - 400
self.h = logo.get_height() - 400
logo = pygame.transform.scale(logo, (self.w,self.h))
lcd.screen.blit(logo, (0, 0))
textAnchorX = 310
textAnchorY = 5
textYoffset = 40
text_surface = font.render("Siesta ...", True, colorWhite)
if self.weather_data['currently']['uvIndex'] >= 8:
text_surface = font.render("Siesta !!!", True, colorRed)
lcd.screen.blit(text_surface, (textAnchorX, textAnchorY))
pygame.display.update()
#time.sleep(self.screenTimeOffset)
self.betweenTime += self.screenTimeOffset
# screen3 siesta ends
# screen3 beginn
if (time.strftime("%H:%M") >= '18:00' and time.strftime("%H:%M") <= '19:30') or (time.strftime("%d/%m") == '05/12'):
lcd.screen.fill(colorBlack)
icon = installPathImgBig + "easteregg.png"
logo = pygame.image.load(icon).convert()
self.w = logo.get_width() - 30
self.h = logo.get_height() - 30
logo = pygame.transform.scale(logo, (self.w,self.h))
lcd.screen.blit(logo, (0, 0))
textAnchorX = 310
textAnchorY = 5
textYoffset = 40
text_surface = font.render("Pause ...", True, colorWhite)
lcd.screen.blit(text_surface, (textAnchorX, textAnchorY))
pygame.display.update()
#time.sleep(self.screenTimeOffset)
self.betweenTime += self.screenTimeOffset
# screen3 ends
def updateValues(self):
if self.weather_data != {} and self.weather_data != None:
try:
# extract current data for today
self.windSpeed = str(self.weather_data['currently']['windSpeed'])
self.currWind = "{} km/h ".format(self.windSpeed)
self.currTemp = str( self.weather_data['currently']['temperature'] ) + u' \N{DEGREE SIGN}' + "C"
self.currPress = str( self.weather_data['currently']['pressure'] ) + " mb"
self.ozon = "{} Ozone".format(self.weather_data['currently']['ozone'])
self.uv = "{} UV-Index".format(self.weather_data['currently']['uvIndex'])
self.humid = "{}% Humidity".format(self.weather_data['currently']['humidity'] * 100)
self.currTempFeeling = "gefühlt " + str( self.weather_data['currently']['apparentTemperature'] ) + u' \N{DEGREE SIGN}' + "C"
self.todayDesc = str( self.weather_data['currently']['summary'] )
except e:
logging.warning("fetching data error in currently data: {}".format(e))
# summary and description of forecast data
self.forecastDesc = ["Day", "Max" + u'\N{DEGREE SIGN}' + "C", "Min" + u'\N{DEGREE SIGN}' + "C", "Hum", "km/h", "UV"] # forecastDesc = ["Day", "Max", "Min", "Hum", "Kmh"]
for i in range(0, 5):
if not(self.weather_data['daily']['data'][i]):
break
try:
self.forecastDays[i] = self.getWeekday(i)
self.forecastSummary[i] = str(self.weather_data['daily']['data'][i]['summary'])
self.forecaseHighs[i] = str(self.weather_data['daily']['data'][i]['temperatureHigh'])
self.forecaseLows[i] = str(self.weather_data['daily']['data'][i]['temperatureLow'])
self.forecastPrecips[i] = str(self.weather_data['daily']['data'][i]['precipType'])
self.forecastPrecipProps[i] = str(self.weather_data['daily']['data'][i]['precipProbability'] * 100) + "%"
self.forecastWinds[i] = str(self.weather_data['daily']['data'][i]['windSpeed'])
self.forecastHums[i] = str(self.weather_data['daily']['data'][i]['humidity'] * 100) + "%"
self.forecastUVs[i] = str(self.weather_data['daily']['data'][i]['uvIndex'])
self.forecastOzones[i] = str(self.weather_data['daily']['data'][i]['ozone'])
except e:
logging.warning("fetching data error in forecast data: {}".format(e))
try:
self.forecastIcons[i] = installPathImgSmall + str(self.weather_data['daily']['data'][i]['icon']) + ".png"
#print(str(self.weather_data['daily']['data'][i]['icon']))
except e:
logging.warning("update icons for pictures: {}".format(e))
logging.debug("update values/icons done.")
def updateScreen(self, state):
# clear everything before changeing screens
lcd.screen.fill(colorBlack)
pygame.display.update()
if state == 1:
self.showScreen1()
if state == 2:
self.showScreen2()
if state == 3:
self.showScreen3()
if state < 0 or state > 3:
logging.warning("updateScreen(): updateing to unknown state")
# Key Event checker Thread
def threadEventChecker(self):
keep_alive = True
while keep_alive:
event = pygame.fastevent.wait()
#print(event)
if event.type == pygame.KEYDOWN:
# Was it the Escape key? If so, stop the loop.
if event.key == pygame.K_ESCAPE:
print("helper thread is dieing")
keep_alive = False
if event.key == pygame.K_RIGHT:
print("right key pressed")
self.state = self.state + 1
if self.state > 2:
self.state = 0
ee = pygame.event.Event(self.screen1_event) # enqueue new event
else:
if self.state == 1:
ee = pygame.event.Event(self.screen2_event) # enqueue new event
if self.state == 2:
ee = pygame.event.Event(self.screen3_event) # enqueue new event
pygame.fastevent.post(ee)
print("next screen: {}".format(self.state))
if event.key == pygame.K_LEFT:
print("left key pressed")
self.state = self.state - 1
if self.state < 0:
self.state = 2
ee = pygame.event.Event(self.screen3_event)
else:
if self.state == 0:
ee = pygame.event.Event(self.screen1_event) # enqueue new event
if self.state == 1:
ee = pygame.event.Event(self.screen2_event)
pygame.fastevent.post(ee)
print("next screen: {}".format(self.state))
# Events Screen related
if event.type == pygame.USEREVENT:
if event.type == self.screen1_event:
print("need to handle screen1 change")
self.showScreen1()
if event.type == self.screen2_event:
print("need to handle screen2 change")
self.showScreen2()
if event.type == self.screen3_event:
print("need to handle screen3 change")
self.showScreen3()
# rotate the states left
def rotate_left(self):
self.state = self.state - 1
if self.state < 0:
self.state = 2
# rotate the states right
def rotate_right(self):
self.state = self.state + 1
if self.state > 2:
self.state = 0
# show the screens matching states
def show_screens(self):
if self.state == 0:
self.showScreen1()
if self.state == 1:
self.showScreen2()
if self.state == 2:
self.showScreen3()
time.sleep(0.001)
def main(self):
# initial stuff do only one time
#todo: Call Server and update data (calling each day 3-5 times (6 hours))
#todo: in initial setup, fire an event which rise again in 6 hours
# initial server calling
self.weather_data = self.callServer(self.weather_data)
if self.weather_data != None:
self.updateValues()
FPS = 60
FramePerSec = pygame.time.Clock()
FramePerSec.tick(FPS)
pygame.fastevent.init()
pygame.event.set_blocked(pygame.MOUSEMOTION)
# wait until fastevent system is alive
while pygame.fastevent.get_init() == False:
pass
# initial screen
self.state = 0
#self.showScreen1()
# enable timer for screen rotation
self.enable_event_timer()
# enable first download timer
pygame.time.set_timer(self.download_data_event, self.downloadTime)
running = True
print("=== Initial Stuff done ===")
# main loop
while running:
# Event Checker
event = pygame.event.wait()
#for event in pygame.fastevent.get():
#print(event)
if event.type == pygame.NOEVENT:
#ee = pygame.event.Event(self.screen1_event)
#pygame.fastevent.post(ee)
pass
# Events Exit related
elif event.type == pygame.QUIT:
running = False
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
print("main thread is dieing")
running = False
# switching between screens on Events Arrow Keys
if event.key == pygame.K_RIGHT:
self.rotate_right()
self.show_screens()
if event.key == pygame.K_LEFT:
self.rotate_left()
self.show_screens()
# Events manageing
elif event.type == self.auto_screen_event:
print("=== screen rotation ===")
self.showNext()
elif event.type == self.screen1_event:
print("event for screen1 recon")
elif event.type == self.screen2_event:
print("event for screen2 recon")
self.showScreen2()
elif event.type == self.screen3_event:
print("event for screen3 recon")
self.showScreen3()
elif event.type == self.download_data_event:
print("=== download event ===")
# handle event
self.progressScreen()
self.weather_data = self.callServer(self.weather_data)
if self.weather_data != None:
self.updateValues()
self.self.updateing_data = False
logging.info("Calling server successful")
# handle timer
pygame.event.clear(self.download_data_event) # delete old event
self.create_download_event_timer() # create new event with jitter
else:
pass # ignore other event types
# Event Checker
# (obsolete) old state machine
"""
if self.betweenTime >= self.updateRate:
self.betweenTime = 0
self.progressScreen() # todo: draw some graphical informations on current screen
logging.info(format(self.updateRate) + " seconds is over, Calling server...")
self.weather_data = self.callServer( self.weather_data )
logging.info("Calling server successful")
"""
pygame.display.quit()
#pygame.quit()
exit()
if __name__ == '__main__':
logging.basicConfig(level=logging.DEBUG, filename="logfile", filemode="a+", format="%(asctime)s %(levelname)s:%(message)s")
try:
myweatherprogramm = PygameWeather()
myweatherprogramm.main()
except Exception as e:
logging.warning(e)
| schnitzlein/weatherstation | WeatherScreen.py | Python | mit | 31,076 |
"""
In this module, the views of the recommender API are defined. According to
their definition, views are functions that take a web request and return a
web response. Therefore, they are the main entry points of the recommender
system. Moreover, they describe what the system is capable of and how the
system is accessed.
"""
from core import InvalidUsage
from flask import request
from flask import jsonify
from flask import Blueprint
from flask import current_app
from flask.ext.restful.inputs import datetime_from_iso8601
from functools import wraps
import logging
from services import report_view_action
from services import report_copy_action
import services
from .recommendations import get_recommender
logger = logging.getLogger(__name__)
rec_api = Blueprint('rec_api', __name__)
def api_key_required(view_function):
"""
Decorator for view functions that checks if the correct API key is
transferred
"""
@wraps(view_function)
def decorated_function(*args, **kwargs):
if 'api_key' in request.args and\
request.args.get('api_key') == current_app.config['API_KEY']:
return view_function(*args, **kwargs)
else:
logger.info('Wrong API Key received')
raise InvalidUsage(
u'Invalid API key',
status_code=403)
return decorated_function
def parse_arg(
request, arg_name, default_value=None, type=None, required=False):
"""
Function for parsing arguments
Arguments can be defined as required. In this case a InvalidUsage exception
is thrown
"""
try:
arg = request.args[arg_name]
if type is not None:
arg = type(arg)
except KeyError:
if required:
raise InvalidUsage(
u'Missing required parameter {}'.format(arg_name),
status_code=400)
arg = default_value
except ValueError:
if required:
raise InvalidUsage(
u'Parameter {} could not be parsed'.format(arg_name),
status_code=400)
arg = default_value
return arg
def parse_bool(string):
"""
Parsing function for bool values
"""
return string.lower() == 'true'
@rec_api.route('/api/view', methods=['GET'])
@api_key_required
def view():
"""
Stores a view action that a user has performed on a record
:param record_id: the id of the record
:param is_internal_record: boolean indicating if record is internal
:param session_id: the id of the session in which the action occurred
:param timestamp: the timestamp of the action
:param query_string: the query that has led to the action
"""
is_internal_record = parse_arg(
request, 'is_internal_record', required=True, type=parse_bool)
record_id = parse_arg(request, 'record_id', required=True)
session_id = parse_arg(request, 'session_id', required=True)
timestamp = parse_arg(
request, 'timestamp', required=True, type=datetime_from_iso8601)
query_string = parse_arg(request, 'query_string', required=False)
current_app.logger.info(
'View action received. Record: %s, Session: %s, Query: %s',
record_id, session_id, query_string)
report_view_action(
query_string=query_string, record_id=record_id, timestamp=timestamp,
session_id=session_id, is_internal_record=is_internal_record)
return jsonify(success=True)
@rec_api.route('/api/copy', methods=['GET'])
@api_key_required
def copy():
"""
Stores a copy action that a user has performed on a record
:param record_id: the id of the record
:param is_internal_record: boolean indicating if record is internal
:param session_id: the id of the session in which the action occurred
:param timestamp: the timestamp of the action
:param query_string: the query that has led to the action
"""
is_internal_record = parse_arg(
request, 'is_internal_record', required=True, type=parse_bool)
record_id = parse_arg(request, 'record_id', required=True)
session_id = parse_arg(request, 'session_id', required=True)
timestamp = parse_arg(
request, 'timestamp', required=True, type=datetime_from_iso8601)
query_string = parse_arg(request, 'query_string', required=False)
current_app.logger.info(
'Copy action received. Record: %s, Session: %s, Query: %s',
record_id, session_id, query_string)
report_copy_action(
query_string=query_string, record_id=record_id, timestamp=timestamp,
session_id=session_id, is_internal_record=is_internal_record)
return jsonify(success=True)
@rec_api.route('/api/influenced_by_your_history', methods=['GET'])
@api_key_required
def influenced_by_your_history():
"""
Gets a list of recommended records based on a session's history
:param session_id: the id of the session to which the records are
recommended
:param max_num_recs: the maximum number of recommendations to return
:param include_internal_records: indicates if internal records should be
recommended
"""
include_internal_records = parse_arg(
request, 'include_internal_records', required=True, type=parse_bool)
print(include_internal_records)
session_id = parse_arg(request, 'session_id', required=True)
max_num_recs = parse_arg(
request, 'max_num_recs', required=False, type=int)
current_app.logger.info(
'Influenced by your history request. Session: %s',
session_id)
recommender = get_recommender(include_internal_records)
recs = recommender.influenced_by_your_history(
session_id=session_id, max_num_recs=max_num_recs)
return jsonify(results=[
{'record_id': record_id, 'score': score} for record_id, score in recs
])
@rec_api.route('/api/other_users_also_used', methods=['GET'])
@api_key_required
def other_users_also_used():
"""
Returns a list of records that were used together with the given one
:param session_id: the id of the record
:param max_num_recs: the maximum number of recommendations to return
:param include_internal_records: indicates if internal records should be
recommended
"""
include_internal_records = parse_arg(
request, 'include_internal_records', required=True, type=parse_bool)
record_id = parse_arg(request, 'record_id', required=True)
max_num_recs = parse_arg(
request, 'max_num_recs', required=False, type=int)
current_app.logger.info(
'Other Users also used. Record: %s',
record_id)
recommender = get_recommender(include_internal_records)
recs = recommender.other_users_also_used(
record_id, max_num_recs=max_num_recs)
return jsonify(results=[
{'record_id': r_id, 'score': score} for r_id, score in recs
])
@rec_api.route('/api/recommended_search_results', methods=['GET'])
@api_key_required
def recommended_search_results():
"""
Returns a list of records that were viewed after entering the query
:param query_string: the query that was entered by the user
:param max_num_recs: the maximum number of recommendations to return
:param include_internal_records: indicates if internal records should be
recommended
"""
include_internal_records = parse_arg(
request, 'include_internal_records', required=True, type=parse_bool)
query_string = parse_arg(request, 'query_string', required=True)
max_num_recs = parse_arg(
request, 'max_num_recs', required=False, type=int)
current_app.logger.info(
'Recommended Search Results. Query: %s',
query_string)
recommender = get_recommender(include_internal_records)
recs = recommender.recommend_search_results(
query_string, max_num_recs=max_num_recs)
return jsonify(results=[rec.serialize() for rec in recs])
@rec_api.route('/api/similar_queries', methods=['GET'])
@api_key_required
def similar_queries():
"""
Returns a list of queries which are similar to the target query
:param query_string: the query that was entered by the user
"""
query_string = parse_arg(request, 'query_string', required=True)
current_app.logger.info(
'Similar Queries Request received: %s', query_string)
similar_queries = get_recommender(True).get_similar_queries(
query_string)
return jsonify(
{'results': [sim_q for sim_q in similar_queries]}
)
@rec_api.route('/api/set_record_active', methods=['GET'])
@api_key_required
def set_record_active():
"""
Sets a record active or inactive. Inactive records will not be recommended.
:param record_id: the id of the record to be activated/deactivated
:param active: boolean indicating if setting active or inactive
"""
record_id = parse_arg(request, 'record_id', required=True)
active = parse_arg(request, 'active', required=True, type=parse_bool)
services.set_record_active(record_id, active)
return jsonify(success=True)
@rec_api.route('/api/import_record_similarity', methods=['GET'])
@api_key_required
def import_record_similarity():
"""
Imports a similarity value from one record to the other
Only as many similarities as specified in max_sims_per_record are stored
per record. If, by inclusion of the similarity, this value is exceeded,
only the top similarities are preserved.
:param from_record_id: the id of the record from which the similarity is
directed
:param from_is_internal: boolean indicating if from record is internal
:param to_record_id: the id of the record to which the similarity is
directed
:param to_is_internal: boolean indicating if the to record is internal
:param similarity: the similarity of the two records
"""
from_record_id = parse_arg(request, 'from_record_id', required=True)
to_record_id = parse_arg(request, 'to_record_id', required=True)
from_is_internal = parse_arg(
request, 'from_record_is_internal', required=True, type=parse_bool)
to_is_internal = parse_arg(
request, 'to_record_is_internal', required=True, type=parse_bool)
sim_value = parse_arg(
request, 'similarity_value', required=True, type=float)
services.import_record_similarity(
from_record_id, from_is_internal,
to_record_id, to_is_internal,
sim_value)
return jsonify(success=True)
@rec_api.errorhandler(InvalidUsage)
def handle_invalid_usage(error):
response = jsonify(error.to_dict())
response.status_code = error.status_code
return response
| feibl/search-rex | search_rex/views.py | Python | mit | 10,635 |
"""
Handler for user Register: Inherits from Signup
Completes the registration of a user i.e. put()
of use details to ndb
"""
# [START imports]
from myapp.handlers.signup import SignUp
from myapp.models.user import *
from myapp.tools.hcookie import make_secure_val
# [END imports]
# [START Register]
class Register(SignUp):
"""
Inherits from the Signup handler.
Manages user duplication error if username already exists.
If username is valid, puts new user details to the datastore,
sets a cookie and redirects to the home page."""
def done(self):
"""Performs final check on unique username, puts user details to ndb"""
# make sure the user doesn't already exist
u = User.by_name(self.username)
if u:
error = 'That user already exists.'
self.render('signup.html', error_username=error)
else:
u = User.register(self.username, self.password, self.email)
u.put()
# set cookie
self.response.headers.add_header(
'Set-Cookie', 'name=%s; Path=/'
% str(make_secure_val(self.username)))
self.redirect('/')
# [END Register]
| cubiio/fsnd-blog | myapp/handlers/register.py | Python | mit | 1,200 |
"""Extension controller for working with extensions in the pod."""
from grow.common import extensions as common_extensions
from grow.extensions import core
from grow.extensions import hooks
from grow.extensions import hook_controller
class ExtensionController(object):
"""Controller for working with pod extensions."""
def __init__(self, pod):
self.pod = pod
self._hooks = {}
self._extensions = {}
for hook in hooks.HOOKS:
self._hooks[hook.KEY] = hook_controller.HookController(
self.pod, hook.KEY, hook(None))
def register_builtins(self):
"""Add new built-in extensions."""
new_extensions = []
for extension_cls in core.EXTENSIONS:
ext = extension_cls(self.pod, {})
new_extensions.append(ext)
# Register the hooks with the hook controllers.
for _, hook in self._hooks.iteritems():
hook.register_extensions(new_extensions)
def register_extensions(self, extension_configs):
"""Add new extensions to the controller."""
new_extensions = []
for config_item in extension_configs:
if isinstance(config_item, basestring):
extension_path = config_item
config = {}
else:
extension_path = config_item.keys()[0]
config = config_item[extension_path]
cls = common_extensions.import_extension(extension_path, [self.pod.root])
ext = cls(self.pod, config)
new_extensions.append(ext)
self._extensions[extension_path] = ext
# Register the hooks with the hook controllers.
for _, hook in self._hooks.iteritems():
hook.register_extensions(new_extensions)
def trigger(self, hook_key, *args, **kwargs):
"""Trigger a hook."""
return self._hooks[hook_key].trigger(*args, **kwargs)
def update_extension_configs(self, extension_configs):
"""Update existing extensions with new configs."""
for config_item in extension_configs:
if isinstance(config_item, basestring):
extension_path = config_item
config = {}
else:
extension_path = config_item.keys()[0]
config = config_item[extension_path]
ext = self._extensions[extension_path]
ext.config = config
| grow/pygrow | grow/extensions/extension_controller.py | Python | mit | 2,425 |
from setuptools import setup, find_packages
from codecs import open
from os import path
#from wmtexe.commands.configure import Configure
#from wmtexe.commands.install import Install
_HERE = path.abspath(path.dirname(__file__))
def read(*names, **kwds):
return open(
path.join(_HERE, *names),
encoding=kwds.get('encoding', 'utf-8')
).read()
def find_version(*file_paths):
import re
version_file = read(*file_paths)
version_match = re.search(r"^__version__ = ['\"]([^'\"]*)['\"]",
version_file, re.M)
if version_match:
return version_match.group(1)
raise RuntimeError("Unable to find version string.")
setup(
name='bmibuilder',
version=find_version("bmibuilder/__init__.py"),
description='Create BMI templates.',
long_description=read('README.md'),
url='https://github.com/csdms/bmi-builder',
author='Eric Hutton',
author_email='[email protected]',
license='MIT',
packages=['bmibuilder', 'bmibuilder.writers'],
entry_points={
'console_scripts': [
'bmi-build=bmibuilder.build:main',
],
},
#cmdclass={
# 'configure': Configure,
# 'install': Install,
#},
)
| bmi-forum/bmi-builder | setup.py | Python | mit | 1,248 |
import copy
import multiprocessing
import os
from pathlib import PurePath
import subprocess
import sys
import tempfile
from textwrap import dedent
import unittest
try:
from unittest.mock import MagicMock
except:
from mock import MagicMock
from green import cmdline
class TestFinalizer(unittest.TestCase):
def setUp(self):
self.tmpdir = tempfile.mkdtemp()
def test_finalizer(self):
"""
Test that the finalizer works on Python 3.8+
"""
sub_tmpdir = tempfile.mkdtemp(dir=self.tmpdir)
for i in range(multiprocessing.cpu_count() * 2):
fh = open(os.path.join(sub_tmpdir, f"test_finalizer{i}.py"), "w")
fh.write(
dedent(
f"""
import unittest
class Pass{i}(unittest.TestCase):
def test_pass{i}(self):
pass
def msg():
print("finalizer worked")
"""
)
)
fh.close()
args = [
sys.executable,
"-m",
"green.cmdline",
"--finalizer=test_finalizer0.msg",
"--maxtasksperchild=1",
]
pythonpath = str(PurePath(__file__).parent.parent.parent)
env = copy.deepcopy(os.environ)
env["PYTHONPATH"] = pythonpath
output = subprocess.run(
args,
cwd=sub_tmpdir,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
env=env,
timeout=10,
).stdout.decode("utf-8")
self.assertIn("finalizer worked", output)
| CleanCut/green | green/test/test_integration.py | Python | mit | 1,664 |
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import glob
import csv
"""Grab the country-codes out of already existing txt-files which
contain the results of 'whois' and write them in a csv-file ordered
descending by occurance"""
# define an empty list to store the temporary results
country_list = []
# assuming that every file containing the whois-data has a filename
# of the type in the brackets of glob.glob
for file in glob.glob('whois*.txt'):
with open(file) as source:
data = source.readlines() # all the lines will be read at once
for line in data:
line = line.strip()
# we want only the lines starting with "country:"
if line.startswith('country:') or line.startswith('Country:'):
country_list.append(line)
break
#defining an empty dictionary for counting the country-codes
lst = {}
# looping through the list, splitting the elements and exctracting only the country-code
for item in country_list:
pieces = item.strip().split(":")
c_code = pieces[1].strip()
# print(c_code) # for debugging purposes
lst[c_code] = lst.get(c_code, 0) + 1
# creating an empty list as "hitlist"
hitlist = []
# loop through the dictionary, write the tuples within the created list with the count
# as the first entry followed by the corresponding country-code
for c_code, count in lst.items():
hitlist.append((count, c_code))
# sort the hitlist in descending order based on how often the ip-address was detected
hitlist.sort(reverse=True)
# write results in a csv-file
target = open("countries.csv", "w")
for item in hitlist:
csv.writer(target).writerow(item)
last_row = [len(country_list), "Total"]
csv.writer(target).writerow(last_row)
target.close() # close the target-file when work is done
| alex-gehrig/geoextractor | geoextractor.py | Python | mit | 1,803 |
# -*- coding: utf-8 -*-
# Generated by Django 1.11 on 2017-07-07 15:11
from __future__ import unicode_literals
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
operations = [
migrations.CreateModel(
name='AnnotationConstraint',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=255, unique=True)),
('description', models.TextField(blank=True)),
('text', models.TextField(blank=True)),
('creation_time', models.DateTimeField()),
],
options={
'db_table': 'vesper_annotation_constraint',
},
),
migrations.CreateModel(
name='AnnotationInfo',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=255, unique=True)),
('description', models.TextField(blank=True)),
('type', models.CharField(choices=[('String', 'String')], max_length=255)),
('creation_time', models.DateTimeField()),
('constraint', models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='annotation_infos', related_query_name='annotation_info', to='vesper.AnnotationConstraint')),
],
options={
'db_table': 'vesper_annotation_info',
},
),
migrations.CreateModel(
name='Clip',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('start_index', models.BigIntegerField(null=True)),
('length', models.BigIntegerField()),
('sample_rate', models.FloatField()),
('start_time', models.DateTimeField()),
('end_time', models.DateTimeField()),
('date', models.DateField()),
('creation_time', models.DateTimeField()),
],
options={
'db_table': 'vesper_clip',
},
),
migrations.CreateModel(
name='Device',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=255, unique=True)),
('serial_number', models.CharField(max_length=255)),
('description', models.TextField(blank=True)),
],
options={
'db_table': 'vesper_device',
},
),
migrations.CreateModel(
name='DeviceConnection',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('start_time', models.DateTimeField()),
('end_time', models.DateTimeField()),
],
options={
'db_table': 'vesper_device_connection',
},
),
migrations.CreateModel(
name='DeviceInput',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('device', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='inputs', related_query_name='input', to='vesper.Device')),
],
options={
'db_table': 'vesper_device_input',
},
),
migrations.CreateModel(
name='DeviceModel',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=255, unique=True)),
('type', models.CharField(max_length=255)),
('manufacturer', models.CharField(max_length=255)),
('model', models.CharField(max_length=255)),
('description', models.TextField(blank=True)),
],
options={
'db_table': 'vesper_device_model',
},
),
migrations.CreateModel(
name='DeviceModelInput',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('local_name', models.CharField(max_length=255)),
('channel_num', models.IntegerField()),
('description', models.TextField(blank=True)),
('model', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='inputs', related_query_name='input', to='vesper.DeviceModel')),
],
options={
'db_table': 'vesper_device_model_input',
},
),
migrations.CreateModel(
name='DeviceModelOutput',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('local_name', models.CharField(max_length=255)),
('channel_num', models.IntegerField()),
('description', models.TextField(blank=True)),
('model', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='outputs', related_query_name='output', to='vesper.DeviceModel')),
],
options={
'db_table': 'vesper_device_model_output',
},
),
migrations.CreateModel(
name='DeviceOutput',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('device', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='outputs', related_query_name='output', to='vesper.Device')),
('model_output', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='device_outputs', related_query_name='device_output', to='vesper.DeviceModelOutput')),
],
options={
'db_table': 'vesper_device_output',
},
),
migrations.CreateModel(
name='Job',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('command', models.TextField()),
('start_time', models.DateTimeField(null=True)),
('end_time', models.DateTimeField(null=True)),
('status', models.CharField(max_length=255)),
('creation_time', models.DateTimeField()),
('creating_job', models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='jobs', related_query_name='job', to='vesper.Job')),
('creating_user', models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='jobs', related_query_name='job', to=settings.AUTH_USER_MODEL)),
],
options={
'db_table': 'vesper_job',
},
),
migrations.CreateModel(
name='Processor',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=255)),
('type', models.CharField(max_length=255)),
('description', models.TextField(blank=True)),
],
options={
'db_table': 'vesper_processor',
},
),
migrations.CreateModel(
name='Recording',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('num_channels', models.IntegerField()),
('length', models.BigIntegerField()),
('sample_rate', models.FloatField()),
('start_time', models.DateTimeField()),
('end_time', models.DateTimeField()),
('creation_time', models.DateTimeField()),
('creating_job', models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='recordings', related_query_name='recording', to='vesper.Job')),
('recorder', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='recordings', related_query_name='recording', to='vesper.Device')),
],
options={
'db_table': 'vesper_recording',
},
),
migrations.CreateModel(
name='RecordingChannel',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('channel_num', models.IntegerField()),
('recorder_channel_num', models.IntegerField()),
('mic_output', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='recording_channels', related_query_name='recording_channel', to='vesper.DeviceOutput')),
('recording', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='channels', related_query_name='channel', to='vesper.Recording')),
],
options={
'db_table': 'vesper_recording_channel',
},
),
migrations.CreateModel(
name='RecordingFile',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('file_num', models.IntegerField()),
('start_index', models.BigIntegerField()),
('length', models.BigIntegerField()),
('path', models.CharField(max_length=255, null=True, unique=True)),
('recording', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='files', related_query_name='file', to='vesper.Recording')),
],
options={
'db_table': 'vesper_recording_file',
},
),
migrations.CreateModel(
name='Station',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=255, unique=True)),
('latitude', models.FloatField(null=True)),
('longitude', models.FloatField(null=True)),
('elevation', models.FloatField(null=True)),
('time_zone', models.CharField(max_length=255)),
('description', models.TextField(blank=True)),
],
options={
'db_table': 'vesper_station',
},
),
migrations.CreateModel(
name='StationDevice',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('start_time', models.DateTimeField()),
('end_time', models.DateTimeField()),
('device', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='station_devices', related_query_name='station_device', to='vesper.Device')),
('station', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='station_devices', related_query_name='station_device', to='vesper.Station')),
],
options={
'db_table': 'vesper_station_device',
},
),
migrations.CreateModel(
name='StringAnnotation',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('value', models.CharField(max_length=255)),
('creation_time', models.DateTimeField()),
('clip', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='string_annotations', related_query_name='string_annotation', to='vesper.Clip')),
('creating_job', models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='string_annotations', related_query_name='string_annotation', to='vesper.Job')),
('creating_processor', models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='string_annotations', related_query_name='string_annotations', to='vesper.Processor')),
('creating_user', models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='string_annotations', related_query_name='string_annotation', to=settings.AUTH_USER_MODEL)),
('info', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='string_annotations', related_query_name='string_annotation', to='vesper.AnnotationInfo')),
],
options={
'db_table': 'vesper_string_annotation',
},
),
migrations.CreateModel(
name='StringAnnotationEdit',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('action', models.CharField(choices=[('S', 'Set'), ('D', 'Delete')], max_length=1)),
('value', models.CharField(max_length=255, null=True)),
('creation_time', models.DateTimeField()),
('clip', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='string_annotation_edits', related_query_name='string_annotation_edit', to='vesper.Clip')),
('creating_job', models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='string_annotation_edits', related_query_name='string_annotation_edit', to='vesper.Job')),
('creating_processor', models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='string_annotation_edits', related_query_name='string_annotation_edits', to='vesper.Processor')),
('creating_user', models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='string_annotation_edits', related_query_name='string_annotation_edit', to=settings.AUTH_USER_MODEL)),
('info', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='string_annotation_edits', related_query_name='string_annotation_edit', to='vesper.AnnotationInfo')),
],
options={
'db_table': 'vesper_string_annotation_edit',
},
),
migrations.CreateModel(
name='Tag',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('creation_time', models.DateTimeField()),
('clip', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='tags', related_query_name='tag', to='vesper.Clip')),
('creating_job', models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='tags', related_query_name='tag', to='vesper.Job')),
('creating_processor', models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='tags', related_query_name='tags', to='vesper.Processor')),
('creating_user', models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='tags', related_query_name='tag', to=settings.AUTH_USER_MODEL)),
],
options={
'db_table': 'vesper_tag',
},
),
migrations.CreateModel(
name='TagEdit',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('action', models.CharField(choices=[('S', 'Set'), ('D', 'Delete')], max_length=1)),
('creation_time', models.DateTimeField()),
('clip', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='tag_edits', related_query_name='tag_edit', to='vesper.Clip')),
('creating_job', models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='tag_edits', related_query_name='tag_edit', to='vesper.Job')),
('creating_processor', models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='tag_edits', related_query_name='tag_edits', to='vesper.Processor')),
('creating_user', models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='tag_edits', related_query_name='tag_edit', to=settings.AUTH_USER_MODEL)),
],
options={
'db_table': 'vesper_tag_edit',
},
),
migrations.CreateModel(
name='TagInfo',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=255, unique=True)),
('description', models.TextField(blank=True)),
('creation_time', models.DateTimeField()),
('creating_job', models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='tag_infos', related_query_name='tag_info', to='vesper.Job')),
('creating_user', models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='tag_infos', related_query_name='tag_info', to=settings.AUTH_USER_MODEL)),
],
options={
'db_table': 'vesper_tag_info',
},
),
migrations.AddField(
model_name='tagedit',
name='info',
field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='tag_edits', related_query_name='tag_edit', to='vesper.TagInfo'),
),
migrations.AddField(
model_name='tag',
name='info',
field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='tags', related_query_name='tag', to='vesper.TagInfo'),
),
migrations.AddField(
model_name='station',
name='devices',
field=models.ManyToManyField(through='vesper.StationDevice', to='vesper.Device'),
),
migrations.AddField(
model_name='recording',
name='station',
field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='recordings', related_query_name='recording', to='vesper.Station'),
),
migrations.AlterUniqueTogether(
name='processor',
unique_together=set([('name', 'type')]),
),
migrations.AddField(
model_name='job',
name='processor',
field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='jobs', related_query_name='job', to='vesper.Processor'),
),
migrations.AlterUniqueTogether(
name='devicemodel',
unique_together=set([('manufacturer', 'model')]),
),
migrations.AddField(
model_name='deviceinput',
name='model_input',
field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='device_inputs', related_query_name='device_input', to='vesper.DeviceModelInput'),
),
migrations.AddField(
model_name='deviceconnection',
name='input',
field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='connections', related_query_name='connection', to='vesper.DeviceInput'),
),
migrations.AddField(
model_name='deviceconnection',
name='output',
field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='connections', related_query_name='connection', to='vesper.DeviceOutput'),
),
migrations.AddField(
model_name='device',
name='model',
field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='devices', related_query_name='device', to='vesper.DeviceModel'),
),
migrations.AddField(
model_name='clip',
name='creating_job',
field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='clips', related_query_name='clip', to='vesper.Job'),
),
migrations.AddField(
model_name='clip',
name='creating_processor',
field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='clips', related_query_name='clip', to='vesper.Processor'),
),
migrations.AddField(
model_name='clip',
name='creating_user',
field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='clips', related_query_name='clip', to=settings.AUTH_USER_MODEL),
),
migrations.AddField(
model_name='clip',
name='mic_output',
field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='clips', related_query_name='clip', to='vesper.DeviceOutput'),
),
migrations.AddField(
model_name='clip',
name='recording_channel',
field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='clips', related_query_name='clip', to='vesper.RecordingChannel'),
),
migrations.AddField(
model_name='clip',
name='station',
field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='clips', related_query_name='clip', to='vesper.Station'),
),
migrations.AddField(
model_name='annotationinfo',
name='creating_job',
field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='annotation_infos', related_query_name='annotation_info', to='vesper.Job'),
),
migrations.AddField(
model_name='annotationinfo',
name='creating_user',
field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='annotation_infos', related_query_name='annotation_info', to=settings.AUTH_USER_MODEL),
),
migrations.AddField(
model_name='annotationconstraint',
name='creating_job',
field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='annotation_constraints', related_query_name='annotation_constraint', to='vesper.Job'),
),
migrations.AddField(
model_name='annotationconstraint',
name='creating_user',
field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='annotation_constraints', related_query_name='annotation_constraint', to=settings.AUTH_USER_MODEL),
),
migrations.AlterUniqueTogether(
name='tag',
unique_together=set([('clip', 'info')]),
),
migrations.AlterUniqueTogether(
name='stringannotation',
unique_together=set([('clip', 'info')]),
),
migrations.AlterUniqueTogether(
name='stationdevice',
unique_together=set([('station', 'device', 'start_time', 'end_time')]),
),
migrations.AlterUniqueTogether(
name='recordingfile',
unique_together=set([('recording', 'file_num')]),
),
migrations.AlterUniqueTogether(
name='recordingchannel',
unique_together=set([('recording', 'channel_num')]),
),
migrations.AlterUniqueTogether(
name='recording',
unique_together=set([('station', 'recorder', 'start_time')]),
),
migrations.AlterUniqueTogether(
name='deviceoutput',
unique_together=set([('device', 'model_output')]),
),
migrations.AlterUniqueTogether(
name='devicemodeloutput',
unique_together=set([('model', 'local_name'), ('model', 'channel_num')]),
),
migrations.AlterUniqueTogether(
name='devicemodelinput',
unique_together=set([('model', 'local_name'), ('model', 'channel_num')]),
),
migrations.AlterUniqueTogether(
name='deviceinput',
unique_together=set([('device', 'model_input')]),
),
migrations.AlterUniqueTogether(
name='deviceconnection',
unique_together=set([('output', 'input', 'start_time', 'end_time')]),
),
migrations.AlterUniqueTogether(
name='device',
unique_together=set([('model', 'serial_number')]),
),
migrations.AlterUniqueTogether(
name='clip',
unique_together=set([('recording_channel', 'start_time', 'creating_processor')]),
),
migrations.AlterIndexTogether(
name='clip',
index_together=set([('station', 'mic_output', 'date', 'creating_processor')]),
),
]
| HaroldMills/Vesper | vesper/django/app/migrations/0001_initial.py | Python | mit | 25,902 |
from unittest import mock
from git_code_debt.server.presentation.commit_delta import CommitDelta
def test_commit_delta_not_overriden():
overrides = {'OtherMetric'}
ret = CommitDelta.from_data('MyMetric', mock.sentinel.delta, overrides)
assert ret == CommitDelta('MyMetric', '', mock.sentinel.delta)
def test_commit_delta_with_overrides():
overrides = {'OtherMetric'}
ret = CommitDelta.from_data('OtherMetric', mock.sentinel.delta, overrides)
assert ret == CommitDelta(
'OtherMetric', 'color-override', mock.sentinel.delta,
)
| Yelp/git-code-debt | tests/server/presentation/commit_delta_test.py | Python | mit | 566 |
'''Sympy to numpy code generator.'''
from .metafun import getmaskarray
__all__ = ['getmaskarray']
| dimasad/sym2num | sym2num/__init__.py | Python | mit | 102 |
# -*- coding: utf-8 -*-
from django import forms
from apps.blog import models
class PostForm(forms.ModelForm):
class Meta:
model = models.Post
exclude = ['last_change']
| python-uni/tutorial-django | tutorial/apps/blog/forms.py | Python | mit | 191 |
class Solution(object):
def reverse(self, x):
MIN_INT32_VALUE = -(2 ** 31)
MAX_INT32_VALUE = 2 ** 31 - 1
# 去除符號
x, sign = abs(x), x < 0
# 數字顛倒
revx = 0
while x:
x, revx = x // 10, revx * 10 + x % 10
# 將符號補上
if sign:
revx = -revx
# 溢位判斷
if MIN_INT32_VALUE <= revx <= MAX_INT32_VALUE:
return revx
return 0
| RevansChen/online-judge | LeetCode/Easy/7_reverse-integer/Python/solution1.py | Python | mit | 510 |
# -*- coding: utf-8 -*-
"""
Implementation of http://elementalselenium.com/tips/2-download-a-file
"""
import os
import time
import shutil
import tempfile
import unittest
from selenium import webdriver
from selenium.webdriver.firefox.options import Options
class Download(unittest.TestCase):
def setUp(self):
self.download_dir = tempfile.mkdtemp()
options = Options()
profile = webdriver.FirefoxProfile()
profile.set_preference("browser.download.dir", self.download_dir)
profile.set_preference("browser.download.folderList", 2)
profile.set_preference(
"browser.helperApps.neverAsk.saveToDisk",
"images/jpeg, application/pdf, application/octet-stream")
profile.set_preference("pdfjs.disabled", True)
options.profile = profile
self.driver = webdriver.Firefox(options=options)
def tearDown(self):
self.driver.quit()
shutil.rmtree(self.download_dir)
def test_example_1(self):
driver = self.driver
driver.get('http://the-internet.herokuapp.com/download')
download_link = driver.find_element_by_css_selector('.example a')
download_link.click()
time.sleep(1.0) # necessary for slow download speeds
files = os.listdir(self.download_dir)
files = [os.path.join(self.download_dir, f)
for f in files] # add directory to each filename
assert len(files) > 0, "no files were downloaded"
assert os.path.getsize(files[0]) > 0, "downloaded file was empty"
if __name__ == "__main__":
unittest.main()
| tourdedave/elemental-selenium-tips | 02-download-a-file/python/download.py | Python | mit | 1,609 |
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Submit
from django import forms
from django.contrib.admin import widgets
from bookings.models import Booking
from providers.models import ProviderService
class CreateBookingForm(forms.ModelForm):
booked_for = forms.DateTimeField()
class Meta:
model = Booking
fields = ('booked_for',)
def __init__(self, *args, **kwargs):
self._user = kwargs.pop('user')
self._service = kwargs.pop('service')
super().__init__(*args, **kwargs)
self.fields['booked_for'].widget.attrs['placeholder'] = 'Appointment Time* '
self.helper = FormHelper()
self.helper.form_method = 'post'
self.helper.form_show_labels = False
# self.helper.form_action = 'submit_survey'
self.helper.add_input(Submit('submit', 'Create Booking'))
def save(self, commit=True):
self.instance.booked_by = self._user
self.instance.service = self._service
return super().save(commit)
class SearchTicketForm(forms.Form):
ticket_id = forms.UUIDField()
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields['ticket_id'].widget.attrs['placeholder'] = 'Ticket ID'
self.helper = FormHelper()
self.helper.form_method = 'get'
self.helper.form_action = '/tickets/validate/'
self.helper.form_show_labels = False
self.helper.add_input(Submit('submit', 'Search'))
| aniruddha-adhikary/bookit | bookit/bookings/forms.py | Python | mit | 1,507 |
# Unit testing framework
import unittest
import mock
# System under test
from chronicle import Messenger
# Standard modules
# External modules
# chronicle modules
from chronicle.messenger import MessengerAttributeError
class MessengerBaseTests(unittest.TestCase):
def setUp(self):
self.core_object = self.setup_object()
self.responder = self.setup_responder()
self.messenger = Messenger(self.core_object, self.responder)
def setup_object(self):
return self.CoreClass()
def setup_responder(self):
responder = mock.Mock()
return responder
class CoreClass(object):
def __init__(self):
self.attribute = None
self._private_attribute = None
def test_initialization(self):
state = {}
for member in self.messenger._core_members_:
state[member] = getattr(self.core_object, member)
self.responder.register.assert_called_once_with(self.messenger, self.core_object, state)
def test_nonmagical_attributes_existence(self):
core_object_attributes = dir(self.core_object)
for attribute in core_object_attributes:
if not self.is_magical(attribute):
self.assertTrue(hasattr(self.messenger, attribute))
def test_attribute_name_clashes(self):
for attribute_name in self.messenger._forbidden_attribute_names_:
clash_object = self.setup_object()
setattr(clash_object, attribute_name, None)
if not self.is_magical(attribute_name):
self.assertRaises(MessengerAttributeError, Messenger, clash_object, self.responder)
def is_magical(self, attribute_name):
dunder = '__'
if attribute_name.startswith(dunder) and attribute_name.endswith(dunder):
return True
return False
class MessengerMemberTests(MessengerBaseTests):
class CoreClass(object):
def __init__(self):
self.member = 0
def test_member_values(self):
core_object_attributes = dir(self.core_object)
for attribute in core_object_attributes:
if not self.is_magical(attribute):
core_object_attribute_value = getattr(self.core_object, attribute)
messenger_attribute_value = getattr(self.messenger, attribute)
self.assertIs(messenger_attribute_value, core_object_attribute_value)
def test_increment(self):
member_value = self.core_object.member
self.messenger.member = self.messenger.member + 1
updated_value = self.core_object.member
self.assertEqual(updated_value, member_value + 1)
def test_member_logging(self):
core_object_attributes = dir(self.core_object)
for attribute in core_object_attributes:
if attribute in self.messenger._core_members_:
attribute_value = getattr(self.messenger, attribute)
expected_notification = (attribute, attribute_value, None, None)
self.responder.notify.assert_called_once_with(self.messenger, expected_notification)
class MessengerMethodTests(MessengerBaseTests):
class CoreClass(object):
def __init__(self):
self.member = 1
def method(self):
return 'method'
def successor(self, a):
return a + 1
def test_method_call(self):
messenger_result = self.messenger.method()
core_object_result = self.core_object.method()
self.assertEqual(messenger_result, core_object_result)
expected_notification = ('method', 'method', (), {})
self.responder.notify.assert_called_once_with(self.messenger, expected_notification)
def test_successor_call(self):
argument = 1
messenger_result = self.messenger.successor(argument)
core_object_result = self.core_object.successor(argument)
self.assertEqual(messenger_result, core_object_result)
expected_notification = ('successor', self.core_object.successor(argument), (argument,), {})
self.responder.notify.assert_called_once_with(self.messenger, expected_notification)
if __name__ == '__main__':
cases = (MessengerBaseTests,
MessengerMemberTests,
MessengerMethodTests)
suite = unittest.TestSuite()
for test_case in cases:
suite.addTests(unittest.TestLoader().loadTestsFromTestCase(test_case))
unittest.TextTestRunner(verbosity = 2).run(suite) | nkashy1/chronicle | test/test_Messenger.py | Python | mit | 4,559 |
# -*- coding: latin-1 -*-
"""Heap queue algorithm (a.k.a. priority queue).
Heaps are arrays for which a[k] <= a[2*k+1] and a[k] <= a[2*k+2] for
all k, counting elements from 0. For the sake of comparison,
non-existing elements are considered to be infinite. The interesting
property of a heap is that a[0] is always its smallest element.
Usage:
heap = [] # creates an empty heap
heappush(heap, item) # pushes a new item on the heap
item = heappop(heap) # pops the smallest item from the heap
item = heap[0] # smallest item on the heap without popping it
heapify(x) # transforms list into a heap, in-place, in linear time
item = heapreplace(heap, item) # pops and returns smallest item, and adds
# new item; the heap size is unchanged
Our API differs from textbook heap algorithms as follows:
- We use 0-based indexing. This makes the relationship between the
index for a node and the indexes for its children slightly less
obvious, but is more suitable since Python uses 0-based indexing.
- Our heappop() method returns the smallest item, not the largest.
These two make it possible to view the heap as a regular Python list
without surprises: heap[0] is the smallest item, and heap.sort()
maintains the heap invariant!
"""
# Original code by Kevin O'Connor, augmented by Tim Peters and Raymond Hettinger
__about__ = """Heap queues
[explanation by François Pinard]
Heaps are arrays for which a[k] <= a[2*k+1] and a[k] <= a[2*k+2] for
all k, counting elements from 0. For the sake of comparison,
non-existing elements are considered to be infinite. The interesting
property of a heap is that a[0] is always its smallest element.
The strange invariant above is meant to be an efficient memory
representation for a tournament. The numbers below are `k', not a[k]:
0
1 2
3 4 5 6
7 8 9 10 11 12 13 14
15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
In the tree above, each cell `k' is topping `2*k+1' and `2*k+2'. In
an usual binary tournament we see in sports, each cell is the winner
over the two cells it tops, and we can trace the winner down the tree
to see all opponents s/he had. However, in many computer applications
of such tournaments, we do not need to trace the history of a winner.
To be more memory efficient, when a winner is promoted, we try to
replace it by something else at a lower level, and the rule becomes
that a cell and the two cells it tops contain three different items,
but the top cell "wins" over the two topped cells.
If this heap invariant is protected at all time, index 0 is clearly
the overall winner. The simplest algorithmic way to remove it and
find the "next" winner is to move some loser (let's say cell 30 in the
diagram above) into the 0 position, and then percolate this new 0 down
the tree, exchanging values, until the invariant is re-established.
This is clearly logarithmic on the total number of items in the tree.
By iterating over all items, you get an O(n ln n) sort.
A nice feature of this sort is that you can efficiently insert new
items while the sort is going on, provided that the inserted items are
not "better" than the last 0'th element you extracted. This is
especially useful in simulation contexts, where the tree holds all
incoming events, and the "win" condition means the smallest scheduled
time. When an event schedule other events for execution, they are
scheduled into the future, so they can easily go into the heap. So, a
heap is a good structure for implementing schedulers (this is what I
used for my MIDI sequencer :-).
Various structures for implementing schedulers have been extensively
studied, and heaps are good for this, as they are reasonably speedy,
the speed is almost constant, and the worst case is not much different
than the average case. However, there are other representations which
are more efficient overall, yet the worst cases might be terrible.
Heaps are also very useful in big disk sorts. You most probably all
know that a big sort implies producing "runs" (which are pre-sorted
sequences, which size is usually related to the amount of CPU memory),
followed by a merging passes for these runs, which merging is often
very cleverly organised[1]. It is very important that the initial
sort produces the longest runs possible. Tournaments are a good way
to that. If, using all the memory available to hold a tournament, you
replace and percolate items that happen to fit the current run, you'll
produce runs which are twice the size of the memory for random input,
and much better for input fuzzily ordered.
Moreover, if you output the 0'th item on disk and get an input which
may not fit in the current tournament (because the value "wins" over
the last output value), it cannot fit in the heap, so the size of the
heap decreases. The freed memory could be cleverly reused immediately
for progressively building a second heap, which grows at exactly the
same rate the first heap is melting. When the first heap completely
vanishes, you switch heaps and start a new run. Clever and quite
effective!
In a word, heaps are useful memory structures to know. I use them in
a few applications, and I think it is good to keep a `heap' module
around. :-)
--------------------
[1] The disk balancing algorithms which are current, nowadays, are
more annoying than clever, and this is a consequence of the seeking
capabilities of the disks. On devices which cannot seek, like big
tape drives, the story was quite different, and one had to be very
clever to ensure (far in advance) that each tape movement will be the
most effective possible (that is, will best participate at
"progressing" the merge). Some tapes were even able to read
backwards, and this was also used to avoid the rewinding time.
Believe me, real good tape sorts were quite spectacular to watch!
From all times, sorting has always been a Great Art! :-)
"""
__all__ = ['heappush', 'heappop', 'heapify', 'heapreplace', 'merge',
'nlargest', 'nsmallest', 'heappushpop']
from itertools import islice, count, imap, izip, tee, chain
from operator import itemgetter
def cmp_lt(x, y):
# Use __lt__ if available; otherwise, try __le__.
# In Py3.x, only __lt__ will be called.
return (x < y) if hasattr(x, '__lt__') else (not y <= x)
def heappush(heap, item):
"""Push item onto heap, maintaining the heap invariant."""
heap.append(item)
_siftdown(heap, 0, len(heap)-1)
def heappop(heap):
"""Pop the smallest item off the heap, maintaining the heap invariant."""
lastelt = heap.pop() # raises appropriate IndexError if heap is empty
if heap:
returnitem = heap[0]
heap[0] = lastelt
_siftup(heap, 0)
else:
returnitem = lastelt
return returnitem
def heapreplace(heap, item):
"""Pop and return the current smallest value, and add the new item.
This is more efficient than heappop() followed by heappush(), and can be
more appropriate when using a fixed-size heap. Note that the value
returned may be larger than item! That constrains reasonable uses of
this routine unless written as part of a conditional replacement:
if item > heap[0]:
item = heapreplace(heap, item)
"""
returnitem = heap[0] # raises appropriate IndexError if heap is empty
heap[0] = item
_siftup(heap, 0)
return returnitem
def heappushpop(heap, item):
"""Fast version of a heappush followed by a heappop."""
if heap and cmp_lt(heap[0], item):
item, heap[0] = heap[0], item
_siftup(heap, 0)
return item
def heapify(x):
"""Transform list into a heap, in-place, in O(len(x)) time."""
n = len(x)
# Transform bottom-up. The largest index there's any point to looking at
# is the largest with a child index in-range, so must have 2*i + 1 < n,
# or i < (n-1)/2. If n is even = 2*j, this is (2*j-1)/2 = j-1/2 so
# j-1 is the largest, which is n//2 - 1. If n is odd = 2*j+1, this is
# (2*j+1-1)/2 = j so j-1 is the largest, and that's again n//2-1.
for i in reversed(xrange(n//2)):
_siftup(x, i)
def _heappushpop_max(heap, item):
"""Maxheap version of a heappush followed by a heappop."""
if heap and cmp_lt(item, heap[0]):
item, heap[0] = heap[0], item
_siftup_max(heap, 0)
return item
def _heapify_max(x):
"""Transform list into a maxheap, in-place, in O(len(x)) time."""
n = len(x)
for i in reversed(range(n//2)):
_siftup_max(x, i)
def nlargest(n, iterable):
"""Find the n largest elements in a dataset.
Equivalent to: sorted(iterable, reverse=True)[:n]
"""
if n < 0:
return []
it = iter(iterable)
result = list(islice(it, n))
if not result:
return result
heapify(result)
_heappushpop = heappushpop
for elem in it:
_heappushpop(result, elem)
result.sort(reverse=True)
return result
def nsmallest(n, iterable):
"""Find the n smallest elements in a dataset.
Equivalent to: sorted(iterable)[:n]
"""
if n < 0:
return []
it = iter(iterable)
result = list(islice(it, n))
if not result:
return result
_heapify_max(result)
_heappushpop = _heappushpop_max
for elem in it:
_heappushpop(result, elem)
result.sort()
return result
# 'heap' is a heap at all indices >= startpos, except possibly for pos. pos
# is the index of a leaf with a possibly out-of-order value. Restore the
# heap invariant.
def _siftdown(heap, startpos, pos):
newitem = heap[pos]
# Follow the path to the root, moving parents down until finding a place
# newitem fits.
while pos > startpos:
parentpos = (pos - 1) >> 1
parent = heap[parentpos]
if cmp_lt(newitem, parent):
heap[pos] = parent
pos = parentpos
continue
break
heap[pos] = newitem
# The child indices of heap index pos are already heaps, and we want to make
# a heap at index pos too. We do this by bubbling the smaller child of
# pos up (and so on with that child's children, etc) until hitting a leaf,
# then using _siftdown to move the oddball originally at index pos into place.
#
# We *could* break out of the loop as soon as we find a pos where newitem <=
# both its children, but turns out that's not a good idea, and despite that
# many books write the algorithm that way. During a heap pop, the last array
# element is sifted in, and that tends to be large, so that comparing it
# against values starting from the root usually doesn't pay (= usually doesn't
# get us out of the loop early). See Knuth, Volume 3, where this is
# explained and quantified in an exercise.
#
# Cutting the # of comparisons is important, since these routines have no
# way to extract "the priority" from an array element, so that intelligence
# is likely to be hiding in custom __cmp__ methods, or in array elements
# storing (priority, record) tuples. Comparisons are thus potentially
# expensive.
#
# On random arrays of length 1000, making this change cut the number of
# comparisons made by heapify() a little, and those made by exhaustive
# heappop() a lot, in accord with theory. Here are typical results from 3
# runs (3 just to demonstrate how small the variance is):
#
# Compares needed by heapify Compares needed by 1000 heappops
# -------------------------- --------------------------------
# 1837 cut to 1663 14996 cut to 8680
# 1855 cut to 1659 14966 cut to 8678
# 1847 cut to 1660 15024 cut to 8703
#
# Building the heap by using heappush() 1000 times instead required
# 2198, 2148, and 2219 compares: heapify() is more efficient, when
# you can use it.
#
# The total compares needed by list.sort() on the same lists were 8627,
# 8627, and 8632 (this should be compared to the sum of heapify() and
# heappop() compares): list.sort() is (unsurprisingly!) more efficient
# for sorting.
def _siftup(heap, pos):
endpos = len(heap)
startpos = pos
newitem = heap[pos]
# Bubble up the smaller child until hitting a leaf.
childpos = 2*pos + 1 # leftmost child position
while childpos < endpos:
# Set childpos to index of smaller child.
rightpos = childpos + 1
if rightpos < endpos and not cmp_lt(heap[childpos], heap[rightpos]):
childpos = rightpos
# Move the smaller child up.
heap[pos] = heap[childpos]
pos = childpos
childpos = 2*pos + 1
# The leaf at pos is empty now. Put newitem there, and bubble it up
# to its final resting place (by sifting its parents down).
heap[pos] = newitem
_siftdown(heap, startpos, pos)
def _siftdown_max(heap, startpos, pos):
'Maxheap variant of _siftdown'
newitem = heap[pos]
# Follow the path to the root, moving parents down until finding a place
# newitem fits.
while pos > startpos:
parentpos = (pos - 1) >> 1
parent = heap[parentpos]
if cmp_lt(parent, newitem):
heap[pos] = parent
pos = parentpos
continue
break
heap[pos] = newitem
def _siftup_max(heap, pos):
'Maxheap variant of _siftup'
endpos = len(heap)
startpos = pos
newitem = heap[pos]
# Bubble up the larger child until hitting a leaf.
childpos = 2*pos + 1 # leftmost child position
while childpos < endpos:
# Set childpos to index of larger child.
rightpos = childpos + 1
if rightpos < endpos and not cmp_lt(heap[rightpos], heap[childpos]):
childpos = rightpos
# Move the larger child up.
heap[pos] = heap[childpos]
pos = childpos
childpos = 2*pos + 1
# The leaf at pos is empty now. Put newitem there, and bubble it up
# to its final resting place (by sifting its parents down).
heap[pos] = newitem
_siftdown_max(heap, startpos, pos)
# If available, use C implementation
try:
from _heapq import *
except ImportError:
pass
def merge(*iterables):
'''Merge multiple sorted inputs into a single sorted output.
Similar to sorted(itertools.chain(*iterables)) but returns a generator,
does not pull the data into memory all at once, and assumes that each of
the input streams is already sorted (smallest to largest).
>>> list(merge([1,3,5,7], [0,2,4,8], [5,10,15,20], [], [25]))
[0, 1, 2, 3, 4, 5, 5, 7, 8, 10, 15, 20, 25]
'''
_heappop, _heapreplace, _StopIteration = heappop, heapreplace, StopIteration
_len = len
h = []
h_append = h.append
for itnum, it in enumerate(map(iter, iterables)):
try:
next = it.next
h_append([next(), itnum, next])
except _StopIteration:
pass
heapify(h)
while _len(h) > 1:
try:
while True:
v, itnum, next = s = h[0]
yield v
s[0] = next() # raises StopIteration when exhausted
_heapreplace(h, s) # restore heap condition
except _StopIteration:
_heappop(h) # remove empty iterator
if h:
# fast case when only a single iterator remains
v, itnum, next = h[0]
yield v
for v in next.__self__:
yield v
# Extend the implementations of nsmallest and nlargest to use a key= argument
_nsmallest = nsmallest
def nsmallest(n, iterable, key=None):
"""Find the n smallest elements in a dataset.
Equivalent to: sorted(iterable, key=key)[:n]
"""
# Short-cut for n==1 is to use min() when len(iterable)>0
if n == 1:
it = iter(iterable)
head = list(islice(it, 1))
if not head:
return []
if key is None:
return [min(chain(head, it))]
return [min(chain(head, it), key=key)]
# When n>=size, it's faster to use sorted()
try:
size = len(iterable)
except (TypeError, AttributeError):
pass
else:
if n >= size:
return sorted(iterable, key=key)[:n]
# When key is none, use simpler decoration
if key is None:
it = izip(iterable, count()) # decorate
result = _nsmallest(n, it)
return map(itemgetter(0), result) # undecorate
# General case, slowest method
in1, in2 = tee(iterable)
it = izip(imap(key, in1), count(), in2) # decorate
result = _nsmallest(n, it)
return map(itemgetter(2), result) # undecorate
_nlargest = nlargest
def nlargest(n, iterable, key=None):
"""Find the n largest elements in a dataset.
Equivalent to: sorted(iterable, key=key, reverse=True)[:n]
"""
# Short-cut for n==1 is to use max() when len(iterable)>0
if n == 1:
it = iter(iterable)
head = list(islice(it, 1))
if not head:
return []
if key is None:
return [max(chain(head, it))]
return [max(chain(head, it), key=key)]
# When n>=size, it's faster to use sorted()
try:
size = len(iterable)
except (TypeError, AttributeError):
pass
else:
if n >= size:
return sorted(iterable, key=key, reverse=True)[:n]
# When key is none, use simpler decoration
if key is None:
it = izip(iterable, count(0,-1)) # decorate
result = _nlargest(n, it)
return map(itemgetter(0), result) # undecorate
# General case, slowest method
in1, in2 = tee(iterable)
it = izip(imap(key, in1), count(0,-1), in2) # decorate
result = _nlargest(n, it)
return map(itemgetter(2), result) # undecorate
if __name__ == "__main__":
# Simple sanity test
heap = []
data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
for item in data:
heappush(heap, item)
sort = []
while heap:
sort.append(heappop(heap))
print sort
import doctest
doctest.testmod()
| Voluntarynet/BitmessageKit | BitmessageKit/Vendor/static-python/Lib/heapq.py | Python | mit | 18,299 |
# coding=utf-8
r"""
This code was generated by
\ / _ _ _| _ _
| (_)\/(_)(_|\/| |(/_ v1.0.0
/ /
"""
from tests import IntegrationTestCase
from tests.holodeck import Request
from twilio.base.exceptions import TwilioException
from twilio.http.response import Response
class ValidationRequestTestCase(IntegrationTestCase):
def test_create_request(self):
self.holodeck.mock(Response(500, ''))
with self.assertRaises(TwilioException):
self.client.api.v2010.accounts("ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") \
.validation_requests.create(phone_number="+15017122661")
values = {'PhoneNumber': "+15017122661", }
self.holodeck.assert_has_request(Request(
'post',
'https://api.twilio.com/2010-04-01/Accounts/ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/OutgoingCallerIds.json',
data=values,
))
def test_create_response(self):
self.holodeck.mock(Response(
201,
'''
{
"account_sid": "ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"call_sid": "CAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"friendly_name": "friendly_name",
"phone_number": "+18001234567",
"validation_code": "111111"
}
'''
))
actual = self.client.api.v2010.accounts("ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") \
.validation_requests.create(phone_number="+15017122661")
self.assertIsNotNone(actual)
| twilio/twilio-python | tests/integration/api/v2010/account/test_validation_request.py | Python | mit | 1,584 |
#####################################################################
# #
# File: qbo.py #
# Developer: Justin Leto #
# #
# qbo class provides an interface from main csv iterator method #
# to handle qbo formatting, validations, and writing to file. #
# #
# Usage: python csvtoqbo.py <options> <csvfiles> #
# #
#####################################################################
import sys, traceback
import os
from datetime import datetime
import logging
import qboconst
class qbo:
# Holds a list of valid transactions via the addTransaction() method
__transactions = list()
# The full QBO document build from constants and transactions
__document = None
# Flag indicating whether the QBO document is valid
__isValid = None
# constructor
def __init__(self):
# Reads in constant values from file, set to private (const) variables
self.__HEADER = qboconst.HEADER
self.__FOOTER = qboconst.FOOTER
self.__DATE_START = qboconst.DATE_START
self.__DATE_END = qboconst.DATE_END
self.__BANKTRANLIST_START = qboconst.BANKTRANLIST_START
self.__BANKTRANLIST_END = qboconst.BANKTRANLIST_END
self.__TRANSACTION_START = qboconst.TRANSACTION_START
self.__TRANSACTION_END = qboconst.TRANSACTION_END
# Set document to valid
self.__isValid = True
# PUBLIC GET METHODS for constant values - used in unit testing.
#
#
def getHEADER(self):
return self.__HEADER
def getFOOTER(self):
return self.__FOOTER
def getDATE_START(self):
return self.__DATE_START
def getDATE_END(self):
return self.__DATE_END
def getBANKTRANLIST_START(self):
return self.__BANKTRANLIST_START
def getBANKTRANLIST_END(self):
return self.__BANKTRANLIST_END
def getTRANSACTION_START(self):
return self.__TRANSACTION_START
def getTRANSACTION_END(self):
return self.__TRANSACTION_END
# method to validate paramters used to submit transactions
def validateTransaction(self, status, date_posted, txn_type, to_from_flag, txn_amount, txn_exrate, name):
# if str.lower(status) != 'completed':
# #log status failure
# logging.info("Transaction status [" + status + "] invalid.")
# raise Exception("Transaction status [" + status + "] invalid.")
#
#if type(datetime.strptime(str(date_posted), '%m/%d/%Y')) is not datetime:
# logging.info("Transaction posted date [" + date_posted + "] invalid.")
# raise Exception("Transaction posted date [" + date_posted + "] invalid.")
# if str.lower(txn_type) not in ('payment','refund','withdrawal', 'withdraw funds', 'send', 'receive'):
# logging.info("Transaction type [" + str(txn_type) + "] not 'Payment', 'Refund', 'Withdraw Funds', or 'Withdrawal'.")
# raise Exception("Transaction type [" + str(txn_type) + "] not 'Payment', 'Refund', 'Withdraw Funds', or 'Withdrawal'.")
#
# if str.lower(to_from_flag) not in ('to', 'from'):
# logging.info("Transaction 'To/From' field [" + to_from_flag + "] invalid.")
# raise Exception("Transaction 'To/From' field [" + to_from_flag + "] invalid.")
#
# #logical test of txn_type and to_from_flag
# if ((str.lower(txn_type) == 'refund' and str.lower(to_from_flag) != 'to') or (str.lower(txn_type) == 'payment' and str.lower(to_from_flag) != 'from')):
# logging.info("Transaction type inconsistent with 'To/From' field.")
# raise Exception("Transaction type inconsistent with 'To/From' field.")
#
if len(name) == 0 or not name:
logging.info("Transaction name empty or null.")
raise Exception("Transaction name empty or null.")
return True
# Add transaction takes in param values uses the required formatting QBO transactions
# and pushes to list
def addTransaction(self, denom, date_posted, txn_memo, txn_id, txn_amount, txn_curamt, txn_category, name):
# try:
# # Validating param values prior to committing transaction
# self.validateTransaction(status, date_posted, txn_type, txn_id, txn_amount, name)
# except:
# raise Exception
# Construct QBO formatted transaction
transaction = ""
day = ""
month = ""
date_array = date_posted.split('-')
day = date_array[2]
month = date_array[1]
year = date_array[0]
if len(day) == 1:
day = "0"+day
if len(month) ==1:
month = "0"+month
rec_date = datetime.strptime(year+"/"+month+"/"+day, '%Y/%m/%d')
rec_date = rec_date.strftime('%Y%m%d%H%M%S') + '.000'
dtposted = ' <DTPOSTED>' + rec_date
if float(txn_amount) > 0:
trtype = ' <TRNTYPE>CREDIT'
else:
trtype = ' <TRNTYPE>DEBIT'
#
# if str.lower(txn_type) == 'receive':
# trtype = '<TRNTYPE>CREDIT'
# elif str.lower(txn_type) == 'send':
# trtype = '<TRNTYPE>DEBIT'
# if str.lower(txn_type) in ('refund', 'withdrawal', 'withdraw funds'):
# tramt = '<TRNAMT>-' + str(txn_amount).replace('$','')
# else:
# tramt = '<TRNAMT>' + str(txn_amount).replace('$','')
tramtbits = float(txn_amount) * denom
tramt = ' <TRNAMT>' + str(tramtbits)
if name:
trname = ' <NAME>' + str(name) + "\n"
else:
trname = ''
exrate = float(txn_curamt) / (tramtbits)
curamt = "{0:0.2f}".format(abs(float(txn_curamt)))
fmtexrate = "{0:0.6f}".format(float(exrate))
rawmemo = 'Rate=' + fmtexrate + " USD=" + curamt + " category=\"" + str(txn_category) + "\" memo=\"" + str(txn_memo)
memo = ' <MEMO>' + rawmemo[:253] + "\"\n"
fitid = ' <FITID>' + str(txn_id)
exrate = ' <CURRATE>' + fmtexrate
transaction = ("" + self.__TRANSACTION_START + "\n"
"" + trtype + "\n"
"" + dtposted + "\n"
"" + tramt + "\n"
"" + fitid + "\n"
"" + trname +
"" + memo +
"" + " <CURRENCY>" + "\n"
"" + exrate + "\n"
"" + " <CURSYM>USD" + "\n"
"" + " </CURRENCY>" + "\n"
"" + self.__TRANSACTION_END + "\n")
# Commit transaction to the document by adding to private member list object
self.__transactions.append(transaction)
logging.info("Transaction [" + str(self.getCount()) + "] Accepted.")
return True
# get the current number of valid committed transactions
def getCount(self):
return len(self.__transactions)
# get the valid status of the document
def isValid(self):
# If number of valid transactions are 0 document is invalid
if self.getCount() == 0:
self.__isValid = False
return self.__isValid
# get the text of the document
def getDocument(self):
self.Build()
return self.__document
# Construct the document, add the transactions
# save str into private member variable __document
def Build(self):
if not self.isValid():
logging.info("Error: QBO document is not valid.")
raise Exception("Error: QBO document is not valid.")
self.__document = ("" + self.__HEADER + "\n"
"" + self.__BANKTRANLIST_START + "\n"
"" + self.__DATE_START + "\n"
"" + self.__DATE_END + "\n")
for txn in self.__transactions:
self.__document = self.__document + str(txn)
self.__document = self.__document + ("" + self.__BANKTRANLIST_END + "\n"
"" + self.__FOOTER + "")
# Write QBO document to file
def Write(self, filename):
try:
with open(filename, 'w') as f:
# getDocument method will build document
# test for validity and return string for write
f.write(self.getDocument())
return True
except:
#log io error return False
exc_type, exc_value, exc_traceback = sys.exc_info()
lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
print(''.join('!! ' + line for line in lines))
logging.info('qbo.Write() method: '.join('!! ' + line for line in lines))
return False
| Airbitz/airbitz-ofx | qbo.py | Python | mit | 7,851 |
import numpy as np
from numba import guvectorize
@guvectorize(['void(float64[:], intp[:], float64[:])'], '(n),()->(n)')
def move_mean(a, window_arr, out):
window_width = window_arr[0]
asum = 0.0
count = 0
for i in range(window_width):
asum += a[i]
count += 1
out[i] = asum / count
for i in range(window_width, len(a)):
asum += a[i] - a[i - window_width]
out[i] = asum / count
arr = np.arange(20, dtype=np.float64).reshape(2, 10)
print(arr)
print(move_mean(arr, 3)) | joseph-ai/aitoolkit | examples/numba_ex1.py | Python | mit | 527 |
from .base import BaseCommand
class TermvectorCommand(BaseCommand):
command_name = "elasticsearch:termvector"
def run_request(self, id=None):
if id is None:
self.show_input_panel("Document Id (option): ", "", self.run)
return
options = dict(
index=self.settings.index,
doc_type=self.settings.doc_type,
id=id,
body=self.get_text()
)
return self.client.termvector(**options)
| KunihikoKido/sublime-elasticsearch-client | commands/termvector.py | Python | mit | 489 |
# Copyright 2017 Merkulov Alexey
#
# The 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.
from __future__ import unicode_literals
__author__ = 'Merkulov Alexey'
from django.db import models
from django.forms.models import model_to_dict
from django.contrib.auth.models import User
from polymorphic.models import PolymorphicModel
class ModeratorActions(models.Model):
json = models.CharField(max_length=1000)
action_date = models.DateTimeField(auto_now_add=True)
author = models.ForeignKey(User)
APPROVED='a'
REJECTED='r'
UNDECIDED='u'
ANSWERED='c' # use c as closed
class Question(models.Model):
QuestionStatus = (
(UNDECIDED, 'Undecided'),
(ANSWERED, 'Answered'),
(APPROVED, 'Approbed'),
(REJECTED, 'Rejected'),
)
status = models.CharField(
max_length=1,
choices=QuestionStatus,
default=UNDECIDED)
text_str = models.CharField(max_length=500)
author = models.ForeignKey(User)
submit_date = models.DateTimeField(auto_now_add=True)
answered = models.IntegerField(default=1)
votes_number = models.IntegerField(default=1)
complains = models.IntegerField(default=0)
class Meta:
permissions = (
('moderator_perm', 'Can do moderator actions'),
)
VOTED = 'v'
LIKE = 'l'
DISLIKE = 'd'
COMPLAIN = 'c'
class QuestionVoteList(models.Model):
QuestionVoteState = (
(VOTED, 'Voted'),
(COMPLAIN, 'Complain')
)
question = models.ForeignKey(Question)
user = models.ForeignKey(User)
state = models.CharField(max_length=1, choices=QuestionVoteState)
def __str__(self):
return '%s %s %s' % (
self.question.text_str,
self.user.username,
self.state)
YOUTUBE = 'y'
TEXT = 't' # not implemented now
class Answer(PolymorphicModel):
AnswerTypes = (
(YOUTUBE, 'Youtube'),
(TEXT, 'Text')
)
AnswerStatus = (
(UNDECIDED, 'Undecided'),
(APPROVED, 'Approbed'),
(REJECTED, 'Rejected'),
)
answer_type = models.CharField(max_length=1, choices=AnswerTypes)
status = models.CharField(
max_length=1,
choices=AnswerStatus,
default=UNDECIDED)
author = models.ForeignKey(User)
question = models.ForeignKey(Question)
submit_date = models.DateTimeField(auto_now_add=True)
position = models.IntegerField(default=0) # 0 means undecided
like_number = models.IntegerField(default=0)
dislike_number = models.IntegerField(default=0)
class YoutubeAnswer(Answer):
video_id = models.CharField(max_length=20)
start = models.IntegerField(default=0)
end = models.IntegerField(default=0)
class TextAnswer(Answer):
answer_text = models.CharField(max_length=500)
class AnswerVoteList(models.Model):
AnswerVoteState = (
(LIKE, 'Like'),
(DISLIKE, 'Dislike'),
(COMPLAIN, 'Complain')
)
question = models.ForeignKey(Question) # unnecessary
user = models.ForeignKey(User)
answer = models.ForeignKey(Answer)
state = models.CharField(max_length=1, choices=AnswerVoteState)
def __str__(self):
return '%s %s %s' % (
self.answer.text_str,
self.user.username,
self.state)
def obj_to_dict(obj):
res = model_to_dict(obj)
res['submit_date'] = str(obj.submit_date)
return res
def answer_to_dict(answer):
res = obj_to_dict(answer)
return res
def add_new_question(text_str, author):
q = Question.objects.create(
text_str=text_str,
author=author)
QuestionVoteList.objects.create(
question=q,
user=author,
state=VOTED)
return q
def add_new_youtube_answer(author, question, video_id, start, end):
a = YoutubeAnswer.objects.create(
answer_type=YOUTUBE,
author=author,
question=question,
video_id=video_id,
start=start,
end=end)
return a
| steelart/ask-navalny | django-backend/askp/models.py | Python | mit | 4,982 |
#!/usr/bin/python
# Copyright 2012, 2013 Andrew Lamoureux
#
# This file is a part of FunChess
#
# FunChess is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#!/usr/bin/python
class ChessMove:
def __init__(self, player_='', moveNum_='', san_='', canonical_='', comments_=[], time_=None, flags_={}):
self.player = player_ # ['w','b'] in chess, ['a','A','b','B'] in bug
self.moveNum = moveNum_ # 1,2,3,...
self.san = san_ # bxh3
self.canonical = canonical_ # c7h3
self.comments = comments_ # [53.057, 'adds pressure to kingside'] (input is like "{53.057}")
self.time = time_ # 118.953
self.flags = flags_ # 'TIME_FORFEIT', 'CAPTURE', 'PROMOTE', etc.
def addComment(self, comment):
# time comment?
if re.match(r'\d+\.\d+', comment):
self.time = float(comment)
# forfeit on time comment? (these are repeated in bughouse-db results)
elif re.search('forfeits on time', comment):
self.flags['TIME_FORFEIT'] = 1
# add to list
self.comments.append(comment)
def fromSan(self, san, boardMap):
pass
def __str__(self):
answer = str(self.moveNum) + self.player + '. ' + self.san
#if self.time:
# answer += " {TIME: %s}" % self.time
#answer += "\nFLAGS: "
for k,v in self.flags.iteritems():
answer += " {%s}" % k
#answer += '\nCOMMENTS: '
for c in self.comments:
answer += ' {%s}' % c
return answer
| thompGIT/chesster | ChessLogic/ChessMove.py | Python | mit | 2,153 |
Subsets and Splits