content
stringlengths 7
1.05M
|
|---|
largura = float(input('Digite a largura da parede:'))
altura = float(input('Digite a altura da parede:'))
area = altura * largura
qntd = area / 2
print('A área da parede é:{} m^2'.format(area))
print('São necessários {} litros de tinta'.format(qntd))
|
"""The ofx parser package. A package to parse OpenFlow messages.
This package is a library that parses and creates OpenFlow Messages.
It contains all implemented versions of OpenFlow protocol
"""
__version__ = '2020.2b3'
|
stormtrooper = r'''
,ooo888888888888888oooo,
o8888YYYYYY77iiiiooo8888888o
8888YYYY77iiYY8888888888888888
[88YYY77iiY88888888888888888888]
88YY7iYY888888888888888888888888
[88YYi 88888888888888888888888888]
i88Yo8888888888888888888888888888i
i] ^^^88888888^^^ o [i
oi8 i o8o i 8io
,77788o ^^ ,oooo8888888ooo, ^ o88777,
7777788888888888888888888888888888877777
77777888888888888888888888888888877777
77777788888888^7777777^8888888777777
,oooo888 ooo 88888778888^7777ooooo7777^8887788888 ,o88^^^^888oo
o8888777788[];78 88888888888888888888888888888888888887 7;8^ 888888888oo^88
o888888iii788 ]; o 78888887788788888^;;^888878877888887 o7;[]88888888888888o
88888877 ii78[]8;7o 7888878^ ^8788^;;;;;;^878^ ^878877 o7;8 ]878888888888888
[88888888887888 87;7oo 777888o8888^;ii;;ii;^888o87777 oo7;7[]8778888888888888
88888888888888[]87;777oooooooooooooo888888oooooooooooo77;78]88877i78888888888
o88888888888888 877;7877788777iiiiiii;;;;;iiiiiiiii77877i;78] 88877i;788888888
88^;iiii^88888 o87;78888888888888888888888888888888888887;778] 88877ii;7788888
;;;iiiii7iiii^ 87;;888888888888888888888888888888888888887;778] 888777ii;78888
;iiiii7iiiii7iiii77;i88888888888888888888i7888888888888888877;77i 888877777ii78
iiiiiiiiiii7iiii7iii;;;i7778888888888888ii7788888888888777i;;;;iiii 88888888888
i;iiiiiiiiiiii7iiiiiiiiiiiiiiiiiiiiiiiiii8877iiiiiiiiiiiiiiiiiii877 88888
ii;;iiiiiiiiiiiiii;;;ii^^^;;;ii77777788888888888887777iii;; 77777 78
77iii;;iiiiiiiiii;;;ii;;;;;;;;;^^^^8888888888888888888777ii;; ii7 ;i78
^ii;8iiiiiiii ';;;;ii;;;;;;;;;;;;;;;;;;^^oo ooooo^^^88888888;;i7 7;788
o ^;;^^88888^ 'i;;;;;;;;;;;;;;;;;;;;;;;;;;;^^^88oo^^^^888ii7 7;i788
88ooooooooo ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; 788oo^;; 7;i888
887ii8788888 ;;;;;;;ii;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;^87 7;788
887i8788888^ ;;;;;;;ii;;;;;;;oo;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;,,, ;;888
87787888888 ;;;;;;;ii;;;;;;;888888oo;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;,,;i788
87i8788888^ ';;;ii;;;;;;;8888878777ii8ooo;;;;;;;;;;;;;;;;;;;;;;;;;;i788 7
77i8788888 ioo;;;;;;oo^^ooooo ^7i88^ooooo;;;;;;;;;;;;;;;;;;;;i7888 78
7i87788888o 7;ii788887i7;7;788888ooooo7888888ooo;;;;;;;;;;;;;;oo ^^^ 78
i; 7888888^ 8888^o;ii778877;7;7888887;;7;7788878;878;; ;;;;;;;i78888o ^
i8 788888 [88888^^ ooo ^^^^^;;77888^^^^;;7787^^^^ ^^;;;; iiii;i78888888
^8 7888^ [87888 87 ^877i;i8ooooooo8778oooooo888877ii; iiiiiiii788888888
^^^ [7i888 87;; ^8i;;i7888888888888888887888888 i7iiiiiii88888^^
87;88 o87;;;;o 87i;;;78888788888888888888^^ o 8ii7iiiiii;;
87;i8 877;77888o ^877;;;i7888888888888^^ 7888 78iii7iii7iiii
^87; 877;778888887o 877;;88888888888^ 7ii7888 788oiiiiiiiii
^ 877;7 7888888887 877i;;8888887ii 87i78888 7888888888
[87;;7 78888888887 87i;;888887i 87ii78888 7888888888]
877;7 7788888888887 887i;887i^ 87ii788888 78888888888
87;i8 788888888888887 887ii;;^ 87ii7888888 78888888888
[87;i8 7888888888888887 ^^^^ 87ii77888888 78888888888
87;;78 7888888888888887ii 87i78888888 778888888888
87;788 7888888888888887i] 87i78888888 788888888888
[87;88 778888888888888887 7ii78888888 788888888888
87;;88 78888888888888887] ii778888888 78888888888]
7;;788 7888888888888888] i7888888888 78888888888'
7;;788 7888888888888888 'i788888888 78888888888
7;i788 788888888888888] 788888888 77888888888]
'7;788 778888888888888] [788888888 78888888888'
';77888 78888888888888 8888888888 7888888888]
778888 78888888888888 8888888888 7888888888]
78888 7888888888888] [8888888888 7888888888
7888 788888888888] 88888888888 788888888]
778 78888888888] ]888888888 778888888]
oooooo ^88888^ ^88888^^^^^^^^8888]
87;78888ooooooo8o ,oooooo oo888oooooo
[877;i77888888888] [;78887i8888878i7888;
^877;;ii7888ii788 ;i777;7788887787;778;
^87777;;;iiii777 ;77^^^^^^^^^^^^^^^^;;
^^^^^^^^^ii7] ^ o88888888877iiioo
77777o [88777777iiiiii;;778
77777iii 8877iiiii;;;77888888]
77iiii;8 [77ii;778 788888888888
7iii;;88 iii;78888 778888888888
77i;78888] ;;;;i88888 78888888888
,7;78888888 [;;i788888 7888888888]
i;788888888 ;i7888888 7888888888
;788888888] i77888888 788888888]
';88888888' [77888888 788888888]
[[8ooo88] 78888888 788888888
[88888] 78888888 788888888
^^^ [7888888 77888888]
88888888 7888887
77888888 7888887
;i88888 788888i
,;;78888 788877i7
,7;;i;777777i7i;;7
87778^^^ ^^^^87778
^^^^ o777777o ^^^
o77777iiiiii7777o
7777iiii88888iii777
;;;i7778888888877ii;;
Imperial Stormtrooper [i77888888^^^^8888877i]
(Standard Shock Trooper) 77888^oooo8888oooo^8887]
[788888888888888888888888]
88888888888888888888888888
]8888888^iiiiiiiii^888888]
Bob VanderClay iiiiiiiiiiiiiiiiiiiiii
^^^^^^^^^^^^^
------------------------------------------------
Thank you for visiting https://asciiart.website/
This ASCII pic can be found at
https://asciiart.website/index.php?art=movies/star%20wars
'''
|
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def removeZeroSumSublists(self, head: ListNode) -> ListNode:
stack = []
cur = head
while cur:
stack.append(cur)
s = 0
for i in range(len(stack) - 1, -1, -1):
s += stack[i].val
if s == 0:
for _ in range(len(stack) - 1, i - 1, -1):
stack.pop(-1)
break
cur = cur.next
dummy = cur = ListNode()
for n in stack:
n.next = None
cur.next = n
cur = cur.next
return dummy.next
|
# -*- coding: utf-8 -*-
"""
Tencent is pleased to support the open source community by making 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community
Edition) available.
Copyright (C) 2017-2019 THL A29 Limited, a Tencent company. All rights reserved.
Licensed under the MIT License (the "License"); you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://opensource.org/licenses/MIT
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
"""
REMOTE_ANALYSIS_URL = ''
REMOTE_API_URL = ''
ESB_SDK_NAME = 'packages.blueking.component'
ESB_AUTH_COMPONENT_SYSTEM = 'bk_login'
ESB_AUTH_GET_USER_INFO = 'get_user'
CALLBACK_KEY = b'jbSH1_3PFsM8WRZZpUXJPhlJuvuA44A7Ov0nPhFk5ZY='
RSA_PRIV_KEY = """
-----BEGIN RSA PRIVATE KEY-----
MIICWwIBAAKBgQDA2XZvbf++4M6YLSgS93kYJS34e2TZvq/s6r0yFDz0je38ekW0
2aH5efPTNijbJgHIbqfXzm8lBpmBbk9VlUHaJVyZitqI6xYBqb3WBRu9WYEd8skF
y1mwOEbxOgsXoOPd9tLkt4etSMzm7kdBqmZKIeiAOtbmirDqkuz6M64b5wIDAQAB
AoGAdHxmX5RP4FomMCFGjX5R9NWwWOEf366g0ThRI4i58PYyBElPBZhXkDurna6f
KxBgD1NXqrEUzYaY/mdFIGrRpQfBPXDTSsJC+r68nxglcGVhuHCFvkY94J5bgYus
f7z2QkWdHi/LdENxP1eo+4ExcJ/XAHgOC18ThYTnZDo7G2ECQQDuzN9uSccn3sRE
Namwg54mcekkaTvBPLpX7+zNyLrNG6vGl/3NPQqi9D2ACXYkeWk8aQ65LoqLYnJJ
4bWmKaRPAkEAzr1S9q1rx/bV6iJOoEeeNGddWizWatTjLCT9XcXkETfIDc3YTpVD
bESXAcagtf6PbkNP1TG1MeXlTVhYp4tw6QJAa+frtnxkH+ILsf7FtNtkpV6nySo8
NC9qzL2/taVUs8YjMtQPfaRtoADZoXelCQpLwV5/prIfLKjJmBUD7he3BQJAVKYs
XBhx8zRcLjvR2cq5OlfAX3XQbXmxcpfKriSi13HxlcVc9gAj1SbYdb+wehQ7AjjJ
bU+nE0FAfETaN+/eUQJAMN4sJTjEMkeSeE+SBzqsmzc4ajMHRrhtu989JgZZvDyr
LOah9mmRwLJdcfa3Js+jw2lOCmxzqauYZHVHg/hH7g==
-----END RSA PRIVATE KEY-----
"""
# PUB_KEY for frontend, which can not use three quotes
RSA_PUB_KEY = "-----BEGIN PUBLIC KEY-----\\n" + \
"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDA2XZvbf++4M6YLSgS93kYJS34\\n" + \
"e2TZvq/s6r0yFDz0je38ekW02aH5efPTNijbJgHIbqfXzm8lBpmBbk9VlUHaJVyZ\\n" + \
"itqI6xYBqb3WBRu9WYEd8skFy1mwOEbxOgsXoOPd9tLkt4etSMzm7kdBqmZKIeiA\\n" + \
"OtbmirDqkuz6M64b5wIDAQAB\\n" + \
"-----END PUBLIC KEY-----"
|
# -*- coding: utf-8 -*-
"""
bandwidth
This file was automatically generated by APIMATIC v3.0 (
https://www.apimatic.io ).
"""
class ConferenceEventMethodEnum(object):
"""Implementation of the 'ConferenceEventMethod' enum.
TODO: type enum description here.
Attributes:
POST: TODO: type description here.
GET: TODO: type description here.
"""
POST = 'POST'
GET = 'GET'
|
# -*- coding: utf-8 -*-
""""
Author: Jean Pierre
Last Edited:
"""
|
# add your QUIC implementation here
IMPLEMENTATIONS = { # name => [ docker image, role ]; role: 0 == 'client', 1 == 'server', 2 == both
"quicgo": {"url": "martenseemann/quic-go-interop:latest", "role": 2},
"quicly": {"url": "janaiyengar/quicly:interop", "role": 2},
"ngtcp2": {"url": "ngtcp2/ngtcp2-interop:latest", "role": 2},
"quant": {"url": "ntap/quant:interop", "role": 2},
"mvfst": {"url": "lnicco/mvfst-qns:latest", "role": 2},
"quiche": {"url": "cloudflare/quiche-qns:latest", "role": 2},
"kwik": {"url": "peterdoornbosch/kwik_n_flupke-interop", "role": 0},
"picoquic": {"url": "privateoctopus/picoquic:latest", "role": 2},
"aioquic": {"url": "aiortc/aioquic-qns:latest", "role": 2},
}
|
class WorksharingDisplayMode(Enum,IComparable,IFormattable,IConvertible):
"""
Indicates which worksharing display mode a view is in.
enum WorksharingDisplayMode,values: CheckoutStatus (1),ModelUpdates (3),Off (0),Owners (2),Worksets (4)
"""
def __eq__(self,*args):
""" x.__eq__(y) <==> x==yx.__eq__(y) <==> x==yx.__eq__(y) <==> x==y """
pass
def __format__(self,*args):
""" __format__(formattable: IFormattable,format: str) -> str """
pass
def __ge__(self,*args):
pass
def __gt__(self,*args):
pass
def __init__(self,*args):
""" x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
pass
def __le__(self,*args):
pass
def __lt__(self,*args):
pass
def __ne__(self,*args):
pass
def __reduce_ex__(self,*args):
pass
def __str__(self,*args):
pass
CheckoutStatus=None
ModelUpdates=None
Off=None
Owners=None
value__=None
Worksets=None
|
class Solution:
def arrayNesting(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
dic={}
for i in range(len(nums)):
if i in dic:
continue
j=i
dic[j]=1
while nums[i]!=j:
dic[j]+=1
i=nums[i]
dic[i]=1
return max(dic.values())
|
class Solution:
def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
"""
[1,2],[2,3],[3,4],[1,3]
[(1,s), (1,s), (2,e), (2, s), (3, e), (3, e), (3, s), (4,e)]
"""
events = []
for start, end in intervals:
events.append((start, 0))
events.append((end, 1))
events.sort(key=lambda x: (x[1], x[0]))
processed_events = []
skipped_events = 0
balance = 0
start = 0
for time, e_type in events:
if balance > 0 and e_type == 0:
skipped_events += 1
balance += 1 if e_type.START else -1
return skipped_events
def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
"""
[1,2],[1,5],[2,3],[3,4]
[1,2],[2,3],[3,4]
"""
events = sorted(intervals, key=lambda x: x[1])
processed_events = []
skipped_events = 0
for start, end in events:
if processed_events and processed_events[-1][1] > start:
skipped_events += 1
else:
processed_events.append([start, end])
return skipped_events
|
# https://stackoverflow.com/questions/16017397/injecting-function-call-after-init-with-decorator
# define a new metaclass which overrides the "__call__" function
class InitModifier(type):
def __call__(cls, *args, **kwargs):
"""Called when you call MyNewClass() """
obj = type.__call__(cls, *args, **kwargs)
# Each time init() is called, so is freeze()
obj._freeze()
return obj
# https://stackoverflow.com/questions/3603502/prevent-creating-new-attributes-outside-init
class FrozenClassTemplate(object):
__isfrozen = False
def __setattr__(self, key, value):
if self.__isfrozen and not hasattr(self, key):
raise TypeError(
"\"" + self.__class__.__name__ + "\" is a frozen class. "
"Adding of attributes after init() is forbidden. "
"Attribute \"" + str(key) + "\" is not defined. "
"Did you misspelled the attribute?"
)
object.__setattr__(self, key, value)
def _freeze(self):
self.__isfrozen = True
class FrozenClass(FrozenClassTemplate):
# Note: named tuples are immutable, -> can't use them for this purpose
__metaclass__ = InitModifier
|
#
# PySNMP MIB module ADTRAN-AOS (http://snmplabs.com/pysmi)
# ASN.1 source file:///Users/davwang4/Dev/mibs.snmplabs.com/asn1/ADTRAN-AOS
# Produced by pysmi-0.3.4 at Mon Apr 29 16:58:35 2019
# On host DAVWANG4-M-1475 platform Darwin version 18.5.0 by user davwang4
# Using Python version 3.7.3 (default, Mar 27 2019, 09:23:15)
#
adShared, adIdentityShared = mibBuilder.importSymbols("ADTRAN-MIB", "adShared", "adIdentityShared")
OctetString, ObjectIdentifier, Integer = mibBuilder.importSymbols("ASN1", "OctetString", "ObjectIdentifier", "Integer")
NamedValues, = mibBuilder.importSymbols("ASN1-ENUMERATION", "NamedValues")
ValueRangeConstraint, ConstraintsUnion, ValueSizeConstraint, ConstraintsIntersection, SingleValueConstraint = mibBuilder.importSymbols("ASN1-REFINEMENT", "ValueRangeConstraint", "ConstraintsUnion", "ValueSizeConstraint", "ConstraintsIntersection", "SingleValueConstraint")
NotificationGroup, ModuleCompliance = mibBuilder.importSymbols("SNMPv2-CONF", "NotificationGroup", "ModuleCompliance")
Integer32, ModuleIdentity, Counter32, Bits, Counter64, Gauge32, MibIdentifier, iso, IpAddress, MibScalar, MibTable, MibTableRow, MibTableColumn, NotificationType, Unsigned32, TimeTicks, ObjectIdentity = mibBuilder.importSymbols("SNMPv2-SMI", "Integer32", "ModuleIdentity", "Counter32", "Bits", "Counter64", "Gauge32", "MibIdentifier", "iso", "IpAddress", "MibScalar", "MibTable", "MibTableRow", "MibTableColumn", "NotificationType", "Unsigned32", "TimeTicks", "ObjectIdentity")
TextualConvention, DisplayString = mibBuilder.importSymbols("SNMPv2-TC", "TextualConvention", "DisplayString")
adGenAOSMib = ModuleIdentity((1, 3, 6, 1, 4, 1, 664, 6, 10000, 53))
adGenAOSMib.setRevisions(('2014-09-10 00:00', '2012-04-27 00:00', '2010-07-05 00:00', '2004-10-20 00:00',))
if mibBuilder.loadTexts: adGenAOSMib.setLastUpdated('201409100000Z')
if mibBuilder.loadTexts: adGenAOSMib.setOrganization('ADTRAN, Inc.')
adGenAOS = MibIdentifier((1, 3, 6, 1, 4, 1, 664, 5, 53))
adGenAOSCommon = MibIdentifier((1, 3, 6, 1, 4, 1, 664, 5, 53, 1))
adGenAOSRouter = MibIdentifier((1, 3, 6, 1, 4, 1, 664, 5, 53, 2))
adGenAOSSecurity = MibIdentifier((1, 3, 6, 1, 4, 1, 664, 5, 53, 3))
adGenAOSSwitch = MibIdentifier((1, 3, 6, 1, 4, 1, 664, 5, 53, 4))
adGenAOSVoice = MibIdentifier((1, 3, 6, 1, 4, 1, 664, 5, 53, 5))
adGenAOSWan = MibIdentifier((1, 3, 6, 1, 4, 1, 664, 5, 53, 6))
adGenAOSPower = MibIdentifier((1, 3, 6, 1, 4, 1, 664, 5, 53, 7))
adGenAOSConformance = MibIdentifier((1, 3, 6, 1, 4, 1, 664, 5, 53, 99))
adGenAOSApplications = MibIdentifier((1, 3, 6, 1, 4, 1, 664, 5, 53, 8))
adGenAOSMef = MibIdentifier((1, 3, 6, 1, 4, 1, 664, 5, 53, 9))
mibBuilder.exportSymbols("ADTRAN-AOS", adGenAOSSwitch=adGenAOSSwitch, adGenAOSPower=adGenAOSPower, adGenAOSMef=adGenAOSMef, adGenAOSWan=adGenAOSWan, adGenAOSVoice=adGenAOSVoice, adGenAOSConformance=adGenAOSConformance, adGenAOS=adGenAOS, PYSNMP_MODULE_ID=adGenAOSMib, adGenAOSSecurity=adGenAOSSecurity, adGenAOSMib=adGenAOSMib, adGenAOSRouter=adGenAOSRouter, adGenAOSApplications=adGenAOSApplications, adGenAOSCommon=adGenAOSCommon)
|
chars_to_remove = ["-", ",", ".", "!", "?"]
with open('text.txt') as text_file:
for i, line in enumerate(text_file):
if i % 2 == 0:
for char in line:
if char in chars_to_remove:
line = line.replace(char, '@')
print(' '.join(reversed(line.split())))
|
def hvplot_with_buffer(gdf, buffer_size, *args, **kwargs):
"""
Convenience function for plotting a GeoPandas point GeoDataFrame using point markers plus buffer polygons
Parameters
----------
gdf : geopandas.GeoDataFrame
point GeoDataFrame to plot
buffer_size : numeric
size of the buffer in meters (measured in EPSG:31287)
"""
buffered = gdf.to_crs('epsg:31287').buffer(buffer_size)
buffered = gdf.copy().set_geometry(buffered).to_crs('epsg:4326')
plot = ( buffered.hvplot(geo=True, tiles='OSM', alpha=0.5, line_width=0, *args, **kwargs) *
gdf.hvplot(geo=True, hover_cols=['DESIGNATION'])
).opts(active_tools=['wheel_zoom'])
return plot
|
# (C) Datadog, Inc. 2019
# All rights reserved
# Licensed under a 3-clause BSD style license (see LICENSE)
STANDARD = [
'sap_hana.backup.latest',
'sap_hana.connection.idle',
'sap_hana.connection.open',
'sap_hana.connection.running',
'sap_hana.cpu.service.utilized',
'sap_hana.disk.free',
'sap_hana.disk.size',
'sap_hana.disk.used',
'sap_hana.disk.utilized',
'sap_hana.file.service.open',
'sap_hana.memory.row_store.free',
'sap_hana.memory.row_store.total',
'sap_hana.memory.row_store.used',
'sap_hana.memory.row_store.utilized',
'sap_hana.memory.service.component.used',
'sap_hana.memory.service.compactor.free',
'sap_hana.memory.service.compactor.total',
'sap_hana.memory.service.compactor.used',
'sap_hana.memory.service.compactor.utilized',
'sap_hana.memory.service.heap.free',
'sap_hana.memory.service.heap.total',
'sap_hana.memory.service.heap.used',
'sap_hana.memory.service.heap.utilized',
'sap_hana.memory.service.overall.physical.total',
'sap_hana.memory.service.overall.free',
'sap_hana.memory.service.overall.total',
'sap_hana.memory.service.overall.used',
'sap_hana.memory.service.overall.utilized',
'sap_hana.memory.service.overall.virtual.total',
'sap_hana.memory.service.shared.free',
'sap_hana.memory.service.shared.total',
'sap_hana.memory.service.shared.used',
'sap_hana.memory.service.shared.utilized',
'sap_hana.network.service.request.active',
'sap_hana.network.service.request.external.total_finished',
'sap_hana.network.service.request.internal.total_finished',
'sap_hana.network.service.request.pending',
'sap_hana.network.service.request.per_second',
'sap_hana.network.service.request.response_time',
'sap_hana.network.service.request.total_finished',
'sap_hana.thread.service.active',
'sap_hana.thread.service.inactive',
'sap_hana.thread.service.total',
'sap_hana.uptime',
'sap_hana.volume.io.read.count',
'sap_hana.volume.io.read.size.count',
'sap_hana.volume.io.read.size.total',
'sap_hana.volume.io.read.total',
'sap_hana.volume.io.read.utilized',
'sap_hana.volume.io.throughput',
'sap_hana.volume.io.utilized',
'sap_hana.volume.io.write.count',
'sap_hana.volume.io.write.size.count',
'sap_hana.volume.io.write.size.total',
'sap_hana.volume.io.write.total',
'sap_hana.volume.io.write.utilized',
]
|
def boxes_packing(length, width, height):
total=[sorted((i,j,k)) for i,j,k in zip(length, width, height)]
res=sorted(total, key=lambda x: -min(x))
for i,j in enumerate(res[1:]):
if any((k-l)<=0 for k,l in zip(res[i], j)):
return False
return True
|
{
'includes': [ '../common.gyp' ],
'targets': [
{
'target_name': 'libjpeg',
'type': 'static_library',
'include_dirs': [
'.',
],
'sources': [
'ckconfig.c',
'jcapimin.c',
'jcapistd.c',
'jccoefct.c',
'jccolor.c',
'jcdctmgr.c',
'jchuff.c',
'jcinit.c',
'jcmainct.c',
'jcmarker.c',
'jcmaster.c',
'jcomapi.c',
'jcparam.c',
'jcphuff.c',
'jcprepct.c',
'jcsample.c',
'jctrans.c',
'jdapimin.c',
'jdapistd.c',
'jdatadst.c',
'jdatasrc.c',
'jdcoefct.c',
'jdcolor.c',
'jddctmgr.c',
'jdhuff.c',
'jdinput.c',
'jdmainct.c',
'jdmarker.c',
'jdmaster.c',
'jdmerge.c',
'jdphuff.c',
'jdpostct.c',
'jdsample.c',
'jdtrans.c',
'jerror.c',
'jfdctflt.c',
'jfdctfst.c',
'jfdctint.c',
'jidctflt.c',
'jidctfst.c',
'jidctint.c',
'jidctred.c',
'jmemansi.c',
#'jmemdos.c',
#'jmemmac.c',
'jmemmgr.c',
#'jmemname.c',
#'jmemnobs.c',
'jquant1.c',
'jquant2.c',
'jutils.c',
],
},
]
}
|
# Copyright (c) 2009 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
{
'target_defaults': {
'defines': [
'_LIB',
'XML_STATIC', # Compile for static linkage.
],
'include_dirs': [
'files/lib',
],
'dependencies': [
]
},
'conditions': [
['OS=="linux" or OS=="freebsd"', {
# On Linux, we implicitly already depend on expat via fontconfig;
# let's not pull it in twice.
'targets': [
{
'target_name': 'expat',
'type': 'settings',
'link_settings': {
'libraries': [
'-lexpat',
],
},
},
],
}, { # OS != linux
'targets': [
{
'target_name': 'expat',
'type': '<(library)',
'sources': [
'files/lib/expat.h',
'files/lib/xmlparse.c',
'files/lib/xmlrole.c',
'files/lib/xmltok.c',
],
# Prefer adding a dependency to expat and relying on the following
# direct_dependent_settings rule over manually adding the include
# path. This is because you'll want any translation units that
# #include these files to pick up the #defines as well.
'direct_dependent_settings': {
'include_dirs': [
'files/lib'
],
'defines': [
'XML_STATIC', # Tell dependants to expect static linkage.
],
},
'conditions': [
['OS=="win"', {
'defines': [
'COMPILED_FROM_DSP',
],
}],
['OS=="mac" or OS=="freebsd"', {
'defines': [
'HAVE_EXPAT_CONFIG_H',
],
}],
],
},
],
}],
],
}
# Local Variables:
# tab-width:2
# indent-tabs-mode:nil
# End:
# vim: set expandtab tabstop=2 shiftwidth=2:
|
"""
BSD 3-Clause License
Copyright (c) 2018, Jerrad Genson
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Inspired by code in "Machine Learning: An Algorithmic Perspective" by
Dr. Stephen Marsland.
"""
def normalize(data):
"""
Normalize data set to have zero mean and unit variance.
Args
data: A numpy array of arrays containing input or target data.
Returns
A normalized numpy array of arrays.
"""
return (data - data.mean(axis=0)) / data.var(axis=0)
|
# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
_SNAKE_TO_CAMEL_CASE_TABLE = {
"acceleration_status": "accelerationStatus",
"accelerator_arn": "acceleratorArn",
"accept_status": "acceptStatus",
"acceptance_required": "acceptanceRequired",
"access_log_settings": "accessLogSettings",
"access_logs": "accessLogs",
"access_policies": "accessPolicies",
"access_policy": "accessPolicy",
"access_url": "accessUrl",
"account_aggregation_source": "accountAggregationSource",
"account_alias": "accountAlias",
"account_id": "accountId",
"actions_enabled": "actionsEnabled",
"activated_rules": "activatedRules",
"activation_code": "activationCode",
"activation_key": "activationKey",
"active_directory_id": "activeDirectoryId",
"active_trusted_signers": "activeTrustedSigners",
"add_header_actions": "addHeaderActions",
"additional_artifacts": "additionalArtifacts",
"additional_authentication_providers": "additionalAuthenticationProviders",
"additional_info": "additionalInfo",
"additional_schema_elements": "additionalSchemaElements",
"address_family": "addressFamily",
"adjustment_type": "adjustmentType",
"admin_account_id": "adminAccountId",
"admin_create_user_config": "adminCreateUserConfig",
"administration_role_arn": "administrationRoleArn",
"advanced_options": "advancedOptions",
"agent_arns": "agentArns",
"agent_version": "agentVersion",
"alarm_actions": "alarmActions",
"alarm_configuration": "alarmConfiguration",
"alarm_description": "alarmDescription",
"alb_target_group_arn": "albTargetGroupArn",
"alias_attributes": "aliasAttributes",
"all_settings": "allSettings",
"allocated_capacity": "allocatedCapacity",
"allocated_memory": "allocatedMemory",
"allocated_storage": "allocatedStorage",
"allocation_id": "allocationId",
"allocation_strategy": "allocationStrategy",
"allow_external_principals": "allowExternalPrincipals",
"allow_major_version_upgrade": "allowMajorVersionUpgrade",
"allow_overwrite": "allowOverwrite",
"allow_reassociation": "allowReassociation",
"allow_self_management": "allowSelfManagement",
"allow_ssh": "allowSsh",
"allow_sudo": "allowSudo",
"allow_unassociated_targets": "allowUnassociatedTargets",
"allow_unauthenticated_identities": "allowUnauthenticatedIdentities",
"allow_users_to_change_password": "allowUsersToChangePassword",
"allow_version_upgrade": "allowVersionUpgrade",
"allowed_oauth_flows": "allowedOauthFlows",
"allowed_oauth_flows_user_pool_client": "allowedOauthFlowsUserPoolClient",
"allowed_oauth_scopes": "allowedOauthScopes",
"allowed_pattern": "allowedPattern",
"allowed_prefixes": "allowedPrefixes",
"allowed_principals": "allowedPrincipals",
"amazon_address": "amazonAddress",
"amazon_side_asn": "amazonSideAsn",
"ami_id": "amiId",
"ami_type": "amiType",
"analytics_configuration": "analyticsConfiguration",
"analyzer_name": "analyzerName",
"api_endpoint": "apiEndpoint",
"api_id": "apiId",
"api_key": "apiKey",
"api_key_required": "apiKeyRequired",
"api_key_selection_expression": "apiKeySelectionExpression",
"api_key_source": "apiKeySource",
"api_mapping_key": "apiMappingKey",
"api_mapping_selection_expression": "apiMappingSelectionExpression",
"api_stages": "apiStages",
"app_name": "appName",
"app_server": "appServer",
"app_server_version": "appServerVersion",
"app_sources": "appSources",
"application_failure_feedback_role_arn": "applicationFailureFeedbackRoleArn",
"application_id": "applicationId",
"application_success_feedback_role_arn": "applicationSuccessFeedbackRoleArn",
"application_success_feedback_sample_rate": "applicationSuccessFeedbackSampleRate",
"apply_immediately": "applyImmediately",
"approval_rules": "approvalRules",
"approved_patches": "approvedPatches",
"approved_patches_compliance_level": "approvedPatchesComplianceLevel",
"appversion_lifecycle": "appversionLifecycle",
"arn_suffix": "arnSuffix",
"artifact_store": "artifactStore",
"assign_generated_ipv6_cidr_block": "assignGeneratedIpv6CidrBlock",
"assign_ipv6_address_on_creation": "assignIpv6AddressOnCreation",
"associate_public_ip_address": "associatePublicIpAddress",
"associate_with_private_ip": "associateWithPrivateIp",
"associated_gateway_id": "associatedGatewayId",
"associated_gateway_owner_account_id": "associatedGatewayOwnerAccountId",
"associated_gateway_type": "associatedGatewayType",
"association_default_route_table_id": "associationDefaultRouteTableId",
"association_id": "associationId",
"association_name": "associationName",
"assume_role_policy": "assumeRolePolicy",
"at_rest_encryption_enabled": "atRestEncryptionEnabled",
"attachment_id": "attachmentId",
"attachments_sources": "attachmentsSources",
"attribute_mapping": "attributeMapping",
"audio_codec_options": "audioCodecOptions",
"audit_stream_arn": "auditStreamArn",
"auth_token": "authToken",
"auth_type": "authType",
"authentication_configuration": "authenticationConfiguration",
"authentication_options": "authenticationOptions",
"authentication_type": "authenticationType",
"authorization_scopes": "authorizationScopes",
"authorization_type": "authorizationType",
"authorizer_credentials": "authorizerCredentials",
"authorizer_credentials_arn": "authorizerCredentialsArn",
"authorizer_id": "authorizerId",
"authorizer_result_ttl_in_seconds": "authorizerResultTtlInSeconds",
"authorizer_type": "authorizerType",
"authorizer_uri": "authorizerUri",
"auto_accept": "autoAccept",
"auto_accept_shared_attachments": "autoAcceptSharedAttachments",
"auto_assign_elastic_ips": "autoAssignElasticIps",
"auto_assign_public_ips": "autoAssignPublicIps",
"auto_bundle_on_deploy": "autoBundleOnDeploy",
"auto_deploy": "autoDeploy",
"auto_deployed": "autoDeployed",
"auto_enable": "autoEnable",
"auto_healing": "autoHealing",
"auto_minor_version_upgrade": "autoMinorVersionUpgrade",
"auto_rollback_configuration": "autoRollbackConfiguration",
"auto_scaling_group_provider": "autoScalingGroupProvider",
"auto_scaling_type": "autoScalingType",
"auto_verified_attributes": "autoVerifiedAttributes",
"automated_snapshot_retention_period": "automatedSnapshotRetentionPeriod",
"automatic_backup_retention_days": "automaticBackupRetentionDays",
"automatic_failover_enabled": "automaticFailoverEnabled",
"automatic_stop_time_minutes": "automaticStopTimeMinutes",
"automation_target_parameter_name": "automationTargetParameterName",
"autoscaling_group_name": "autoscalingGroupName",
"autoscaling_groups": "autoscalingGroups",
"autoscaling_policy": "autoscalingPolicy",
"autoscaling_role": "autoscalingRole",
"availability_zone": "availabilityZone",
"availability_zone_id": "availabilityZoneId",
"availability_zone_name": "availabilityZoneName",
"availability_zones": "availabilityZones",
"aws_account_id": "awsAccountId",
"aws_device": "awsDevice",
"aws_flow_ruby_settings": "awsFlowRubySettings",
"aws_kms_key_arn": "awsKmsKeyArn",
"aws_service_access_principals": "awsServiceAccessPrincipals",
"aws_service_name": "awsServiceName",
"az_mode": "azMode",
"backtrack_window": "backtrackWindow",
"backup_retention_period": "backupRetentionPeriod",
"backup_window": "backupWindow",
"badge_enabled": "badgeEnabled",
"badge_url": "badgeUrl",
"base_endpoint_dns_names": "baseEndpointDnsNames",
"base_path": "basePath",
"baseline_id": "baselineId",
"batch_size": "batchSize",
"batch_target": "batchTarget",
"behavior_on_mx_failure": "behaviorOnMxFailure",
"berkshelf_version": "berkshelfVersion",
"bgp_asn": "bgpAsn",
"bgp_auth_key": "bgpAuthKey",
"bgp_peer_id": "bgpPeerId",
"bgp_status": "bgpStatus",
"bid_price": "bidPrice",
"billing_mode": "billingMode",
"binary_media_types": "binaryMediaTypes",
"bisect_batch_on_function_error": "bisectBatchOnFunctionError",
"block_device_mappings": "blockDeviceMappings",
"block_duration_minutes": "blockDurationMinutes",
"block_public_acls": "blockPublicAcls",
"block_public_policy": "blockPublicPolicy",
"blue_green_deployment_config": "blueGreenDeploymentConfig",
"blueprint_id": "blueprintId",
"bootstrap_actions": "bootstrapActions",
"bootstrap_brokers": "bootstrapBrokers",
"bootstrap_brokers_tls": "bootstrapBrokersTls",
"bounce_actions": "bounceActions",
"branch_filter": "branchFilter",
"broker_name": "brokerName",
"broker_node_group_info": "brokerNodeGroupInfo",
"bucket_domain_name": "bucketDomainName",
"bucket_name": "bucketName",
"bucket_prefix": "bucketPrefix",
"bucket_regional_domain_name": "bucketRegionalDomainName",
"budget_type": "budgetType",
"build_id": "buildId",
"build_timeout": "buildTimeout",
"bundle_id": "bundleId",
"bundler_version": "bundlerVersion",
"byte_match_tuples": "byteMatchTuples",
"ca_cert_identifier": "caCertIdentifier",
"cache_cluster_enabled": "cacheClusterEnabled",
"cache_cluster_size": "cacheClusterSize",
"cache_control": "cacheControl",
"cache_key_parameters": "cacheKeyParameters",
"cache_namespace": "cacheNamespace",
"cache_nodes": "cacheNodes",
"caching_config": "cachingConfig",
"callback_urls": "callbackUrls",
"caller_reference": "callerReference",
"campaign_hook": "campaignHook",
"capacity_provider_strategies": "capacityProviderStrategies",
"capacity_providers": "capacityProviders",
"capacity_reservation_specification": "capacityReservationSpecification",
"catalog_id": "catalogId",
"catalog_targets": "catalogTargets",
"cdc_start_time": "cdcStartTime",
"certificate_arn": "certificateArn",
"certificate_authority": "certificateAuthority",
"certificate_authority_arn": "certificateAuthorityArn",
"certificate_authority_configuration": "certificateAuthorityConfiguration",
"certificate_body": "certificateBody",
"certificate_chain": "certificateChain",
"certificate_id": "certificateId",
"certificate_name": "certificateName",
"certificate_pem": "certificatePem",
"certificate_private_key": "certificatePrivateKey",
"certificate_signing_request": "certificateSigningRequest",
"certificate_upload_date": "certificateUploadDate",
"certificate_wallet": "certificateWallet",
"channel_id": "channelId",
"chap_enabled": "chapEnabled",
"character_set_name": "characterSetName",
"child_health_threshold": "childHealthThreshold",
"child_healthchecks": "childHealthchecks",
"cidr_block": "cidrBlock",
"cidr_blocks": "cidrBlocks",
"ciphertext_blob": "ciphertextBlob",
"classification_type": "classificationType",
"client_affinity": "clientAffinity",
"client_authentication": "clientAuthentication",
"client_certificate_id": "clientCertificateId",
"client_cidr_block": "clientCidrBlock",
"client_id": "clientId",
"client_id_lists": "clientIdLists",
"client_lists": "clientLists",
"client_secret": "clientSecret",
"client_token": "clientToken",
"client_vpn_endpoint_id": "clientVpnEndpointId",
"clone_url_http": "cloneUrlHttp",
"clone_url_ssh": "cloneUrlSsh",
"cloud_watch_logs_group_arn": "cloudWatchLogsGroupArn",
"cloud_watch_logs_role_arn": "cloudWatchLogsRoleArn",
"cloudfront_access_identity_path": "cloudfrontAccessIdentityPath",
"cloudfront_distribution_arn": "cloudfrontDistributionArn",
"cloudfront_domain_name": "cloudfrontDomainName",
"cloudfront_zone_id": "cloudfrontZoneId",
"cloudwatch_alarm": "cloudwatchAlarm",
"cloudwatch_alarm_name": "cloudwatchAlarmName",
"cloudwatch_alarm_region": "cloudwatchAlarmRegion",
"cloudwatch_destinations": "cloudwatchDestinations",
"cloudwatch_log_group_arn": "cloudwatchLogGroupArn",
"cloudwatch_logging_options": "cloudwatchLoggingOptions",
"cloudwatch_metric": "cloudwatchMetric",
"cloudwatch_role_arn": "cloudwatchRoleArn",
"cluster_address": "clusterAddress",
"cluster_certificates": "clusterCertificates",
"cluster_config": "clusterConfig",
"cluster_endpoint_identifier": "clusterEndpointIdentifier",
"cluster_id": "clusterId",
"cluster_identifier": "clusterIdentifier",
"cluster_identifier_prefix": "clusterIdentifierPrefix",
"cluster_members": "clusterMembers",
"cluster_mode": "clusterMode",
"cluster_name": "clusterName",
"cluster_parameter_group_name": "clusterParameterGroupName",
"cluster_public_key": "clusterPublicKey",
"cluster_resource_id": "clusterResourceId",
"cluster_revision_number": "clusterRevisionNumber",
"cluster_security_groups": "clusterSecurityGroups",
"cluster_state": "clusterState",
"cluster_subnet_group_name": "clusterSubnetGroupName",
"cluster_type": "clusterType",
"cluster_version": "clusterVersion",
"cname_prefix": "cnamePrefix",
"cognito_identity_providers": "cognitoIdentityProviders",
"cognito_options": "cognitoOptions",
"company_code": "companyCode",
"comparison_operator": "comparisonOperator",
"compatible_runtimes": "compatibleRuntimes",
"complete_lock": "completeLock",
"compliance_severity": "complianceSeverity",
"compute_environment_name": "computeEnvironmentName",
"compute_environment_name_prefix": "computeEnvironmentNamePrefix",
"compute_environments": "computeEnvironments",
"compute_platform": "computePlatform",
"compute_resources": "computeResources",
"computer_name": "computerName",
"configuration_endpoint": "configurationEndpoint",
"configuration_endpoint_address": "configurationEndpointAddress",
"configuration_id": "configurationId",
"configuration_info": "configurationInfo",
"configuration_manager_name": "configurationManagerName",
"configuration_manager_version": "configurationManagerVersion",
"configuration_set_name": "configurationSetName",
"configurations_json": "configurationsJson",
"confirmation_timeout_in_minutes": "confirmationTimeoutInMinutes",
"connect_settings": "connectSettings",
"connection_draining": "connectionDraining",
"connection_draining_timeout": "connectionDrainingTimeout",
"connection_events": "connectionEvents",
"connection_id": "connectionId",
"connection_log_options": "connectionLogOptions",
"connection_notification_arn": "connectionNotificationArn",
"connection_properties": "connectionProperties",
"connection_type": "connectionType",
"connections_bandwidth": "connectionsBandwidth",
"container_definitions": "containerDefinitions",
"container_name": "containerName",
"container_properties": "containerProperties",
"content_base64": "contentBase64",
"content_based_deduplication": "contentBasedDeduplication",
"content_config": "contentConfig",
"content_config_permissions": "contentConfigPermissions",
"content_disposition": "contentDisposition",
"content_encoding": "contentEncoding",
"content_handling": "contentHandling",
"content_handling_strategy": "contentHandlingStrategy",
"content_language": "contentLanguage",
"content_type": "contentType",
"cookie_expiration_period": "cookieExpirationPeriod",
"cookie_name": "cookieName",
"copy_tags_to_backups": "copyTagsToBackups",
"copy_tags_to_snapshot": "copyTagsToSnapshot",
"core_instance_count": "coreInstanceCount",
"core_instance_group": "coreInstanceGroup",
"core_instance_type": "coreInstanceType",
"cors_configuration": "corsConfiguration",
"cors_rules": "corsRules",
"cost_filters": "costFilters",
"cost_types": "costTypes",
"cpu_core_count": "cpuCoreCount",
"cpu_count": "cpuCount",
"cpu_options": "cpuOptions",
"cpu_threads_per_core": "cpuThreadsPerCore",
"create_date": "createDate",
"create_timestamp": "createTimestamp",
"created_at": "createdAt",
"created_date": "createdDate",
"created_time": "createdTime",
"creation_date": "creationDate",
"creation_time": "creationTime",
"creation_token": "creationToken",
"credential_duration": "credentialDuration",
"credentials_arn": "credentialsArn",
"credit_specification": "creditSpecification",
"cross_zone_load_balancing": "crossZoneLoadBalancing",
"csv_classifier": "csvClassifier",
"current_version": "currentVersion",
"custom_ami_id": "customAmiId",
"custom_configure_recipes": "customConfigureRecipes",
"custom_cookbooks_sources": "customCookbooksSources",
"custom_deploy_recipes": "customDeployRecipes",
"custom_endpoint_type": "customEndpointType",
"custom_error_responses": "customErrorResponses",
"custom_instance_profile_arn": "customInstanceProfileArn",
"custom_json": "customJson",
"custom_security_group_ids": "customSecurityGroupIds",
"custom_setup_recipes": "customSetupRecipes",
"custom_shutdown_recipes": "customShutdownRecipes",
"custom_suffix": "customSuffix",
"custom_undeploy_recipes": "customUndeployRecipes",
"customer_address": "customerAddress",
"customer_aws_id": "customerAwsId",
"customer_gateway_configuration": "customerGatewayConfiguration",
"customer_gateway_id": "customerGatewayId",
"customer_master_key_spec": "customerMasterKeySpec",
"customer_owned_ip": "customerOwnedIp",
"customer_owned_ipv4_pool": "customerOwnedIpv4Pool",
"customer_user_name": "customerUserName",
"daily_automatic_backup_start_time": "dailyAutomaticBackupStartTime",
"dashboard_arn": "dashboardArn",
"dashboard_body": "dashboardBody",
"dashboard_name": "dashboardName",
"data_encryption_key_id": "dataEncryptionKeyId",
"data_retention_in_hours": "dataRetentionInHours",
"data_source": "dataSource",
"data_source_arn": "dataSourceArn",
"data_source_database_name": "dataSourceDatabaseName",
"data_source_type": "dataSourceType",
"database_name": "databaseName",
"datapoints_to_alarm": "datapointsToAlarm",
"db_cluster_identifier": "dbClusterIdentifier",
"db_cluster_parameter_group_name": "dbClusterParameterGroupName",
"db_cluster_snapshot_arn": "dbClusterSnapshotArn",
"db_cluster_snapshot_identifier": "dbClusterSnapshotIdentifier",
"db_instance_identifier": "dbInstanceIdentifier",
"db_parameter_group_name": "dbParameterGroupName",
"db_password": "dbPassword",
"db_snapshot_arn": "dbSnapshotArn",
"db_snapshot_identifier": "dbSnapshotIdentifier",
"db_subnet_group_name": "dbSubnetGroupName",
"db_user": "dbUser",
"dbi_resource_id": "dbiResourceId",
"dead_letter_config": "deadLetterConfig",
"default_action": "defaultAction",
"default_actions": "defaultActions",
"default_arguments": "defaultArguments",
"default_association_route_table": "defaultAssociationRouteTable",
"default_authentication_method": "defaultAuthenticationMethod",
"default_availability_zone": "defaultAvailabilityZone",
"default_branch": "defaultBranch",
"default_cache_behavior": "defaultCacheBehavior",
"default_capacity_provider_strategies": "defaultCapacityProviderStrategies",
"default_client_id": "defaultClientId",
"default_cooldown": "defaultCooldown",
"default_instance_profile_arn": "defaultInstanceProfileArn",
"default_network_acl_id": "defaultNetworkAclId",
"default_os": "defaultOs",
"default_propagation_route_table": "defaultPropagationRouteTable",
"default_redirect_uri": "defaultRedirectUri",
"default_result": "defaultResult",
"default_root_device_type": "defaultRootDeviceType",
"default_root_object": "defaultRootObject",
"default_route_settings": "defaultRouteSettings",
"default_route_table_association": "defaultRouteTableAssociation",
"default_route_table_id": "defaultRouteTableId",
"default_route_table_propagation": "defaultRouteTablePropagation",
"default_run_properties": "defaultRunProperties",
"default_security_group_id": "defaultSecurityGroupId",
"default_sender_id": "defaultSenderId",
"default_sms_type": "defaultSmsType",
"default_ssh_key_name": "defaultSshKeyName",
"default_storage_class": "defaultStorageClass",
"default_subnet_id": "defaultSubnetId",
"default_value": "defaultValue",
"default_version": "defaultVersion",
"default_version_id": "defaultVersionId",
"delay_seconds": "delaySeconds",
"delegation_set_id": "delegationSetId",
"delete_automated_backups": "deleteAutomatedBackups",
"delete_ebs": "deleteEbs",
"delete_eip": "deleteEip",
"deletion_protection": "deletionProtection",
"deletion_window_in_days": "deletionWindowInDays",
"delivery_policy": "deliveryPolicy",
"delivery_status_iam_role_arn": "deliveryStatusIamRoleArn",
"delivery_status_success_sampling_rate": "deliveryStatusSuccessSamplingRate",
"deployment_config_id": "deploymentConfigId",
"deployment_config_name": "deploymentConfigName",
"deployment_controller": "deploymentController",
"deployment_group_name": "deploymentGroupName",
"deployment_id": "deploymentId",
"deployment_maximum_percent": "deploymentMaximumPercent",
"deployment_minimum_healthy_percent": "deploymentMinimumHealthyPercent",
"deployment_mode": "deploymentMode",
"deployment_style": "deploymentStyle",
"deregistration_delay": "deregistrationDelay",
"desired_capacity": "desiredCapacity",
"desired_count": "desiredCount",
"destination_arn": "destinationArn",
"destination_cidr_block": "destinationCidrBlock",
"destination_config": "destinationConfig",
"destination_id": "destinationId",
"destination_ipv6_cidr_block": "destinationIpv6CidrBlock",
"destination_location_arn": "destinationLocationArn",
"destination_name": "destinationName",
"destination_port_range": "destinationPortRange",
"destination_prefix_list_id": "destinationPrefixListId",
"destination_stream_arn": "destinationStreamArn",
"detail_type": "detailType",
"detector_id": "detectorId",
"developer_provider_name": "developerProviderName",
"device_ca_certificate": "deviceCaCertificate",
"device_configuration": "deviceConfiguration",
"device_index": "deviceIndex",
"device_name": "deviceName",
"dhcp_options_id": "dhcpOptionsId",
"direct_internet_access": "directInternetAccess",
"directory_id": "directoryId",
"directory_name": "directoryName",
"directory_type": "directoryType",
"disable_api_termination": "disableApiTermination",
"disable_email_notification": "disableEmailNotification",
"disable_rollback": "disableRollback",
"disk_id": "diskId",
"disk_size": "diskSize",
"display_name": "displayName",
"dkim_tokens": "dkimTokens",
"dns_config": "dnsConfig",
"dns_entries": "dnsEntries",
"dns_ip_addresses": "dnsIpAddresses",
"dns_ips": "dnsIps",
"dns_name": "dnsName",
"dns_servers": "dnsServers",
"dns_support": "dnsSupport",
"document_format": "documentFormat",
"document_root": "documentRoot",
"document_type": "documentType",
"document_version": "documentVersion",
"documentation_version": "documentationVersion",
"domain_endpoint_options": "domainEndpointOptions",
"domain_iam_role_name": "domainIamRoleName",
"domain_id": "domainId",
"domain_name": "domainName",
"domain_name_configuration": "domainNameConfiguration",
"domain_name_servers": "domainNameServers",
"domain_validation_options": "domainValidationOptions",
"drain_elb_on_shutdown": "drainElbOnShutdown",
"drop_invalid_header_fields": "dropInvalidHeaderFields",
"dx_gateway_association_id": "dxGatewayAssociationId",
"dx_gateway_id": "dxGatewayId",
"dx_gateway_owner_account_id": "dxGatewayOwnerAccountId",
"dynamodb_config": "dynamodbConfig",
"dynamodb_targets": "dynamodbTargets",
"ebs_block_devices": "ebsBlockDevices",
"ebs_configs": "ebsConfigs",
"ebs_optimized": "ebsOptimized",
"ebs_options": "ebsOptions",
"ebs_root_volume_size": "ebsRootVolumeSize",
"ebs_volumes": "ebsVolumes",
"ec2_attributes": "ec2Attributes",
"ec2_config": "ec2Config",
"ec2_inbound_permissions": "ec2InboundPermissions",
"ec2_instance_id": "ec2InstanceId",
"ec2_instance_type": "ec2InstanceType",
"ec2_tag_filters": "ec2TagFilters",
"ec2_tag_sets": "ec2TagSets",
"ecs_cluster_arn": "ecsClusterArn",
"ecs_service": "ecsService",
"ecs_target": "ecsTarget",
"efs_file_system_arn": "efsFileSystemArn",
"egress_only_gateway_id": "egressOnlyGatewayId",
"elastic_gpu_specifications": "elasticGpuSpecifications",
"elastic_inference_accelerator": "elasticInferenceAccelerator",
"elastic_ip": "elasticIp",
"elastic_load_balancer": "elasticLoadBalancer",
"elasticsearch_config": "elasticsearchConfig",
"elasticsearch_configuration": "elasticsearchConfiguration",
"elasticsearch_settings": "elasticsearchSettings",
"elasticsearch_version": "elasticsearchVersion",
"email_configuration": "emailConfiguration",
"email_verification_message": "emailVerificationMessage",
"email_verification_subject": "emailVerificationSubject",
"ena_support": "enaSupport",
"enable_classiclink": "enableClassiclink",
"enable_classiclink_dns_support": "enableClassiclinkDnsSupport",
"enable_cloudwatch_logs_exports": "enableCloudwatchLogsExports",
"enable_cross_zone_load_balancing": "enableCrossZoneLoadBalancing",
"enable_deletion_protection": "enableDeletionProtection",
"enable_dns_hostnames": "enableDnsHostnames",
"enable_dns_support": "enableDnsSupport",
"enable_ecs_managed_tags": "enableEcsManagedTags",
"enable_http2": "enableHttp2",
"enable_http_endpoint": "enableHttpEndpoint",
"enable_key_rotation": "enableKeyRotation",
"enable_log_file_validation": "enableLogFileValidation",
"enable_logging": "enableLogging",
"enable_monitoring": "enableMonitoring",
"enable_network_isolation": "enableNetworkIsolation",
"enable_sni": "enableSni",
"enable_ssl": "enableSsl",
"enable_sso": "enableSso",
"enabled_cloudwatch_logs_exports": "enabledCloudwatchLogsExports",
"enabled_cluster_log_types": "enabledClusterLogTypes",
"enabled_metrics": "enabledMetrics",
"enabled_policy_types": "enabledPolicyTypes",
"encoded_key": "encodedKey",
"encrypt_at_rest": "encryptAtRest",
"encrypted_fingerprint": "encryptedFingerprint",
"encrypted_password": "encryptedPassword",
"encrypted_private_key": "encryptedPrivateKey",
"encrypted_secret": "encryptedSecret",
"encryption_config": "encryptionConfig",
"encryption_configuration": "encryptionConfiguration",
"encryption_info": "encryptionInfo",
"encryption_key": "encryptionKey",
"encryption_options": "encryptionOptions",
"encryption_type": "encryptionType",
"end_date": "endDate",
"end_date_type": "endDateType",
"end_time": "endTime",
"endpoint_arn": "endpointArn",
"endpoint_auto_confirms": "endpointAutoConfirms",
"endpoint_config_name": "endpointConfigName",
"endpoint_configuration": "endpointConfiguration",
"endpoint_configurations": "endpointConfigurations",
"endpoint_details": "endpointDetails",
"endpoint_group_region": "endpointGroupRegion",
"endpoint_id": "endpointId",
"endpoint_type": "endpointType",
"endpoint_url": "endpointUrl",
"enforce_consumer_deletion": "enforceConsumerDeletion",
"engine_mode": "engineMode",
"engine_name": "engineName",
"engine_type": "engineType",
"engine_version": "engineVersion",
"enhanced_monitoring": "enhancedMonitoring",
"enhanced_vpc_routing": "enhancedVpcRouting",
"eni_id": "eniId",
"environment_id": "environmentId",
"ephemeral_block_devices": "ephemeralBlockDevices",
"ephemeral_storage": "ephemeralStorage",
"estimated_instance_warmup": "estimatedInstanceWarmup",
"evaluate_low_sample_count_percentiles": "evaluateLowSampleCountPercentiles",
"evaluation_periods": "evaluationPeriods",
"event_categories": "eventCategories",
"event_delivery_failure_topic_arn": "eventDeliveryFailureTopicArn",
"event_endpoint_created_topic_arn": "eventEndpointCreatedTopicArn",
"event_endpoint_deleted_topic_arn": "eventEndpointDeletedTopicArn",
"event_endpoint_updated_topic_arn": "eventEndpointUpdatedTopicArn",
"event_pattern": "eventPattern",
"event_selectors": "eventSelectors",
"event_source_arn": "eventSourceArn",
"event_source_token": "eventSourceToken",
"event_type_ids": "eventTypeIds",
"excess_capacity_termination_policy": "excessCapacityTerminationPolicy",
"excluded_accounts": "excludedAccounts",
"excluded_members": "excludedMembers",
"execution_arn": "executionArn",
"execution_property": "executionProperty",
"execution_role_arn": "executionRoleArn",
"execution_role_name": "executionRoleName",
"expiration_date": "expirationDate",
"expiration_model": "expirationModel",
"expire_passwords": "expirePasswords",
"explicit_auth_flows": "explicitAuthFlows",
"export_path": "exportPath",
"extended_s3_configuration": "extendedS3Configuration",
"extended_statistic": "extendedStatistic",
"extra_connection_attributes": "extraConnectionAttributes",
"failover_routing_policies": "failoverRoutingPolicies",
"failure_feedback_role_arn": "failureFeedbackRoleArn",
"failure_threshold": "failureThreshold",
"fargate_profile_name": "fargateProfileName",
"feature_name": "featureName",
"feature_set": "featureSet",
"fifo_queue": "fifoQueue",
"file_system_arn": "fileSystemArn",
"file_system_config": "fileSystemConfig",
"file_system_id": "fileSystemId",
"fileshare_id": "fileshareId",
"filter_groups": "filterGroups",
"filter_pattern": "filterPattern",
"filter_policy": "filterPolicy",
"final_snapshot_identifier": "finalSnapshotIdentifier",
"finding_publishing_frequency": "findingPublishingFrequency",
"fixed_rate": "fixedRate",
"fleet_arn": "fleetArn",
"fleet_type": "fleetType",
"force_delete": "forceDelete",
"force_destroy": "forceDestroy",
"force_detach": "forceDetach",
"force_detach_policies": "forceDetachPolicies",
"force_new_deployment": "forceNewDeployment",
"force_update_version": "forceUpdateVersion",
"from_address": "fromAddress",
"from_port": "fromPort",
"function_arn": "functionArn",
"function_id": "functionId",
"function_name": "functionName",
"function_version": "functionVersion",
"gateway_arn": "gatewayArn",
"gateway_id": "gatewayId",
"gateway_ip_address": "gatewayIpAddress",
"gateway_name": "gatewayName",
"gateway_timezone": "gatewayTimezone",
"gateway_type": "gatewayType",
"gateway_vpc_endpoint": "gatewayVpcEndpoint",
"generate_secret": "generateSecret",
"geo_match_constraints": "geoMatchConstraints",
"geolocation_routing_policies": "geolocationRoutingPolicies",
"get_password_data": "getPasswordData",
"global_cluster_identifier": "globalClusterIdentifier",
"global_cluster_resource_id": "globalClusterResourceId",
"global_filters": "globalFilters",
"global_secondary_indexes": "globalSecondaryIndexes",
"glue_version": "glueVersion",
"grant_creation_tokens": "grantCreationTokens",
"grant_id": "grantId",
"grant_token": "grantToken",
"grantee_principal": "granteePrincipal",
"grok_classifier": "grokClassifier",
"group_name": "groupName",
"group_names": "groupNames",
"guess_mime_type_enabled": "guessMimeTypeEnabled",
"hard_expiry": "hardExpiry",
"has_logical_redundancy": "hasLogicalRedundancy",
"has_public_access_policy": "hasPublicAccessPolicy",
"hash_key": "hashKey",
"hash_type": "hashType",
"health_check": "healthCheck",
"health_check_config": "healthCheckConfig",
"health_check_custom_config": "healthCheckCustomConfig",
"health_check_grace_period": "healthCheckGracePeriod",
"health_check_grace_period_seconds": "healthCheckGracePeriodSeconds",
"health_check_id": "healthCheckId",
"health_check_interval_seconds": "healthCheckIntervalSeconds",
"health_check_path": "healthCheckPath",
"health_check_port": "healthCheckPort",
"health_check_protocol": "healthCheckProtocol",
"health_check_type": "healthCheckType",
"healthcheck_method": "healthcheckMethod",
"healthcheck_url": "healthcheckUrl",
"heartbeat_timeout": "heartbeatTimeout",
"hibernation_options": "hibernationOptions",
"hls_ingests": "hlsIngests",
"home_directory": "homeDirectory",
"home_region": "homeRegion",
"host_id": "hostId",
"host_instance_type": "hostInstanceType",
"host_key": "hostKey",
"host_key_fingerprint": "hostKeyFingerprint",
"host_vpc_id": "hostVpcId",
"hosted_zone": "hostedZone",
"hosted_zone_id": "hostedZoneId",
"hostname_theme": "hostnameTheme",
"hsm_eni_id": "hsmEniId",
"hsm_id": "hsmId",
"hsm_state": "hsmState",
"hsm_type": "hsmType",
"http_config": "httpConfig",
"http_failure_feedback_role_arn": "httpFailureFeedbackRoleArn",
"http_method": "httpMethod",
"http_success_feedback_role_arn": "httpSuccessFeedbackRoleArn",
"http_success_feedback_sample_rate": "httpSuccessFeedbackSampleRate",
"http_version": "httpVersion",
"iam_arn": "iamArn",
"iam_database_authentication_enabled": "iamDatabaseAuthenticationEnabled",
"iam_fleet_role": "iamFleetRole",
"iam_instance_profile": "iamInstanceProfile",
"iam_role": "iamRole",
"iam_role_arn": "iamRoleArn",
"iam_role_id": "iamRoleId",
"iam_roles": "iamRoles",
"iam_user_access_to_billing": "iamUserAccessToBilling",
"icmp_code": "icmpCode",
"icmp_type": "icmpType",
"identifier_prefix": "identifierPrefix",
"identity_pool_id": "identityPoolId",
"identity_pool_name": "identityPoolName",
"identity_provider": "identityProvider",
"identity_provider_type": "identityProviderType",
"identity_source": "identitySource",
"identity_sources": "identitySources",
"identity_type": "identityType",
"identity_validation_expression": "identityValidationExpression",
"idle_timeout": "idleTimeout",
"idp_identifiers": "idpIdentifiers",
"ignore_deletion_error": "ignoreDeletionError",
"ignore_public_acls": "ignorePublicAcls",
"image_id": "imageId",
"image_location": "imageLocation",
"image_scanning_configuration": "imageScanningConfiguration",
"image_tag_mutability": "imageTagMutability",
"import_path": "importPath",
"imported_file_chunk_size": "importedFileChunkSize",
"in_progress_validation_batches": "inProgressValidationBatches",
"include_global_service_events": "includeGlobalServiceEvents",
"include_original_headers": "includeOriginalHeaders",
"included_object_versions": "includedObjectVersions",
"inference_accelerators": "inferenceAccelerators",
"infrastructure_class": "infrastructureClass",
"initial_lifecycle_hooks": "initialLifecycleHooks",
"input_bucket": "inputBucket",
"input_parameters": "inputParameters",
"input_path": "inputPath",
"input_transformer": "inputTransformer",
"install_updates_on_boot": "installUpdatesOnBoot",
"instance_class": "instanceClass",
"instance_count": "instanceCount",
"instance_groups": "instanceGroups",
"instance_id": "instanceId",
"instance_initiated_shutdown_behavior": "instanceInitiatedShutdownBehavior",
"instance_interruption_behaviour": "instanceInterruptionBehaviour",
"instance_market_options": "instanceMarketOptions",
"instance_match_criteria": "instanceMatchCriteria",
"instance_name": "instanceName",
"instance_owner_id": "instanceOwnerId",
"instance_platform": "instancePlatform",
"instance_pools_to_use_count": "instancePoolsToUseCount",
"instance_port": "instancePort",
"instance_ports": "instancePorts",
"instance_profile_arn": "instanceProfileArn",
"instance_role_arn": "instanceRoleArn",
"instance_shutdown_timeout": "instanceShutdownTimeout",
"instance_state": "instanceState",
"instance_tenancy": "instanceTenancy",
"instance_type": "instanceType",
"instance_types": "instanceTypes",
"insufficient_data_actions": "insufficientDataActions",
"insufficient_data_health_status": "insufficientDataHealthStatus",
"integration_http_method": "integrationHttpMethod",
"integration_id": "integrationId",
"integration_method": "integrationMethod",
"integration_response_key": "integrationResponseKey",
"integration_response_selection_expression": "integrationResponseSelectionExpression",
"integration_type": "integrationType",
"integration_uri": "integrationUri",
"invalid_user_lists": "invalidUserLists",
"invert_healthcheck": "invertHealthcheck",
"invitation_arn": "invitationArn",
"invitation_message": "invitationMessage",
"invocation_role": "invocationRole",
"invoke_arn": "invokeArn",
"invoke_url": "invokeUrl",
"iot_analytics": "iotAnalytics",
"iot_events": "iotEvents",
"ip_address": "ipAddress",
"ip_address_type": "ipAddressType",
"ip_address_version": "ipAddressVersion",
"ip_addresses": "ipAddresses",
"ip_group_ids": "ipGroupIds",
"ip_set_descriptors": "ipSetDescriptors",
"ip_sets": "ipSets",
"ipc_mode": "ipcMode",
"ipv6_address": "ipv6Address",
"ipv6_address_count": "ipv6AddressCount",
"ipv6_addresses": "ipv6Addresses",
"ipv6_association_id": "ipv6AssociationId",
"ipv6_cidr_block": "ipv6CidrBlock",
"ipv6_cidr_block_association_id": "ipv6CidrBlockAssociationId",
"ipv6_cidr_blocks": "ipv6CidrBlocks",
"ipv6_support": "ipv6Support",
"is_enabled": "isEnabled",
"is_ipv6_enabled": "isIpv6Enabled",
"is_multi_region_trail": "isMultiRegionTrail",
"is_organization_trail": "isOrganizationTrail",
"is_static_ip": "isStaticIp",
"jdbc_targets": "jdbcTargets",
"joined_method": "joinedMethod",
"joined_timestamp": "joinedTimestamp",
"json_classifier": "jsonClassifier",
"jumbo_frame_capable": "jumboFrameCapable",
"jvm_options": "jvmOptions",
"jvm_type": "jvmType",
"jvm_version": "jvmVersion",
"jwt_configuration": "jwtConfiguration",
"kafka_settings": "kafkaSettings",
"kafka_version": "kafkaVersion",
"kafka_versions": "kafkaVersions",
"keep_job_flow_alive_when_no_steps": "keepJobFlowAliveWhenNoSteps",
"kerberos_attributes": "kerberosAttributes",
"kernel_id": "kernelId",
"key_arn": "keyArn",
"key_fingerprint": "keyFingerprint",
"key_id": "keyId",
"key_material_base64": "keyMaterialBase64",
"key_name": "keyName",
"key_name_prefix": "keyNamePrefix",
"key_pair_id": "keyPairId",
"key_pair_name": "keyPairName",
"key_state": "keyState",
"key_type": "keyType",
"key_usage": "keyUsage",
"kibana_endpoint": "kibanaEndpoint",
"kinesis_destination": "kinesisDestination",
"kinesis_settings": "kinesisSettings",
"kinesis_source_configuration": "kinesisSourceConfiguration",
"kinesis_target": "kinesisTarget",
"kms_data_key_reuse_period_seconds": "kmsDataKeyReusePeriodSeconds",
"kms_encrypted": "kmsEncrypted",
"kms_key_arn": "kmsKeyArn",
"kms_key_id": "kmsKeyId",
"kms_master_key_id": "kmsMasterKeyId",
"lag_id": "lagId",
"lambda_": "lambda",
"lambda_actions": "lambdaActions",
"lambda_config": "lambdaConfig",
"lambda_failure_feedback_role_arn": "lambdaFailureFeedbackRoleArn",
"lambda_function_arn": "lambdaFunctionArn",
"lambda_functions": "lambdaFunctions",
"lambda_multi_value_headers_enabled": "lambdaMultiValueHeadersEnabled",
"lambda_success_feedback_role_arn": "lambdaSuccessFeedbackRoleArn",
"lambda_success_feedback_sample_rate": "lambdaSuccessFeedbackSampleRate",
"last_modified": "lastModified",
"last_modified_date": "lastModifiedDate",
"last_modified_time": "lastModifiedTime",
"last_processing_result": "lastProcessingResult",
"last_service_error_id": "lastServiceErrorId",
"last_update_timestamp": "lastUpdateTimestamp",
"last_updated_date": "lastUpdatedDate",
"last_updated_time": "lastUpdatedTime",
"latency_routing_policies": "latencyRoutingPolicies",
"latest_revision": "latestRevision",
"latest_version": "latestVersion",
"launch_configuration": "launchConfiguration",
"launch_configurations": "launchConfigurations",
"launch_group": "launchGroup",
"launch_specifications": "launchSpecifications",
"launch_template": "launchTemplate",
"launch_template_config": "launchTemplateConfig",
"launch_template_configs": "launchTemplateConfigs",
"launch_type": "launchType",
"layer_arn": "layerArn",
"layer_ids": "layerIds",
"layer_name": "layerName",
"lb_port": "lbPort",
"license_configuration_arn": "licenseConfigurationArn",
"license_count": "licenseCount",
"license_count_hard_limit": "licenseCountHardLimit",
"license_counting_type": "licenseCountingType",
"license_info": "licenseInfo",
"license_model": "licenseModel",
"license_rules": "licenseRules",
"license_specifications": "licenseSpecifications",
"lifecycle_config_name": "lifecycleConfigName",
"lifecycle_policy": "lifecyclePolicy",
"lifecycle_rules": "lifecycleRules",
"lifecycle_transition": "lifecycleTransition",
"limit_amount": "limitAmount",
"limit_unit": "limitUnit",
"listener_arn": "listenerArn",
"load_balancer": "loadBalancer",
"load_balancer_arn": "loadBalancerArn",
"load_balancer_info": "loadBalancerInfo",
"load_balancer_name": "loadBalancerName",
"load_balancer_port": "loadBalancerPort",
"load_balancer_type": "loadBalancerType",
"load_balancers": "loadBalancers",
"load_balancing_algorithm_type": "loadBalancingAlgorithmType",
"local_gateway_id": "localGatewayId",
"local_gateway_route_table_id": "localGatewayRouteTableId",
"local_gateway_virtual_interface_group_id": "localGatewayVirtualInterfaceGroupId",
"local_secondary_indexes": "localSecondaryIndexes",
"location_arn": "locationArn",
"location_uri": "locationUri",
"lock_token": "lockToken",
"log_config": "logConfig",
"log_destination": "logDestination",
"log_destination_type": "logDestinationType",
"log_format": "logFormat",
"log_group": "logGroup",
"log_group_name": "logGroupName",
"log_paths": "logPaths",
"log_publishing_options": "logPublishingOptions",
"log_uri": "logUri",
"logging_config": "loggingConfig",
"logging_configuration": "loggingConfiguration",
"logging_info": "loggingInfo",
"logging_role": "loggingRole",
"logout_urls": "logoutUrls",
"logs_config": "logsConfig",
"lun_number": "lunNumber",
"mac_address": "macAddress",
"mail_from_domain": "mailFromDomain",
"main_route_table_id": "mainRouteTableId",
"maintenance_window": "maintenanceWindow",
"maintenance_window_start_time": "maintenanceWindowStartTime",
"major_engine_version": "majorEngineVersion",
"manage_berkshelf": "manageBerkshelf",
"manage_bundler": "manageBundler",
"manage_ebs_snapshots": "manageEbsSnapshots",
"manages_vpc_endpoints": "managesVpcEndpoints",
"map_public_ip_on_launch": "mapPublicIpOnLaunch",
"master_account_arn": "masterAccountArn",
"master_account_email": "masterAccountEmail",
"master_account_id": "masterAccountId",
"master_id": "masterId",
"master_instance_group": "masterInstanceGroup",
"master_instance_type": "masterInstanceType",
"master_password": "masterPassword",
"master_public_dns": "masterPublicDns",
"master_username": "masterUsername",
"match_criterias": "matchCriterias",
"matching_types": "matchingTypes",
"max_aggregation_interval": "maxAggregationInterval",
"max_allocated_storage": "maxAllocatedStorage",
"max_capacity": "maxCapacity",
"max_concurrency": "maxConcurrency",
"max_errors": "maxErrors",
"max_instance_lifetime": "maxInstanceLifetime",
"max_message_size": "maxMessageSize",
"max_password_age": "maxPasswordAge",
"max_retries": "maxRetries",
"max_session_duration": "maxSessionDuration",
"max_size": "maxSize",
"maximum_batching_window_in_seconds": "maximumBatchingWindowInSeconds",
"maximum_event_age_in_seconds": "maximumEventAgeInSeconds",
"maximum_execution_frequency": "maximumExecutionFrequency",
"maximum_record_age_in_seconds": "maximumRecordAgeInSeconds",
"maximum_retry_attempts": "maximumRetryAttempts",
"measure_latency": "measureLatency",
"media_type": "mediaType",
"medium_changer_type": "mediumChangerType",
"member_account_id": "memberAccountId",
"member_clusters": "memberClusters",
"member_status": "memberStatus",
"memory_size": "memorySize",
"mesh_name": "meshName",
"message_retention_seconds": "messageRetentionSeconds",
"messages_per_second": "messagesPerSecond",
"metadata_options": "metadataOptions",
"method_path": "methodPath",
"metric_aggregation_type": "metricAggregationType",
"metric_groups": "metricGroups",
"metric_name": "metricName",
"metric_queries": "metricQueries",
"metric_transformation": "metricTransformation",
"metrics_granularity": "metricsGranularity",
"mfa_configuration": "mfaConfiguration",
"migration_type": "migrationType",
"min_adjustment_magnitude": "minAdjustmentMagnitude",
"min_capacity": "minCapacity",
"min_elb_capacity": "minElbCapacity",
"min_size": "minSize",
"minimum_compression_size": "minimumCompressionSize",
"minimum_healthy_hosts": "minimumHealthyHosts",
"minimum_password_length": "minimumPasswordLength",
"mixed_instances_policy": "mixedInstancesPolicy",
"model_selection_expression": "modelSelectionExpression",
"mongodb_settings": "mongodbSettings",
"monitoring_interval": "monitoringInterval",
"monitoring_role_arn": "monitoringRoleArn",
"monthly_spend_limit": "monthlySpendLimit",
"mount_options": "mountOptions",
"mount_target_dns_name": "mountTargetDnsName",
"multi_attach_enabled": "multiAttachEnabled",
"multi_az": "multiAz",
"multivalue_answer_routing_policy": "multivalueAnswerRoutingPolicy",
"name_prefix": "namePrefix",
"name_servers": "nameServers",
"namespace_id": "namespaceId",
"nat_gateway_id": "natGatewayId",
"neptune_cluster_parameter_group_name": "neptuneClusterParameterGroupName",
"neptune_parameter_group_name": "neptuneParameterGroupName",
"neptune_subnet_group_name": "neptuneSubnetGroupName",
"netbios_name_servers": "netbiosNameServers",
"netbios_node_type": "netbiosNodeType",
"network_acl_id": "networkAclId",
"network_configuration": "networkConfiguration",
"network_interface": "networkInterface",
"network_interface_id": "networkInterfaceId",
"network_interface_ids": "networkInterfaceIds",
"network_interface_port": "networkInterfacePort",
"network_interfaces": "networkInterfaces",
"network_load_balancer_arn": "networkLoadBalancerArn",
"network_load_balancer_arns": "networkLoadBalancerArns",
"network_mode": "networkMode",
"network_origin": "networkOrigin",
"network_services": "networkServices",
"new_game_session_protection_policy": "newGameSessionProtectionPolicy",
"nfs_file_share_defaults": "nfsFileShareDefaults",
"node_group_name": "nodeGroupName",
"node_role_arn": "nodeRoleArn",
"node_to_node_encryption": "nodeToNodeEncryption",
"node_type": "nodeType",
"nodejs_version": "nodejsVersion",
"non_master_accounts": "nonMasterAccounts",
"not_after": "notAfter",
"not_before": "notBefore",
"notification_arns": "notificationArns",
"notification_metadata": "notificationMetadata",
"notification_property": "notificationProperty",
"notification_target_arn": "notificationTargetArn",
"notification_topic_arn": "notificationTopicArn",
"notification_type": "notificationType",
"ntp_servers": "ntpServers",
"num_cache_nodes": "numCacheNodes",
"number_cache_clusters": "numberCacheClusters",
"number_of_broker_nodes": "numberOfBrokerNodes",
"number_of_nodes": "numberOfNodes",
"number_of_workers": "numberOfWorkers",
"object_acl": "objectAcl",
"object_lock_configuration": "objectLockConfiguration",
"object_lock_legal_hold_status": "objectLockLegalHoldStatus",
"object_lock_mode": "objectLockMode",
"object_lock_retain_until_date": "objectLockRetainUntilDate",
"ok_actions": "okActions",
"on_create": "onCreate",
"on_demand_options": "onDemandOptions",
"on_failure": "onFailure",
"on_prem_config": "onPremConfig",
"on_premises_instance_tag_filters": "onPremisesInstanceTagFilters",
"on_start": "onStart",
"open_monitoring": "openMonitoring",
"openid_connect_config": "openidConnectConfig",
"openid_connect_provider_arns": "openidConnectProviderArns",
"operating_system": "operatingSystem",
"operation_name": "operationName",
"opt_in_status": "optInStatus",
"optimize_for_end_user_location": "optimizeForEndUserLocation",
"option_group_description": "optionGroupDescription",
"option_group_name": "optionGroupName",
"optional_fields": "optionalFields",
"ordered_cache_behaviors": "orderedCacheBehaviors",
"ordered_placement_strategies": "orderedPlacementStrategies",
"organization_aggregation_source": "organizationAggregationSource",
"origin_groups": "originGroups",
"original_route_table_id": "originalRouteTableId",
"outpost_arn": "outpostArn",
"output_bucket": "outputBucket",
"output_location": "outputLocation",
"owner_account": "ownerAccount",
"owner_account_id": "ownerAccountId",
"owner_alias": "ownerAlias",
"owner_arn": "ownerArn",
"owner_id": "ownerId",
"owner_information": "ownerInformation",
"packet_length": "packetLength",
"parallelization_factor": "parallelizationFactor",
"parameter_group_name": "parameterGroupName",
"parameter_overrides": "parameterOverrides",
"parent_id": "parentId",
"partition_keys": "partitionKeys",
"passenger_version": "passengerVersion",
"passthrough_behavior": "passthroughBehavior",
"password_data": "passwordData",
"password_length": "passwordLength",
"password_policy": "passwordPolicy",
"password_reset_required": "passwordResetRequired",
"password_reuse_prevention": "passwordReusePrevention",
"patch_group": "patchGroup",
"path_part": "pathPart",
"payload_format_version": "payloadFormatVersion",
"payload_url": "payloadUrl",
"peer_account_id": "peerAccountId",
"peer_owner_id": "peerOwnerId",
"peer_region": "peerRegion",
"peer_transit_gateway_id": "peerTransitGatewayId",
"peer_vpc_id": "peerVpcId",
"pem_encoded_certificate": "pemEncodedCertificate",
"performance_insights_enabled": "performanceInsightsEnabled",
"performance_insights_kms_key_id": "performanceInsightsKmsKeyId",
"performance_insights_retention_period": "performanceInsightsRetentionPeriod",
"performance_mode": "performanceMode",
"permanent_deletion_time_in_days": "permanentDeletionTimeInDays",
"permissions_boundary": "permissionsBoundary",
"pgp_key": "pgpKey",
"physical_connection_requirements": "physicalConnectionRequirements",
"pid_mode": "pidMode",
"pipeline_config": "pipelineConfig",
"placement_constraints": "placementConstraints",
"placement_group": "placementGroup",
"placement_group_id": "placementGroupId",
"placement_tenancy": "placementTenancy",
"plan_id": "planId",
"platform_arn": "platformArn",
"platform_credential": "platformCredential",
"platform_principal": "platformPrincipal",
"platform_types": "platformTypes",
"platform_version": "platformVersion",
"player_latency_policies": "playerLatencyPolicies",
"pod_execution_role_arn": "podExecutionRoleArn",
"point_in_time_recovery": "pointInTimeRecovery",
"policy_arn": "policyArn",
"policy_attributes": "policyAttributes",
"policy_body": "policyBody",
"policy_details": "policyDetails",
"policy_document": "policyDocument",
"policy_id": "policyId",
"policy_name": "policyName",
"policy_names": "policyNames",
"policy_type": "policyType",
"policy_type_name": "policyTypeName",
"policy_url": "policyUrl",
"poll_interval": "pollInterval",
"port_ranges": "portRanges",
"posix_user": "posixUser",
"preferred_availability_zones": "preferredAvailabilityZones",
"preferred_backup_window": "preferredBackupWindow",
"preferred_maintenance_window": "preferredMaintenanceWindow",
"prefix_list_id": "prefixListId",
"prefix_list_ids": "prefixListIds",
"prevent_user_existence_errors": "preventUserExistenceErrors",
"price_class": "priceClass",
"pricing_plan": "pricingPlan",
"primary_container": "primaryContainer",
"primary_endpoint_address": "primaryEndpointAddress",
"primary_network_interface_id": "primaryNetworkInterfaceId",
"principal_arn": "principalArn",
"private_dns": "privateDns",
"private_dns_enabled": "privateDnsEnabled",
"private_dns_name": "privateDnsName",
"private_ip": "privateIp",
"private_ip_address": "privateIpAddress",
"private_ips": "privateIps",
"private_ips_count": "privateIpsCount",
"private_key": "privateKey",
"product_arn": "productArn",
"product_code": "productCode",
"production_variants": "productionVariants",
"project_name": "projectName",
"promotion_tier": "promotionTier",
"promotional_messages_per_second": "promotionalMessagesPerSecond",
"propagate_tags": "propagateTags",
"propagating_vgws": "propagatingVgws",
"propagation_default_route_table_id": "propagationDefaultRouteTableId",
"proposal_id": "proposalId",
"protect_from_scale_in": "protectFromScaleIn",
"protocol_type": "protocolType",
"provider_arns": "providerArns",
"provider_details": "providerDetails",
"provider_name": "providerName",
"provider_type": "providerType",
"provisioned_concurrent_executions": "provisionedConcurrentExecutions",
"provisioned_throughput_in_mibps": "provisionedThroughputInMibps",
"proxy_configuration": "proxyConfiguration",
"proxy_protocol_v2": "proxyProtocolV2",
"public_access_block_configuration": "publicAccessBlockConfiguration",
"public_dns": "publicDns",
"public_ip": "publicIp",
"public_ip_address": "publicIpAddress",
"public_ipv4_pool": "publicIpv4Pool",
"public_key": "publicKey",
"publicly_accessible": "publiclyAccessible",
"qualified_arn": "qualifiedArn",
"queue_url": "queueUrl",
"queued_timeout": "queuedTimeout",
"quiet_time": "quietTime",
"quota_code": "quotaCode",
"quota_name": "quotaName",
"quota_settings": "quotaSettings",
"rails_env": "railsEnv",
"ram_disk_id": "ramDiskId",
"ram_size": "ramSize",
"ramdisk_id": "ramdiskId",
"range_key": "rangeKey",
"rate_key": "rateKey",
"rate_limit": "rateLimit",
"raw_message_delivery": "rawMessageDelivery",
"rds_db_instance_arn": "rdsDbInstanceArn",
"read_attributes": "readAttributes",
"read_capacity": "readCapacity",
"read_only": "readOnly",
"reader_endpoint": "readerEndpoint",
"receive_wait_time_seconds": "receiveWaitTimeSeconds",
"receiver_account_id": "receiverAccountId",
"recording_group": "recordingGroup",
"recovery_points": "recoveryPoints",
"recovery_window_in_days": "recoveryWindowInDays",
"redrive_policy": "redrivePolicy",
"redshift_configuration": "redshiftConfiguration",
"reference_data_sources": "referenceDataSources",
"reference_name": "referenceName",
"refresh_token_validity": "refreshTokenValidity",
"regex_match_tuples": "regexMatchTuples",
"regex_pattern_strings": "regexPatternStrings",
"regional_certificate_arn": "regionalCertificateArn",
"regional_certificate_name": "regionalCertificateName",
"regional_domain_name": "regionalDomainName",
"regional_zone_id": "regionalZoneId",
"registered_by": "registeredBy",
"registration_code": "registrationCode",
"registration_count": "registrationCount",
"registration_limit": "registrationLimit",
"registry_id": "registryId",
"regular_expressions": "regularExpressions",
"rejected_patches": "rejectedPatches",
"relationship_status": "relationshipStatus",
"release_label": "releaseLabel",
"release_version": "releaseVersion",
"remote_access": "remoteAccess",
"remote_domain_name": "remoteDomainName",
"replace_unhealthy_instances": "replaceUnhealthyInstances",
"replicate_source_db": "replicateSourceDb",
"replication_configuration": "replicationConfiguration",
"replication_factor": "replicationFactor",
"replication_group_description": "replicationGroupDescription",
"replication_group_id": "replicationGroupId",
"replication_instance_arn": "replicationInstanceArn",
"replication_instance_class": "replicationInstanceClass",
"replication_instance_id": "replicationInstanceId",
"replication_instance_private_ips": "replicationInstancePrivateIps",
"replication_instance_public_ips": "replicationInstancePublicIps",
"replication_source_identifier": "replicationSourceIdentifier",
"replication_subnet_group_arn": "replicationSubnetGroupArn",
"replication_subnet_group_description": "replicationSubnetGroupDescription",
"replication_subnet_group_id": "replicationSubnetGroupId",
"replication_task_arn": "replicationTaskArn",
"replication_task_id": "replicationTaskId",
"replication_task_settings": "replicationTaskSettings",
"report_name": "reportName",
"reported_agent_version": "reportedAgentVersion",
"reported_os_family": "reportedOsFamily",
"reported_os_name": "reportedOsName",
"reported_os_version": "reportedOsVersion",
"repository_id": "repositoryId",
"repository_name": "repositoryName",
"repository_url": "repositoryUrl",
"request_id": "requestId",
"request_interval": "requestInterval",
"request_mapping_template": "requestMappingTemplate",
"request_models": "requestModels",
"request_parameters": "requestParameters",
"request_payer": "requestPayer",
"request_status": "requestStatus",
"request_template": "requestTemplate",
"request_templates": "requestTemplates",
"request_validator_id": "requestValidatorId",
"requester_managed": "requesterManaged",
"requester_pays": "requesterPays",
"require_lowercase_characters": "requireLowercaseCharacters",
"require_numbers": "requireNumbers",
"require_symbols": "requireSymbols",
"require_uppercase_characters": "requireUppercaseCharacters",
"requires_compatibilities": "requiresCompatibilities",
"reservation_plan_settings": "reservationPlanSettings",
"reserved_concurrent_executions": "reservedConcurrentExecutions",
"reservoir_size": "reservoirSize",
"resolver_endpoint_id": "resolverEndpointId",
"resolver_rule_id": "resolverRuleId",
"resource_arn": "resourceArn",
"resource_creation_limit_policy": "resourceCreationLimitPolicy",
"resource_group_arn": "resourceGroupArn",
"resource_id": "resourceId",
"resource_id_scope": "resourceIdScope",
"resource_path": "resourcePath",
"resource_query": "resourceQuery",
"resource_share_arn": "resourceShareArn",
"resource_type": "resourceType",
"resource_types_scopes": "resourceTypesScopes",
"response_mapping_template": "responseMappingTemplate",
"response_models": "responseModels",
"response_parameters": "responseParameters",
"response_template": "responseTemplate",
"response_templates": "responseTemplates",
"response_type": "responseType",
"rest_api": "restApi",
"rest_api_id": "restApiId",
"restrict_public_buckets": "restrictPublicBuckets",
"retain_on_delete": "retainOnDelete",
"retain_stack": "retainStack",
"retention_in_days": "retentionInDays",
"retention_period": "retentionPeriod",
"retire_on_delete": "retireOnDelete",
"retiring_principal": "retiringPrincipal",
"retry_strategy": "retryStrategy",
"revocation_configuration": "revocationConfiguration",
"revoke_rules_on_delete": "revokeRulesOnDelete",
"role_arn": "roleArn",
"role_mappings": "roleMappings",
"role_name": "roleName",
"root_block_device": "rootBlockDevice",
"root_block_devices": "rootBlockDevices",
"root_device_name": "rootDeviceName",
"root_device_type": "rootDeviceType",
"root_device_volume_id": "rootDeviceVolumeId",
"root_directory": "rootDirectory",
"root_password": "rootPassword",
"root_password_on_all_instances": "rootPasswordOnAllInstances",
"root_resource_id": "rootResourceId",
"root_snapshot_id": "rootSnapshotId",
"root_volume_encryption_enabled": "rootVolumeEncryptionEnabled",
"rotation_enabled": "rotationEnabled",
"rotation_lambda_arn": "rotationLambdaArn",
"rotation_rules": "rotationRules",
"route_filter_prefixes": "routeFilterPrefixes",
"route_id": "routeId",
"route_key": "routeKey",
"route_response_key": "routeResponseKey",
"route_response_selection_expression": "routeResponseSelectionExpression",
"route_selection_expression": "routeSelectionExpression",
"route_settings": "routeSettings",
"route_table_id": "routeTableId",
"route_table_ids": "routeTableIds",
"routing_config": "routingConfig",
"routing_strategy": "routingStrategy",
"ruby_version": "rubyVersion",
"rubygems_version": "rubygemsVersion",
"rule_action": "ruleAction",
"rule_id": "ruleId",
"rule_identifier": "ruleIdentifier",
"rule_name": "ruleName",
"rule_number": "ruleNumber",
"rule_set_name": "ruleSetName",
"rule_type": "ruleType",
"rules_package_arns": "rulesPackageArns",
"run_command_targets": "runCommandTargets",
"running_instance_count": "runningInstanceCount",
"runtime_configuration": "runtimeConfiguration",
"s3_actions": "s3Actions",
"s3_bucket": "s3Bucket",
"s3_bucket_arn": "s3BucketArn",
"s3_bucket_name": "s3BucketName",
"s3_canonical_user_id": "s3CanonicalUserId",
"s3_config": "s3Config",
"s3_configuration": "s3Configuration",
"s3_destination": "s3Destination",
"s3_import": "s3Import",
"s3_key": "s3Key",
"s3_key_prefix": "s3KeyPrefix",
"s3_object_version": "s3ObjectVersion",
"s3_prefix": "s3Prefix",
"s3_region": "s3Region",
"s3_settings": "s3Settings",
"s3_targets": "s3Targets",
"saml_metadata_document": "samlMetadataDocument",
"saml_provider_arns": "samlProviderArns",
"scalable_dimension": "scalableDimension",
"scalable_target_action": "scalableTargetAction",
"scale_down_behavior": "scaleDownBehavior",
"scaling_adjustment": "scalingAdjustment",
"scaling_config": "scalingConfig",
"scaling_configuration": "scalingConfiguration",
"scan_enabled": "scanEnabled",
"schedule_expression": "scheduleExpression",
"schedule_identifier": "scheduleIdentifier",
"schedule_timezone": "scheduleTimezone",
"scheduled_action_name": "scheduledActionName",
"scheduling_strategy": "schedulingStrategy",
"schema_change_policy": "schemaChangePolicy",
"schema_version": "schemaVersion",
"scope_identifiers": "scopeIdentifiers",
"search_string": "searchString",
"secondary_artifacts": "secondaryArtifacts",
"secondary_sources": "secondarySources",
"secret_binary": "secretBinary",
"secret_id": "secretId",
"secret_key": "secretKey",
"secret_string": "secretString",
"security_configuration": "securityConfiguration",
"security_group_id": "securityGroupId",
"security_group_ids": "securityGroupIds",
"security_group_names": "securityGroupNames",
"security_groups": "securityGroups",
"security_policy": "securityPolicy",
"selection_pattern": "selectionPattern",
"selection_tags": "selectionTags",
"self_managed_active_directory": "selfManagedActiveDirectory",
"self_service_permissions": "selfServicePermissions",
"sender_account_id": "senderAccountId",
"sender_id": "senderId",
"server_certificate_arn": "serverCertificateArn",
"server_hostname": "serverHostname",
"server_id": "serverId",
"server_name": "serverName",
"server_properties": "serverProperties",
"server_side_encryption": "serverSideEncryption",
"server_side_encryption_configuration": "serverSideEncryptionConfiguration",
"server_type": "serverType",
"service_access_role": "serviceAccessRole",
"service_code": "serviceCode",
"service_linked_role_arn": "serviceLinkedRoleArn",
"service_name": "serviceName",
"service_namespace": "serviceNamespace",
"service_registries": "serviceRegistries",
"service_role": "serviceRole",
"service_role_arn": "serviceRoleArn",
"service_type": "serviceType",
"ses_smtp_password": "sesSmtpPassword",
"ses_smtp_password_v4": "sesSmtpPasswordV4",
"session_name": "sessionName",
"session_number": "sessionNumber",
"set_identifier": "setIdentifier",
"shard_count": "shardCount",
"shard_level_metrics": "shardLevelMetrics",
"share_arn": "shareArn",
"share_id": "shareId",
"share_name": "shareName",
"share_status": "shareStatus",
"short_code": "shortCode",
"short_name": "shortName",
"size_constraints": "sizeConstraints",
"skip_destroy": "skipDestroy",
"skip_final_backup": "skipFinalBackup",
"skip_final_snapshot": "skipFinalSnapshot",
"slow_start": "slowStart",
"smb_active_directory_settings": "smbActiveDirectorySettings",
"smb_guest_password": "smbGuestPassword",
"sms_authentication_message": "smsAuthenticationMessage",
"sms_configuration": "smsConfiguration",
"sms_verification_message": "smsVerificationMessage",
"snapshot_arns": "snapshotArns",
"snapshot_cluster_identifier": "snapshotClusterIdentifier",
"snapshot_copy": "snapshotCopy",
"snapshot_copy_grant_name": "snapshotCopyGrantName",
"snapshot_delivery_properties": "snapshotDeliveryProperties",
"snapshot_id": "snapshotId",
"snapshot_identifier": "snapshotIdentifier",
"snapshot_name": "snapshotName",
"snapshot_options": "snapshotOptions",
"snapshot_retention_limit": "snapshotRetentionLimit",
"snapshot_type": "snapshotType",
"snapshot_window": "snapshotWindow",
"snapshot_without_reboot": "snapshotWithoutReboot",
"sns_actions": "snsActions",
"sns_destination": "snsDestination",
"sns_topic": "snsTopic",
"sns_topic_arn": "snsTopicArn",
"sns_topic_name": "snsTopicName",
"software_token_mfa_configuration": "softwareTokenMfaConfiguration",
"solution_stack_name": "solutionStackName",
"source_account": "sourceAccount",
"source_ami_id": "sourceAmiId",
"source_ami_region": "sourceAmiRegion",
"source_arn": "sourceArn",
"source_backup_identifier": "sourceBackupIdentifier",
"source_cidr_block": "sourceCidrBlock",
"source_code_hash": "sourceCodeHash",
"source_code_size": "sourceCodeSize",
"source_db_cluster_snapshot_arn": "sourceDbClusterSnapshotArn",
"source_db_snapshot_identifier": "sourceDbSnapshotIdentifier",
"source_dest_check": "sourceDestCheck",
"source_endpoint_arn": "sourceEndpointArn",
"source_ids": "sourceIds",
"source_instance_id": "sourceInstanceId",
"source_location_arn": "sourceLocationArn",
"source_port_range": "sourcePortRange",
"source_region": "sourceRegion",
"source_security_group": "sourceSecurityGroup",
"source_security_group_id": "sourceSecurityGroupId",
"source_snapshot_id": "sourceSnapshotId",
"source_type": "sourceType",
"source_version": "sourceVersion",
"source_volume_arn": "sourceVolumeArn",
"split_tunnel": "splitTunnel",
"splunk_configuration": "splunkConfiguration",
"spot_bid_status": "spotBidStatus",
"spot_instance_id": "spotInstanceId",
"spot_options": "spotOptions",
"spot_price": "spotPrice",
"spot_request_state": "spotRequestState",
"spot_type": "spotType",
"sql_injection_match_tuples": "sqlInjectionMatchTuples",
"sql_version": "sqlVersion",
"sqs_failure_feedback_role_arn": "sqsFailureFeedbackRoleArn",
"sqs_success_feedback_role_arn": "sqsSuccessFeedbackRoleArn",
"sqs_success_feedback_sample_rate": "sqsSuccessFeedbackSampleRate",
"sqs_target": "sqsTarget",
"sriov_net_support": "sriovNetSupport",
"ssh_host_dsa_key_fingerprint": "sshHostDsaKeyFingerprint",
"ssh_host_rsa_key_fingerprint": "sshHostRsaKeyFingerprint",
"ssh_key_name": "sshKeyName",
"ssh_public_key": "sshPublicKey",
"ssh_public_key_id": "sshPublicKeyId",
"ssh_username": "sshUsername",
"ssl_configurations": "sslConfigurations",
"ssl_mode": "sslMode",
"ssl_policy": "sslPolicy",
"stack_endpoint": "stackEndpoint",
"stack_id": "stackId",
"stack_set_id": "stackSetId",
"stack_set_name": "stackSetName",
"stage_description": "stageDescription",
"stage_name": "stageName",
"stage_variables": "stageVariables",
"standards_arn": "standardsArn",
"start_date": "startDate",
"start_time": "startTime",
"starting_position": "startingPosition",
"starting_position_timestamp": "startingPositionTimestamp",
"state_transition_reason": "stateTransitionReason",
"statement_id": "statementId",
"statement_id_prefix": "statementIdPrefix",
"static_ip_name": "staticIpName",
"static_members": "staticMembers",
"static_routes_only": "staticRoutesOnly",
"stats_enabled": "statsEnabled",
"stats_password": "statsPassword",
"stats_url": "statsUrl",
"stats_user": "statsUser",
"status_code": "statusCode",
"status_reason": "statusReason",
"step_adjustments": "stepAdjustments",
"step_concurrency_level": "stepConcurrencyLevel",
"step_functions": "stepFunctions",
"step_scaling_policy_configuration": "stepScalingPolicyConfiguration",
"stop_actions": "stopActions",
"storage_capacity": "storageCapacity",
"storage_class": "storageClass",
"storage_class_analysis": "storageClassAnalysis",
"storage_descriptor": "storageDescriptor",
"storage_encrypted": "storageEncrypted",
"storage_location": "storageLocation",
"storage_type": "storageType",
"stream_arn": "streamArn",
"stream_enabled": "streamEnabled",
"stream_label": "streamLabel",
"stream_view_type": "streamViewType",
"subject_alternative_names": "subjectAlternativeNames",
"subnet_group_name": "subnetGroupName",
"subnet_id": "subnetId",
"subnet_ids": "subnetIds",
"subnet_mappings": "subnetMappings",
"success_feedback_role_arn": "successFeedbackRoleArn",
"success_feedback_sample_rate": "successFeedbackSampleRate",
"support_code": "supportCode",
"supported_identity_providers": "supportedIdentityProviders",
"supported_login_providers": "supportedLoginProviders",
"suspended_processes": "suspendedProcesses",
"system_packages": "systemPackages",
"table_mappings": "tableMappings",
"table_name": "tableName",
"table_prefix": "tablePrefix",
"table_type": "tableType",
"tag_key_scope": "tagKeyScope",
"tag_specifications": "tagSpecifications",
"tag_value_scope": "tagValueScope",
"tags_collection": "tagsCollection",
"tape_drive_type": "tapeDriveType",
"target_action": "targetAction",
"target_arn": "targetArn",
"target_capacity": "targetCapacity",
"target_capacity_specification": "targetCapacitySpecification",
"target_endpoint_arn": "targetEndpointArn",
"target_group_arn": "targetGroupArn",
"target_group_arns": "targetGroupArns",
"target_id": "targetId",
"target_ips": "targetIps",
"target_key_arn": "targetKeyArn",
"target_key_id": "targetKeyId",
"target_name": "targetName",
"target_pipeline": "targetPipeline",
"target_tracking_configuration": "targetTrackingConfiguration",
"target_tracking_scaling_policy_configuration": "targetTrackingScalingPolicyConfiguration",
"target_type": "targetType",
"task_arn": "taskArn",
"task_definition": "taskDefinition",
"task_invocation_parameters": "taskInvocationParameters",
"task_parameters": "taskParameters",
"task_role_arn": "taskRoleArn",
"task_type": "taskType",
"team_id": "teamId",
"template_body": "templateBody",
"template_name": "templateName",
"template_selection_expression": "templateSelectionExpression",
"template_url": "templateUrl",
"terminate_instances": "terminateInstances",
"terminate_instances_with_expiration": "terminateInstancesWithExpiration",
"termination_policies": "terminationPolicies",
"termination_protection": "terminationProtection",
"thing_type_name": "thingTypeName",
"threshold_count": "thresholdCount",
"threshold_metric_id": "thresholdMetricId",
"throttle_settings": "throttleSettings",
"throughput_capacity": "throughputCapacity",
"throughput_mode": "throughputMode",
"thumbnail_config": "thumbnailConfig",
"thumbnail_config_permissions": "thumbnailConfigPermissions",
"thumbprint_lists": "thumbprintLists",
"time_period_end": "timePeriodEnd",
"time_period_start": "timePeriodStart",
"time_unit": "timeUnit",
"timeout_in_minutes": "timeoutInMinutes",
"timeout_in_seconds": "timeoutInSeconds",
"timeout_milliseconds": "timeoutMilliseconds",
"tls_policy": "tlsPolicy",
"to_port": "toPort",
"token_key": "tokenKey",
"token_key_id": "tokenKeyId",
"topic_arn": "topicArn",
"tracing_config": "tracingConfig",
"traffic_dial_percentage": "trafficDialPercentage",
"traffic_direction": "trafficDirection",
"traffic_mirror_filter_id": "trafficMirrorFilterId",
"traffic_mirror_target_id": "trafficMirrorTargetId",
"traffic_routing_config": "trafficRoutingConfig",
"traffic_type": "trafficType",
"transactional_messages_per_second": "transactionalMessagesPerSecond",
"transit_encryption_enabled": "transitEncryptionEnabled",
"transit_gateway_attachment_id": "transitGatewayAttachmentId",
"transit_gateway_default_route_table_association": "transitGatewayDefaultRouteTableAssociation",
"transit_gateway_default_route_table_propagation": "transitGatewayDefaultRouteTablePropagation",
"transit_gateway_id": "transitGatewayId",
"transit_gateway_route_table_id": "transitGatewayRouteTableId",
"transport_protocol": "transportProtocol",
"treat_missing_data": "treatMissingData",
"trigger_configurations": "triggerConfigurations",
"trigger_types": "triggerTypes",
"tunnel1_address": "tunnel1Address",
"tunnel1_bgp_asn": "tunnel1BgpAsn",
"tunnel1_bgp_holdtime": "tunnel1BgpHoldtime",
"tunnel1_cgw_inside_address": "tunnel1CgwInsideAddress",
"tunnel1_inside_cidr": "tunnel1InsideCidr",
"tunnel1_preshared_key": "tunnel1PresharedKey",
"tunnel1_vgw_inside_address": "tunnel1VgwInsideAddress",
"tunnel2_address": "tunnel2Address",
"tunnel2_bgp_asn": "tunnel2BgpAsn",
"tunnel2_bgp_holdtime": "tunnel2BgpHoldtime",
"tunnel2_cgw_inside_address": "tunnel2CgwInsideAddress",
"tunnel2_inside_cidr": "tunnel2InsideCidr",
"tunnel2_preshared_key": "tunnel2PresharedKey",
"tunnel2_vgw_inside_address": "tunnel2VgwInsideAddress",
"unique_id": "uniqueId",
"url_path": "urlPath",
"usage_plan_id": "usagePlanId",
"usage_report_s3_bucket": "usageReportS3Bucket",
"use_custom_cookbooks": "useCustomCookbooks",
"use_ebs_optimized_instances": "useEbsOptimizedInstances",
"use_opsworks_security_groups": "useOpsworksSecurityGroups",
"user_arn": "userArn",
"user_data": "userData",
"user_data_base64": "userDataBase64",
"user_name": "userName",
"user_pool_add_ons": "userPoolAddOns",
"user_pool_config": "userPoolConfig",
"user_pool_id": "userPoolId",
"user_role": "userRole",
"user_volume_encryption_enabled": "userVolumeEncryptionEnabled",
"username_attributes": "usernameAttributes",
"username_configuration": "usernameConfiguration",
"valid_from": "validFrom",
"valid_to": "validTo",
"valid_until": "validUntil",
"valid_user_lists": "validUserLists",
"validate_request_body": "validateRequestBody",
"validate_request_parameters": "validateRequestParameters",
"validation_emails": "validationEmails",
"validation_method": "validationMethod",
"validation_record_fqdns": "validationRecordFqdns",
"vault_name": "vaultName",
"verification_message_template": "verificationMessageTemplate",
"verification_token": "verificationToken",
"version_id": "versionId",
"version_stages": "versionStages",
"vgw_telemetries": "vgwTelemetries",
"video_codec_options": "videoCodecOptions",
"video_watermarks": "videoWatermarks",
"view_expanded_text": "viewExpandedText",
"view_original_text": "viewOriginalText",
"viewer_certificate": "viewerCertificate",
"virtual_interface_id": "virtualInterfaceId",
"virtual_network_id": "virtualNetworkId",
"virtual_router_name": "virtualRouterName",
"virtualization_type": "virtualizationType",
"visibility_timeout_seconds": "visibilityTimeoutSeconds",
"visible_to_all_users": "visibleToAllUsers",
"volume_arn": "volumeArn",
"volume_encryption_key": "volumeEncryptionKey",
"volume_id": "volumeId",
"volume_size": "volumeSize",
"volume_size_in_bytes": "volumeSizeInBytes",
"volume_tags": "volumeTags",
"vpc_classic_link_id": "vpcClassicLinkId",
"vpc_classic_link_security_groups": "vpcClassicLinkSecurityGroups",
"vpc_config": "vpcConfig",
"vpc_configuration": "vpcConfiguration",
"vpc_endpoint_id": "vpcEndpointId",
"vpc_endpoint_service_id": "vpcEndpointServiceId",
"vpc_endpoint_type": "vpcEndpointType",
"vpc_id": "vpcId",
"vpc_options": "vpcOptions",
"vpc_owner_id": "vpcOwnerId",
"vpc_peering_connection_id": "vpcPeeringConnectionId",
"vpc_region": "vpcRegion",
"vpc_security_group_ids": "vpcSecurityGroupIds",
"vpc_settings": "vpcSettings",
"vpc_zone_identifiers": "vpcZoneIdentifiers",
"vpn_connection_id": "vpnConnectionId",
"vpn_ecmp_support": "vpnEcmpSupport",
"vpn_gateway_id": "vpnGatewayId",
"wait_for_capacity_timeout": "waitForCapacityTimeout",
"wait_for_deployment": "waitForDeployment",
"wait_for_elb_capacity": "waitForElbCapacity",
"wait_for_fulfillment": "waitForFulfillment",
"wait_for_ready_timeout": "waitForReadyTimeout",
"wait_for_steady_state": "waitForSteadyState",
"web_acl_arn": "webAclArn",
"web_acl_id": "webAclId",
"website_ca_id": "websiteCaId",
"website_domain": "websiteDomain",
"website_endpoint": "websiteEndpoint",
"website_redirect": "websiteRedirect",
"weekly_maintenance_start_time": "weeklyMaintenanceStartTime",
"weighted_routing_policies": "weightedRoutingPolicies",
"window_id": "windowId",
"worker_type": "workerType",
"workflow_execution_retention_period_in_days": "workflowExecutionRetentionPeriodInDays",
"workflow_name": "workflowName",
"workmail_actions": "workmailActions",
"workspace_properties": "workspaceProperties",
"workspace_security_group_id": "workspaceSecurityGroupId",
"write_attributes": "writeAttributes",
"write_capacity": "writeCapacity",
"xml_classifier": "xmlClassifier",
"xray_enabled": "xrayEnabled",
"xray_tracing_enabled": "xrayTracingEnabled",
"xss_match_tuples": "xssMatchTuples",
"zone_id": "zoneId",
"zookeeper_connect_string": "zookeeperConnectString",
}
_CAMEL_TO_SNAKE_CASE_TABLE = {
"accelerationStatus": "acceleration_status",
"acceleratorArn": "accelerator_arn",
"acceptStatus": "accept_status",
"acceptanceRequired": "acceptance_required",
"accessLogSettings": "access_log_settings",
"accessLogs": "access_logs",
"accessPolicies": "access_policies",
"accessPolicy": "access_policy",
"accessUrl": "access_url",
"accountAggregationSource": "account_aggregation_source",
"accountAlias": "account_alias",
"accountId": "account_id",
"actionsEnabled": "actions_enabled",
"activatedRules": "activated_rules",
"activationCode": "activation_code",
"activationKey": "activation_key",
"activeDirectoryId": "active_directory_id",
"activeTrustedSigners": "active_trusted_signers",
"addHeaderActions": "add_header_actions",
"additionalArtifacts": "additional_artifacts",
"additionalAuthenticationProviders": "additional_authentication_providers",
"additionalInfo": "additional_info",
"additionalSchemaElements": "additional_schema_elements",
"addressFamily": "address_family",
"adjustmentType": "adjustment_type",
"adminAccountId": "admin_account_id",
"adminCreateUserConfig": "admin_create_user_config",
"administrationRoleArn": "administration_role_arn",
"advancedOptions": "advanced_options",
"agentArns": "agent_arns",
"agentVersion": "agent_version",
"alarmActions": "alarm_actions",
"alarmConfiguration": "alarm_configuration",
"alarmDescription": "alarm_description",
"albTargetGroupArn": "alb_target_group_arn",
"aliasAttributes": "alias_attributes",
"allSettings": "all_settings",
"allocatedCapacity": "allocated_capacity",
"allocatedMemory": "allocated_memory",
"allocatedStorage": "allocated_storage",
"allocationId": "allocation_id",
"allocationStrategy": "allocation_strategy",
"allowExternalPrincipals": "allow_external_principals",
"allowMajorVersionUpgrade": "allow_major_version_upgrade",
"allowOverwrite": "allow_overwrite",
"allowReassociation": "allow_reassociation",
"allowSelfManagement": "allow_self_management",
"allowSsh": "allow_ssh",
"allowSudo": "allow_sudo",
"allowUnassociatedTargets": "allow_unassociated_targets",
"allowUnauthenticatedIdentities": "allow_unauthenticated_identities",
"allowUsersToChangePassword": "allow_users_to_change_password",
"allowVersionUpgrade": "allow_version_upgrade",
"allowedOauthFlows": "allowed_oauth_flows",
"allowedOauthFlowsUserPoolClient": "allowed_oauth_flows_user_pool_client",
"allowedOauthScopes": "allowed_oauth_scopes",
"allowedPattern": "allowed_pattern",
"allowedPrefixes": "allowed_prefixes",
"allowedPrincipals": "allowed_principals",
"amazonAddress": "amazon_address",
"amazonSideAsn": "amazon_side_asn",
"amiId": "ami_id",
"amiType": "ami_type",
"analyticsConfiguration": "analytics_configuration",
"analyzerName": "analyzer_name",
"apiEndpoint": "api_endpoint",
"apiId": "api_id",
"apiKey": "api_key",
"apiKeyRequired": "api_key_required",
"apiKeySelectionExpression": "api_key_selection_expression",
"apiKeySource": "api_key_source",
"apiMappingKey": "api_mapping_key",
"apiMappingSelectionExpression": "api_mapping_selection_expression",
"apiStages": "api_stages",
"appName": "app_name",
"appServer": "app_server",
"appServerVersion": "app_server_version",
"appSources": "app_sources",
"applicationFailureFeedbackRoleArn": "application_failure_feedback_role_arn",
"applicationId": "application_id",
"applicationSuccessFeedbackRoleArn": "application_success_feedback_role_arn",
"applicationSuccessFeedbackSampleRate": "application_success_feedback_sample_rate",
"applyImmediately": "apply_immediately",
"approvalRules": "approval_rules",
"approvedPatches": "approved_patches",
"approvedPatchesComplianceLevel": "approved_patches_compliance_level",
"appversionLifecycle": "appversion_lifecycle",
"arnSuffix": "arn_suffix",
"artifactStore": "artifact_store",
"assignGeneratedIpv6CidrBlock": "assign_generated_ipv6_cidr_block",
"assignIpv6AddressOnCreation": "assign_ipv6_address_on_creation",
"associatePublicIpAddress": "associate_public_ip_address",
"associateWithPrivateIp": "associate_with_private_ip",
"associatedGatewayId": "associated_gateway_id",
"associatedGatewayOwnerAccountId": "associated_gateway_owner_account_id",
"associatedGatewayType": "associated_gateway_type",
"associationDefaultRouteTableId": "association_default_route_table_id",
"associationId": "association_id",
"associationName": "association_name",
"assumeRolePolicy": "assume_role_policy",
"atRestEncryptionEnabled": "at_rest_encryption_enabled",
"attachmentId": "attachment_id",
"attachmentsSources": "attachments_sources",
"attributeMapping": "attribute_mapping",
"audioCodecOptions": "audio_codec_options",
"auditStreamArn": "audit_stream_arn",
"authToken": "auth_token",
"authType": "auth_type",
"authenticationConfiguration": "authentication_configuration",
"authenticationOptions": "authentication_options",
"authenticationType": "authentication_type",
"authorizationScopes": "authorization_scopes",
"authorizationType": "authorization_type",
"authorizerCredentials": "authorizer_credentials",
"authorizerCredentialsArn": "authorizer_credentials_arn",
"authorizerId": "authorizer_id",
"authorizerResultTtlInSeconds": "authorizer_result_ttl_in_seconds",
"authorizerType": "authorizer_type",
"authorizerUri": "authorizer_uri",
"autoAccept": "auto_accept",
"autoAcceptSharedAttachments": "auto_accept_shared_attachments",
"autoAssignElasticIps": "auto_assign_elastic_ips",
"autoAssignPublicIps": "auto_assign_public_ips",
"autoBundleOnDeploy": "auto_bundle_on_deploy",
"autoDeploy": "auto_deploy",
"autoDeployed": "auto_deployed",
"autoEnable": "auto_enable",
"autoHealing": "auto_healing",
"autoMinorVersionUpgrade": "auto_minor_version_upgrade",
"autoRollbackConfiguration": "auto_rollback_configuration",
"autoScalingGroupProvider": "auto_scaling_group_provider",
"autoScalingType": "auto_scaling_type",
"autoVerifiedAttributes": "auto_verified_attributes",
"automatedSnapshotRetentionPeriod": "automated_snapshot_retention_period",
"automaticBackupRetentionDays": "automatic_backup_retention_days",
"automaticFailoverEnabled": "automatic_failover_enabled",
"automaticStopTimeMinutes": "automatic_stop_time_minutes",
"automationTargetParameterName": "automation_target_parameter_name",
"autoscalingGroupName": "autoscaling_group_name",
"autoscalingGroups": "autoscaling_groups",
"autoscalingPolicy": "autoscaling_policy",
"autoscalingRole": "autoscaling_role",
"availabilityZone": "availability_zone",
"availabilityZoneId": "availability_zone_id",
"availabilityZoneName": "availability_zone_name",
"availabilityZones": "availability_zones",
"awsAccountId": "aws_account_id",
"awsDevice": "aws_device",
"awsFlowRubySettings": "aws_flow_ruby_settings",
"awsKmsKeyArn": "aws_kms_key_arn",
"awsServiceAccessPrincipals": "aws_service_access_principals",
"awsServiceName": "aws_service_name",
"azMode": "az_mode",
"backtrackWindow": "backtrack_window",
"backupRetentionPeriod": "backup_retention_period",
"backupWindow": "backup_window",
"badgeEnabled": "badge_enabled",
"badgeUrl": "badge_url",
"baseEndpointDnsNames": "base_endpoint_dns_names",
"basePath": "base_path",
"baselineId": "baseline_id",
"batchSize": "batch_size",
"batchTarget": "batch_target",
"behaviorOnMxFailure": "behavior_on_mx_failure",
"berkshelfVersion": "berkshelf_version",
"bgpAsn": "bgp_asn",
"bgpAuthKey": "bgp_auth_key",
"bgpPeerId": "bgp_peer_id",
"bgpStatus": "bgp_status",
"bidPrice": "bid_price",
"billingMode": "billing_mode",
"binaryMediaTypes": "binary_media_types",
"bisectBatchOnFunctionError": "bisect_batch_on_function_error",
"blockDeviceMappings": "block_device_mappings",
"blockDurationMinutes": "block_duration_minutes",
"blockPublicAcls": "block_public_acls",
"blockPublicPolicy": "block_public_policy",
"blueGreenDeploymentConfig": "blue_green_deployment_config",
"blueprintId": "blueprint_id",
"bootstrapActions": "bootstrap_actions",
"bootstrapBrokers": "bootstrap_brokers",
"bootstrapBrokersTls": "bootstrap_brokers_tls",
"bounceActions": "bounce_actions",
"branchFilter": "branch_filter",
"brokerName": "broker_name",
"brokerNodeGroupInfo": "broker_node_group_info",
"bucketDomainName": "bucket_domain_name",
"bucketName": "bucket_name",
"bucketPrefix": "bucket_prefix",
"bucketRegionalDomainName": "bucket_regional_domain_name",
"budgetType": "budget_type",
"buildId": "build_id",
"buildTimeout": "build_timeout",
"bundleId": "bundle_id",
"bundlerVersion": "bundler_version",
"byteMatchTuples": "byte_match_tuples",
"caCertIdentifier": "ca_cert_identifier",
"cacheClusterEnabled": "cache_cluster_enabled",
"cacheClusterSize": "cache_cluster_size",
"cacheControl": "cache_control",
"cacheKeyParameters": "cache_key_parameters",
"cacheNamespace": "cache_namespace",
"cacheNodes": "cache_nodes",
"cachingConfig": "caching_config",
"callbackUrls": "callback_urls",
"callerReference": "caller_reference",
"campaignHook": "campaign_hook",
"capacityProviderStrategies": "capacity_provider_strategies",
"capacityProviders": "capacity_providers",
"capacityReservationSpecification": "capacity_reservation_specification",
"catalogId": "catalog_id",
"catalogTargets": "catalog_targets",
"cdcStartTime": "cdc_start_time",
"certificateArn": "certificate_arn",
"certificateAuthority": "certificate_authority",
"certificateAuthorityArn": "certificate_authority_arn",
"certificateAuthorityConfiguration": "certificate_authority_configuration",
"certificateBody": "certificate_body",
"certificateChain": "certificate_chain",
"certificateId": "certificate_id",
"certificateName": "certificate_name",
"certificatePem": "certificate_pem",
"certificatePrivateKey": "certificate_private_key",
"certificateSigningRequest": "certificate_signing_request",
"certificateUploadDate": "certificate_upload_date",
"certificateWallet": "certificate_wallet",
"channelId": "channel_id",
"chapEnabled": "chap_enabled",
"characterSetName": "character_set_name",
"childHealthThreshold": "child_health_threshold",
"childHealthchecks": "child_healthchecks",
"cidrBlock": "cidr_block",
"cidrBlocks": "cidr_blocks",
"ciphertextBlob": "ciphertext_blob",
"classificationType": "classification_type",
"clientAffinity": "client_affinity",
"clientAuthentication": "client_authentication",
"clientCertificateId": "client_certificate_id",
"clientCidrBlock": "client_cidr_block",
"clientId": "client_id",
"clientIdLists": "client_id_lists",
"clientLists": "client_lists",
"clientSecret": "client_secret",
"clientToken": "client_token",
"clientVpnEndpointId": "client_vpn_endpoint_id",
"cloneUrlHttp": "clone_url_http",
"cloneUrlSsh": "clone_url_ssh",
"cloudWatchLogsGroupArn": "cloud_watch_logs_group_arn",
"cloudWatchLogsRoleArn": "cloud_watch_logs_role_arn",
"cloudfrontAccessIdentityPath": "cloudfront_access_identity_path",
"cloudfrontDistributionArn": "cloudfront_distribution_arn",
"cloudfrontDomainName": "cloudfront_domain_name",
"cloudfrontZoneId": "cloudfront_zone_id",
"cloudwatchAlarm": "cloudwatch_alarm",
"cloudwatchAlarmName": "cloudwatch_alarm_name",
"cloudwatchAlarmRegion": "cloudwatch_alarm_region",
"cloudwatchDestinations": "cloudwatch_destinations",
"cloudwatchLogGroupArn": "cloudwatch_log_group_arn",
"cloudwatchLoggingOptions": "cloudwatch_logging_options",
"cloudwatchMetric": "cloudwatch_metric",
"cloudwatchRoleArn": "cloudwatch_role_arn",
"clusterAddress": "cluster_address",
"clusterCertificates": "cluster_certificates",
"clusterConfig": "cluster_config",
"clusterEndpointIdentifier": "cluster_endpoint_identifier",
"clusterId": "cluster_id",
"clusterIdentifier": "cluster_identifier",
"clusterIdentifierPrefix": "cluster_identifier_prefix",
"clusterMembers": "cluster_members",
"clusterMode": "cluster_mode",
"clusterName": "cluster_name",
"clusterParameterGroupName": "cluster_parameter_group_name",
"clusterPublicKey": "cluster_public_key",
"clusterResourceId": "cluster_resource_id",
"clusterRevisionNumber": "cluster_revision_number",
"clusterSecurityGroups": "cluster_security_groups",
"clusterState": "cluster_state",
"clusterSubnetGroupName": "cluster_subnet_group_name",
"clusterType": "cluster_type",
"clusterVersion": "cluster_version",
"cnamePrefix": "cname_prefix",
"cognitoIdentityProviders": "cognito_identity_providers",
"cognitoOptions": "cognito_options",
"companyCode": "company_code",
"comparisonOperator": "comparison_operator",
"compatibleRuntimes": "compatible_runtimes",
"completeLock": "complete_lock",
"complianceSeverity": "compliance_severity",
"computeEnvironmentName": "compute_environment_name",
"computeEnvironmentNamePrefix": "compute_environment_name_prefix",
"computeEnvironments": "compute_environments",
"computePlatform": "compute_platform",
"computeResources": "compute_resources",
"computerName": "computer_name",
"configurationEndpoint": "configuration_endpoint",
"configurationEndpointAddress": "configuration_endpoint_address",
"configurationId": "configuration_id",
"configurationInfo": "configuration_info",
"configurationManagerName": "configuration_manager_name",
"configurationManagerVersion": "configuration_manager_version",
"configurationSetName": "configuration_set_name",
"configurationsJson": "configurations_json",
"confirmationTimeoutInMinutes": "confirmation_timeout_in_minutes",
"connectSettings": "connect_settings",
"connectionDraining": "connection_draining",
"connectionDrainingTimeout": "connection_draining_timeout",
"connectionEvents": "connection_events",
"connectionId": "connection_id",
"connectionLogOptions": "connection_log_options",
"connectionNotificationArn": "connection_notification_arn",
"connectionProperties": "connection_properties",
"connectionType": "connection_type",
"connectionsBandwidth": "connections_bandwidth",
"containerDefinitions": "container_definitions",
"containerName": "container_name",
"containerProperties": "container_properties",
"contentBase64": "content_base64",
"contentBasedDeduplication": "content_based_deduplication",
"contentConfig": "content_config",
"contentConfigPermissions": "content_config_permissions",
"contentDisposition": "content_disposition",
"contentEncoding": "content_encoding",
"contentHandling": "content_handling",
"contentHandlingStrategy": "content_handling_strategy",
"contentLanguage": "content_language",
"contentType": "content_type",
"cookieExpirationPeriod": "cookie_expiration_period",
"cookieName": "cookie_name",
"copyTagsToBackups": "copy_tags_to_backups",
"copyTagsToSnapshot": "copy_tags_to_snapshot",
"coreInstanceCount": "core_instance_count",
"coreInstanceGroup": "core_instance_group",
"coreInstanceType": "core_instance_type",
"corsConfiguration": "cors_configuration",
"corsRules": "cors_rules",
"costFilters": "cost_filters",
"costTypes": "cost_types",
"cpuCoreCount": "cpu_core_count",
"cpuCount": "cpu_count",
"cpuOptions": "cpu_options",
"cpuThreadsPerCore": "cpu_threads_per_core",
"createDate": "create_date",
"createTimestamp": "create_timestamp",
"createdAt": "created_at",
"createdDate": "created_date",
"createdTime": "created_time",
"creationDate": "creation_date",
"creationTime": "creation_time",
"creationToken": "creation_token",
"credentialDuration": "credential_duration",
"credentialsArn": "credentials_arn",
"creditSpecification": "credit_specification",
"crossZoneLoadBalancing": "cross_zone_load_balancing",
"csvClassifier": "csv_classifier",
"currentVersion": "current_version",
"customAmiId": "custom_ami_id",
"customConfigureRecipes": "custom_configure_recipes",
"customCookbooksSources": "custom_cookbooks_sources",
"customDeployRecipes": "custom_deploy_recipes",
"customEndpointType": "custom_endpoint_type",
"customErrorResponses": "custom_error_responses",
"customInstanceProfileArn": "custom_instance_profile_arn",
"customJson": "custom_json",
"customSecurityGroupIds": "custom_security_group_ids",
"customSetupRecipes": "custom_setup_recipes",
"customShutdownRecipes": "custom_shutdown_recipes",
"customSuffix": "custom_suffix",
"customUndeployRecipes": "custom_undeploy_recipes",
"customerAddress": "customer_address",
"customerAwsId": "customer_aws_id",
"customerGatewayConfiguration": "customer_gateway_configuration",
"customerGatewayId": "customer_gateway_id",
"customerMasterKeySpec": "customer_master_key_spec",
"customerOwnedIp": "customer_owned_ip",
"customerOwnedIpv4Pool": "customer_owned_ipv4_pool",
"customerUserName": "customer_user_name",
"dailyAutomaticBackupStartTime": "daily_automatic_backup_start_time",
"dashboardArn": "dashboard_arn",
"dashboardBody": "dashboard_body",
"dashboardName": "dashboard_name",
"dataEncryptionKeyId": "data_encryption_key_id",
"dataRetentionInHours": "data_retention_in_hours",
"dataSource": "data_source",
"dataSourceArn": "data_source_arn",
"dataSourceDatabaseName": "data_source_database_name",
"dataSourceType": "data_source_type",
"databaseName": "database_name",
"datapointsToAlarm": "datapoints_to_alarm",
"dbClusterIdentifier": "db_cluster_identifier",
"dbClusterParameterGroupName": "db_cluster_parameter_group_name",
"dbClusterSnapshotArn": "db_cluster_snapshot_arn",
"dbClusterSnapshotIdentifier": "db_cluster_snapshot_identifier",
"dbInstanceIdentifier": "db_instance_identifier",
"dbParameterGroupName": "db_parameter_group_name",
"dbPassword": "db_password",
"dbSnapshotArn": "db_snapshot_arn",
"dbSnapshotIdentifier": "db_snapshot_identifier",
"dbSubnetGroupName": "db_subnet_group_name",
"dbUser": "db_user",
"dbiResourceId": "dbi_resource_id",
"deadLetterConfig": "dead_letter_config",
"defaultAction": "default_action",
"defaultActions": "default_actions",
"defaultArguments": "default_arguments",
"defaultAssociationRouteTable": "default_association_route_table",
"defaultAuthenticationMethod": "default_authentication_method",
"defaultAvailabilityZone": "default_availability_zone",
"defaultBranch": "default_branch",
"defaultCacheBehavior": "default_cache_behavior",
"defaultCapacityProviderStrategies": "default_capacity_provider_strategies",
"defaultClientId": "default_client_id",
"defaultCooldown": "default_cooldown",
"defaultInstanceProfileArn": "default_instance_profile_arn",
"defaultNetworkAclId": "default_network_acl_id",
"defaultOs": "default_os",
"defaultPropagationRouteTable": "default_propagation_route_table",
"defaultRedirectUri": "default_redirect_uri",
"defaultResult": "default_result",
"defaultRootDeviceType": "default_root_device_type",
"defaultRootObject": "default_root_object",
"defaultRouteSettings": "default_route_settings",
"defaultRouteTableAssociation": "default_route_table_association",
"defaultRouteTableId": "default_route_table_id",
"defaultRouteTablePropagation": "default_route_table_propagation",
"defaultRunProperties": "default_run_properties",
"defaultSecurityGroupId": "default_security_group_id",
"defaultSenderId": "default_sender_id",
"defaultSmsType": "default_sms_type",
"defaultSshKeyName": "default_ssh_key_name",
"defaultStorageClass": "default_storage_class",
"defaultSubnetId": "default_subnet_id",
"defaultValue": "default_value",
"defaultVersion": "default_version",
"defaultVersionId": "default_version_id",
"delaySeconds": "delay_seconds",
"delegationSetId": "delegation_set_id",
"deleteAutomatedBackups": "delete_automated_backups",
"deleteEbs": "delete_ebs",
"deleteEip": "delete_eip",
"deletionProtection": "deletion_protection",
"deletionWindowInDays": "deletion_window_in_days",
"deliveryPolicy": "delivery_policy",
"deliveryStatusIamRoleArn": "delivery_status_iam_role_arn",
"deliveryStatusSuccessSamplingRate": "delivery_status_success_sampling_rate",
"deploymentConfigId": "deployment_config_id",
"deploymentConfigName": "deployment_config_name",
"deploymentController": "deployment_controller",
"deploymentGroupName": "deployment_group_name",
"deploymentId": "deployment_id",
"deploymentMaximumPercent": "deployment_maximum_percent",
"deploymentMinimumHealthyPercent": "deployment_minimum_healthy_percent",
"deploymentMode": "deployment_mode",
"deploymentStyle": "deployment_style",
"deregistrationDelay": "deregistration_delay",
"desiredCapacity": "desired_capacity",
"desiredCount": "desired_count",
"destinationArn": "destination_arn",
"destinationCidrBlock": "destination_cidr_block",
"destinationConfig": "destination_config",
"destinationId": "destination_id",
"destinationIpv6CidrBlock": "destination_ipv6_cidr_block",
"destinationLocationArn": "destination_location_arn",
"destinationName": "destination_name",
"destinationPortRange": "destination_port_range",
"destinationPrefixListId": "destination_prefix_list_id",
"destinationStreamArn": "destination_stream_arn",
"detailType": "detail_type",
"detectorId": "detector_id",
"developerProviderName": "developer_provider_name",
"deviceCaCertificate": "device_ca_certificate",
"deviceConfiguration": "device_configuration",
"deviceIndex": "device_index",
"deviceName": "device_name",
"dhcpOptionsId": "dhcp_options_id",
"directInternetAccess": "direct_internet_access",
"directoryId": "directory_id",
"directoryName": "directory_name",
"directoryType": "directory_type",
"disableApiTermination": "disable_api_termination",
"disableEmailNotification": "disable_email_notification",
"disableRollback": "disable_rollback",
"diskId": "disk_id",
"diskSize": "disk_size",
"displayName": "display_name",
"dkimTokens": "dkim_tokens",
"dnsConfig": "dns_config",
"dnsEntries": "dns_entries",
"dnsIpAddresses": "dns_ip_addresses",
"dnsIps": "dns_ips",
"dnsName": "dns_name",
"dnsServers": "dns_servers",
"dnsSupport": "dns_support",
"documentFormat": "document_format",
"documentRoot": "document_root",
"documentType": "document_type",
"documentVersion": "document_version",
"documentationVersion": "documentation_version",
"domainEndpointOptions": "domain_endpoint_options",
"domainIamRoleName": "domain_iam_role_name",
"domainId": "domain_id",
"domainName": "domain_name",
"domainNameConfiguration": "domain_name_configuration",
"domainNameServers": "domain_name_servers",
"domainValidationOptions": "domain_validation_options",
"drainElbOnShutdown": "drain_elb_on_shutdown",
"dropInvalidHeaderFields": "drop_invalid_header_fields",
"dxGatewayAssociationId": "dx_gateway_association_id",
"dxGatewayId": "dx_gateway_id",
"dxGatewayOwnerAccountId": "dx_gateway_owner_account_id",
"dynamodbConfig": "dynamodb_config",
"dynamodbTargets": "dynamodb_targets",
"ebsBlockDevices": "ebs_block_devices",
"ebsConfigs": "ebs_configs",
"ebsOptimized": "ebs_optimized",
"ebsOptions": "ebs_options",
"ebsRootVolumeSize": "ebs_root_volume_size",
"ebsVolumes": "ebs_volumes",
"ec2Attributes": "ec2_attributes",
"ec2Config": "ec2_config",
"ec2InboundPermissions": "ec2_inbound_permissions",
"ec2InstanceId": "ec2_instance_id",
"ec2InstanceType": "ec2_instance_type",
"ec2TagFilters": "ec2_tag_filters",
"ec2TagSets": "ec2_tag_sets",
"ecsClusterArn": "ecs_cluster_arn",
"ecsService": "ecs_service",
"ecsTarget": "ecs_target",
"efsFileSystemArn": "efs_file_system_arn",
"egressOnlyGatewayId": "egress_only_gateway_id",
"elasticGpuSpecifications": "elastic_gpu_specifications",
"elasticInferenceAccelerator": "elastic_inference_accelerator",
"elasticIp": "elastic_ip",
"elasticLoadBalancer": "elastic_load_balancer",
"elasticsearchConfig": "elasticsearch_config",
"elasticsearchConfiguration": "elasticsearch_configuration",
"elasticsearchSettings": "elasticsearch_settings",
"elasticsearchVersion": "elasticsearch_version",
"emailConfiguration": "email_configuration",
"emailVerificationMessage": "email_verification_message",
"emailVerificationSubject": "email_verification_subject",
"enaSupport": "ena_support",
"enableClassiclink": "enable_classiclink",
"enableClassiclinkDnsSupport": "enable_classiclink_dns_support",
"enableCloudwatchLogsExports": "enable_cloudwatch_logs_exports",
"enableCrossZoneLoadBalancing": "enable_cross_zone_load_balancing",
"enableDeletionProtection": "enable_deletion_protection",
"enableDnsHostnames": "enable_dns_hostnames",
"enableDnsSupport": "enable_dns_support",
"enableEcsManagedTags": "enable_ecs_managed_tags",
"enableHttp2": "enable_http2",
"enableHttpEndpoint": "enable_http_endpoint",
"enableKeyRotation": "enable_key_rotation",
"enableLogFileValidation": "enable_log_file_validation",
"enableLogging": "enable_logging",
"enableMonitoring": "enable_monitoring",
"enableNetworkIsolation": "enable_network_isolation",
"enableSni": "enable_sni",
"enableSsl": "enable_ssl",
"enableSso": "enable_sso",
"enabledCloudwatchLogsExports": "enabled_cloudwatch_logs_exports",
"enabledClusterLogTypes": "enabled_cluster_log_types",
"enabledMetrics": "enabled_metrics",
"enabledPolicyTypes": "enabled_policy_types",
"encodedKey": "encoded_key",
"encryptAtRest": "encrypt_at_rest",
"encryptedFingerprint": "encrypted_fingerprint",
"encryptedPassword": "encrypted_password",
"encryptedPrivateKey": "encrypted_private_key",
"encryptedSecret": "encrypted_secret",
"encryptionConfig": "encryption_config",
"encryptionConfiguration": "encryption_configuration",
"encryptionInfo": "encryption_info",
"encryptionKey": "encryption_key",
"encryptionOptions": "encryption_options",
"encryptionType": "encryption_type",
"endDate": "end_date",
"endDateType": "end_date_type",
"endTime": "end_time",
"endpointArn": "endpoint_arn",
"endpointAutoConfirms": "endpoint_auto_confirms",
"endpointConfigName": "endpoint_config_name",
"endpointConfiguration": "endpoint_configuration",
"endpointConfigurations": "endpoint_configurations",
"endpointDetails": "endpoint_details",
"endpointGroupRegion": "endpoint_group_region",
"endpointId": "endpoint_id",
"endpointType": "endpoint_type",
"endpointUrl": "endpoint_url",
"enforceConsumerDeletion": "enforce_consumer_deletion",
"engineMode": "engine_mode",
"engineName": "engine_name",
"engineType": "engine_type",
"engineVersion": "engine_version",
"enhancedMonitoring": "enhanced_monitoring",
"enhancedVpcRouting": "enhanced_vpc_routing",
"eniId": "eni_id",
"environmentId": "environment_id",
"ephemeralBlockDevices": "ephemeral_block_devices",
"ephemeralStorage": "ephemeral_storage",
"estimatedInstanceWarmup": "estimated_instance_warmup",
"evaluateLowSampleCountPercentiles": "evaluate_low_sample_count_percentiles",
"evaluationPeriods": "evaluation_periods",
"eventCategories": "event_categories",
"eventDeliveryFailureTopicArn": "event_delivery_failure_topic_arn",
"eventEndpointCreatedTopicArn": "event_endpoint_created_topic_arn",
"eventEndpointDeletedTopicArn": "event_endpoint_deleted_topic_arn",
"eventEndpointUpdatedTopicArn": "event_endpoint_updated_topic_arn",
"eventPattern": "event_pattern",
"eventSelectors": "event_selectors",
"eventSourceArn": "event_source_arn",
"eventSourceToken": "event_source_token",
"eventTypeIds": "event_type_ids",
"excessCapacityTerminationPolicy": "excess_capacity_termination_policy",
"excludedAccounts": "excluded_accounts",
"excludedMembers": "excluded_members",
"executionArn": "execution_arn",
"executionProperty": "execution_property",
"executionRoleArn": "execution_role_arn",
"executionRoleName": "execution_role_name",
"expirationDate": "expiration_date",
"expirationModel": "expiration_model",
"expirePasswords": "expire_passwords",
"explicitAuthFlows": "explicit_auth_flows",
"exportPath": "export_path",
"extendedS3Configuration": "extended_s3_configuration",
"extendedStatistic": "extended_statistic",
"extraConnectionAttributes": "extra_connection_attributes",
"failoverRoutingPolicies": "failover_routing_policies",
"failureFeedbackRoleArn": "failure_feedback_role_arn",
"failureThreshold": "failure_threshold",
"fargateProfileName": "fargate_profile_name",
"featureName": "feature_name",
"featureSet": "feature_set",
"fifoQueue": "fifo_queue",
"fileSystemArn": "file_system_arn",
"fileSystemConfig": "file_system_config",
"fileSystemId": "file_system_id",
"fileshareId": "fileshare_id",
"filterGroups": "filter_groups",
"filterPattern": "filter_pattern",
"filterPolicy": "filter_policy",
"finalSnapshotIdentifier": "final_snapshot_identifier",
"findingPublishingFrequency": "finding_publishing_frequency",
"fixedRate": "fixed_rate",
"fleetArn": "fleet_arn",
"fleetType": "fleet_type",
"forceDelete": "force_delete",
"forceDestroy": "force_destroy",
"forceDetach": "force_detach",
"forceDetachPolicies": "force_detach_policies",
"forceNewDeployment": "force_new_deployment",
"forceUpdateVersion": "force_update_version",
"fromAddress": "from_address",
"fromPort": "from_port",
"functionArn": "function_arn",
"functionId": "function_id",
"functionName": "function_name",
"functionVersion": "function_version",
"gatewayArn": "gateway_arn",
"gatewayId": "gateway_id",
"gatewayIpAddress": "gateway_ip_address",
"gatewayName": "gateway_name",
"gatewayTimezone": "gateway_timezone",
"gatewayType": "gateway_type",
"gatewayVpcEndpoint": "gateway_vpc_endpoint",
"generateSecret": "generate_secret",
"geoMatchConstraints": "geo_match_constraints",
"geolocationRoutingPolicies": "geolocation_routing_policies",
"getPasswordData": "get_password_data",
"globalClusterIdentifier": "global_cluster_identifier",
"globalClusterResourceId": "global_cluster_resource_id",
"globalFilters": "global_filters",
"globalSecondaryIndexes": "global_secondary_indexes",
"glueVersion": "glue_version",
"grantCreationTokens": "grant_creation_tokens",
"grantId": "grant_id",
"grantToken": "grant_token",
"granteePrincipal": "grantee_principal",
"grokClassifier": "grok_classifier",
"groupName": "group_name",
"groupNames": "group_names",
"guessMimeTypeEnabled": "guess_mime_type_enabled",
"hardExpiry": "hard_expiry",
"hasLogicalRedundancy": "has_logical_redundancy",
"hasPublicAccessPolicy": "has_public_access_policy",
"hashKey": "hash_key",
"hashType": "hash_type",
"healthCheck": "health_check",
"healthCheckConfig": "health_check_config",
"healthCheckCustomConfig": "health_check_custom_config",
"healthCheckGracePeriod": "health_check_grace_period",
"healthCheckGracePeriodSeconds": "health_check_grace_period_seconds",
"healthCheckId": "health_check_id",
"healthCheckIntervalSeconds": "health_check_interval_seconds",
"healthCheckPath": "health_check_path",
"healthCheckPort": "health_check_port",
"healthCheckProtocol": "health_check_protocol",
"healthCheckType": "health_check_type",
"healthcheckMethod": "healthcheck_method",
"healthcheckUrl": "healthcheck_url",
"heartbeatTimeout": "heartbeat_timeout",
"hibernationOptions": "hibernation_options",
"hlsIngests": "hls_ingests",
"homeDirectory": "home_directory",
"homeRegion": "home_region",
"hostId": "host_id",
"hostInstanceType": "host_instance_type",
"hostKey": "host_key",
"hostKeyFingerprint": "host_key_fingerprint",
"hostVpcId": "host_vpc_id",
"hostedZone": "hosted_zone",
"hostedZoneId": "hosted_zone_id",
"hostnameTheme": "hostname_theme",
"hsmEniId": "hsm_eni_id",
"hsmId": "hsm_id",
"hsmState": "hsm_state",
"hsmType": "hsm_type",
"httpConfig": "http_config",
"httpFailureFeedbackRoleArn": "http_failure_feedback_role_arn",
"httpMethod": "http_method",
"httpSuccessFeedbackRoleArn": "http_success_feedback_role_arn",
"httpSuccessFeedbackSampleRate": "http_success_feedback_sample_rate",
"httpVersion": "http_version",
"iamArn": "iam_arn",
"iamDatabaseAuthenticationEnabled": "iam_database_authentication_enabled",
"iamFleetRole": "iam_fleet_role",
"iamInstanceProfile": "iam_instance_profile",
"iamRole": "iam_role",
"iamRoleArn": "iam_role_arn",
"iamRoleId": "iam_role_id",
"iamRoles": "iam_roles",
"iamUserAccessToBilling": "iam_user_access_to_billing",
"icmpCode": "icmp_code",
"icmpType": "icmp_type",
"identifierPrefix": "identifier_prefix",
"identityPoolId": "identity_pool_id",
"identityPoolName": "identity_pool_name",
"identityProvider": "identity_provider",
"identityProviderType": "identity_provider_type",
"identitySource": "identity_source",
"identitySources": "identity_sources",
"identityType": "identity_type",
"identityValidationExpression": "identity_validation_expression",
"idleTimeout": "idle_timeout",
"idpIdentifiers": "idp_identifiers",
"ignoreDeletionError": "ignore_deletion_error",
"ignorePublicAcls": "ignore_public_acls",
"imageId": "image_id",
"imageLocation": "image_location",
"imageScanningConfiguration": "image_scanning_configuration",
"imageTagMutability": "image_tag_mutability",
"importPath": "import_path",
"importedFileChunkSize": "imported_file_chunk_size",
"inProgressValidationBatches": "in_progress_validation_batches",
"includeGlobalServiceEvents": "include_global_service_events",
"includeOriginalHeaders": "include_original_headers",
"includedObjectVersions": "included_object_versions",
"inferenceAccelerators": "inference_accelerators",
"infrastructureClass": "infrastructure_class",
"initialLifecycleHooks": "initial_lifecycle_hooks",
"inputBucket": "input_bucket",
"inputParameters": "input_parameters",
"inputPath": "input_path",
"inputTransformer": "input_transformer",
"installUpdatesOnBoot": "install_updates_on_boot",
"instanceClass": "instance_class",
"instanceCount": "instance_count",
"instanceGroups": "instance_groups",
"instanceId": "instance_id",
"instanceInitiatedShutdownBehavior": "instance_initiated_shutdown_behavior",
"instanceInterruptionBehaviour": "instance_interruption_behaviour",
"instanceMarketOptions": "instance_market_options",
"instanceMatchCriteria": "instance_match_criteria",
"instanceName": "instance_name",
"instanceOwnerId": "instance_owner_id",
"instancePlatform": "instance_platform",
"instancePoolsToUseCount": "instance_pools_to_use_count",
"instancePort": "instance_port",
"instancePorts": "instance_ports",
"instanceProfileArn": "instance_profile_arn",
"instanceRoleArn": "instance_role_arn",
"instanceShutdownTimeout": "instance_shutdown_timeout",
"instanceState": "instance_state",
"instanceTenancy": "instance_tenancy",
"instanceType": "instance_type",
"instanceTypes": "instance_types",
"insufficientDataActions": "insufficient_data_actions",
"insufficientDataHealthStatus": "insufficient_data_health_status",
"integrationHttpMethod": "integration_http_method",
"integrationId": "integration_id",
"integrationMethod": "integration_method",
"integrationResponseKey": "integration_response_key",
"integrationResponseSelectionExpression": "integration_response_selection_expression",
"integrationType": "integration_type",
"integrationUri": "integration_uri",
"invalidUserLists": "invalid_user_lists",
"invertHealthcheck": "invert_healthcheck",
"invitationArn": "invitation_arn",
"invitationMessage": "invitation_message",
"invocationRole": "invocation_role",
"invokeArn": "invoke_arn",
"invokeUrl": "invoke_url",
"iotAnalytics": "iot_analytics",
"iotEvents": "iot_events",
"ipAddress": "ip_address",
"ipAddressType": "ip_address_type",
"ipAddressVersion": "ip_address_version",
"ipAddresses": "ip_addresses",
"ipGroupIds": "ip_group_ids",
"ipSetDescriptors": "ip_set_descriptors",
"ipSets": "ip_sets",
"ipcMode": "ipc_mode",
"ipv6Address": "ipv6_address",
"ipv6AddressCount": "ipv6_address_count",
"ipv6Addresses": "ipv6_addresses",
"ipv6AssociationId": "ipv6_association_id",
"ipv6CidrBlock": "ipv6_cidr_block",
"ipv6CidrBlockAssociationId": "ipv6_cidr_block_association_id",
"ipv6CidrBlocks": "ipv6_cidr_blocks",
"ipv6Support": "ipv6_support",
"isEnabled": "is_enabled",
"isIpv6Enabled": "is_ipv6_enabled",
"isMultiRegionTrail": "is_multi_region_trail",
"isOrganizationTrail": "is_organization_trail",
"isStaticIp": "is_static_ip",
"jdbcTargets": "jdbc_targets",
"joinedMethod": "joined_method",
"joinedTimestamp": "joined_timestamp",
"jsonClassifier": "json_classifier",
"jumboFrameCapable": "jumbo_frame_capable",
"jvmOptions": "jvm_options",
"jvmType": "jvm_type",
"jvmVersion": "jvm_version",
"jwtConfiguration": "jwt_configuration",
"kafkaSettings": "kafka_settings",
"kafkaVersion": "kafka_version",
"kafkaVersions": "kafka_versions",
"keepJobFlowAliveWhenNoSteps": "keep_job_flow_alive_when_no_steps",
"kerberosAttributes": "kerberos_attributes",
"kernelId": "kernel_id",
"keyArn": "key_arn",
"keyFingerprint": "key_fingerprint",
"keyId": "key_id",
"keyMaterialBase64": "key_material_base64",
"keyName": "key_name",
"keyNamePrefix": "key_name_prefix",
"keyPairId": "key_pair_id",
"keyPairName": "key_pair_name",
"keyState": "key_state",
"keyType": "key_type",
"keyUsage": "key_usage",
"kibanaEndpoint": "kibana_endpoint",
"kinesisDestination": "kinesis_destination",
"kinesisSettings": "kinesis_settings",
"kinesisSourceConfiguration": "kinesis_source_configuration",
"kinesisTarget": "kinesis_target",
"kmsDataKeyReusePeriodSeconds": "kms_data_key_reuse_period_seconds",
"kmsEncrypted": "kms_encrypted",
"kmsKeyArn": "kms_key_arn",
"kmsKeyId": "kms_key_id",
"kmsMasterKeyId": "kms_master_key_id",
"lagId": "lag_id",
"lambda": "lambda_",
"lambdaActions": "lambda_actions",
"lambdaConfig": "lambda_config",
"lambdaFailureFeedbackRoleArn": "lambda_failure_feedback_role_arn",
"lambdaFunctionArn": "lambda_function_arn",
"lambdaFunctions": "lambda_functions",
"lambdaMultiValueHeadersEnabled": "lambda_multi_value_headers_enabled",
"lambdaSuccessFeedbackRoleArn": "lambda_success_feedback_role_arn",
"lambdaSuccessFeedbackSampleRate": "lambda_success_feedback_sample_rate",
"lastModified": "last_modified",
"lastModifiedDate": "last_modified_date",
"lastModifiedTime": "last_modified_time",
"lastProcessingResult": "last_processing_result",
"lastServiceErrorId": "last_service_error_id",
"lastUpdateTimestamp": "last_update_timestamp",
"lastUpdatedDate": "last_updated_date",
"lastUpdatedTime": "last_updated_time",
"latencyRoutingPolicies": "latency_routing_policies",
"latestRevision": "latest_revision",
"latestVersion": "latest_version",
"launchConfiguration": "launch_configuration",
"launchConfigurations": "launch_configurations",
"launchGroup": "launch_group",
"launchSpecifications": "launch_specifications",
"launchTemplate": "launch_template",
"launchTemplateConfig": "launch_template_config",
"launchTemplateConfigs": "launch_template_configs",
"launchType": "launch_type",
"layerArn": "layer_arn",
"layerIds": "layer_ids",
"layerName": "layer_name",
"lbPort": "lb_port",
"licenseConfigurationArn": "license_configuration_arn",
"licenseCount": "license_count",
"licenseCountHardLimit": "license_count_hard_limit",
"licenseCountingType": "license_counting_type",
"licenseInfo": "license_info",
"licenseModel": "license_model",
"licenseRules": "license_rules",
"licenseSpecifications": "license_specifications",
"lifecycleConfigName": "lifecycle_config_name",
"lifecyclePolicy": "lifecycle_policy",
"lifecycleRules": "lifecycle_rules",
"lifecycleTransition": "lifecycle_transition",
"limitAmount": "limit_amount",
"limitUnit": "limit_unit",
"listenerArn": "listener_arn",
"loadBalancer": "load_balancer",
"loadBalancerArn": "load_balancer_arn",
"loadBalancerInfo": "load_balancer_info",
"loadBalancerName": "load_balancer_name",
"loadBalancerPort": "load_balancer_port",
"loadBalancerType": "load_balancer_type",
"loadBalancers": "load_balancers",
"loadBalancingAlgorithmType": "load_balancing_algorithm_type",
"localGatewayId": "local_gateway_id",
"localGatewayRouteTableId": "local_gateway_route_table_id",
"localGatewayVirtualInterfaceGroupId": "local_gateway_virtual_interface_group_id",
"localSecondaryIndexes": "local_secondary_indexes",
"locationArn": "location_arn",
"locationUri": "location_uri",
"lockToken": "lock_token",
"logConfig": "log_config",
"logDestination": "log_destination",
"logDestinationType": "log_destination_type",
"logFormat": "log_format",
"logGroup": "log_group",
"logGroupName": "log_group_name",
"logPaths": "log_paths",
"logPublishingOptions": "log_publishing_options",
"logUri": "log_uri",
"loggingConfig": "logging_config",
"loggingConfiguration": "logging_configuration",
"loggingInfo": "logging_info",
"loggingRole": "logging_role",
"logoutUrls": "logout_urls",
"logsConfig": "logs_config",
"lunNumber": "lun_number",
"macAddress": "mac_address",
"mailFromDomain": "mail_from_domain",
"mainRouteTableId": "main_route_table_id",
"maintenanceWindow": "maintenance_window",
"maintenanceWindowStartTime": "maintenance_window_start_time",
"majorEngineVersion": "major_engine_version",
"manageBerkshelf": "manage_berkshelf",
"manageBundler": "manage_bundler",
"manageEbsSnapshots": "manage_ebs_snapshots",
"managesVpcEndpoints": "manages_vpc_endpoints",
"mapPublicIpOnLaunch": "map_public_ip_on_launch",
"masterAccountArn": "master_account_arn",
"masterAccountEmail": "master_account_email",
"masterAccountId": "master_account_id",
"masterId": "master_id",
"masterInstanceGroup": "master_instance_group",
"masterInstanceType": "master_instance_type",
"masterPassword": "master_password",
"masterPublicDns": "master_public_dns",
"masterUsername": "master_username",
"matchCriterias": "match_criterias",
"matchingTypes": "matching_types",
"maxAggregationInterval": "max_aggregation_interval",
"maxAllocatedStorage": "max_allocated_storage",
"maxCapacity": "max_capacity",
"maxConcurrency": "max_concurrency",
"maxErrors": "max_errors",
"maxInstanceLifetime": "max_instance_lifetime",
"maxMessageSize": "max_message_size",
"maxPasswordAge": "max_password_age",
"maxRetries": "max_retries",
"maxSessionDuration": "max_session_duration",
"maxSize": "max_size",
"maximumBatchingWindowInSeconds": "maximum_batching_window_in_seconds",
"maximumEventAgeInSeconds": "maximum_event_age_in_seconds",
"maximumExecutionFrequency": "maximum_execution_frequency",
"maximumRecordAgeInSeconds": "maximum_record_age_in_seconds",
"maximumRetryAttempts": "maximum_retry_attempts",
"measureLatency": "measure_latency",
"mediaType": "media_type",
"mediumChangerType": "medium_changer_type",
"memberAccountId": "member_account_id",
"memberClusters": "member_clusters",
"memberStatus": "member_status",
"memorySize": "memory_size",
"meshName": "mesh_name",
"messageRetentionSeconds": "message_retention_seconds",
"messagesPerSecond": "messages_per_second",
"metadataOptions": "metadata_options",
"methodPath": "method_path",
"metricAggregationType": "metric_aggregation_type",
"metricGroups": "metric_groups",
"metricName": "metric_name",
"metricQueries": "metric_queries",
"metricTransformation": "metric_transformation",
"metricsGranularity": "metrics_granularity",
"mfaConfiguration": "mfa_configuration",
"migrationType": "migration_type",
"minAdjustmentMagnitude": "min_adjustment_magnitude",
"minCapacity": "min_capacity",
"minElbCapacity": "min_elb_capacity",
"minSize": "min_size",
"minimumCompressionSize": "minimum_compression_size",
"minimumHealthyHosts": "minimum_healthy_hosts",
"minimumPasswordLength": "minimum_password_length",
"mixedInstancesPolicy": "mixed_instances_policy",
"modelSelectionExpression": "model_selection_expression",
"mongodbSettings": "mongodb_settings",
"monitoringInterval": "monitoring_interval",
"monitoringRoleArn": "monitoring_role_arn",
"monthlySpendLimit": "monthly_spend_limit",
"mountOptions": "mount_options",
"mountTargetDnsName": "mount_target_dns_name",
"multiAttachEnabled": "multi_attach_enabled",
"multiAz": "multi_az",
"multivalueAnswerRoutingPolicy": "multivalue_answer_routing_policy",
"namePrefix": "name_prefix",
"nameServers": "name_servers",
"namespaceId": "namespace_id",
"natGatewayId": "nat_gateway_id",
"neptuneClusterParameterGroupName": "neptune_cluster_parameter_group_name",
"neptuneParameterGroupName": "neptune_parameter_group_name",
"neptuneSubnetGroupName": "neptune_subnet_group_name",
"netbiosNameServers": "netbios_name_servers",
"netbiosNodeType": "netbios_node_type",
"networkAclId": "network_acl_id",
"networkConfiguration": "network_configuration",
"networkInterface": "network_interface",
"networkInterfaceId": "network_interface_id",
"networkInterfaceIds": "network_interface_ids",
"networkInterfacePort": "network_interface_port",
"networkInterfaces": "network_interfaces",
"networkLoadBalancerArn": "network_load_balancer_arn",
"networkLoadBalancerArns": "network_load_balancer_arns",
"networkMode": "network_mode",
"networkOrigin": "network_origin",
"networkServices": "network_services",
"newGameSessionProtectionPolicy": "new_game_session_protection_policy",
"nfsFileShareDefaults": "nfs_file_share_defaults",
"nodeGroupName": "node_group_name",
"nodeRoleArn": "node_role_arn",
"nodeToNodeEncryption": "node_to_node_encryption",
"nodeType": "node_type",
"nodejsVersion": "nodejs_version",
"nonMasterAccounts": "non_master_accounts",
"notAfter": "not_after",
"notBefore": "not_before",
"notificationArns": "notification_arns",
"notificationMetadata": "notification_metadata",
"notificationProperty": "notification_property",
"notificationTargetArn": "notification_target_arn",
"notificationTopicArn": "notification_topic_arn",
"notificationType": "notification_type",
"ntpServers": "ntp_servers",
"numCacheNodes": "num_cache_nodes",
"numberCacheClusters": "number_cache_clusters",
"numberOfBrokerNodes": "number_of_broker_nodes",
"numberOfNodes": "number_of_nodes",
"numberOfWorkers": "number_of_workers",
"objectAcl": "object_acl",
"objectLockConfiguration": "object_lock_configuration",
"objectLockLegalHoldStatus": "object_lock_legal_hold_status",
"objectLockMode": "object_lock_mode",
"objectLockRetainUntilDate": "object_lock_retain_until_date",
"okActions": "ok_actions",
"onCreate": "on_create",
"onDemandOptions": "on_demand_options",
"onFailure": "on_failure",
"onPremConfig": "on_prem_config",
"onPremisesInstanceTagFilters": "on_premises_instance_tag_filters",
"onStart": "on_start",
"openMonitoring": "open_monitoring",
"openidConnectConfig": "openid_connect_config",
"openidConnectProviderArns": "openid_connect_provider_arns",
"operatingSystem": "operating_system",
"operationName": "operation_name",
"optInStatus": "opt_in_status",
"optimizeForEndUserLocation": "optimize_for_end_user_location",
"optionGroupDescription": "option_group_description",
"optionGroupName": "option_group_name",
"optionalFields": "optional_fields",
"orderedCacheBehaviors": "ordered_cache_behaviors",
"orderedPlacementStrategies": "ordered_placement_strategies",
"organizationAggregationSource": "organization_aggregation_source",
"originGroups": "origin_groups",
"originalRouteTableId": "original_route_table_id",
"outpostArn": "outpost_arn",
"outputBucket": "output_bucket",
"outputLocation": "output_location",
"ownerAccount": "owner_account",
"ownerAccountId": "owner_account_id",
"ownerAlias": "owner_alias",
"ownerArn": "owner_arn",
"ownerId": "owner_id",
"ownerInformation": "owner_information",
"packetLength": "packet_length",
"parallelizationFactor": "parallelization_factor",
"parameterGroupName": "parameter_group_name",
"parameterOverrides": "parameter_overrides",
"parentId": "parent_id",
"partitionKeys": "partition_keys",
"passengerVersion": "passenger_version",
"passthroughBehavior": "passthrough_behavior",
"passwordData": "password_data",
"passwordLength": "password_length",
"passwordPolicy": "password_policy",
"passwordResetRequired": "password_reset_required",
"passwordReusePrevention": "password_reuse_prevention",
"patchGroup": "patch_group",
"pathPart": "path_part",
"payloadFormatVersion": "payload_format_version",
"payloadUrl": "payload_url",
"peerAccountId": "peer_account_id",
"peerOwnerId": "peer_owner_id",
"peerRegion": "peer_region",
"peerTransitGatewayId": "peer_transit_gateway_id",
"peerVpcId": "peer_vpc_id",
"pemEncodedCertificate": "pem_encoded_certificate",
"performanceInsightsEnabled": "performance_insights_enabled",
"performanceInsightsKmsKeyId": "performance_insights_kms_key_id",
"performanceInsightsRetentionPeriod": "performance_insights_retention_period",
"performanceMode": "performance_mode",
"permanentDeletionTimeInDays": "permanent_deletion_time_in_days",
"permissionsBoundary": "permissions_boundary",
"pgpKey": "pgp_key",
"physicalConnectionRequirements": "physical_connection_requirements",
"pidMode": "pid_mode",
"pipelineConfig": "pipeline_config",
"placementConstraints": "placement_constraints",
"placementGroup": "placement_group",
"placementGroupId": "placement_group_id",
"placementTenancy": "placement_tenancy",
"planId": "plan_id",
"platformArn": "platform_arn",
"platformCredential": "platform_credential",
"platformPrincipal": "platform_principal",
"platformTypes": "platform_types",
"platformVersion": "platform_version",
"playerLatencyPolicies": "player_latency_policies",
"podExecutionRoleArn": "pod_execution_role_arn",
"pointInTimeRecovery": "point_in_time_recovery",
"policyArn": "policy_arn",
"policyAttributes": "policy_attributes",
"policyBody": "policy_body",
"policyDetails": "policy_details",
"policyDocument": "policy_document",
"policyId": "policy_id",
"policyName": "policy_name",
"policyNames": "policy_names",
"policyType": "policy_type",
"policyTypeName": "policy_type_name",
"policyUrl": "policy_url",
"pollInterval": "poll_interval",
"portRanges": "port_ranges",
"posixUser": "posix_user",
"preferredAvailabilityZones": "preferred_availability_zones",
"preferredBackupWindow": "preferred_backup_window",
"preferredMaintenanceWindow": "preferred_maintenance_window",
"prefixListId": "prefix_list_id",
"prefixListIds": "prefix_list_ids",
"preventUserExistenceErrors": "prevent_user_existence_errors",
"priceClass": "price_class",
"pricingPlan": "pricing_plan",
"primaryContainer": "primary_container",
"primaryEndpointAddress": "primary_endpoint_address",
"primaryNetworkInterfaceId": "primary_network_interface_id",
"principalArn": "principal_arn",
"privateDns": "private_dns",
"privateDnsEnabled": "private_dns_enabled",
"privateDnsName": "private_dns_name",
"privateIp": "private_ip",
"privateIpAddress": "private_ip_address",
"privateIps": "private_ips",
"privateIpsCount": "private_ips_count",
"privateKey": "private_key",
"productArn": "product_arn",
"productCode": "product_code",
"productionVariants": "production_variants",
"projectName": "project_name",
"promotionTier": "promotion_tier",
"promotionalMessagesPerSecond": "promotional_messages_per_second",
"propagateTags": "propagate_tags",
"propagatingVgws": "propagating_vgws",
"propagationDefaultRouteTableId": "propagation_default_route_table_id",
"proposalId": "proposal_id",
"protectFromScaleIn": "protect_from_scale_in",
"protocolType": "protocol_type",
"providerArns": "provider_arns",
"providerDetails": "provider_details",
"providerName": "provider_name",
"providerType": "provider_type",
"provisionedConcurrentExecutions": "provisioned_concurrent_executions",
"provisionedThroughputInMibps": "provisioned_throughput_in_mibps",
"proxyConfiguration": "proxy_configuration",
"proxyProtocolV2": "proxy_protocol_v2",
"publicAccessBlockConfiguration": "public_access_block_configuration",
"publicDns": "public_dns",
"publicIp": "public_ip",
"publicIpAddress": "public_ip_address",
"publicIpv4Pool": "public_ipv4_pool",
"publicKey": "public_key",
"publiclyAccessible": "publicly_accessible",
"qualifiedArn": "qualified_arn",
"queueUrl": "queue_url",
"queuedTimeout": "queued_timeout",
"quietTime": "quiet_time",
"quotaCode": "quota_code",
"quotaName": "quota_name",
"quotaSettings": "quota_settings",
"railsEnv": "rails_env",
"ramDiskId": "ram_disk_id",
"ramSize": "ram_size",
"ramdiskId": "ramdisk_id",
"rangeKey": "range_key",
"rateKey": "rate_key",
"rateLimit": "rate_limit",
"rawMessageDelivery": "raw_message_delivery",
"rdsDbInstanceArn": "rds_db_instance_arn",
"readAttributes": "read_attributes",
"readCapacity": "read_capacity",
"readOnly": "read_only",
"readerEndpoint": "reader_endpoint",
"receiveWaitTimeSeconds": "receive_wait_time_seconds",
"receiverAccountId": "receiver_account_id",
"recordingGroup": "recording_group",
"recoveryPoints": "recovery_points",
"recoveryWindowInDays": "recovery_window_in_days",
"redrivePolicy": "redrive_policy",
"redshiftConfiguration": "redshift_configuration",
"referenceDataSources": "reference_data_sources",
"referenceName": "reference_name",
"refreshTokenValidity": "refresh_token_validity",
"regexMatchTuples": "regex_match_tuples",
"regexPatternStrings": "regex_pattern_strings",
"regionalCertificateArn": "regional_certificate_arn",
"regionalCertificateName": "regional_certificate_name",
"regionalDomainName": "regional_domain_name",
"regionalZoneId": "regional_zone_id",
"registeredBy": "registered_by",
"registrationCode": "registration_code",
"registrationCount": "registration_count",
"registrationLimit": "registration_limit",
"registryId": "registry_id",
"regularExpressions": "regular_expressions",
"rejectedPatches": "rejected_patches",
"relationshipStatus": "relationship_status",
"releaseLabel": "release_label",
"releaseVersion": "release_version",
"remoteAccess": "remote_access",
"remoteDomainName": "remote_domain_name",
"replaceUnhealthyInstances": "replace_unhealthy_instances",
"replicateSourceDb": "replicate_source_db",
"replicationConfiguration": "replication_configuration",
"replicationFactor": "replication_factor",
"replicationGroupDescription": "replication_group_description",
"replicationGroupId": "replication_group_id",
"replicationInstanceArn": "replication_instance_arn",
"replicationInstanceClass": "replication_instance_class",
"replicationInstanceId": "replication_instance_id",
"replicationInstancePrivateIps": "replication_instance_private_ips",
"replicationInstancePublicIps": "replication_instance_public_ips",
"replicationSourceIdentifier": "replication_source_identifier",
"replicationSubnetGroupArn": "replication_subnet_group_arn",
"replicationSubnetGroupDescription": "replication_subnet_group_description",
"replicationSubnetGroupId": "replication_subnet_group_id",
"replicationTaskArn": "replication_task_arn",
"replicationTaskId": "replication_task_id",
"replicationTaskSettings": "replication_task_settings",
"reportName": "report_name",
"reportedAgentVersion": "reported_agent_version",
"reportedOsFamily": "reported_os_family",
"reportedOsName": "reported_os_name",
"reportedOsVersion": "reported_os_version",
"repositoryId": "repository_id",
"repositoryName": "repository_name",
"repositoryUrl": "repository_url",
"requestId": "request_id",
"requestInterval": "request_interval",
"requestMappingTemplate": "request_mapping_template",
"requestModels": "request_models",
"requestParameters": "request_parameters",
"requestPayer": "request_payer",
"requestStatus": "request_status",
"requestTemplate": "request_template",
"requestTemplates": "request_templates",
"requestValidatorId": "request_validator_id",
"requesterManaged": "requester_managed",
"requesterPays": "requester_pays",
"requireLowercaseCharacters": "require_lowercase_characters",
"requireNumbers": "require_numbers",
"requireSymbols": "require_symbols",
"requireUppercaseCharacters": "require_uppercase_characters",
"requiresCompatibilities": "requires_compatibilities",
"reservationPlanSettings": "reservation_plan_settings",
"reservedConcurrentExecutions": "reserved_concurrent_executions",
"reservoirSize": "reservoir_size",
"resolverEndpointId": "resolver_endpoint_id",
"resolverRuleId": "resolver_rule_id",
"resourceArn": "resource_arn",
"resourceCreationLimitPolicy": "resource_creation_limit_policy",
"resourceGroupArn": "resource_group_arn",
"resourceId": "resource_id",
"resourceIdScope": "resource_id_scope",
"resourcePath": "resource_path",
"resourceQuery": "resource_query",
"resourceShareArn": "resource_share_arn",
"resourceType": "resource_type",
"resourceTypesScopes": "resource_types_scopes",
"responseMappingTemplate": "response_mapping_template",
"responseModels": "response_models",
"responseParameters": "response_parameters",
"responseTemplate": "response_template",
"responseTemplates": "response_templates",
"responseType": "response_type",
"restApi": "rest_api",
"restApiId": "rest_api_id",
"restrictPublicBuckets": "restrict_public_buckets",
"retainOnDelete": "retain_on_delete",
"retainStack": "retain_stack",
"retentionInDays": "retention_in_days",
"retentionPeriod": "retention_period",
"retireOnDelete": "retire_on_delete",
"retiringPrincipal": "retiring_principal",
"retryStrategy": "retry_strategy",
"revocationConfiguration": "revocation_configuration",
"revokeRulesOnDelete": "revoke_rules_on_delete",
"roleArn": "role_arn",
"roleMappings": "role_mappings",
"roleName": "role_name",
"rootBlockDevice": "root_block_device",
"rootBlockDevices": "root_block_devices",
"rootDeviceName": "root_device_name",
"rootDeviceType": "root_device_type",
"rootDeviceVolumeId": "root_device_volume_id",
"rootDirectory": "root_directory",
"rootPassword": "root_password",
"rootPasswordOnAllInstances": "root_password_on_all_instances",
"rootResourceId": "root_resource_id",
"rootSnapshotId": "root_snapshot_id",
"rootVolumeEncryptionEnabled": "root_volume_encryption_enabled",
"rotationEnabled": "rotation_enabled",
"rotationLambdaArn": "rotation_lambda_arn",
"rotationRules": "rotation_rules",
"routeFilterPrefixes": "route_filter_prefixes",
"routeId": "route_id",
"routeKey": "route_key",
"routeResponseKey": "route_response_key",
"routeResponseSelectionExpression": "route_response_selection_expression",
"routeSelectionExpression": "route_selection_expression",
"routeSettings": "route_settings",
"routeTableId": "route_table_id",
"routeTableIds": "route_table_ids",
"routingConfig": "routing_config",
"routingStrategy": "routing_strategy",
"rubyVersion": "ruby_version",
"rubygemsVersion": "rubygems_version",
"ruleAction": "rule_action",
"ruleId": "rule_id",
"ruleIdentifier": "rule_identifier",
"ruleName": "rule_name",
"ruleNumber": "rule_number",
"ruleSetName": "rule_set_name",
"ruleType": "rule_type",
"rulesPackageArns": "rules_package_arns",
"runCommandTargets": "run_command_targets",
"runningInstanceCount": "running_instance_count",
"runtimeConfiguration": "runtime_configuration",
"s3Actions": "s3_actions",
"s3Bucket": "s3_bucket",
"s3BucketArn": "s3_bucket_arn",
"s3BucketName": "s3_bucket_name",
"s3CanonicalUserId": "s3_canonical_user_id",
"s3Config": "s3_config",
"s3Configuration": "s3_configuration",
"s3Destination": "s3_destination",
"s3Import": "s3_import",
"s3Key": "s3_key",
"s3KeyPrefix": "s3_key_prefix",
"s3ObjectVersion": "s3_object_version",
"s3Prefix": "s3_prefix",
"s3Region": "s3_region",
"s3Settings": "s3_settings",
"s3Targets": "s3_targets",
"samlMetadataDocument": "saml_metadata_document",
"samlProviderArns": "saml_provider_arns",
"scalableDimension": "scalable_dimension",
"scalableTargetAction": "scalable_target_action",
"scaleDownBehavior": "scale_down_behavior",
"scalingAdjustment": "scaling_adjustment",
"scalingConfig": "scaling_config",
"scalingConfiguration": "scaling_configuration",
"scanEnabled": "scan_enabled",
"scheduleExpression": "schedule_expression",
"scheduleIdentifier": "schedule_identifier",
"scheduleTimezone": "schedule_timezone",
"scheduledActionName": "scheduled_action_name",
"schedulingStrategy": "scheduling_strategy",
"schemaChangePolicy": "schema_change_policy",
"schemaVersion": "schema_version",
"scopeIdentifiers": "scope_identifiers",
"searchString": "search_string",
"secondaryArtifacts": "secondary_artifacts",
"secondarySources": "secondary_sources",
"secretBinary": "secret_binary",
"secretId": "secret_id",
"secretKey": "secret_key",
"secretString": "secret_string",
"securityConfiguration": "security_configuration",
"securityGroupId": "security_group_id",
"securityGroupIds": "security_group_ids",
"securityGroupNames": "security_group_names",
"securityGroups": "security_groups",
"securityPolicy": "security_policy",
"selectionPattern": "selection_pattern",
"selectionTags": "selection_tags",
"selfManagedActiveDirectory": "self_managed_active_directory",
"selfServicePermissions": "self_service_permissions",
"senderAccountId": "sender_account_id",
"senderId": "sender_id",
"serverCertificateArn": "server_certificate_arn",
"serverHostname": "server_hostname",
"serverId": "server_id",
"serverName": "server_name",
"serverProperties": "server_properties",
"serverSideEncryption": "server_side_encryption",
"serverSideEncryptionConfiguration": "server_side_encryption_configuration",
"serverType": "server_type",
"serviceAccessRole": "service_access_role",
"serviceCode": "service_code",
"serviceLinkedRoleArn": "service_linked_role_arn",
"serviceName": "service_name",
"serviceNamespace": "service_namespace",
"serviceRegistries": "service_registries",
"serviceRole": "service_role",
"serviceRoleArn": "service_role_arn",
"serviceType": "service_type",
"sesSmtpPassword": "ses_smtp_password",
"sesSmtpPasswordV4": "ses_smtp_password_v4",
"sessionName": "session_name",
"sessionNumber": "session_number",
"setIdentifier": "set_identifier",
"shardCount": "shard_count",
"shardLevelMetrics": "shard_level_metrics",
"shareArn": "share_arn",
"shareId": "share_id",
"shareName": "share_name",
"shareStatus": "share_status",
"shortCode": "short_code",
"shortName": "short_name",
"sizeConstraints": "size_constraints",
"skipDestroy": "skip_destroy",
"skipFinalBackup": "skip_final_backup",
"skipFinalSnapshot": "skip_final_snapshot",
"slowStart": "slow_start",
"smbActiveDirectorySettings": "smb_active_directory_settings",
"smbGuestPassword": "smb_guest_password",
"smsAuthenticationMessage": "sms_authentication_message",
"smsConfiguration": "sms_configuration",
"smsVerificationMessage": "sms_verification_message",
"snapshotArns": "snapshot_arns",
"snapshotClusterIdentifier": "snapshot_cluster_identifier",
"snapshotCopy": "snapshot_copy",
"snapshotCopyGrantName": "snapshot_copy_grant_name",
"snapshotDeliveryProperties": "snapshot_delivery_properties",
"snapshotId": "snapshot_id",
"snapshotIdentifier": "snapshot_identifier",
"snapshotName": "snapshot_name",
"snapshotOptions": "snapshot_options",
"snapshotRetentionLimit": "snapshot_retention_limit",
"snapshotType": "snapshot_type",
"snapshotWindow": "snapshot_window",
"snapshotWithoutReboot": "snapshot_without_reboot",
"snsActions": "sns_actions",
"snsDestination": "sns_destination",
"snsTopic": "sns_topic",
"snsTopicArn": "sns_topic_arn",
"snsTopicName": "sns_topic_name",
"softwareTokenMfaConfiguration": "software_token_mfa_configuration",
"solutionStackName": "solution_stack_name",
"sourceAccount": "source_account",
"sourceAmiId": "source_ami_id",
"sourceAmiRegion": "source_ami_region",
"sourceArn": "source_arn",
"sourceBackupIdentifier": "source_backup_identifier",
"sourceCidrBlock": "source_cidr_block",
"sourceCodeHash": "source_code_hash",
"sourceCodeSize": "source_code_size",
"sourceDbClusterSnapshotArn": "source_db_cluster_snapshot_arn",
"sourceDbSnapshotIdentifier": "source_db_snapshot_identifier",
"sourceDestCheck": "source_dest_check",
"sourceEndpointArn": "source_endpoint_arn",
"sourceIds": "source_ids",
"sourceInstanceId": "source_instance_id",
"sourceLocationArn": "source_location_arn",
"sourcePortRange": "source_port_range",
"sourceRegion": "source_region",
"sourceSecurityGroup": "source_security_group",
"sourceSecurityGroupId": "source_security_group_id",
"sourceSnapshotId": "source_snapshot_id",
"sourceType": "source_type",
"sourceVersion": "source_version",
"sourceVolumeArn": "source_volume_arn",
"splitTunnel": "split_tunnel",
"splunkConfiguration": "splunk_configuration",
"spotBidStatus": "spot_bid_status",
"spotInstanceId": "spot_instance_id",
"spotOptions": "spot_options",
"spotPrice": "spot_price",
"spotRequestState": "spot_request_state",
"spotType": "spot_type",
"sqlInjectionMatchTuples": "sql_injection_match_tuples",
"sqlVersion": "sql_version",
"sqsFailureFeedbackRoleArn": "sqs_failure_feedback_role_arn",
"sqsSuccessFeedbackRoleArn": "sqs_success_feedback_role_arn",
"sqsSuccessFeedbackSampleRate": "sqs_success_feedback_sample_rate",
"sqsTarget": "sqs_target",
"sriovNetSupport": "sriov_net_support",
"sshHostDsaKeyFingerprint": "ssh_host_dsa_key_fingerprint",
"sshHostRsaKeyFingerprint": "ssh_host_rsa_key_fingerprint",
"sshKeyName": "ssh_key_name",
"sshPublicKey": "ssh_public_key",
"sshPublicKeyId": "ssh_public_key_id",
"sshUsername": "ssh_username",
"sslConfigurations": "ssl_configurations",
"sslMode": "ssl_mode",
"sslPolicy": "ssl_policy",
"stackEndpoint": "stack_endpoint",
"stackId": "stack_id",
"stackSetId": "stack_set_id",
"stackSetName": "stack_set_name",
"stageDescription": "stage_description",
"stageName": "stage_name",
"stageVariables": "stage_variables",
"standardsArn": "standards_arn",
"startDate": "start_date",
"startTime": "start_time",
"startingPosition": "starting_position",
"startingPositionTimestamp": "starting_position_timestamp",
"stateTransitionReason": "state_transition_reason",
"statementId": "statement_id",
"statementIdPrefix": "statement_id_prefix",
"staticIpName": "static_ip_name",
"staticMembers": "static_members",
"staticRoutesOnly": "static_routes_only",
"statsEnabled": "stats_enabled",
"statsPassword": "stats_password",
"statsUrl": "stats_url",
"statsUser": "stats_user",
"statusCode": "status_code",
"statusReason": "status_reason",
"stepAdjustments": "step_adjustments",
"stepConcurrencyLevel": "step_concurrency_level",
"stepFunctions": "step_functions",
"stepScalingPolicyConfiguration": "step_scaling_policy_configuration",
"stopActions": "stop_actions",
"storageCapacity": "storage_capacity",
"storageClass": "storage_class",
"storageClassAnalysis": "storage_class_analysis",
"storageDescriptor": "storage_descriptor",
"storageEncrypted": "storage_encrypted",
"storageLocation": "storage_location",
"storageType": "storage_type",
"streamArn": "stream_arn",
"streamEnabled": "stream_enabled",
"streamLabel": "stream_label",
"streamViewType": "stream_view_type",
"subjectAlternativeNames": "subject_alternative_names",
"subnetGroupName": "subnet_group_name",
"subnetId": "subnet_id",
"subnetIds": "subnet_ids",
"subnetMappings": "subnet_mappings",
"successFeedbackRoleArn": "success_feedback_role_arn",
"successFeedbackSampleRate": "success_feedback_sample_rate",
"supportCode": "support_code",
"supportedIdentityProviders": "supported_identity_providers",
"supportedLoginProviders": "supported_login_providers",
"suspendedProcesses": "suspended_processes",
"systemPackages": "system_packages",
"tableMappings": "table_mappings",
"tableName": "table_name",
"tablePrefix": "table_prefix",
"tableType": "table_type",
"tagKeyScope": "tag_key_scope",
"tagSpecifications": "tag_specifications",
"tagValueScope": "tag_value_scope",
"tagsCollection": "tags_collection",
"tapeDriveType": "tape_drive_type",
"targetAction": "target_action",
"targetArn": "target_arn",
"targetCapacity": "target_capacity",
"targetCapacitySpecification": "target_capacity_specification",
"targetEndpointArn": "target_endpoint_arn",
"targetGroupArn": "target_group_arn",
"targetGroupArns": "target_group_arns",
"targetId": "target_id",
"targetIps": "target_ips",
"targetKeyArn": "target_key_arn",
"targetKeyId": "target_key_id",
"targetName": "target_name",
"targetPipeline": "target_pipeline",
"targetTrackingConfiguration": "target_tracking_configuration",
"targetTrackingScalingPolicyConfiguration": "target_tracking_scaling_policy_configuration",
"targetType": "target_type",
"taskArn": "task_arn",
"taskDefinition": "task_definition",
"taskInvocationParameters": "task_invocation_parameters",
"taskParameters": "task_parameters",
"taskRoleArn": "task_role_arn",
"taskType": "task_type",
"teamId": "team_id",
"templateBody": "template_body",
"templateName": "template_name",
"templateSelectionExpression": "template_selection_expression",
"templateUrl": "template_url",
"terminateInstances": "terminate_instances",
"terminateInstancesWithExpiration": "terminate_instances_with_expiration",
"terminationPolicies": "termination_policies",
"terminationProtection": "termination_protection",
"thingTypeName": "thing_type_name",
"thresholdCount": "threshold_count",
"thresholdMetricId": "threshold_metric_id",
"throttleSettings": "throttle_settings",
"throughputCapacity": "throughput_capacity",
"throughputMode": "throughput_mode",
"thumbnailConfig": "thumbnail_config",
"thumbnailConfigPermissions": "thumbnail_config_permissions",
"thumbprintLists": "thumbprint_lists",
"timePeriodEnd": "time_period_end",
"timePeriodStart": "time_period_start",
"timeUnit": "time_unit",
"timeoutInMinutes": "timeout_in_minutes",
"timeoutInSeconds": "timeout_in_seconds",
"timeoutMilliseconds": "timeout_milliseconds",
"tlsPolicy": "tls_policy",
"toPort": "to_port",
"tokenKey": "token_key",
"tokenKeyId": "token_key_id",
"topicArn": "topic_arn",
"tracingConfig": "tracing_config",
"trafficDialPercentage": "traffic_dial_percentage",
"trafficDirection": "traffic_direction",
"trafficMirrorFilterId": "traffic_mirror_filter_id",
"trafficMirrorTargetId": "traffic_mirror_target_id",
"trafficRoutingConfig": "traffic_routing_config",
"trafficType": "traffic_type",
"transactionalMessagesPerSecond": "transactional_messages_per_second",
"transitEncryptionEnabled": "transit_encryption_enabled",
"transitGatewayAttachmentId": "transit_gateway_attachment_id",
"transitGatewayDefaultRouteTableAssociation": "transit_gateway_default_route_table_association",
"transitGatewayDefaultRouteTablePropagation": "transit_gateway_default_route_table_propagation",
"transitGatewayId": "transit_gateway_id",
"transitGatewayRouteTableId": "transit_gateway_route_table_id",
"transportProtocol": "transport_protocol",
"treatMissingData": "treat_missing_data",
"triggerConfigurations": "trigger_configurations",
"triggerTypes": "trigger_types",
"tunnel1Address": "tunnel1_address",
"tunnel1BgpAsn": "tunnel1_bgp_asn",
"tunnel1BgpHoldtime": "tunnel1_bgp_holdtime",
"tunnel1CgwInsideAddress": "tunnel1_cgw_inside_address",
"tunnel1InsideCidr": "tunnel1_inside_cidr",
"tunnel1PresharedKey": "tunnel1_preshared_key",
"tunnel1VgwInsideAddress": "tunnel1_vgw_inside_address",
"tunnel2Address": "tunnel2_address",
"tunnel2BgpAsn": "tunnel2_bgp_asn",
"tunnel2BgpHoldtime": "tunnel2_bgp_holdtime",
"tunnel2CgwInsideAddress": "tunnel2_cgw_inside_address",
"tunnel2InsideCidr": "tunnel2_inside_cidr",
"tunnel2PresharedKey": "tunnel2_preshared_key",
"tunnel2VgwInsideAddress": "tunnel2_vgw_inside_address",
"uniqueId": "unique_id",
"urlPath": "url_path",
"usagePlanId": "usage_plan_id",
"usageReportS3Bucket": "usage_report_s3_bucket",
"useCustomCookbooks": "use_custom_cookbooks",
"useEbsOptimizedInstances": "use_ebs_optimized_instances",
"useOpsworksSecurityGroups": "use_opsworks_security_groups",
"userArn": "user_arn",
"userData": "user_data",
"userDataBase64": "user_data_base64",
"userName": "user_name",
"userPoolAddOns": "user_pool_add_ons",
"userPoolConfig": "user_pool_config",
"userPoolId": "user_pool_id",
"userRole": "user_role",
"userVolumeEncryptionEnabled": "user_volume_encryption_enabled",
"usernameAttributes": "username_attributes",
"usernameConfiguration": "username_configuration",
"validFrom": "valid_from",
"validTo": "valid_to",
"validUntil": "valid_until",
"validUserLists": "valid_user_lists",
"validateRequestBody": "validate_request_body",
"validateRequestParameters": "validate_request_parameters",
"validationEmails": "validation_emails",
"validationMethod": "validation_method",
"validationRecordFqdns": "validation_record_fqdns",
"vaultName": "vault_name",
"verificationMessageTemplate": "verification_message_template",
"verificationToken": "verification_token",
"versionId": "version_id",
"versionStages": "version_stages",
"vgwTelemetries": "vgw_telemetries",
"videoCodecOptions": "video_codec_options",
"videoWatermarks": "video_watermarks",
"viewExpandedText": "view_expanded_text",
"viewOriginalText": "view_original_text",
"viewerCertificate": "viewer_certificate",
"virtualInterfaceId": "virtual_interface_id",
"virtualNetworkId": "virtual_network_id",
"virtualRouterName": "virtual_router_name",
"virtualizationType": "virtualization_type",
"visibilityTimeoutSeconds": "visibility_timeout_seconds",
"visibleToAllUsers": "visible_to_all_users",
"volumeArn": "volume_arn",
"volumeEncryptionKey": "volume_encryption_key",
"volumeId": "volume_id",
"volumeSize": "volume_size",
"volumeSizeInBytes": "volume_size_in_bytes",
"volumeTags": "volume_tags",
"vpcClassicLinkId": "vpc_classic_link_id",
"vpcClassicLinkSecurityGroups": "vpc_classic_link_security_groups",
"vpcConfig": "vpc_config",
"vpcConfiguration": "vpc_configuration",
"vpcEndpointId": "vpc_endpoint_id",
"vpcEndpointServiceId": "vpc_endpoint_service_id",
"vpcEndpointType": "vpc_endpoint_type",
"vpcId": "vpc_id",
"vpcOptions": "vpc_options",
"vpcOwnerId": "vpc_owner_id",
"vpcPeeringConnectionId": "vpc_peering_connection_id",
"vpcRegion": "vpc_region",
"vpcSecurityGroupIds": "vpc_security_group_ids",
"vpcSettings": "vpc_settings",
"vpcZoneIdentifiers": "vpc_zone_identifiers",
"vpnConnectionId": "vpn_connection_id",
"vpnEcmpSupport": "vpn_ecmp_support",
"vpnGatewayId": "vpn_gateway_id",
"waitForCapacityTimeout": "wait_for_capacity_timeout",
"waitForDeployment": "wait_for_deployment",
"waitForElbCapacity": "wait_for_elb_capacity",
"waitForFulfillment": "wait_for_fulfillment",
"waitForReadyTimeout": "wait_for_ready_timeout",
"waitForSteadyState": "wait_for_steady_state",
"webAclArn": "web_acl_arn",
"webAclId": "web_acl_id",
"websiteCaId": "website_ca_id",
"websiteDomain": "website_domain",
"websiteEndpoint": "website_endpoint",
"websiteRedirect": "website_redirect",
"weeklyMaintenanceStartTime": "weekly_maintenance_start_time",
"weightedRoutingPolicies": "weighted_routing_policies",
"windowId": "window_id",
"workerType": "worker_type",
"workflowExecutionRetentionPeriodInDays": "workflow_execution_retention_period_in_days",
"workflowName": "workflow_name",
"workmailActions": "workmail_actions",
"workspaceProperties": "workspace_properties",
"workspaceSecurityGroupId": "workspace_security_group_id",
"writeAttributes": "write_attributes",
"writeCapacity": "write_capacity",
"xmlClassifier": "xml_classifier",
"xrayEnabled": "xray_enabled",
"xrayTracingEnabled": "xray_tracing_enabled",
"xssMatchTuples": "xss_match_tuples",
"zoneId": "zone_id",
"zookeeperConnectString": "zookeeper_connect_string",
}
|
N, *S = open(0).read().split()
t = 1
f = 1
for s in S:
if s == 'AND':
f = t + f * 2
elif s == 'OR':
t = t * 2 + f
print(t)
|
# %% [1221. Split a String in Balanced Strings](https://leetcode.com/problems/split-a-string-in-balanced-strings/)
class Solution:
def balancedStringSplit(self, s: str) -> int:
res = cnt = 0
for c in s:
cnt += (c == "L") * 2 - 1
res += not cnt
return res
|
words = ['cat', 'window', "defenestrate"]
for w in words :
print(w, len(w))
users = ['A', "B", "C"]
for i in users :
print(i)
for i in range(5):
print(i)
|
COOK_LABEL_LIST = [
"Cook",
]
MOVIE_LABEL_LIST = [
"Movie",
]
READ_LABEL_LIST = [
"Read",
]
DRAMA_LABEL_LIST = [
"Drama",
]
PUSHUP_LABEL_LIST = [
"PushUps",
]
BANGUMI_LABEL_LIST = [
"Bangumi",
]
GAME_LABEL_LIST = [
"Game",
]
MONEY_LABEL_LIST = [
"Money",
]
MEDITATION_LABEL_LIST = [
"Meditation",
]
MORNING_LABEL_LIST = [
"Morning",
]
RIDE_LABEL_LIST = [
"Ride",
]
# MY_BLOG_REPO = ""
GITHUB_README_COMMENTS = (
"(<!--START_SECTION:{name}-->\n)(.*)(<!--END_SECTION:{name}-->\n)"
)
# add new label here
LABEL_DICT = {
"Cook": {"label_list": COOK_LABEL_LIST, "comment_name": "my_cook"},
"Movie": {"label_list": MOVIE_LABEL_LIST, "comment_name": "my_movie"},
"Read": {"label_list": READ_LABEL_LIST, "comment_name": "my_read"},
"Drama": {"label_list": DRAMA_LABEL_LIST, "comment_name": "my_drama"},
"Bangumi": {"label_list": BANGUMI_LABEL_LIST, "comment_name": "my_bangumi"},
"Game": {"label_list": GAME_LABEL_LIST, "comment_name": "my_game"},
"Ride": {"label_list": RIDE_LABEL_LIST, "comment_name": "my_ride"},
}
##### COMMENTS DAILY ######
LABEL_DAILY_DICT = {
# label, map_func, reduce_func
"俯卧撑": [PUSHUP_LABEL_LIST, int, sum],
"花费": [MONEY_LABEL_LIST, float, sum],
"冥想": [MEDITATION_LABEL_LIST, int, sum],
"骑行": [RIDE_LABEL_LIST, float, sum],
"早起": [MORNING_LABEL_LIST, len, len], # Do Nothing
}
##### SHANBAY ######
MY_SHANBAY_USER_NAME = "mq0707"
SHANBAY_CALENDAR_API = "https://apiv3.shanbay.com/uc/checkin/calendar/dates/?user_id={user_name}&start_date={start_date}&end_date={end_date}"
MY_SHANBAY_URL = f"https://web.shanbay.com/web/users/{MY_SHANBAY_USER_NAME}/zone"
##### DUO ######
MY_DUOLINGO_URL = "https://www.duolingo.com/profile/MQU3K9"
##### FOOD ######
MY_FOOD_STAT_HEAD = (
"| Name | First_date | Last_date | Times | \n | ---- | ---- | ---- | ---- |\n"
)
MY_FOOD_STAT_TEMPLATE = "| {name} | {first_date} | {last_date} | {times} |\n"
|
lista_de_compras = ["gabinete cooler master", "placa devídeo GeForce RTX 2080Ti"]
print(lista_de_compras)
lista_de_compras.remove("gabinete cooler master")
lista_de_compras.remove("placa devídeo GeForce RTX 2080Ti")
print(lista_de_compras)
|
"""
You can use this file as a template to store your api credentials. Just copy (or
rename) this file to `api_credentials.py` and fill in your key and secret.
`api_credentials.py` is in this repository's `.gitignore` file.
"""
PAYONEER_ESCROW_API_KEY = 'ENTER_YOUR_API_KEY_HERE'
PAYONEER_ESCROW_SECRET = 'ENTER_YOUR_API_SECRET_HERE'
|
#Kunal Gautam
#Codewars : @Kunalpod
#Problem name: Valid Braces
#Problem level: 4 kyu
valid = {'(': ')', '[': ']', '{': '}'}
def validBraces(string):
li=[]
for item in string:
if item in valid: li.append(item)
elif li and valid[li[-1]] == item: li.pop()
else: return False
return False if li else True
|
summultiples = 0
for i in range(1000):
if i % 3 == 0 or i % 5 == 0:
summultiples += i
print(summultiples)
|
def say_hello(name: str = 'Lucas'):
print(f'Hello {name} ')
def ask_age():
user_age = input('Age?')
return user_age
def say_hello_mp(name, age_user=25):
print(f'Hello {name} {age_user}')
if __name__ == '__main__':
say_hello()
say_hello(123)
print(say_hello('Pierre'))
say_hello_mp(age_user=23, name='toto')
say_hello_mp('toto', 23)
age = ask_age()
print(f'You are {age} year(s) old')
|
# Prints arithmetic progression of 10 numbers
print('10 Termos de uma PA')
number = int(input('Primeiro termo: '))
constant = int(input('Razão: '))
total = 0
for c in range (1, 11):
total = number + (c - 1) * constant
print('{}'.format(total), end = ' → ')
print('ACABOU')
|
# -*- coding: utf-8 -*-
########################################################################
#
# License: BSD
# Created: October 19, 2004
# Author: Ivan Vilata i Balaguer - reverse:net.selidor@ivan
#
# $Id$
#
########################################################################
"""Special node behaviours for PyTables.
This package contains several modules that give specific behaviours
to PyTables nodes. For instance, the filenode module provides
a file interface to a PyTables node.
Package modules:
filenode -- A file interface to nodes for PyTables databases.
"""
# The list of names to be exported to the importing module.
__all__ = ['filenode']
## Local Variables:
## mode: python
## py-indent-offset: 4
## tab-width: 4
## End:
|
class News:
# 允许绑定的对象
__slots__ = ('__id', '__time', '__department', '__info')
# 构造函数
def __init__(self, url, time, department, info):
self.__id = url
self.__time = time
self.__department = department
self.__info = info
@property
def id(self):
return self.__id
@property
def time(self):
return self.__time
@time.setter
def time(self, new_value):
self.__time = new_value
@property
def department(self):
return self.__department
@department.setter
def department(self, new_value):
self.__department = new_value
@property
def info(self):
return self.__info
@info.setter
def info(self, new_value):
self.__info = new_value
def __eq__(self, other):
return self.time == other.time \
and self.department == other.department \
and self.info == other.info
def __hash__(self):
return hash((self.time, self.department, self.info))
def __str__(self):
return "时间: %s, 部门: %s, 信息: %s" % (self.time, self.department, self.info)
def __repr__(self):
return "时间: %s, 部门: %s, 信息: %s" % (self.time, self.department, self.info)
|
# -*- coding: utf-8 -*-
"""
Created on Thu Oct 1 13:12:08 2020
@author: Abhishek Parashar
"""
stack=[]
vector=[]
arr=[4,5,2,10,8]
for i in range(len(arr)-1):
if (len(stack)==0):
vector.append(-1)
elif (len(stack)>0 and stack[-1]<arr[i]):
vector.append(stack[-1])
elif (len(stack)>0 and stack[-1]>=arr[i]):
while(len(stack)>0 and stack[-1]>=arr[i]):
stack.pop(-1)
if(len(stack)==0):
vector.append(-1)
else:
vector.append(stack[-1])
stack.append(arr[i])
print(vector)
|
def foo(t1, t2, t3):
return str(t1)+str(t2)
res = foo(t1,t2,t3)
print("Testing output!")
|
"""
* Copyright 2007,2008,2009 John C. Gunther
* Copyright (C) 2009 Luke Kenneth Casson Leighton <lkcl@lkcl.net>
*
* Licensed under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* http:#www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
* either express or implied. See the License for the specific
* language governing permissions and limitations under the
* License.
*
"""
"""*
* Defines how the <tt>update</tt> method updates the touched
* point, that is, the point the user is considered to be
* hovered over.
*
* @see #update(TouchedPointUpdateOption) update
*
"""
class TouchedPointUpdateOption(object):
def __init__(self):
pass
"""*
* When this option is passed to the update method, any
* touched point is cleared as a consequence of the update.
* <p>
*
* This option can be used when you want to "start fresh"
* with regards to hover feedback after an update, and want
* to assure that only explicit user-generated mouse move
* actions (rather than objects moving <i>underneath</i> a
* fixed-position mouse cursor) can trigger hover feedback.
*
* @see #update update
* @see #TOUCHED_POINT_LOCKED TOUCHED_POINT_LOCKED
* @see #TOUCHED_POINT_UPDATED TOUCHED_POINT_UPDATED
*
"""
TOUCHED_POINT_CLEARED = TouchedPointUpdateOption()
"""*
* When this option is passed to the update method, any
* previously touched point is locked in (remains unchanged).
* <p>
*
* For example, if the mouse is over a certain point before
* the update, and that point moves away from the mouse
* (without the mouse moving otherwise) as a consequence of
* the update, the hover feedback remains "locked in" to the
* original point, even though the mouse is no longer on top
* of that point.
* <p>
*
* This option is useful for hover widgets that modify the
* position, size, symbol of points/curves, and do not want the
* selected point/curve (and popup hover widget) to change as
* a consequence of such changes.
* <p>
*
* <i>Note:</i> If the currently touched point or the curve
* containing it is deleted, GChart sets the touched point
* reference to <tt>None</tt>. In that case, this option and
* <tt>TOUCHED_POINT_CLEARED</tt> behave the same way.
*
*
* @see #update update
* @see #TOUCHED_POINT_CLEARED TOUCHED_POINT_CLEARED
* @see #TOUCHED_POINT_UPDATED TOUCHED_POINT_UPDATED
*
"""
TOUCHED_POINT_LOCKED = TouchedPointUpdateOption()
"""*
* When this option is passed to the update method, the
* touched point is updated so that it reflects whatever point
* is underneath the mouse cursor after the update
* completes.
* <p>
*
* For example, if the mouse is not hovering over any point
* before the update, but the update repositions one of the
* points so that it is now underneath the mouse cursor,
* the hover feedback for that point will be displayed.
* Similarly, if the update moves a point away from the
* mouse cursor, previously displayed hover feedback will
* be eliminated.
* <p>
*
* @see #update update
* @see #TOUCHED_POINT_CLEARED TOUCHED_POINT_CLEARED
* @see #TOUCHED_POINT_LOCKED TOUCHED_POINT_LOCKED
*
"""
TOUCHED_POINT_UPDATED = TouchedPointUpdateOption()
|
'''
@file: __init__.py.py
@author: qxLiu
@time: 2020/3/14 9:37
'''
|
__author__ = 'Ahmfrkyvz'
def vigerene_cipher(plainText, key):
i = 0
encryptedText = ""
key = key.lower()
plainText = plainText.replace('İ', 'i')
plainText = plainText.lower()
while i < len(plainText):
char = ord(plainText[i])
charOfKey = ord(key[i%(len(key))])
if char >= 97 and char <= 122 and charOfKey >= 97 and charOfKey <= 122:
encryptedText += chr((char + charOfKey - 2*97)%26 +97)
else:
encryptedText += chr(char)
i=i+1
return encryptedText
def decrypt_vigerene_cipher(encryptedText, key):
i=0
plainText = ""
while i < len(encryptedText):
char = ord(encryptedText[i])
charOfKey = ord(key[i%(len(key))])
if char >= 97 and char <= 122 and charOfKey >= 97 and charOfKey <= 122:
plainText += chr((char - charOfKey)%26 + 97)
else:
plainText += chr(char)
i=i+1
return plainText
|
def set(name):
ret = {
'name': name,
'changes': {},
'result': False,
'comment': ''
}
current_name = __salt__['c_hostname.get_hostname']()
if name == current_name:
ret['result'] = True
ret['comment'] = "Hostname \"{0}\" already set.".format(name)
return ret
if __opts__['test'] is True:
ret['comment'] = "Hostname \"{0}\" will be set".format(name)
else:
__salt__['c_hostname.set_hostname'](name)
ret['changes']['hostname'] = {'old': current_name, 'new': name}
ret['comment'] = "Hostname \"{0}\" has been set".format(name)
ret['result'] = True
return ret
|
class Solution:
def canCross(self, stones: List[int]) -> bool:
n = len(stones)
# dp[i][j] := True if a frog can make a size j jump to stones[i]
dp = [[False] * (n + 1) for _ in range(n)]
dp[0][0] = True
for i in range(1, n):
for j in range(i):
k = stones[i] - stones[j]
if k > n:
continue
for x in (k - 1, k, k + 1):
if 0 <= x <= n:
dp[i][k] |= dp[j][x]
return any(dp[-1])
|
class PPSTimingCalibrationModeEnum:
CondDB = 0
JSON = 1
SQLite = 2
|
a = input()
i = ord(a)
for i in range(i-96):
print(chr(i+97),end=" ")
|
number = 16#71398757
base = 16#12
#должно получиться 35699370
def getZerosCount(number, base):
#находим простые делители системы счисления
i = 2
b = base
dividers = []
degrees = []
ps_i = 0
step = 0 #степень - т.е. количество раз повторения делителя
while i <= base:
if b % i == 0:
if i > ps_i:
degrees.append(step)
dividers.append(i)
ps_i = i
step = 0
print('b = ', b, 'i = ', i)
b /= i
step += 1
else:
i +=1
degrees.append(step)
del degrees[0]
print(dividers, degrees)
def countdel(delit, stepen):
temp = number
count = 0
i = delit
while temp // i > 1:
count += temp // i
print('c', count, 'i = ', i)
i *= delit
count = count // stepen
return count
variants = []
for i in range(0, len(dividers)):
variants.append(countdel(dividers[i],degrees[i]))
#print(variants)
res = min(variants)
print('result = ', res)
# #находим количество разложений числа number на делители base
# temp = number
# count1 = 0
# #step = 0
# i = dividers[1]
# while temp // i > 1:
# count1 += temp // i
# print('c1', count1, 'i = ', i)
# i *= dividers[1]
# #step += 1
# #if step > 1:
# # step +=1
# count1 = count1 // dividers[2]
# print('count1', count1)
# if len(dividers) > 3:
# temp = number
# count2 = 0
# step = 0
# i = dividers[3]
# while temp // i > 1:
# count2 += temp // i
# print('c2 = ', count2, 'i = ', i)
# i *= dividers[3]
# step += 1
# count2 = count2 // dividers[4]
# #if step > 1:
# # step += 1
# # count2
# print('count2', count2)
# if count1 < count2:
# print('Количество нулей: ', count1)
# else:
# print('Количество нулей: ', count2)
# else:
# print('Количество нулей: ', count1)
getZerosCount(number, base)
|
n=int(input("From number"))
n1=int(input("To number"))
for i in range(n,n1):
for j in range(2,i):
if i%j==0:
break
else:
print(i)
|
# Recursive implementation to find the gcd (greatest common divisor) of two integers using the euclidean algorithm.
# For more than two numbers, e.g. three, you can box it like this: gcd(a,gcd(b,greatest_common_divisor.c)) etc.
# This runs in O(log(n)) where n is the maximum of a and b.
# :param a: the first integer
# :param b: the second integer
# :return: the greatest common divisor (gcd) of the two integers.
def gcd(a, b):
# print("New *a* is " + str(a) + ", new *b* is " + str(b))
if b == 0:
# print("b is 0, stopping recursion, a is the gcd: " + str(a))
return a
# print("Recursing with new a = b and new b = a % b...")
return gcd(b, a % b)
|
def _build(**kwargs):
kwargs.setdefault("mac_src", '00.00.00.00.00.01')
kwargs.setdefault("mac_dst", '00.00.00.00.00.02')
kwargs.setdefault("mac_src_step", '00.00.00.00.00.01')
kwargs.setdefault("mac_dst_step", '00.00.00.00.00.01')
kwargs.setdefault("arp_src_hw_addr", '01.00.00.00.00.01')
kwargs.setdefault("arp_dst_hw_addr", '01.00.00.00.00.02')
kwargs.setdefault("ip_src_addr", '11.1.1.1')
kwargs.setdefault("ip_dst_addr", '225.1.1.1')
kwargs.setdefault("ip_src_step", '0.0.0.1')
kwargs.setdefault("ip_dst_step", '0.0.0.1')
kwargs.setdefault("mac_src_count", 20)
kwargs.setdefault("mac_dst_count", 20)
kwargs.setdefault("arp_src_hw_count", 20)
kwargs.setdefault("arp_dst_hw_count", 10)
kwargs.setdefault("ip_src_count", 20)
kwargs.setdefault("ip_dst_count", 20)
kwargs.setdefault("transmit_mode", 'continuous')
kwargs.setdefault("length_mode", 'fixed')
kwargs.setdefault("vlan_id", 10)
kwargs.setdefault("vlan_id_count", 10)
kwargs.setdefault("vlan_id_step", 3)
kwargs.setdefault("l2_encap", 'ethernet_ii')
kwargs.setdefault("frame_size", 64)
kwargs.setdefault("pkts_per_burst", 10)
kwargs.setdefault("mode", "create")
return kwargs
def _build2(index=0):
if index == 0: return _build()
if index == 1: return _build(length_mode='random', transmit_mode='single_burst')
if index == 2: return _build(length_mode='increment', transmit_mode='single_burst', frame_size_step=2000)
if index == 3: return _build(mac_dst_mode="increment")
if index == 4: return _build(mac_src_mode="increment", transmit_mode='single_burst')
if index == 5: return _build(l3_protocol='arp', arp_src_hw_mode="increment", arp_dst_hw_mode="decrement")
if index == 6: return _build(rate_pps=1, l3_protocol='ipv4', ip_src_mode='increment', ip_dst_mode='decrement')
if index == 7: return _build(vlan_user_priority="3", l2_encap="ethernet_ii_vlan", vlan_id_mode="increment")
if index == 8: return _build(vlan="enable", l3_protocol='ipv4', ip_src_addr='1.1.1.1', ip_dst_addr='5.5.5.5',
ip_dscp="8", high_speed_result_analysis=0, track_by='trackingenabled0 ipv4DefaultPhb0',
ip_dscp_tracking=1)
if index == 9: return _build(l2_encap='ethernet_ii', ethernet_value='88CC',
data_pattern='02 07 04 00 11 97 2F 8E 80 04 07 03 00 11 97 2F 8E 82 06 02 00 78 00 00 00 00 '
'00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00')
if index == 10: return _build(l2_encap='ethernet_ii', ethernet_value='8809', data_pattern_mode='fixed',
data_pattern='02 07 04 00 11 97 2F 8E 80 04 07 03 00 11 97 2F 8E 82 06 02 00 78 00 00 00 00 '
'00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00')
if index == 11: return _build(data_pattern='FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 00 2D 01 04 00 C8 00 5A 05 05 '
'05 05 10 02 0E 01 04 00 01 00 01 02 00 41 04 00 00 00 C8', l3_protocol='ipv4', ip_protocol=6,
ip_src_addr='1.1.1.1', l4_protocol='tcp', ip_precedence=5, frame_size=103,
ip_dst_addr='1.1.1.2', tcp_dst_port=179, tcp_src_port=54821, tcp_window=115,
tcp_seq_num=1115372998, tcp_ack_num=1532875182,tcp_ack_flag=1, tcp_psh_flag=1, ip_ttl=1)
if index == 12: return _build(l3_protocol='ipv6', data_pattern='01 D1 49 5E 00 08 00 02 00 78 00 01 00 0A 00 03 00 01 00 13 '
'5F 1F F2 80 00 06 00 06 00 19 00 17 00 18 00 19 00 0C 00 33 ' '00 01 00 00 00 00 00 00 00 00',
frame_size=116, ipv6_dst_addr="FF02:0:0:0:0:0:1:2", ipv6_src_addr="FE80:0:0:0:201:5FF:FE00:500",
ipv6_next_header=17, ipv6_traffic_class=224,l4_protocol='udp',udp_dst_port=546,
udp_src_port=547, ipv6_hop_limit=255)
if index == 13: return _build(l3_protocol='arp', arp_src_hw_addr="00:00:00:11:11:80",
arp_dst_hw_addr="00:00:00:00:00:00", arp_operation='arpRequest', ip_src_addr='1.1.1.1', ip_dst_addr='1.1.1.2')
if index == 14: return _build(l3_protocol='ipv6', data_pattern='FF FF', l4_protocol="icmp", ipv6_dst_addr="fe80::ba6a:97ff:feca:bb98",
ipv6_src_addr="2001::2", ipv6_next_header=58, icmp_target_addr='2001::2', icmp_type=136, icmp_ndp_nam_o_flag=0,
icmp_ndp_nam_r_flag=1, icmp_ndp_nam_s_flag=1, ipv6_hop_limit=255)
if index == 15: return _build(rate_pps=1, l3_protocol='ipv4',ip_src_addr='11.1.1.1', ip_dst_addr='225.1.1.1',ip_protocol=2, \
l4_protocol='igmp',igmp_msg_type='report',igmp_group_addr='225.1.1.1',high_speed_result_analysis=0)
return None
def ut_stream_get(index=0, **kws):
kwargs = _build2(index)
if kwargs: kwargs.update(kws)
return kwargs
if __name__ == '__main__':
print(ut_stream_get(0))
for i in range(100):
d = ut_stream_get(i)
if not d:
break
print(d)
|
#Weird algorithm for matrix multiplication. just addition will produce result matrix
class Solution:
def oddCells(self, n: int, m: int, indices: List[List[int]]) -> int:
row = [0] * n
col = [0] * m
ans = 0
for r,c in indices:
row[r] += 1
col[c] += 1
for i in range(n):
for j in range(m):
ans += (row[i] + col[j] )%2
return ans
|
# -*- coding: utf-8 -*-
"""
Created on Tue Oct 13 20:04:26 2020
@author: ninjaac
"""
def count_substring(string, sub_string):
return string.count(sub_string)
#return (''.join(string)).count(''.join(sub_string))
if __name__ == '__main__':
string = input().strip()
sub_string = input().strip()
count = count_substring(string, sub_string)
print(count)
|
unavailable_dict = {
"0": {
("11", "12", "13"): [
"message_1",
"message_4"
],
("21", "22", "23"): [
"message_3",
"message_6"
],
("24",): [
"message_2",
"message_5"
],
("0", "blank",): [
"message_7"
]
},
"1": {
("11", "12", "13"): [
"message_8"
],
("21", "22", "23"): [
"message_9"
],
("0", "blank",): [
"message_10"
]
},
"2": {("0", "blank",):
[
"message_11"
]}
}
earnings_dict = {
"0": {
"13": {
"4": "after_3_years_23_4"
},
"11": {
"3": "earnings_15_months_unavailable_22_21_3",
"4": "after_3_years_21_22_4"
},
"12": {
"3": "earnings_15_months_unavailable_22_21_3",
"4": "after_3_years_21_22_4"
},
"23": {
"4": "after_3_years_23_4"
},
"21": {
"3": "earnings_15_months_unavailable_22_21_3",
"4": "after_3_years_21_22_4"
},
"22": {
"3": "earnings_15_months_unavailable_22_21_3",
"4": "after_3_years_21_22_4"
},
"blank": "unavailable_0_any"
},
"1": {
"13": {
"4": "after_3_years_23_4"
},
"11": {
"3": "earnings_15_months_unavailable_22_21_3",
"4": "after_3_years_21_22_4"
},
"12": {
"3": "earnings_15_months_unavailable_22_21_3",
"4": "after_3_years_21_22_4"
},
"23": {
"4": "after_3_years_23_4"
},
"21": {
"3": "earnings_15_months_unavailable_22_21_3",
"4": "after_3_years_21_22_4"
},
"22": {
"3": "earnings_15_months_unavailable_22_21_3",
"4": "after_3_years_21_22_4"
},
"blank": "unavailable_1_any"
},
"2": {
"13": {
"4": "after_3_years_23_4"
},
"11": {
"3": "earnings_15_months_unavailable_22_21_3",
"4": "after_3_years_21_22_4"
},
"12": {
"3": "earnings_15_months_unavailable_22_21_3",
"4": "after_3_years_21_22_4"
},
"23": {
"4": "after_3_years_23_4"
},
"21": {
"3": "earnings_15_months_unavailable_22_21_3",
"4": "after_3_years_21_22_4"
},
"22": {
"3": "earnings_15_months_unavailable_22_21_3",
"4": "after_3_years_21_22_4"
},
"blank": "unavailable_2_any"
},
}
|
# In theory, RightScale's API is discoverable through ``links`` in responses.
# In practice, we have to help our robots along with the following hints:
RS_DEFAULT_ACTIONS = {
'index': {
'http_method': 'get',
},
'show': {
'http_method': 'get',
'extra_path': '/%(res_id)s',
},
'create': {
'http_method': 'post',
},
'update': {
'http_method': 'put',
'extra_path': '/%(res_id)s',
},
'destroy': {
'http_method': 'delete',
'extra_path': '/%(res_id)s',
},
}
ALERT_ACTIONS = {
'disable': {
'http_method': 'post',
'extra_path': '/%(res_id)s/disable',
},
'enable': {
'http_method': 'post',
'extra_path': '/%(res_id)s/enable',
},
'quench': {
'http_method': 'post',
'extra_path': '/%(res_id)s/quench',
},
'create': None,
'update': None,
'destroy': None,
}
COOKBOOK_ATTACHMENT_ACTIONS = {
'multi_attach': {
'http_method': 'post',
'extra_path': '/multi_attach',
},
'multi_detach': {
'http_method': 'post',
'extra_path': '/multi_detach',
},
'update': None,
}
INPUT_ACTIONS = {
'multi_update': {
'http_method': 'put',
'extra_path': '/multi_update',
},
'show': None,
'create': None,
'update': None,
'destroy': None,
}
INSTANCE_ACTIONS = {
'launch': {
'http_method': 'post',
'extra_path': '/%(res_id)s/launch',
},
'lock': {
'http_method': 'post',
'extra_path': '/%(res_id)s/lock',
},
'multi_run_executable': {
'http_method': 'post',
'extra_path': '/multi_run_executable',
},
'multi_terminate': {
'http_method': 'post',
'extra_path': '/multi_terminate',
},
'reboot': {
'http_method': 'post',
'extra_path': '/%(res_id)s/reboot',
},
'run_executable': {
'http_method': 'post',
'extra_path': '/%(res_id)s/run_executable',
},
'set_custom_lodgement': {
'http_method': 'post',
'extra_path': '/%(res_id)s/set_custom_lodgement',
},
'start': {
'http_method': 'post',
'extra_path': '/%(res_id)s/start',
},
'stop': {
'http_method': 'post',
'extra_path': '/%(res_id)s/stop',
},
'terminate': {
'http_method': 'post',
'extra_path': '/%(res_id)s/terminate',
},
'unlock': {
'http_method': 'post',
'extra_path': '/%(res_id)s/unlock',
},
'create': None,
'destroy': None,
}
MULTI_CLOUD_IMAGE_ACTIONS = {
'clone': {
'http_method': 'post',
'extra_path': '/%(res_id)s/clone',
},
'commit': {
'http_method': 'post',
'extra_path': '/%(res_id)s/commit',
},
}
SERVER_ARRAY_ACTIONS = {
'clone': {
'http_method': 'post',
'extra_path': '/%(res_id)s/clone',
},
'current_instances': {
'http_method': 'get',
'extra_path': '/%(res_id)s/current_instances',
},
'launch': {
'http_method': 'post',
'extra_path': '/%(res_id)s/launch',
},
'multi_run_executable': {
'http_method': 'post',
'extra_path': '/%(res_id)s/multi_run_executable',
},
'multi_terminate': {
'http_method': 'post',
'extra_path': '/%(res_id)s/multi_terminate',
},
}
UPDATE_NONE_ACTIONS = {
'update': None,
}
# Specify variations from the default actions defined in RS_DEFAULT_ACTIONS.
# These specs come from http://reference.rightscale.com/api1.5/index.html
ROOT_COLLECTIONS = {
'account_groups': {
'create': None,
'update': None,
'destroy': None,
},
'accounts': {
'index': None,
'create': None,
'update': None,
'destroy': None,
},
# alert_specs use defaults
'alerts': ALERT_ACTIONS,
'audit_entries': {
'append': {
'http_method': 'post',
'extra_path': '/%(res_id)s/append',
},
'detail': {
'http_method': 'get',
'extra_path': '/%(res_id)s/detail',
},
'destroy': None,
},
'backups': {
'cleanup': {
'http_method': 'post',
'extra_path': '/cleanup',
},
},
'child_accounts': {
'show': None,
'destroy': None,
},
'cloud_accounts': {
'update': None,
},
'clouds': {
'create': None,
'update': None,
'destroy': None,
},
# these are only in the 1.5 docs and are not available as hrefs.
'cookbook_attachments': COOKBOOK_ATTACHMENT_ACTIONS,
'cookbooks': {
'follow': {
'http_method': 'post',
'extra_path': '/%(res_id)s/follow',
},
'freeze': {
'http_method': 'post',
'extra_path': '/%(res_id)s/freeze',
},
'obsolete': {
'http_method': 'post',
'extra_path': '/%(res_id)s/obsolete',
},
'create': None,
'update': None,
},
# credentials use defaults
'deployments': {
'clone': {
'http_method': 'post',
'extra_path': '/%(res_id)s/clone',
},
'lock': {
'http_method': 'post',
'extra_path': '/%(res_id)s/lock',
},
'servers': {
'http_method': 'get',
'extra_path': '/%(res_id)s/servers',
},
'unlock': {
'http_method': 'post',
'extra_path': '/%(res_id)s/unlock',
},
},
'identity_providers': {
'create': None,
'update': None,
'destroy': None,
},
'multi_cloud_images': MULTI_CLOUD_IMAGE_ACTIONS,
# network_gateways use defaults
# network_option_group_attachments use defaults
# network_option_groups use defaults
# networks use defaults
# oauth2 is a special case just used during auth
'permissions': {
'update': None,
},
# only in 1.5 api docs, not discoverable via href
'placement_groups': {
'update': None,
},
'preferences': {
'create': None,
},
'publication_lineages': {
'index': None,
'create': None,
'update': None,
'destroy': None,
},
'publications': {
'import': {
'http_method': 'post',
'extra_path': '/%(res_id)s/import',
},
'create': None,
'update': None,
'destroy': None,
},
'repositories': {
'cookbook_import': {
'http_method': 'post',
'extra_path': '/%(res_id)s/cookbook_import',
},
'refetch': {
'http_method': 'post',
'extra_path': '/%(res_id)s/refetch',
},
'resolve': {
'http_method': 'post',
'extra_path': '/resolve',
},
},
'right_scripts': {
'create': {
'http_method': 'post',
},
'commit': {
'http_method': 'post',
'extra_path': '/%(res_id)s/commit',
},
'update': {
'http_method': 'put',
},
'destroy': {
'http_method': 'delete',
},
},
# route_tables uses defaults
# routes uses defaults
# security_group_rules uses defaults
# rs api 1.5 returns a link where rel=self for the ``/api/sessions``
# resource. sadly, the href=/api/session. regardless, we don't need
# it as an attribute because it's where we started off.
'self': None,
'server_arrays': SERVER_ARRAY_ACTIONS,
'server_template_multi_cloud_images': {
'make_default': {
'http_method': 'post',
'extra_path': '/%(res_id)s/make_default',
},
'update': None,
},
'server_templates': {
'clone': {
'http_method': 'post',
'extra_path': '/%(res_id)s/clone',
},
'commit': {
'http_method': 'post',
'extra_path': '/%(res_id)s/commit',
},
'detect_changes_in_head': {
'http_method': 'post',
'extra_path': '/%(res_id)s/detect_changes_in_head',
},
'publish': {
'http_method': 'post',
'extra_path': '/%(res_id)s/publish',
},
'resolve': {
'http_method': 'post',
'extra_path': '/%(res_id)s/resolve',
},
'swap_repository': {
'http_method': 'post',
'extra_path': '/%(res_id)s/swap_repository',
},
},
'servers': {
'clone': {
'http_method': 'post',
'extra_path': '/%(res_id)s/clone',
},
'launch': {
'http_method': 'post',
'extra_path': '/%(res_id)s/launch',
},
'terminate': {
'http_method': 'post',
'extra_path': '/%(res_id)s/terminate',
},
},
# workaround inconsistency in rs hateoas
'sessions': {
'accounts': {
'http_method': 'get',
'extra_path': '/accounts',
},
'index': None,
'show': None,
'create': None,
'update': None,
'destroy': None,
},
'tags': {
'by_resource': {
'http_method': 'post',
'extra_path': '/by_resource',
},
'by_tag': {
'http_method': 'post',
'extra_path': '/by_tag',
},
'multi_add': {
'http_method': 'post',
'extra_path': '/multi_add',
},
'multi_delete': {
'http_method': 'post',
'extra_path': '/multi_delete',
},
'index': None,
'show': None,
'create': None,
'update': None,
'destroy': None,
},
'users': {
'destroy': None,
},
}
CLOUD_COLLECTIONS = {
'datacenters': {
'create': None,
'update': None,
'destroy': None,
},
'images': {
'create': None,
'update': None,
'destroy': None,
},
'instance_types': {
'create': None,
'update': None,
'destroy': None,
},
'instances': INSTANCE_ACTIONS,
'ip_address_bindings': UPDATE_NONE_ACTIONS,
# ip_addresses uses defaults
'recurring_volume_attachments': UPDATE_NONE_ACTIONS,
'security_groups': {
'update': None,
},
'ssh_keys': {
'update': None,
},
# subnets uses defaults
'volume_attachments': UPDATE_NONE_ACTIONS,
'volume_snapshots': UPDATE_NONE_ACTIONS,
}
INSTANCE_COLLECTIONS = {
'alerts': ALERT_ACTIONS,
'inputs': INPUT_ACTIONS,
# instance_custom_lodgements uses defaults
'monitoring_metrics': {
'data': {
'http_method': 'get',
'extra_path': '/%(res_id)s/data',
},
'create': None,
'update': None,
'destroy': None,
},
# subnets uses defaults
# TODO: investigate to see how useful tasks is by itself. i.e. there's
# no way to index() all tasks for an instance. regardless, this
# definition is here at least for completeness.
'tasks': {
'show': {
'http_method': 'get',
'extra_path': '/live/tasks/%(res_id)s',
},
'index': None,
'create': None,
'update': None,
'destroy': None,
},
'volume_attachments': UPDATE_NONE_ACTIONS,
'volumes': {
'update': None,
},
'volume_types': {
'create': None,
'update': None,
'destroy': None,
},
}
COOKBOOK_COLLECTIONS = {
'cookbook_attachments': COOKBOOK_ATTACHMENT_ACTIONS,
}
DEPLOYMENT_COLLECTIONS = {
'alerts': ALERT_ACTIONS,
'inputs': INPUT_ACTIONS,
'server_arrays': SERVER_ARRAY_ACTIONS,
}
IP_ADDRESS_COLLECTIONS = {
'ip_address_bindings': UPDATE_NONE_ACTIONS,
}
REPOSITORY_COLLECTIONS = {
'repository_assets': {
'create': None,
'update': None,
'destroy': None,
},
}
SERVER_COLLECTIONS = {
# alert_specs use defaults
'alerts': ALERT_ACTIONS,
}
SERVER_ARRAY_COLLECTIONS = {
# alert_specs use defaults
'alerts': ALERT_ACTIONS,
'current_instances': INSTANCE_ACTIONS,
}
SERVER_TEMPLATES_COLLECTIONS = {
'cookbook_attachments': COOKBOOK_ATTACHMENT_ACTIONS,
'inputs': INPUT_ACTIONS,
'multi_cloud_images': MULTI_CLOUD_IMAGE_ACTIONS,
'runnable_bindings': {
'multi_update': {
'http_method': 'put',
'extra_path': '/multi_update',
},
'update': None,
},
}
VOLUME_COLLECTIONS = {
'recurring_volume_attachments': UPDATE_NONE_ACTIONS,
'volume_snapshots': UPDATE_NONE_ACTIONS,
}
VOLUME_SNAPSHOT_COLLECTIONS = {
'recurring_volume_attachments': UPDATE_NONE_ACTIONS,
}
COLLECTIONS = {
'application/vnd.rightscale.session+json': ROOT_COLLECTIONS,
'application/vnd.rightscale.cookbook+json': COOKBOOK_COLLECTIONS,
'application/vnd.rightscale.cloud+json': CLOUD_COLLECTIONS,
'application/vnd.rightscale.instance+json': INSTANCE_COLLECTIONS,
'application/vnd.rightscale.ip_address+json': IP_ADDRESS_COLLECTIONS,
'application/vnd.rightscale.deployment+json': DEPLOYMENT_COLLECTIONS,
# multi_cloud_image has a ``settings`` collection (a.k.a.
# MultiCloudImageSettings in the RS docs) that just uses defaults, so
# no need for an extra map
'application/vnd.rightscale.repository+json': REPOSITORY_COLLECTIONS,
'application/vnd.rightscale.server+json': SERVER_COLLECTIONS,
'application/vnd.rightscale.server_array+json': SERVER_ARRAY_COLLECTIONS,
'application/vnd.rightscale.server_template+json': SERVER_TEMPLATES_COLLECTIONS,
# security_group has a ``security_group_rules`` collection that just
# uses defaults, so no need for an extra map
'application/vnd.rightscale.volume+json': VOLUME_COLLECTIONS,
'application/vnd.rightscale.volume_snapshot+json': VOLUME_SNAPSHOT_COLLECTIONS,
}
|
'''
Created on Oct 1, 2011
@author: jose
'''
|
"""
Union and Intersection of Two Linked Lists
Your task for this problem is to fill out the union and intersection functions. The union of two sets A and B is the set of elements which are in A, in B, or in both A and B. The intersection of two sets A and B, denoted by A ∩ B, is the set of all objects that are members of both the sets A and B.
You will take in two linked lists and return a linked list that is composed of either the union or intersection, respectively. Once you have completed the problem you will create your own test cases and perform your own run time analysis on the code.
We have provided a code template below, you are not required to use it:
"""
class Node:
def __init__(self, value):
self.value = value
self.next = None
def __repr__(self):
return str(self.value)
class LinkedList:
def __init__(self):
self.head = None
def __str__(self):
cur_head = self.head
out_string = ""
while cur_head:
out_string += str(cur_head.value) + " -> "
cur_head = cur_head.next
out_string += "None"
return out_string
def append(self, value):
if self.head is None:
self.head = Node(value)
return
node = self.head
while node.next:
node = node.next
node.next = Node(value)
def size(self):
size = 0
node = self.head
while node:
size += 1
node = node.next
return size
def to_list(self):
return [n for n in self]
def __iter__(self):
node = self.head
while node:
yield node.value
node = node.next
def union(llist_1, llist_2):
if llist_1 is None and llist_2 is None:
return LinkedList()
elif llist_1 is None:
return llist_2
elif llist_2 is None:
return llist_1
# a common dictionary/hashtable to maintain elements encountered in both lists,
# I am dict for fast insert/search operations to keep my overall time complexity minimum
common_dict = {}
# go through first list and mark items encountered
for item in llist_1:
common_dict[item] = True
# go through second list and mark items encountered
for item in llist_2:
common_dict[item] = True
# now add items encountered in either list to resultant list
union_linked_list = LinkedList()
for item, status in common_dict.items():
union_linked_list.append(item)
return union_linked_list
def intersection(llist_1, llist_2):
if llist_1 is None:
return LinkedList()
elif llist_2 is None:
return LinkedList()
# a common dictionary/hashtable to maintain elements encountered in both lists,
# I am dict for fast insert/search operations to keep my overall time complexity minimum
common_dict = {}
# go through first list and mark items encountered with value 1 (only 1
for item in llist_1:
common_dict[item] = 1
# go through second list and mark items encountered by increasing the counter of that item
for item in llist_2:
if common_dict.get(item, 0) != 0:
common_dict[item] = common_dict[item] + 1
# add items that are counted at least 2 times
intersection_list = LinkedList()
for item, count in common_dict.items():
if count >= 2:
intersection_list.append(item)
return intersection_list
def test_case(list1, list2, expected_union_sorted_output, expected_intersection_sorted_output):
linked_list_1 = LinkedList()
linked_list_2 = LinkedList()
for i in list1:
linked_list_1.append(i)
for i in list2:
linked_list_2.append(i)
union_output = union(linked_list_1, linked_list_2).to_list()
# NOTE: I am sorting the output so that I can add asserts otherwise order will be not defined
union_output.sort()
print(union_output)
assert (union_output == expected_union_sorted_output)
intersection_output = intersection(linked_list_1, linked_list_2).to_list()
# NOTE: I am sorting the output so that I can add asserts otherwise order will be not defined
intersection_output.sort()
print(intersection_output)
assert (intersection_output == expected_intersection_sorted_output)
def test():
# Test case 1
print("--------> Test-1")
element_1 = [3,2,4,35,6,65,6,4,3,21]
element_2 = [6,32,4,9,6,1,11,21,1]
expected_union_output = [1, 2, 3, 4, 6, 9, 11, 21, 32, 35, 65]
expected_intersection_output = [4, 6, 21]
test_case(element_1, element_2, expected_union_output, expected_intersection_output)
# Test case 2
print("--------> Test-2")
element_1 = [3,2,4,35,6,65,6,4,3,23]
element_2 = [1,7,8,9,11,21,1]
expected_union_output = [1, 2, 3, 4, 6, 7, 8, 9, 11, 21, 23, 35, 65]
expected_intersection_output = []
test_case(element_1, element_2, expected_union_output, expected_intersection_output)
# Test case 3
print("--------> Test-3")
element_1 = [5, 6, 4, -1]
element_2 = [1, 2, 3, -1]
expected_union_output = [-1, 1, 2, 3, 4, 5, 6]
expected_intersection_output = [-1]
test_case(element_1, element_2, expected_union_output, expected_intersection_output)
# Edge cases
# Test case 4
print("--------> Test-4")
element_1 = []
element_2 = []
expected_union_output = []
expected_intersection_output = []
test_case(element_1, element_2, expected_union_output, expected_intersection_output)
# Test case 5
print("--------> Test-5")
union_output = union(None, None).to_list()
print(union_output) # should print []
assert(union_output == [])
intersection_output = intersection(None, None).to_list()
print(intersection_output) # should print []
# Test case 6
print("--------> Test-6")
union_output = union(None, LinkedList()).to_list()
print(union_output) # should print []
assert (union_output == [])
intersection_output = intersection(LinkedList(), None).to_list()
print(intersection_output) # should print []
test()
|
"""binary tree
"""
#https://www.hackerrank.com/challenges/tree-preorder-traversal/problem
#recrusive:
def preOrder(root):
print(root.info,end=' ')
if root.left:
preOrder(root.left)
if root.right:
preOrder(root.right)
#itrative:
def preOrder(root):
stack=[root]
while(stack):
a=stack.pop()
print(a.info,end=' ')
if(a.right):
stack.append(a.right)
if a.left:
stack.append(a.left)
#https://www.hackerrank.com/challenges/tree-postorder-traversal/problem
#recursice:
def postOrder(root):
if(root.left):
postOrder(root.left)
if root.right:
postOrder(root.right)
print(root.info,end=' ')
#itreative:
def postOrder(root):
queue=[]
stack=[root]
while stack:
a=stack.pop()
queue.append(a.info)
if a.left:
stack.append(a.left)
if a.right:
stack.append(a.right)
for i in range(len(queue)):
print(queue[-i-1],end=' ')
#https://www.hackerrank.com/challenges/tree-inorder-traversal/problem
def inOrder(root):
if root.left:
inOrder(root.left)
print(root.info,end=' ')
if root.right:
inOrder(root.right)
#itreative:
def inOrder(root):
cur=root
stack=[]
q=[]
while True:
while cur:
stack.append(cur)
cur=cur.left
cur=stack.pop()
print(cur.info,end=' ')
cur=cur.right
if not (cur or stack):
break
"""
today leet code challenge
https://leetcode.com/explore/challenge/card/april-leetcoding-challenge-2021/594/week-2-april-8th-april-14th/3702/
"""
class Solution:
def isAlienSorted(self, words: List[str], order: str) -> bool:
d,l={},[]
for i in range(len(order)):
d[order[i]]=i
print(d)
for i in words:
l.append([d[j]for j in i])
for i in range(1,len(l)):
if l[i-1]>l[i]:
return False
return True
#https://leetcode.com/problems/binary-tree-inorder-traversal/
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def inorderTraversal(self, root: TreeNode) -> List[int]:
l=[]
ans=[]
a=root
while True:
if not(a or l):
break
while a:
l.append(a)
a=a.left
a=l.pop()
ans.append(a.val)
a=a.right
return ans
|
# Definition for a undirected graph node
class UndirectedGraphNode:
def __init__(self, x):
self.label = x
self.neighbors = []
def __str__(self):
return "({} -> {})".format(self.label,
[nb.label for nb in self.neighbors])
def __repr__(self):
return self.__str__()
class Solution:
# @param node, a undirected graph node
# @return a undirected graph node
def cloneGraph(self, node):
if node is None:
return None
old_labels = dict()
frontier = [node]
old_labels[node.label] = node
while frontier:
top = frontier.pop()
for nb in top.neighbors:
if nb.label not in old_labels:
old_labels[nb.label] = nb
frontier.append(nb)
new_labels = dict()
for v in old_labels:
new_labels[v] = UndirectedGraphNode(v)
for v in old_labels:
for nb in old_labels[v].neighbors:
new_labels[v].neighbors.append(new_labels[nb.label])
return new_labels[node.label]
def main():
graph = [0, 1, 2]
for i in range(3):
graph[i] = UndirectedGraphNode(i)
graph[0].neighbors = [graph[1], graph[2]]
graph[1].neighbors = [graph[0], graph[2]]
graph[2].neighbors = [graph[0], graph[1], graph[2]]
fn = Solution().cloneGraph
node = fn(graph[0])
print(node, node.neighbors[0], node.neighbors[1])
if __name__ == '__main__':
main()
|
class Salary:
def __init__(self,pay,bonus):
self.pay=pay
self.bonus=bonus
def annual(self):
return (self.pay*12)+self.bonus
class employee:
def __init__(self,name,age,pay,bonus):
self.name=name
self.age=age
self.pay=pay
self.bonus=bonus
self.obj_salary=Salary(pay,bonus)
def total_salary(self):
return self.obj_salary.annual()
emp=employee('ajay',12,1,1)
print(emp.total_salary())
|
# 给定一个整数数组，判断是否存在重复元素。
# 如果任何值在数组中出现至少两次，函数返回 true。如果数组中每个元素都不相同，则返回 false。
# 示例 1:
# 输入: [1,2,3,1]
# 输出: true
class Solution:
def containsDuplicate(self, nums: list) -> bool:
return len(nums) != len(set(nums))
v = Solution().containsDuplicate([1,1,1,3,3,4,3,2,4,2])
print(v)
|
try:
n = int(input('Numerador: '))
n2 = int(input('Denominador: '))
r = n / n2
except (ValueError, TypeError):
print(f'Tivemos um problema com o tipo de dado que você digitou!')
except ZeroDivisionError:
print(f'Você não pode dividir por zero!')
except KeyboardInterrupt:
print(f'O usuário preferiu não informar os dados!')
else:
print(f'{r:.2f}')
finally:
print(f'Volte sempre e muito obrigado!')
|
test = {
'name': 'smallest-int',
'points': 0,
'suites': [
{
'cases': [
{
'code': r"""
sqlite> SELECT * FROM smallest_int;
11/11/2015 10:01:03|7
11/11/2015 13:53:36|7
11/11/2015 14:52:07|7
11/11/2015 15:36:00|7
11/11/2015 15:46:03|7
11/11/2015 16:11:56|7
11/11/2015 17:42:09|7
11/11/2015 11:49:59|8
11/12/2015 14:30:09|8
11/11/2015 9:57:49|9
11/11/2015 10:29:15|10
11/11/2015 11:18:22|10
11/11/2015 16:56:15|10
11/11/2015 10:04:51|11
11/11/2015 10:27:47|11
11/11/2015 11:04:43|11
11/11/2015 12:27:14|11
11/11/2015 12:52:33|11
11/11/2015 13:05:03|11
11/11/2015 13:48:29|11
""",
'hidden': False,
'locked': False
}
],
'ordered': False,
'scored': True,
'setup': r"""
sqlite> .read lab12.sql
""",
'teardown': '',
'type': 'sqlite'
}
]
}
|
# Christian Piper
# 11/11/19
# This will accept algebra equations on the input and solve for the variable
def main():
equation = input("Input your equation: ")
variable = input("Input the variable to be solved for: ")
solveAlgebraEquation(equation, variable)
def solveAlgebraEquation(equation, variable):
collector = ["","","","","",""]
iteration = 0
for char in equation:
if char == " " or char == "+" or char == "-" or char == "*" or char == "/" or char == ")" or char == "=" or char == "^":
print(char + " - It's a separator!")
iteration += 1
else:
collector[iteration] = collector[iteration] + char
for count in range(0, iteration):
print(collector[count])
main()
|
# Location of exported xml playlist from itunes
# Update username and directory to their appropriate path e.g C:/users/bob/desktop/file.xml
xml_playlist_loc = 'C:/users/username/directory/_MyMusic_.xml'
# name of user directory where your Music folder is located
# example: C:/users/bob/music/itunes
music_folder_dir = 'name'
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
class Address(dict):
"""
Dictionary class that provides some convenience wrappers for accessing
commonly used data elements on an Address.
"""
def __init__(self, address_dict, order="lat"):
super(Address, self).__init__(address_dict)
self.order = order
@property
def coords(self):
"""
Returns a tuple representing the location of the address in a
GIS coords format, i.e. (longitude, latitude).
"""
x, y = ("lat", "lng") if self.order == "lat" else ("lng", "lat")
try:
return (self["location"][x], self["location"][y])
except KeyError:
return None
@property
def accuracy(self):
"""
Returns the accuracy integer or None of the geocoded address.
"""
try:
return self["accuracy"]
except KeyError:
return None
@property
def formatted_address(self):
"""
Returns a list of formatted addresses from the Location list
"""
return self.get("formatted_address", "")
class Location(dict):
"""
Dictionary class that provides some convenience accessors to commonly used
data elements.
"""
def __init__(self, result_dict, order="lat"):
super(Location, self).__init__(result_dict)
try:
self.best_match = Address(self["results"][0], order=order)
# A KeyError would be raised if an address could not be parsed or
# geocoded, i.e. from a batch address geocoding process. An index error
# would be raised under similar circumstances, e.g. the 'results' key
# just refers to an empty list.
except (KeyError, IndexError):
self.best_match = Address({})
self.order = order
@property
def coords(self):
"""
Returns a tuple representing the location of the first result in a
GIS coords format, i.e. (longitude, latitude).
"""
return self.best_match.coords
@property
def accuracy(self):
"""
Returns the accuracy integer or None of the geocoded address.
"""
return self.best_match.accuracy
@property
def formatted_address(self):
"""
Returns a list of formatted addresses from the Location list
"""
return self.best_match.formatted_address
class LocationCollection(list):
"""
A list of Location objects, with dictionary lookup by address.
"""
lookups = {}
def __init__(self, results_list, order="lat"):
"""
Loads the individual responses into an internal list and uses the query
values as lookup keys.
"""
results = []
for index, result in enumerate(results_list):
results.append(Location(result["response"], order=order))
self.lookups[result["query"]] = index
super(LocationCollection, self).__init__(results)
self.order = order
def get(self, key):
"""
Returns an individual Location by query lookup, e.g. address or point.
"""
if isinstance(key, tuple):
# TODO handle different ordering
try:
x, y = float(key[0]), float(key[1])
except IndexError:
raise ValueError("Two values are required for a coordinate pair")
except ValueError:
raise ValueError("Only float or float-coercable values can be passed")
key = "{0},{1}".format(x, y)
return self[self.lookups[key]]
@property
def coords(self):
"""
Returns a list of tuples for the best matched coordinates.
"""
return [l.coords for l in self]
@property
def formatted_addresses(self):
"""
Returns a list of formatted addresses from the Location list
"""
return [l.formatted_address for l in self]
|
def backtickify(s):
return '`{}`'.format(s)
def bind_exercises(g, exercises, start=1):
for i, ex in enumerate(exercises):
qno = i + start
varname = 'q{}'.format(qno)
assert varname not in g
g[varname] = ex
yield varname
|
# -*- coding: utf-8 -*-
"""
Created on Sat Jul 31 17:42:50 2021
@author: tan_k
"""
|
# LER O PESO DE 5 PESSOAS E MOSTRE O MAIOR E O MENOR
maior = 0
menor = 0
for pessoa in range(1, 6):
peso = float(input(f'Digite o {pessoa}° peso: '))
# SEMPRE NO 1° LAÇO O VALOR SERA O MAIOR E O MENOR POIS NAO HA REFERENCIA
if pessoa == 1:
maior = peso
menor = peso
# A PARTIR DO 2° LAÇO COMEÇA EFETUAR A VALIDAÇÃO
else:
if peso > maior:
maior = peso
if peso < menor:
menor = peso
print(f'O maior peso lido foi de {maior}KG')
print(f'O menor peso lido foi de {menor}KG')
|
#
# PySNMP MIB module RBN-CONFIG-FILE-MIB (http://snmplabs.com/pysmi)
# ASN.1 source file:///Users/davwang4/Dev/mibs.snmplabs.com/asn1/RBN-CONFIG-FILE-MIB
# Produced by pysmi-0.3.4 at Mon Apr 29 20:44:14 2019
# On host DAVWANG4-M-1475 platform Darwin version 18.5.0 by user davwang4
# Using Python version 3.7.3 (default, Mar 27 2019, 09:23:15)
#
ObjectIdentifier, OctetString, Integer = mibBuilder.importSymbols("ASN1", "ObjectIdentifier", "OctetString", "Integer")
NamedValues, = mibBuilder.importSymbols("ASN1-ENUMERATION", "NamedValues")
SingleValueConstraint, ValueRangeConstraint, ConstraintsIntersection, ConstraintsUnion, ValueSizeConstraint = mibBuilder.importSymbols("ASN1-REFINEMENT", "SingleValueConstraint", "ValueRangeConstraint", "ConstraintsIntersection", "ConstraintsUnion", "ValueSizeConstraint")
InetAddress, InetAddressType = mibBuilder.importSymbols("INET-ADDRESS-MIB", "InetAddress", "InetAddressType")
rbnMgmt, = mibBuilder.importSymbols("RBN-SMI", "rbnMgmt")
OwnerString, = mibBuilder.importSymbols("RMON-MIB", "OwnerString")
SnmpAdminString, = mibBuilder.importSymbols("SNMP-FRAMEWORK-MIB", "SnmpAdminString")
NotificationGroup, ObjectGroup, ModuleCompliance = mibBuilder.importSymbols("SNMPv2-CONF", "NotificationGroup", "ObjectGroup", "ModuleCompliance")
MibIdentifier, iso, Bits, Counter64, ObjectIdentity, NotificationType, Integer32, Counter32, Gauge32, ModuleIdentity, Unsigned32, TimeTicks, MibScalar, MibTable, MibTableRow, MibTableColumn, IpAddress = mibBuilder.importSymbols("SNMPv2-SMI", "MibIdentifier", "iso", "Bits", "Counter64", "ObjectIdentity", "NotificationType", "Integer32", "Counter32", "Gauge32", "ModuleIdentity", "Unsigned32", "TimeTicks", "MibScalar", "MibTable", "MibTableRow", "MibTableColumn", "IpAddress")
TestAndIncr, TextualConvention, DisplayString, TruthValue, RowStatus, TimeStamp = mibBuilder.importSymbols("SNMPv2-TC", "TestAndIncr", "TextualConvention", "DisplayString", "TruthValue", "RowStatus", "TimeStamp")
rbnConfigFileMib = ModuleIdentity((1, 3, 6, 1, 4, 1, 2352, 2, 13))
rbnConfigFileMib.setRevisions(('2002-05-29 00:00', '2001-10-10 00:00',))
if mibBuilder.loadTexts: rbnConfigFileMib.setLastUpdated('200110100000Z')
if mibBuilder.loadTexts: rbnConfigFileMib.setOrganization('Redback Networks, Inc.')
rbnConfigFileMIBNotifications = MibIdentifier((1, 3, 6, 1, 4, 1, 2352, 2, 13, 0))
rbnConfigFileMIBObjects = MibIdentifier((1, 3, 6, 1, 4, 1, 2352, 2, 13, 1))
rbnConfigFileMIBConformance = MibIdentifier((1, 3, 6, 1, 4, 1, 2352, 2, 13, 2))
rcfJobs = MibIdentifier((1, 3, 6, 1, 4, 1, 2352, 2, 13, 1, 1))
rcfJobSpinLock = MibScalar((1, 3, 6, 1, 4, 1, 2352, 2, 13, 1, 1, 1), TestAndIncr()).setMaxAccess("readwrite")
if mibBuilder.loadTexts: rcfJobSpinLock.setStatus('current')
rcfJobNextIndex = MibScalar((1, 3, 6, 1, 4, 1, 2352, 2, 13, 1, 1, 2), Unsigned32()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rcfJobNextIndex.setStatus('current')
rcfJobTable = MibTable((1, 3, 6, 1, 4, 1, 2352, 2, 13, 1, 1, 3), )
if mibBuilder.loadTexts: rcfJobTable.setStatus('current')
rcfJobEntry = MibTableRow((1, 3, 6, 1, 4, 1, 2352, 2, 13, 1, 1, 3, 1), ).setIndexNames((0, "RBN-CONFIG-FILE-MIB", "rcfJobIndex"))
if mibBuilder.loadTexts: rcfJobEntry.setStatus('current')
rcfJobIndex = MibTableColumn((1, 3, 6, 1, 4, 1, 2352, 2, 13, 1, 1, 3, 1, 1), Unsigned32().subtype(subtypeSpec=ValueRangeConstraint(1, 4294967295)))
if mibBuilder.loadTexts: rcfJobIndex.setStatus('current')
rcfJobOp = MibTableColumn((1, 3, 6, 1, 4, 1, 2352, 2, 13, 1, 1, 3, 1, 2), Integer32().subtype(subtypeSpec=ConstraintsUnion(SingleValueConstraint(0, 1))).clone(namedValues=NamedValues(("load", 0), ("save", 1)))).setMaxAccess("readcreate")
if mibBuilder.loadTexts: rcfJobOp.setStatus('current')
rcfJobProtocol = MibTableColumn((1, 3, 6, 1, 4, 1, 2352, 2, 13, 1, 1, 3, 1, 3), Integer32().subtype(subtypeSpec=ConstraintsUnion(SingleValueConstraint(0, 1, 2))).clone(namedValues=NamedValues(("local", 0), ("tftp", 1), ("ftp", 2))).clone('local')).setMaxAccess("readcreate")
if mibBuilder.loadTexts: rcfJobProtocol.setStatus('current')
rcfJobFilename = MibTableColumn((1, 3, 6, 1, 4, 1, 2352, 2, 13, 1, 1, 3, 1, 4), SnmpAdminString().subtype(subtypeSpec=ValueSizeConstraint(1, 128))).setMaxAccess("readcreate")
if mibBuilder.loadTexts: rcfJobFilename.setStatus('current')
rcfJobIpAddressType = MibTableColumn((1, 3, 6, 1, 4, 1, 2352, 2, 13, 1, 1, 3, 1, 5), InetAddressType()).setMaxAccess("readcreate")
if mibBuilder.loadTexts: rcfJobIpAddressType.setStatus('current')
rcfJobIpAddress = MibTableColumn((1, 3, 6, 1, 4, 1, 2352, 2, 13, 1, 1, 3, 1, 6), InetAddress()).setMaxAccess("readcreate")
if mibBuilder.loadTexts: rcfJobIpAddress.setStatus('current')
rcfJobUsername = MibTableColumn((1, 3, 6, 1, 4, 1, 2352, 2, 13, 1, 1, 3, 1, 7), SnmpAdminString().subtype(subtypeSpec=ValueSizeConstraint(1, 32))).setMaxAccess("readcreate")
if mibBuilder.loadTexts: rcfJobUsername.setStatus('current')
rcfJobPassword = MibTableColumn((1, 3, 6, 1, 4, 1, 2352, 2, 13, 1, 1, 3, 1, 8), SnmpAdminString().subtype(subtypeSpec=ValueSizeConstraint(0, 128))).setMaxAccess("readcreate")
if mibBuilder.loadTexts: rcfJobPassword.setStatus('current')
rcfJobPassiveMode = MibTableColumn((1, 3, 6, 1, 4, 1, 2352, 2, 13, 1, 1, 3, 1, 9), TruthValue().clone('false')).setMaxAccess("readcreate")
if mibBuilder.loadTexts: rcfJobPassiveMode.setStatus('current')
rcfJobStopAtLine = MibTableColumn((1, 3, 6, 1, 4, 1, 2352, 2, 13, 1, 1, 3, 1, 10), Unsigned32()).setMaxAccess("readcreate")
if mibBuilder.loadTexts: rcfJobStopAtLine.setStatus('current')
rcfJobSaveDefaults = MibTableColumn((1, 3, 6, 1, 4, 1, 2352, 2, 13, 1, 1, 3, 1, 11), TruthValue().clone('false')).setMaxAccess("readcreate")
if mibBuilder.loadTexts: rcfJobSaveDefaults.setStatus('current')
rcfJobState = MibTableColumn((1, 3, 6, 1, 4, 1, 2352, 2, 13, 1, 1, 3, 1, 12), Integer32().subtype(subtypeSpec=ConstraintsUnion(SingleValueConstraint(0, 1, 2))).clone(namedValues=NamedValues(("pending", 0), ("inProgress", 1), ("completed", 2)))).setMaxAccess("readonly")
if mibBuilder.loadTexts: rcfJobState.setStatus('current')
rcfJobResult = MibTableColumn((1, 3, 6, 1, 4, 1, 2352, 2, 13, 1, 1, 3, 1, 13), Integer32().subtype(subtypeSpec=ConstraintsUnion(SingleValueConstraint(0, 1, 2, 3, 4, 5))).clone(namedValues=NamedValues(("success", 0), ("other", 1), ("noMemory", 2), ("parse", 3), ("io", 4), ("access", 5)))).setMaxAccess("readonly")
if mibBuilder.loadTexts: rcfJobResult.setStatus('current')
rcfJobErrorMsgs = MibTableColumn((1, 3, 6, 1, 4, 1, 2352, 2, 13, 1, 1, 3, 1, 14), SnmpAdminString()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rcfJobErrorMsgs.setStatus('current')
rcfJobCreateTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2352, 2, 13, 1, 1, 3, 1, 15), TimeStamp()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rcfJobCreateTime.setStatus('current')
rcfJobStartTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2352, 2, 13, 1, 1, 3, 1, 16), TimeStamp()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rcfJobStartTime.setStatus('current')
rcfJobStopTime = MibTableColumn((1, 3, 6, 1, 4, 1, 2352, 2, 13, 1, 1, 3, 1, 17), TimeStamp()).setMaxAccess("readonly")
if mibBuilder.loadTexts: rcfJobStopTime.setStatus('current')
rcfJobNotifyOnCompletion = MibTableColumn((1, 3, 6, 1, 4, 1, 2352, 2, 13, 1, 1, 3, 1, 18), TruthValue().clone('false')).setMaxAccess("readcreate")
if mibBuilder.loadTexts: rcfJobNotifyOnCompletion.setStatus('current')
rcfJobOwner = MibTableColumn((1, 3, 6, 1, 4, 1, 2352, 2, 13, 1, 1, 3, 1, 19), OwnerString()).setMaxAccess("readcreate")
if mibBuilder.loadTexts: rcfJobOwner.setStatus('current')
rcfJobRowStatus = MibTableColumn((1, 3, 6, 1, 4, 1, 2352, 2, 13, 1, 1, 3, 1, 20), RowStatus()).setMaxAccess("readcreate")
if mibBuilder.loadTexts: rcfJobRowStatus.setStatus('current')
rcfJobCompleted = NotificationType((1, 3, 6, 1, 4, 1, 2352, 2, 13, 0, 1)).setObjects(("RBN-CONFIG-FILE-MIB", "rcfJobResult"), ("RBN-CONFIG-FILE-MIB", "rcfJobErrorMsgs"))
if mibBuilder.loadTexts: rcfJobCompleted.setStatus('current')
rbnConfigFileCompliances = MibIdentifier((1, 3, 6, 1, 4, 1, 2352, 2, 13, 2, 1))
rbnConfigFileGroups = MibIdentifier((1, 3, 6, 1, 4, 1, 2352, 2, 13, 2, 2))
rcfJobGroup = ObjectGroup((1, 3, 6, 1, 4, 1, 2352, 2, 13, 2, 2, 1)).setObjects(("RBN-CONFIG-FILE-MIB", "rcfJobSpinLock"), ("RBN-CONFIG-FILE-MIB", "rcfJobNextIndex"), ("RBN-CONFIG-FILE-MIB", "rcfJobOp"), ("RBN-CONFIG-FILE-MIB", "rcfJobProtocol"), ("RBN-CONFIG-FILE-MIB", "rcfJobFilename"), ("RBN-CONFIG-FILE-MIB", "rcfJobIpAddressType"), ("RBN-CONFIG-FILE-MIB", "rcfJobIpAddress"), ("RBN-CONFIG-FILE-MIB", "rcfJobUsername"), ("RBN-CONFIG-FILE-MIB", "rcfJobPassword"), ("RBN-CONFIG-FILE-MIB", "rcfJobPassiveMode"), ("RBN-CONFIG-FILE-MIB", "rcfJobStopAtLine"), ("RBN-CONFIG-FILE-MIB", "rcfJobSaveDefaults"), ("RBN-CONFIG-FILE-MIB", "rcfJobState"), ("RBN-CONFIG-FILE-MIB", "rcfJobResult"), ("RBN-CONFIG-FILE-MIB", "rcfJobCreateTime"), ("RBN-CONFIG-FILE-MIB", "rcfJobStartTime"), ("RBN-CONFIG-FILE-MIB", "rcfJobStopTime"), ("RBN-CONFIG-FILE-MIB", "rcfJobErrorMsgs"), ("RBN-CONFIG-FILE-MIB", "rcfJobNotifyOnCompletion"), ("RBN-CONFIG-FILE-MIB", "rcfJobOwner"), ("RBN-CONFIG-FILE-MIB", "rcfJobRowStatus"))
if getattr(mibBuilder, 'version', (0, 0, 0)) > (4, 4, 0):
rcfJobGroup = rcfJobGroup.setStatus('current')
rcfJobNotifyGroup = NotificationGroup((1, 3, 6, 1, 4, 1, 2352, 2, 13, 2, 2, 2)).setObjects(("RBN-CONFIG-FILE-MIB", "rcfJobCompleted"))
if getattr(mibBuilder, 'version', (0, 0, 0)) > (4, 4, 0):
rcfJobNotifyGroup = rcfJobNotifyGroup.setStatus('current')
rbnConfigFileCompliance = ModuleCompliance((1, 3, 6, 1, 4, 1, 2352, 2, 13, 2, 1, 1)).setObjects(("RBN-CONFIG-FILE-MIB", "rcfJobGroup"), ("RBN-CONFIG-FILE-MIB", "rcfJobNotifyGroup"))
if getattr(mibBuilder, 'version', (0, 0, 0)) > (4, 4, 0):
rbnConfigFileCompliance = rbnConfigFileCompliance.setStatus('current')
mibBuilder.exportSymbols("RBN-CONFIG-FILE-MIB", rcfJobIpAddress=rcfJobIpAddress, rcfJobErrorMsgs=rcfJobErrorMsgs, rbnConfigFileMIBNotifications=rbnConfigFileMIBNotifications, rcfJobNotifyGroup=rcfJobNotifyGroup, rcfJobUsername=rcfJobUsername, rcfJobStartTime=rcfJobStartTime, rcfJobSpinLock=rcfJobSpinLock, rcfJobRowStatus=rcfJobRowStatus, rcfJobStopTime=rcfJobStopTime, rcfJobIpAddressType=rcfJobIpAddressType, rcfJobEntry=rcfJobEntry, rcfJobs=rcfJobs, rbnConfigFileGroups=rbnConfigFileGroups, rcfJobState=rcfJobState, rcfJobCompleted=rcfJobCompleted, rcfJobNextIndex=rcfJobNextIndex, rcfJobPassword=rcfJobPassword, rcfJobStopAtLine=rcfJobStopAtLine, rcfJobPassiveMode=rcfJobPassiveMode, rcfJobTable=rcfJobTable, rcfJobCreateTime=rcfJobCreateTime, rbnConfigFileMib=rbnConfigFileMib, rcfJobFilename=rcfJobFilename, rcfJobOp=rcfJobOp, rbnConfigFileMIBObjects=rbnConfigFileMIBObjects, rcfJobSaveDefaults=rcfJobSaveDefaults, rcfJobNotifyOnCompletion=rcfJobNotifyOnCompletion, rcfJobIndex=rcfJobIndex, PYSNMP_MODULE_ID=rbnConfigFileMib, rcfJobOwner=rcfJobOwner, rbnConfigFileCompliances=rbnConfigFileCompliances, rbnConfigFileCompliance=rbnConfigFileCompliance, rcfJobProtocol=rcfJobProtocol, rbnConfigFileMIBConformance=rbnConfigFileMIBConformance, rcfJobGroup=rcfJobGroup, rcfJobResult=rcfJobResult)
|
lista = ['Intel Core i9-9900KF.','Gigabyte B360M-Gaming 3','32GB DDR4 GDDR6','GeForce RTX 2080Ti','1TB de HD + 480GB de SSD','80PLUS 600W','Noctua NH-D15']
print('lista de todas as suas compras :', (lista))
print('Notamos que o preço da compra ultrapassou o orçamento limite definido pelo cliente, por isso, tomamos a liberdade de retirar a placa de vídeo e o cooler master da sua lista de compras.')
del lista[3]
del lista[5]
print('Nova lista :',(lista))
|
# 1이 될 때까지
# 하
# 그리드
N, K = map(int, input().split())
result = 0
while N >= K:
while N % K != 0:
N -= 1
result += 1
N //= K
result += 1
while N > 1:
result += 1
print(result)
|
# Definition for singly-linked list.
class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
class Solution:
def removeElements(self, head: ListNode, val: int) -> ListNode:
dummy = ListNode(-1)
dummy.next = head
def t(d):
if d.next:
if d.next.val == val:
d.next = d.next.next
t(d)
else:
t(d.next)
t(dummy)
return dummy.next
if __name__=="__main__":
output=Solution().removeElements([1,2,6,3,4,5,6],6)
print(output)
|
# nxn chessboard
n = 10
# number of dragons on the chessboard
dragons = 10
solution = [-1]*n
captured = [[0 for i in range(n)] for i in range(n)]
number = 0
local_calls = 0
total_calls = 0
def init():
global captured
def isCaptured(x, y):
global captured
return captured[x][y]
def capture(x, y):
for i in range(n):
captured[i][y] += 1
captured[x][i] += 1
# this point double counted in prev. for-loop,
captured[x][y] -= 1
i = x + 1
j = y + 1
while (i < n and j < n):
captured[i][j] += 1
i += 1
j += 1
i = x + 1
j = y - 1
while (i < n and j >= 0):
captured[i][j] += 1
i += 1
j -= 1
i = x - 1
j = y - 1
while (i >= 0 and j >= 0):
captured[i][j] += 1
i -= 1
j -= 1
i = x - 1
j = y + 1
while (i >= 0 and j < n):
captured[i][j] += 1
i -= 1
j += 1
if x - 2 >= 0:
if y - 1 >= 0:
captured[x-2][y-1] += 1
if y + 1 < n:
captured[x-2][y+1] += 1
if x + 2 < n:
if y - 1 >= 0:
captured[x + 2][y - 1] += 1
if y + 1 < n:
captured[x + 2][y + 1] += 1
if y - 2 >= 0:
if x - 1 >= 0:
captured[x - 1][y - 2] += 1
if x + 1 < n:
captured[x + 1][y - 2] += 1
if y + 2 < n:
if x - 1 >= 0:
captured[x - 1][y + 2] += 1
if x + 1 < n:
captured[x + 1][y + 2] += 1
def free (x, y):
for i in range(n):
captured[i][y] -= 1
captured[x][i] -= 1
# this point double counted in prev. for-loop,
captured[x][y] += 1
i = x + 1
j = y + 1
while (i < n and j < n):
captured[i][j] -= 1
i += 1
j += 1
i = x + 1
j = y - 1
while (i < n and j >= 0):
captured[i][j] -= 1
i += 1
j -= 1
i = x - 1
j = y - 1
while (i >= 0 and j >= 0):
captured[i][j] -= 1
i -= 1
j -= 1
i = x - 1
j = y + 1
while (i >= 0 and j < n):
captured[i][j] -= 1
i -= 1
j += 1
if x - 2 >= 0:
if y - 1 >= 0:
captured[x-2][y-1] -= 1
if y + 1 < n:
captured[x-2][y+1] -= 1
if x + 2 < n:
if y - 1 >= 0:
captured[x + 2][y - 1] -= 1
if y + 1 < n:
captured[x + 2][y + 1] -= 1
if y - 2 >= 0:
if x - 1 >= 0:
captured[x - 1][y - 2] -= 1
if x + 1 < n:
captured[x + 1][y - 2] -= 1
if y + 2 < n:
if x - 1 >= 0:
captured[x - 1][y + 2] -= 1
if x + 1 < n:
captured[x + 1][y + 2] -= 1
def find(x, d):
global captured, solution, number, total_calls, local_calls, dragons
total_calls += 1
local_calls += 1
if x == d:
number += 1
print("Soluiton: ", number, " Coord: ", solution)
print("Number of local calls ", local_calls)
local_calls = 0
return
for j in range(n):
if not isCaptured(x, j):
solution[x] = j
capture(x, j)
find(x + 1, dragons)
free(x, j)
print("")
print("Coordinate '-1' means no Dragon in that line")
print("")
find(0, dragons)
print("")
print("Number of total calls ", total_calls)
|
class ApiException(Exception):
pass
class Forbidden(ApiException):
def __init__(self, message):
self.message = message
self.status_code = 403
class NotFound(ApiException):
def __init__(self, message):
self.message = message
self.status_code = 404
class BadRequest(ApiException):
def __init__(self, message):
self.message = message
self.status_code = 400
|
#
# Copyright (C) 2018 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
def test(name, input0, input1, input2, output0, input0_data, input1_data, input2_data, output_data):
model = Model().Operation("SELECT", input0, input1, input2).To(output0)
quant8 = DataTypeConverter().Identify({
input1: ["TENSOR_QUANT8_ASYMM", 1.5, 129],
input2: ["TENSOR_QUANT8_ASYMM", 0.5, 127],
output0: ["TENSOR_QUANT8_ASYMM", 1.0, 128],
})
example = Example({
input0: input0_data,
input1: input1_data,
input2: input2_data,
output0: output_data,
}, model=model, name=name).AddVariations("int32", "float16", "relaxed", quant8)
test(
name="one_dim",
input0=Input("input0", "TENSOR_BOOL8", "{3}"),
input1=Input("input1", "TENSOR_FLOAT32", "{3}"),
input2=Input("input2", "TENSOR_FLOAT32", "{3}"),
output0=Output("output0", "TENSOR_FLOAT32", "{3}"),
input0_data=[True, False, True],
input1_data=[1, 2, 3],
input2_data=[4, 5, 6],
output_data=[1, 5, 3],
)
test(
name="two_dim",
input0=Input("input0", "TENSOR_BOOL8", "{2, 2}"),
input1=Input("input1", "TENSOR_FLOAT32", "{2, 2}"),
input2=Input("input2", "TENSOR_FLOAT32", "{2, 2}"),
output0=Output("output0", "TENSOR_FLOAT32", "{2, 2}"),
input0_data=[False, True, False, True],
input1_data=[1, 2, 3, 4],
input2_data=[5, 6, 7, 8],
output_data=[5, 2, 7, 4],
)
test(
name="five_dim",
input0=Input("input0", "TENSOR_BOOL8", "{2, 1, 2, 1, 2}"),
input1=Input("input1", "TENSOR_FLOAT32", "{2, 1, 2, 1, 2}"),
input2=Input("input2", "TENSOR_FLOAT32", "{2, 1, 2, 1, 2}"),
output0=Output("output0", "TENSOR_FLOAT32", "{2, 1, 2, 1, 2}"),
input0_data=[True, False, True, False, True, False, True, False],
input1_data=[1, 2, 3, 4, 5, 6, 7, 8],
input2_data=[9, 10, 11, 12, 13, 14, 15, 16],
output_data=[1, 10, 3, 12, 5, 14, 7, 16],
)
|
# -*- coding: utf-8 -*-
#
# Copyright (C) 2005-2018 Edgewall Software
# All rights reserved.
#
# This software is licensed as described in the file COPYING, which
# you should have received as part of this distribution. The terms
# are also available at http://trac.edgewall.com/license.html.
#
# This software consists of voluntary contributions made by many
# individuals. For the exact contribution history, see the revision
# history and logs, available at http://trac.edgewall.org/.
sql = [
"""CREATE TEMPORARY TABLE node_change_old AS SELECT * FROM node_change;""",
"""DROP TABLE node_change;""",
"""CREATE TABLE node_change (
rev text,
path text,
kind char(1),
change char(1),
base_path text,
base_rev text,
UNIQUE(rev, path, change)
);""",
"""INSERT INTO node_change (rev,path,kind,change,base_path,base_rev)
SELECT rev,path,kind,change,base_path,base_rev FROM node_change_old;""",
"""DROP TABLE node_change_old;"""
]
def do_upgrade(env, ver, cursor):
# Wiki pages were accidentially created with the version number starting at
# 0 instead of 1; This should fix that
cursor.execute("SELECT name, version FROM wiki WHERE name IN "
"(SELECT name FROM wiki WHERE version=0) ORDER BY name,"
"version DESC")
result = cursor.fetchall()
if result:
cursor.executemany("UPDATE wiki SET version=version+1 WHERE name=%s "
"and version=%s",
[tuple(row) for row in result])
# Correct difference between db_default.py and upgrades/db10.py: The
# 'change' was missing from the uniqueness constraint
for s in sql:
cursor.execute(s)
|
class LDAP_record:
"""
consume LDAP record and provide methods for accessing interesting data
"""
def __init__(self, unid):
self.error = False
ldap_dict = {}
#
# request complete user record from LDAP
cmd = "/Users/" + unid
try:
raw_data = subprocess.check_output(["/usr/bin/dscl", "/LDAPv3/your.ldap.server", "-read", cmd])
except:
self.error = True
return
#
# begin parsing data into dictionary
raw_data = string.replace(raw_data, '\n ', ' ')
raw_data = raw_data.split('\n')
for line in raw_data:
y = line.split(":")
y = [x for x in y if 'dsAttrTypeNative' not in x]
if len(y) == 2:
key = y[0]
value = y[1]
value = value.lstrip()
else:
key = y[0]
value = y[1:]
value = [x for x in value if x]
if key:
ldap_dict[key] = value
self.record = ldap_dict
def is_student(self):
try:
if 'CurrentStudent' in self.record['Student']:
return True
else:
return False
except:
return False
def is_staff(self):
try:
if self.record['Employee']: return True
except:
return False
def my_name(self):
try:
if self.record['gecos']:
if len(self.record['gecos']) > 1:
return self.record['gecos']
else:
# print "Beep!"
try:
if self.record['displayName']: return self.record['displayName']
except:
return None
except:
try:
if self.record['displayName']: return self.record['displayName']
except:
return None
def my_title(self):
try:
if self.record['title']: return self.record['title']
except:
return None
def my_email(self):
try:
if self.record['mail']: return self.record['mail']
except:
try:
if self.record['ExtensionAttribute4']: return self.record['ExtensionAttribute4']
except:
return None
def my_phone(self):
try:
if self.record['telephoneNumber']: return self.record['telephoneNumber']
except:
return None
def my_department(self):
try:
if self.record['department']: return self.record['department']
except:
return None
def my_address(self):
try:
if self.record['streetAddress']: return self.record['streetAddress']
except:
return None
#
# diagnostic methods
def print_full(self):
for k, v in self.record.items():
print ("%s > %r" % (k, v))
def print_keys(self):
return self.record.keys()
def ldap(self):
"""
translate LDAP data from object into fields used in tugboat
"""
try:
self.status_label.configure(style='Normal.TLabel')
self.status_string.set("LDAP selected.")
if self.valid_unid():
print("ldap %r" % self.endusername_string.get())
this_person = LDAP_record(self.endusername_string.get())
if not this_person.error:
self.fullname_string.set(this_person.my_name())
self.email_string.set(this_person.my_email())
self.phone_string.set(this_person.my_phone())
self.room_string.set(this_person.my_address())
if this_person.my_title() is None:
if this_person.my_department() is None:
self.position_string.set("")
else:
self.position_string.set(this_person.my_department())
else:
if this_person.my_department() is None:
self.position_string.set(this_person.my_title())
else:
self.position_string.set(this_person.my_title() + "/" + this_person.my_department())
if self.division_string.get():
self.division_string.set('None')
if self.building_string.get():
self.building_string.set('None')
else:
self.status_label.configure(style='Warning.TLabel')
self.status_string.set("LDAP error, no record found for uNID.")
self.reset_data()
else:
self.status_label.configure(style='Warning.TLabel')
self.status_string.set("Error setting LDAP Mode, no valid uNID.")
self.reset_user()
return
except ValueError:
self.status_label.configure(style='Warning.TLabel')
self.status_string.set("Error setting LDAP Mode.")
return
|
NAME='nagios'
CFLAGS = []
LDFLAGS = []
LIBS = []
GCC_LIST = ['nagios']
|
class Solution:
def find_permutation(self, S):
S = sorted(S)
self.res = []
visited = [False] * len(S)
self.find_permutationUtil(S, visited, '')
return self.res
def find_permutationUtil(self, S, visited, str):
if len(str) == len(S):
self.res.append(str)
return
for i in range(len(S)):
char = S[i]
if visited[i] == False:
visited[i] = True
self.find_permutationUtil(S, visited, str+char)
visited[i] = False
if __name__ == '__main__':
sol = Solution()
sol.find_permutation("ABC")
|
s = set(map(int, input().split()))
print(s)
print("max is: ",max(s))
print("min is: ",min(s))
|
def transact(environment, t, to_agent, from_agent, settlement_type, amount, description):
"Function that ensures a correct transaction between agents"
environment.measurement['period'].append(t)
environment.measurement['to_agent'].append(to_agent)
environment.measurement['from_agent'].append(from_agent)
environment.measurement['settlement_type'].append(settlement_type)
environment.measurement['amount'].append(amount)
environment.measurement['description'].append(description)
|
class NSGA2:
def __init__(self, initializer, evaluator, selector, crossover, mutator, stopper):
self.initializer = initializer
self.evaluator = evaluator
self.selector = selector
self.crossover = crossover
self.mutator = mutator
self.stopper = stopper
self.population = None
self.population_log = []
def make_phenotype(self, population):
for individual in population.values():
individual.evaluate()
def make_next_population(self, champions):
next_population = {}
for parent_a, parent_b in zip(champions[::2], champions[1::2]):
child_a, child_b = self.crossover.crossover(parent_a, parent_b)
next_population[child_a.individual_id] = child_a
next_population[child_b.individual_id] = child_b
for individual in next_population.values():
self.mutator.mutate(individual)
return next_population
def search(self, verbose=False):
if verbose:
print("Initialize population...")
population = self.initializer.initialize()
self.make_phenotype(population)
self.evaluator.evaluate(population)
self.population_log.append(population)
if verbose:
print("Run search...")
interrupt = False
while not self.stopper.stop(population):
try:
champions = self.selector.select(population)
next_population = self.make_next_population(champions)
self.make_phenotype(next_population)
self.evaluator.evaluate(next_population)
population = next_population
self.population_log.append(population)
except KeyboardInterrupt:
if verbose:
print("Search interrupted...")
break
if verbose:
print("Terminating search...")
self.population = population
return population
|
class RetrievalError(Exception):
pass
class SetterError(Exception):
pass
class ControlError(SetterError):
pass
class AuthentificationError(Exception):
pass
class TemporaryAuthentificationError(AuthentificationError):
pass
class APICompatibilityError(Exception):
pass
class APIError(Exception):
pass
|
# Based on largest_rectangle_in_histagram 84
def maximal_rectrangle_in_matrix(matrix):
if len(matrix) == 0 or len(matrix[0]) == 0:
return 0
# Append extra 0 to the end, to mark the end of the curr row
curr_row = [0] * (len(matrix[0]) + 1)
ans = 0
for row in range(len(matrix)):
for column in range(len(matrix[0])):
if matrix[row][column] == '1':
curr_row[column] += 1
else:
curr_row[column] = 0
stack = [-1]
# print(curr_row)
for curr_index, height in enumerate(curr_row):
while height < curr_row[stack[-1]]:
prev_index = stack.pop()
h = curr_row[prev_index]
w = curr_index - stack[-1] - 1
ans = max(ans, h * w)
# print(ans, curr_index, prev_index)
stack.append(curr_index)
return ans
# print(maximal_rectrangle_in_matrix([["0", "1"], ["1", "0"]]))
print(maximal_rectrangle_in_matrix([
["1", "0", "1", "0", "0"],
["1", "0", "1", "1", "1"],
["1", "1", "1", "1", "1"],
["1", "0", "0", "1", "0"]
]))
def maximalRectangle_new(matrix):
if not matrix or not matrix[0]:
return 0
n = len(matrix[0])
height = [0] * (n + 1)
ans = 0
for row in matrix:
for i in range(n):
height[i] = height[i] + 1 if row[i] == '1' else 0
stack = [-1]
# print(height)
for i in range(n + 1):
while height[i] < height[stack[-1]]:
h = height[stack.pop()]
w = i - 1 - stack[-1]
ans = max(ans, h * w)
stack.append(i)
return ans
# print(maximal_rectrangle_in_matrix([["0", "1"], ["1", "0"]]))
print(maximalRectangle_new([
["1", "0", "1", "0", "0"],
["1", "0", "1", "1", "1"],
["1", "1", "1", "1", "1"],
["1", "0", "0", "1", "0"]
]))
|
class Deque(object):
"""A deque (double-ended queue) is a linear structure of
ordered items where the addition and removal of items can
take place on any end.
Thus deques can work as FIFO (First In, First Out) or
LIFO (Last In, First Out)
Examples:
>>> d = Deque()
>>> d.is_empty()
True
>>> d.add_front(4)
>>> d.add_front('dog')
>>> print(d)
[4, 'dog']
>>> d.size()
2
>>> d.remove_front()
'dog'
>>> d.add_rear(True)
>>> print(d)
[True, 4]
>>> d.remove_rear()
True
"""
def __init__(self):
self.items = []
def __str__(self):
"""Return the string method of the deque"""
return str(list(self.items))
def is_empty(self):
"""See whether the deque is empty"""
return self.items == []
def add_front(self, item):
"""Add an item in the front"""
self.items.append(item)
def add_rear(self, item):
"""Add an item in the rear"""
self.items.insert(0, item)
def remove_front(self):
"""Remove an item in the front"""
return self.items.pop()
def remove_rear(self):
"""Remove an item in the rear"""
return self.items.pop(0)
def size(self):
"""Return the number of items on the deque"""
return len(self.items)
|
"""
Sampler metadata
"""
class Sampler(object):
method_name = None
def __init__(self):
pass
class GibbsSampler(Sampler):
method_name = 'gibbs'
def __init__(self, n_iter=1000, n_burnin=100, n_thread=1):
# super(GibbsSampler, self).__init__()
self.n_iter = n_iter
self.n_burnin = n_burnin
self.n_thread = n_thread
class MAPtpx(Sampler):
method_name = 'maptpx'
SAMPLERS = [(cls.method_name, cls) for cls in (GibbsSampler, MAPtpx)]
|
# A program to check if the number is odd or even
def even_or_odd(num):
if num == "q":
return "Invalid"
elif num % 2 == 0:
return "Even"
else:
return "Odd"
while True:
try:
user_input = float(input("Enter then number you would like to check is odd or even"))
except ValueError or TypeError:
user_input = "q"
finally:
print("The number is ", even_or_odd(user_input))
|
# -*- coding: utf-8 -*-
"""
Created on Mon Feb 13 16:43:18 2017
@author: coskun
"""
def closest_power(base, num):
'''
base: base of the exponential, integer > 1
num: number you want to be closest to, integer > 0
Find the integer exponent such that base**exponent is closest to num.
Note that the base**exponent may be either greater or smaller than num.
In case of a tie, return the smaller value.
Returns the exponent.
'''
exp = 0
# Limitations here
if base <= 1:
return 0
if num <= 0:
return 0
if base == num:
return 1
if num == 1:
return 0
if abs(base) > abs(num):
return 0
else:
i = 1
tmp = 0
while abs(base)**i < abs(num):
tmp = i
i += 1
if abs(num) == abs(base)**i:
#global exp
exp = i
elif (abs(num) - abs(base)**tmp) == (abs(base)**i - abs(num)):
# in case of tie :)
exp = tmp
elif (abs(num) - abs(base)**tmp) < (abs(base)**i - abs(num)):
#global exp
exp = tmp
else:
#global exp
exp = i
#Return Conditions
return exp
print(closest_power(3,210))
|
class Solution:
def minCut(self, s: str) -> int:
if not s:
return 0
memo = dict()
def helper(l,r):
if l > r:
return 0
minVal = float('inf')
for i in range(l,r+1,1):
strs = s[l:i+1]
if strs == strs[::-1]:
if s[i+1:r+1] in memo:
minVal = min(memo[s[i+1:r+1]], minVal)
else:
minVal = min(helper(i+1,r), minVal)
memo[s[l:r+1]] = minVal + 1
return memo[s[l:r+1]]
helper(0,len(s)-1)
return memo[s]-1 if memo[s] != float('inf') else 0
|
'''https://practice.geeksforgeeks.org/problems/cyclically-rotate-an-array-by-one2614/1
Cyclically rotate an array by one
Basic Accuracy: 64.05% Submissions: 66795 Points: 1
Given an array, rotate the array by one position in clock-wise direction.
Example 1:
Input:
N = 5
A[] = {1, 2, 3, 4, 5}
Output:
5 1 2 3 4
Example 2:
Input:
N = 8
A[] = {9, 8, 7, 6, 4, 2, 1, 3}
Output:
3 9 8 7 6 4 2 1
Your Task:
You don't need to read input or print anything. Your task is to complete the function rotate() which takes the array A[] and its size N as inputs and modify the array.
Expected Time Complexity: O(N)
Expected Auxiliary Space: O(1)
Constraints:
1<=N<=105
0<=a[i]<=105'''
def rotate(arr, n):
temp = arr[n-1]
i = n-1
while(i > 0):
b = i-1
arr[i] = arr[b]
i -= 1
arr[0] = temp
|
#!/usr/bin/env python
# -*- coding:utf-8 -*-
def max_min(v):
m_min, m_max = min(v[0], v[-1]), max(v[0], v[-1])
for i in v[1:len(v)-1]:
if i<m_min:
m_min = i
elif i > m_max:
m_max = i
return m_min, m_max
if __name__ == '__main__':
m_min, m_max = max_min([9, 3, 4, 7, 2, 0])
print(m_min, m_max)
|
# -*- coding: utf-8 -*-
"""
seqansphinx
~~~~~~~~~~~~~
This package is a namespace package that contains all extensions
distributed in the ``seqansphinx`` distribution.
:copyright: Copyright 2014 by Manuel Holtgrewe
:license: MIT, see LICENSE for details.
"""
__import__('pkg_resources').declare_namespace(__name__)
|
print(f'\033[1:33m{"-"*40:^40}\033[m')
print(f'\033[1:33m{"CADASTRO DE JOGADOR DE FUTEBOL - v2.0":^40}\033[m')
print(f'\033[1:33m{"-"*40:^40}\033[m')
player = dict()
matches = list()
team = list()
status = 'o'
allMatches = allGoals = 0
while status not in 'nN':
player['Nome'] = str(input('Nome do jogador: '))
allMatches = int(input(f'Quantas partidas {player["Nome"]} jogou? '))
for i in range(0, allMatches):
matches.append(int(input(f'Gols na {i+1}ª partida: ')))
allGoals = allGoals + matches[i]
player['Gols'] = matches[:]
player['Total'] = allGoals
team.append(player.copy())
player.clear()
matches.clear()
allGoals = 0
status = input('Deseja continuar? [\033[1:32mS\033[m/\033[1:31mN\033[m] ')
while status not in 'nNsS':
status = input('Deseja continuar? [\033[1:32mS\033[m/\033[1:31mN\033[m] ')
print(f'\033[1m{"-" * 50}\033[m')
print(f'Nº Nome Gols Total')
print(f'\033[1m{"-" * 50}\033[m')
for i in range(0, len(team)):
if i >= 1:
print()
print(f'\033[1m{i:<4}\033[m', end='')
for k, v in team[i].items():
if k == 'Nome':
print(f'\033[1:32m{v:<12}\033[m', end='')
elif k == 'Gols':
n = 23 - (len(team[i]['Gols'])*3)
print(f' \033[1m{v}\033[m', ' '*n, end='')
elif k == 'Total':
print(f'\033[1:35m{v:<4}\033[m', end='')
print(f'\n\033[1m{"-" * 50}\033[m')
print(f'\033[1:33m[999 para finalizar]\033[m')
option = int(input('Mostrar dados de qual jogador? (Nº) '))
while option != 999:
while option < 0 or option > len(team)-1:
print(f'\033[1:31mERRO!\033[m Não existe um jogador com o nº {option}')
option = int(input('Mostrar dados de qual jogador? (Nº) '))
if option == 999:
break
if option == 999:
break
print(f'>> LEVANTAMENTO DO JOGADOR \033[1:32m{team[option]["Nome"]}\033[m')
for k in range(0, len(team[option]['Gols'])):
if team[option]["Gols"][k] == 0:
print(f' <> No \033[1:34m{k+1}º jogo\033[m fez \033[1:31mNenhum gol\033[m.')
elif team[option]["Gols"][k] == 1:
print(f' <> No \033[1:34m{k+1}º jogo\033[m fez \033[1:31m{team[option]["Gols"][k]} gol\033[m.')
else:
print(f' <> No \033[1:34m{k+1}º jogo\033[m fez \033[1:31m{team[option]["Gols"][k]} gols\033[m.')
print(f'\033[1m{"-" * 50}\033[m')
option = int(input('Mostrar dados de qual jogador? (Nº) '))
print(f'\033[1m{"-" * 50}\033[m')
print(f'\033[33m{"< < < < < < < <-- VOLTE SEMPRE! --> > > > > > > >":^50}\033[m')
|
string = [x for x in input()]
string_list_after = []
index = 0
power = 0
for el in range(len(string)):
if string[index] == ">":
expl = int(string[el + 1])
power += int(expl)
string.pop(el+1)
string.append('')
power -= 1
while power > 0:
index = el
string.pop(el + 1)
string.append('')
power -= 1
else:
string_list_after.append(string[index])
index += 1
print()
|
"""Exceptions for cmd_utils."""
class CommandException(Exception):
"""
Base Exception for cmd_utils exceptions.
Attributes:
exc - string message
return_code - return code of command
"""
def __init__(self, exc, return_code=None):
Exception.__init__(self)
self.exc = exc
self.return_code = return_code
def __str__(self):
return self.__repr__()
def __repr__(self):
return self.exc
class ReturnCodeError(CommandException):
"""Raised when a command returns a non-zero exit code."""
pass
class SSHError(CommandException):
"""Raised when SSH connection fails."""
pass
|
#A more compact version of the algorithm that can be executed parallelly.
list1 = [0x58, 0x76, 0x54, 0x3a, 0xbe, 0x58, 0x76, 0x54, 0xbe, 0xcd, 0x45, 0x66, 0x85, 0x65]
# ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^
# Par=4: bulk bulk bulk bulk bulk bulk bulk bulk bulk bulk bulk bulk rest rest
# desc desc desc
def parallel_roling_mac_hash(list, par):
multiplier = 0x01000193 #algorithm parameter
hash = [0 for x in range(par)] #the fields of the array can be computed parallelly
mult_powers = [multiplier**(x+1) for x in range(par)]
list_length = len(list)
bulk = list_length//par
rest = list_length%par
for i in range(rest): #"rest" number of threads have to go one step further
for j in range(bulk + 1):
index = j * par + i
hash[i] += list[index]
if index > list_length-par:
mult_index = -par + (list_length - index) - 1 #going from highest power to first order
hash[i] *= mult_powers[mult_index]
else:
hash[i] *= mult_powers[-1]
hash[i] %= 2**32
for i in range(rest,par): #threads for calculating the remaining data
for j in range(bulk):
index = j * par + i
hash[i] += list[index]
if index > list_length-par:
mult_index = -par + (list_length - index) - 1 #going from highest power to first order
hash[i] *= mult_powers[mult_index]
else:
hash[i] *= mult_powers[-1]
hash[i] %= 2**32
sum = 0
for i in range(par): #summing up results of the parallel computations (single threaded mostly)
sum += hash[i]
sum %= 2**32
return(sum)
#TESTING
def rolling_hash_by_mac(list):
hash = 0
for byte in list:
hash += byte
hash *= 0x01000193
hash %= 2**32
return(hash)
print('parallel:', parallel_roling_mac_hash(list1,3))
print('parallel:', parallel_roling_mac_hash(list1,5))
print('parallel:', parallel_roling_mac_hash(list1,8))
print('expected:', rolling_hash_by_mac(list1))
|
#!/usr/bin/env python
# coding: utf-8
# In[ ]:
# In[4]:
def fib(n):
a, b = 0,1
while a < n:
print(a)
a, b = b, a + b
# In[8]:
def primos(n):
numbers = [True, True] + [True] * (n-1)
last_prime_number = 2
i = last_prime_number
while last_prime_number**2 <= n:
i += last_prime_number
while i <= n:
numbers[i] = False
i += last_prime_number
j = last_prime_number + 1
while j < n:
if numbers[j]:
last_prime_number = j
break
j += 1
i = last_prime_number
return [i + 2 for i, not_crossed in enumerate(numbers[2:]) if not_crossed]
# In[34]:
def perfecto(num):
suma = 0
for i in range(1, num):
#print(i)
if num % i == 0:
suma = suma + i
if (suma == num):
return True
else:
return False
# In[45]:
def numeros_perfectos(n):
factors = []
i = 1
while len(factors) != n:
if perfecto(i):
factors.append(i)
i += 1
return factors
# In[48]:
numeros_perfectos(3)
primos(10)
fib(10)
# In[ ]:
|
"""
Number of Provinces
There are n cities. Some of them are connected, while some are not.
If city a is connected directly with city b, and city b is connected directly with city c,
then city a is connected indirectly with city c.
A province is a group of directly or indirectly connected cities
and no other cities outside of the group.
You are given an n x n matrix isConnected where isConnected[i][j] = 1 if the
ith city and the jth city are directly connected, and
isConnected[i][j] = 0 otherwise.
Return the total number of provinces.
Example 1:
Input: isConnected = [[1,1,0],[1,1,0],[0,0,1]]
Output: 2
Example 2:
Input: isConnected = [[1,0,0],[0,1,0],[0,0,1]]
Output: 3
Constraints:
1 <= n <= 200
n == isConnected.length
n == isConnected[i].length
isConnected[i][j] is 1 or 0.
isConnected[i][i] == 1
isConnected[i][j] == isConnected[j][i]
"""
# time: O(n^2)
# space: O(n) to store visit list
class Solution:
def findCircleNum(self, M: List[List[int]]) -> int:
if not M:
return 0
n = len(M)
visit = [False]*n
def dfs(u):
for v in range(n):
if M[u][v] ==1 and visit[v] == False:
visit[v] = True
dfs(v)
count = 0
for i in range(n):
if visit[i] == False:
count += 1
visit[i] = True
dfs(i)
return count
|
class CliError(RuntimeError):
pass
|
class AjaxableResponseMixin(object):
"""
Mixin to add AJAX support to a form.
Must be used with an object-based FormView (e.g. CreateView)
"""
def form_invalid(self, form):
response = super(AjaxableResponseMixin, self).form_invalid(form)
if self.request.is_ajax():
return JsonResponse(form.errors, status=400)
else:
return response
def form_valid(self, form):
# We make sure to call the parent's form_valid() method because
# it might do some processing (in the case of CreateView, it will
# call form.save() for example).
response = super(AjaxableResponseMixin, self).form_valid(form)
if self.request.is_ajax():
data = {
'pk': self.object.pk,
}
return JsonResponse(data)
else:
return response
|
#!/usr/bin/env python
__author__ = "Giuseppe Chiesa"
__copyright__ = "Copyright 2017-2021, Giuseppe Chiesa"
__credits__ = ["Giuseppe Chiesa"]
__license__ = "BSD"
__maintainer__ = "Giuseppe Chiesa"
__email__ = "mail@giuseppechiesa.it"
__status__ = "PerpetualBeta"
def write_with_modecheck(file_handler, data):
if file_handler.mode == 'w':
file_handler.write(data.decode('utf-8'))
else:
file_handler.write(data)
|
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
class BaseEmitter(object):
'''Base for emitters of the *data-migrator*.
Attributes:
manager (BaseManager): reference to the manager that is calling this
emitter to export objects from that manager
model_class (Model): reference to the model linked to the class
extension (str): file extension for output file of this emitter
note: :attr:`~.model_class` and :attr:`~.manager` are linked together
'''
def __init__(self, extension=None, manager=None):
# reference to the manager that is calling this emitter to
# export objects from the manager
self.manager = manager
self.model_class = manager.model_class
self.meta = self.model_class._meta
self.extension = extension or getattr(self.__class__,
'extension', '.txt')
def emit(self, l):
'''output the result set of an object.
Args:
l (Model): object to transform
Returns:
list: generated strings
'''
raise NotImplementedError
def filename(self):
'''generate filename for this emitter.
generates a filename bases on :attr:`~.BaseEmitter.extension` and
either :attr:`~.Options.file_name` or :attr:`~.Options.table_name`
Returns:
str: filename
'''
_ext = self.extension
if _ext[0] != '.':
_ext = '.' + _ext
_filename = self.meta.file_name or (self.meta.table_name + _ext)
return _filename
def preamble(self, headers):
'''generate a premable for the file to emit.
Args:
headers (list): additional header to provide outside the emitter
(e.g. statistics)
Returns:
list: preamble lines
'''
raise NotImplementedError
def postamble(self): #pylint disable=no-self-use
'''generate a postamble for the file to emit.
Returns:
list: postamble lines
'''
return []
|
"""
LeetCode Problem: 833. Find And Replace in String
Link: https://leetcode.com/problems/find-and-replace-in-string/
Language: Python
Written by: Mostofa Adib Shakib
Time complexity: O(n)
Space Complexity: O(n)
"""
class Solution:
def findReplaceString(self, S: str, indexes: List[int], sources: List[str], targets: List[str]) -> str:
modified = list(S)
for index, source, target in zip(indexes, sources, targets):
if not S[index:].startswith(source):
continue
else:
modified[index] = target
for i in range(index+1, len(source) + index):
modified[i] = ""
return "".join(modified)
|
class Stack(object):
def __init__(self):
self.stack = []
def is_empty(self):
return not self.stack
def push(self, v):
self.stack.append(v)
def pop(self):
data = self.stack[-1]
del self.stack[-1]
return data
def peek(self):
return self.stack[-1]
def size_stack(self):
return len(self.stack)
if __name__ == "__main__":
s = Stack()
s.push(1)
s.push(2)
s.push(3)
print(s.size_stack())
print("Popped: ", s.pop())
print("Popped: ", s.pop())
print(s.size_stack())
print("Peek: ", s.peek())
print("Popped: ", s.pop())
print(s.size_stack())
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.