I am new to Kivy and widget binding.
I found the following code on Github that presents a time picker with a nice clock.
It should be simple but I just don't get how to modify the program to simply print out the time.
from kivy.lang import Builder
from kivymd.app import MDApp
from kivymd.uix.picker import MDTimePicker
KV = '''
FloatLayout:
MDRaisedButton:
text: "Time 1"
pos_hint: {'x': .1, 'y': .95}
on_release: app.show_time_picker1()
'''
class Clock(MDApp):
def build(self):
return Builder.load_string(KV)
def show_time_picker1(self):
'''Open time picker dialog.'''
time_dialog1 = MDTimePicker()
time_dialog1.bind(time=self.get_time)
time_dialog1.open()
def get_time(self, instance, time):
'''
The method returns the set time.
:type instance: <kivymd.uix.picker.MDTimePicker object>
:type time: <class 'datetime.time'>
'''
return time
Clock().run()
Just add a print to the get_time() method:
def get_time(self, instance, time):
'''
The method returns the set time.
:type instance: <kivymd.uix.picker.MDTimePicker object>
:type time: <class 'datetime.time'>
'''
print('picked time is', time)
return time
Related
I am trying to write a class that create methods dynamically that should executed parallel each with it's own duration with asyncio. But I am really new in the topic python asyncio and now on a point where I got stuck and have no idea how to go.
I collect servers with ip, port and command duration from config file and try to create methods in a loop and then gather these methods with async, here is my code:
import asyncio
from datetime import datetime
# from common.config import ConfigConstructor
class RCONserver:
def __init__(self, game: str, server_name=None):
self.game = game
self.server_name = server_name
# self.game_config = ConfigConstructor('cfg/rcon_server.yml')
async def send_rcon_command(self, ip: str, port: str, period: int, cnt: int):
await asyncio.sleep(int(period))
print(str(datetime.now()) + ": " + ip + " " + port)
def get_servers(self):
servers = []
for server in ['game1','game2']:
print(server)
if server[:4] == "game":
# s = self.game_config
# s.fetch_section(server)
# print(s)
servers.append(
self.send_rcon_command('192.168.178.1',
'30000',
300,
3)
return servers
async def main():
obj = RCONserver('game')
await asyncio.gather(*obj.get_servers())
asyncio.run(main())
The code is running but only one time for each server in the yml File.
What do I have to do to run it periodically for the given parameter watch period?
i think this should do the trick with loop and gather i can create functions dynamically and run each with it's own interval parallel:
import asyncio
from datetime import datetime
import random
class RCONServer:
def __init__(self):
self.rcon_loop = asyncio.get_event_loop()
def dt(self):
return datetime.now().strftime("%Y/%m/%d %H:%M:%S")
def build_rcon_functions(self):
rcon_servers = []
for server in ['game1','game2']:
rcon_servers.append(
self.rcon_command(server,
"192.168.0.1",
"30000",
"some_password",
random.randint(5, 10)
)
)
return rcon_servers
async def rcon_command(self, server: str, ip: str, port: str, passwd: str, interval: int):
while True:
await asyncio.sleep(int(interval))
print(self.dt(), ">", server)
async def run_loop(self):
rcon_tasks = self.build_rcon_functions()
try:
print(self.dt(), "> Start")
await asyncio.gather(*rcon_tasks)
self.rcon_loop.run_forever()
except KeyboardInterrupt:
pass
finally:
print(self.dt(), "> End")
self.rcon_loop.close()
obj = RCONServer()
asyncio.run(obj.run_loop())
Some suggestions for optimizing? or some hints how it can be solved better?
class budgetSerializer(serializers.ModelSerializer):
budget_used = serializers.SerializerMethodField()
budget_remain = serializers.SerializerMethodField()
total_budget = serializers.IntegerField(default=250000)
def get_budget_used(self, obj):
budget_used = budget_u.objects.filter(
user=obj.user
).aggregate(total=Sum('budget_stord__bytes'))['total'] or 0
if budget_used > 250000:
return 'you exceed the total budget limit'
return f'budget : {(budget_used/1000)}'
def get_total_budget(self,obj):
total_budget = 250000
return f'total_budget: {(total_budget/1000)} '
def get_remain(self,obj):
remain = (self.context.get(total_budget)) - (self.context.get(budget_used))
return remain
class Meta:
model = budget_u
fields = ("budget_used","total_budget","budget_remain")
Any help when i run the code above aim getting Error
(self.context.get(total_budget)) - (self.context.get(budget_used)) TypeError:
unsupported operand type(s) for -: 'NoneType' and 'NoneType'
The context does not store values of intermediate calculations, it is a dictionary that is used, for example by a ModelViewSet to inject data into the serializer.
To make matters even worse, even if the context indeed behaved the way as you are using it, it would still not work, since the get_budget_used and get_total_budget methods, return strings. You can not subtract two strings from each other, what would 'foo' - 'bar' mean? Or in this case 'total budget: 25000' - 'budget : 1425'? This may look simple if you interpret the strings, but for Python these are just strings, and the operations need to be non-ambiguous, hence it makes no sense.
You can define methods that return the value, and then use these by calling the functions:
class budgetSerializer(serializers.ModelSerializer):
# …
def _budget_used(self, obj):
return budget_u.objects.filter(
user=obj.user
).aggregate(total=Sum('budget_stord__bytes'))['total'] or 0
def _total_budget(self, obj):
return 250000
def get_budget_used(self, obj):
budget_used = self._budget_used(obj)
if budget_used > 250000:
return 'you exceed the total budget limit'
return f'budget : {(budget_used/1000)}'
def get_total_budget(self, obj):
total_budget = self._total_budget(obj)
return f'total_budget: {(total_budget/1000)} '
def get_remain(self,obj):
return self._total_budget(obj) - self._budget_used(obj)
Is overriding from_yaml enough to register a tag from a class or is it necessary to use yaml.add_constructor(Class.yaml_tag, Class.from_yaml)? If I don't use te add_constructor method, my YAML tags are not recognized. Example of what I have:
import yaml
class Something(yaml.YAMLObject):
yaml_tag = u'!Something'
#classmethod
def from_yaml(cls,loader,node):
# Set attributes to None if not in file
values = loader.construct_mapping(node, deep=True)
attr = ['attr1','attr2']
result = {}
for val in attr:
try:
result[val] = values[val]
except KeyError:
result[val] = None
return cls(**result)
Is this enough for it to work? I'm confused with the use of from_yaml vs any other constructor you would register using the method I mentioned above. I suppose there's something fundamental I'm missing, since they say:
Subclassing YAMLObject is an easy way to define tags, constructors,
and representers for your classes. You only need to override the
yaml_tag attribute. If you want to define your custom constructor and
representer, redefine the from_yaml and to_yaml method
correspondingly.
There is indeed no need to register explicitly:
import yaml
class Something(yaml.YAMLObject):
yaml_tag = u'!Something'
def __init__(self, *args, **kw):
print('some_init', args, kw)
#classmethod
def from_yaml(cls,loader,node):
# Set attributes to None if not in file
values = loader.construct_mapping(node, deep=True)
attr = ['attr1','attr2']
result = {}
for val in attr:
try:
result[val] = values[val]
except KeyError:
result[val] = None
return cls(**result)
yaml_str = """\
test: !Something
attr1: 1
attr2: 2
"""
d = yaml.load(yaml_str)
which gives:
some_init () {'attr1': 1, 'attr2': 2}
But there is no need at all to use PyYAML's load() which is
documented to be unsafe. You can just use safe_load if you set the yaml_loader class attribute:
import yaml
class Something(yaml.YAMLObject):
yaml_tag = u'!Something'
yaml_loader = yaml.SafeLoader
def __init__(self, *args, **kw):
print('some_init', args, kw)
#classmethod
def from_yaml(cls,loader,node):
# Set attributes to None if not in file
values = loader.construct_mapping(node, deep=True)
attr = ['attr1','attr2']
result = {}
for val in attr:
try:
result[val] = values[val]
except KeyError:
result[val] = None
return cls(**result)
yaml_str = """\
test: !Something
attr1: 1
attr2: 2
"""
d = yaml.safe_load(yaml_str)
as this gives the same:
some_init () {'attr1': 1, 'attr2': 2}
(done both with Python 3.6 and Python 2.7)
The registering is done in the __init__() of the metaclass of yaml.YAMLObject:
class YAMLObjectMetaclass(type):
"""
The metaclass for YAMLObject.
"""
def __init__(cls, name, bases, kwds):
super(YAMLObjectMetaclass, cls).__init__(name, bases, kwds)
if 'yaml_tag' in kwds and kwds['yaml_tag'] is not None:
cls.yaml_loader.add_constructor(cls.yaml_tag, cls.from_yaml)
cls.yaml_dumper.add_representer(cls, cls.to_yaml)
So maybe you are somehow interfering with that initialisation in your full class definition. Try to start with a minimal implementation as I did, and add the functionality on your class that you need until things break.
I have an ABC BaseAbstract class with several getter/setter properties defined.
I want to require that the value to be set is an int and from 0 - 15.
#luminance.setter
#abstractproperty
#ValidateProperty(Exception, types=(int,), valid=lambda x: True if 0 <= x <= 15 else False)
def luminance(self, value):
"""
Set a value that indicate the level of light emitted from the block
:param value: (int): 0 (darkest) - 15 (brightest)
:return:
"""
pass
Can someone help me figure out what my ValidateProperty class/method should look like. I started with a class and called the accepts method but this is causing an error:
function object has no attribute 'func_code'
current source:
class ValidateProperty(object):
#staticmethod
def accepts(exception, *types, **kwargs):
def check_accepts(f, **kwargs):
assert len(types) == f.func_code.co_argcount
def new_f(*args, **kwds):
for i, v in enumerate(args):
if f.func_code.co_varnames[i] in types and\
not isinstance(v, types[f.func_code.co_varnames[i]]):
arg = f.func_code.co_varnames[i]
exp = types[f.func_code.co_varnames[i]]
raise exception("arg '{arg}'={r} does not match {exp}".format(arg=arg,
r=v,
exp=exp))
# del exp (unreachable)
for k,v in kwds.__iter__():
if k in types and not isinstance(v, types[k]):
raise exception("arg '{arg}'={r} does not match {exp}".format(arg=k,
r=v,
exp=types[k]))
return f(*args, **kwds)
new_f.func_name = f.func_name
return new_f
return check_accepts
One of us is confused about how decorators, descriptors (e.g. properties), and abstracts work -- I hope it's not me. ;)
Here is a rough working example:
from abc import ABCMeta, abstractproperty
class ValidateProperty:
def __init__(inst, exception, arg_type, valid):
# called on the #ValidateProperty(...) line
#
# save the exception to raise, the expected argument type, and
# the validator code for later use
inst.exception = exception
inst.arg_type = arg_type
inst.validator = valid
def __call__(inst, func):
# called after the def has finished, but before it is stored
#
# func is the def'd function, save it for later to be called
# after validating the argument
def check_accepts(self, value):
if not inst.validator(value):
raise inst.exception('value %s is not valid' % value)
func(self, value)
return check_accepts
class AbstractTestClass(metaclass=ABCMeta):
#abstractproperty
def luminance(self):
# abstract property
return
#luminance.setter
#ValidateProperty(Exception, int, lambda x: 0 <= x <= 15)
def luminance(self, value):
# abstract property with validator
return
class TestClass(AbstractTestClass):
# concrete class
val = 7
#property
def luminance(self):
# concrete property
return self.val
#luminance.setter
def luminance(self, value):
# concrete property setter
# call base class first to activate the validator
AbstractTestClass.__dict__['luminance'].__set__(self, value)
self.val = value
tc = TestClass()
print(tc.luminance)
tc.luminance = 10
print(tc.luminance)
tc.luminance = 25
print(tc.luminance)
Which results in:
7
10
Traceback (most recent call last):
File "abstract.py", line 47, in <module>
tc.luminance = 25
File "abstract.py", line 40, in luminance
AbstractTestClass.__dict__['luminance'].__set__(self, value)
File "abstract.py", line 14, in check_accepts
raise inst.exception('value %s is not valid' % value)
Exception: value 25 is not valid
A few points to think about:
The ValidateProperty is much simpler because a property setter only takes two parameters: self and the new_value
When using a class for a decorator, and the decorator takes arguments, then you will need __init__ to save the parameters, and __call__ to actually deal with the defd function
Calling a base class property setter is ugly, but you could hide that in a helper function
you might want to use a custom metaclass to ensure the validation code is run (which would also avoid the ugly base-class property call)
I suggested a metaclass above to eliminate the need for a direct call to the base class's abstractproperty, and here is an example of such:
from abc import ABCMeta, abstractproperty
class AbstractTestClassMeta(ABCMeta):
def __new__(metacls, cls, bases, clsdict):
# create new class
new_cls = super().__new__(metacls, cls, bases, clsdict)
# collect all base class dictionaries
base_dicts = [b.__dict__ for b in bases]
if not base_dicts:
return new_cls
# iterate through clsdict looking for properties
for name, obj in clsdict.items():
if not isinstance(obj, (property)):
continue
prop_set = getattr(obj, 'fset')
# found one, now look in bases for validation code
validators = []
for d in base_dicts:
b_obj = d.get(name)
if (
b_obj is not None and
isinstance(b_obj.fset, ValidateProperty)
):
validators.append(b_obj.fset)
if validators:
def check_validators(self, new_val):
for func in validators:
func(new_val)
prop_set(self, new_val)
new_prop = obj.setter(check_validators)
setattr(new_cls, name, new_prop)
return new_cls
This subclasses ABCMeta, and has ABCMeta do all of its work first, then does some additional processing. Namely:
go through the created class and look for properties
check the base classes to see if they have a matching abstractproperty
check the abstractproperty's fset code to see if it is an instance of ValidateProperty
if so, save it in a list of validators
if the list of validators is not empty
make a wrapper that will call each validator before calling the actual property's fset code
replace the found property with a new one that uses the wrapper as the setter code
ValidateProperty is a little different as well:
class ValidateProperty:
def __init__(self, exception, arg_type):
# called on the #ValidateProperty(...) line
#
# save the exception to raise and the expected argument type
self.exception = exception
self.arg_type = arg_type
self.validator = None
def __call__(self, func_or_value):
# on the first call, func_or_value is the function to use
# as the validator
if self.validator is None:
self.validator = func_or_value
return self
# every subsequent call will be to do the validation
if (
not isinstance(func_or_value, self.arg_type) or
not self.validator(None, func_or_value)
):
raise self.exception(
'%r is either not a type of %r or is outside '
'argument range' %
(func_or_value, type(func_or_value))
)
The base AbstractTestClass now uses the new AbstractTestClassMeta, and has the validator code directly in the abstractproperty:
class AbstractTestClass(metaclass=AbstractTestClassMeta):
#abstractproperty
def luminance(self):
# abstract property
pass
#luminance.setter
#ValidateProperty(Exception, int)
def luminance(self, value):
# abstract property validator
return 0 <= value <= 15
The final class is the same:
class TestClass(AbstractTestClass):
# concrete class
val = 7
#property
def luminance(self):
# concrete property
return self.val
#luminance.setter
def luminance(self, value):
# concrete property setter
# call base class first to activate the validator
# AbstractTestClass.__dict__['luminance'].__set__(self, value)
self.val = value
My only GUI experience is with java.swing. I'm using PySide to update which of two QGridLayouts are set to a QLabel depending on a button press, but the actual update isn't happening. Making a call to self.update() after lines 123 and 130 didn't work. Should I be using a repaint event or something?
def displaySimulator(self):
if self.sim_vis == True: pass
else:
self.sim_vis = True
self.graph_vis = False
self.options.setLayout(self.simulator_settings)
def displayGraphing(self):
if self.graph_vis == True: pass
else:
self.graph_vis = True
self.sim_vis = False
self.options.setLayout(self.graphing_settings)
Here's the full code.
----------------------------------------------------------------------------------
Also, the toolbar label at the top is way too big...
self.layout.setRowMinimumHeight(0,20)
self.layout.setColumnMinimumWidth(0,250)
self.layout.setColumnMinimumWidth(1,1000)
setColumnMinimumWidth() works fine but setRowMinimumHeight() doesn't seem to work at all. I'm still a little confused about how the size of QWidgets are affected by layouts, containers, and subwidgets...perhaps I need to adjust the size of the QLabel, toolbar?
Try using a QWidget instead of a QLabel for self.options. Does that change anything?
For the toolbar spacing, do addStretch() after you add the last widget to the layout, but note that if you use a layout in a toolbar, you lose the built-in capabilities for it to autosize and hide buttons in a "... more options ..." type thing.
Since you name your object a toolbar I would actually make it a QToolbar. I would like to point out some styling points, because you said you were new.
import * is always bad for many reasons. You should know what you are importing and from where.
from PySide import QtGui, QtCore
Since you have a main GUI that you are running I would make that a QMainWindow. I would then add a menu bar and move some of your functionality to a file menu or edit menu.
This is just my style and how I like to do things
import sys
from PySide import QtGui, QtCore
class SimulatorWindow(QtGui.QMainWindow):
"""Application for running a simulator and displaying the resutls."""
def __init__(self):
super(SimulatorWindow, self).__init__()
self.setWindowTitle("Simulator") # Main window
# Properties
self.main_menu = None
self.simulator = None
self.export_action = None
self.settings_action = None
self.exit_action = None
self.initUI()
self.initMenu()
self.resize(600, 400)
# end Constructor
# Builds Simulator GUI
def initUI(self):
self.simulator = Simulator()
self.setCentralWidget(self.simulator)
self.addToolBar(self.simulator.toolbar)
# end initUI
def initMenu(self):
"""Initialize the menu bar."""
menubar = self.menuBar()
# ===== File Menu =====
self.file_menu = menubar.addMenu('&File')
# Export action
iexport = QtGui.QIcon()
self.export_action = QtGui.QAction(iexport, "Export", self)
self.export_action.triggered.connect(self.export)
self.file_menu.addAction(self.export_action)
# Separator
self.file_menu.addSeparator()
# Simulator Settings Dialog action
isettings = QtGui.QIcon()
self.settings_action = QtGui.QAction(isettings, "Settings", self)
self.settings_action.triggered.connect(self.simulator.dialog.show)
self.file_menu.addAction(self.settings_action)
# Exit action
iexit = QtGui.QIcon('exit.png')
self.exit_action = QtGui.QAction(iexit, '&Exit', self)
self.exit_action.triggered.connect(self.close)
self.file_menu.addAction(self.exit_action)
# ===== Edit Menu =====
self.edit_menu = menubar.addMenu('&Edit')
self.edit_menu.addAction(self.simulator.run_action)
# end initMenu
def export(self):
"""Export the simulation file."""
pass
# end export
# end class SimulatorWindow
class Simulator(QtGui.QWidget):
"""Simulator display."""
def __init__(self):
super().__init__()
#Properties
self.toolbar = None
self.dialog = None
self.run_action = None
# Layout
self.main_layout = QtGui.QGridLayout()
self.setLayout(self.main_layout)
# Graph
stuff = QtGui.QLabel("<font color=red size=300>Graphing stuff</font>")
stuff.setStyleSheet("QLabel {background-color: rgb(50,50,50); font-size:250;}")
stuff.setAlignment(QtCore.Qt.AlignCenter)
graph = QtGui.QLabel("<font color=green size=250>Graph here</font>")
graph.setStyleSheet("QLabel {background-color: rgb(0,0,0); font-size:250;}")
graph.setAlignment(QtCore.Qt.AlignCenter)
graph.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Preferred)
self.main_layout.addWidget(stuff)
self.main_layout.addWidget(graph)
self.initToolbar()
self.initSettingsDialog()
# end Constructor
def initToolbar(self):
self.toolbar = QtGui.QToolBar()
irun = QtGui.QIcon()
self.run_action = QtGui.QAction(irun, "Run", self)
self.run_action.triggered.connect(self.run)
self.toolbar.addAction(self.run_action)
# end initToolbar
def initSettingsDialog(self):
"""Initialize the Settings dialog."""
self.dialog = QtGui.QDialog(self)
self.dialog.setWindowFlags(QtCore.Qt.Dialog | QtCore.Qt.WindowSystemMenuHint)
layout = QtGui.QGridLayout()
self.dialog.setLayout(layout)
# Initialize the Widgets
title = QtGui.QLabel("<font size=6>Simulator Settings</font>")
num_sim = QtGui.QLineEdit("Number of simulations")
num_trials = QtGui.QLineEdit("Number of trials (per learning phase)")
network = QtGui.QComboBox()
subject = QtGui.QComboBox()
# Set the layout
layout.addWidget(title, 0, 0, 1, 2, QtCore.Qt.AlignCenter)
layout.addWidget(num_sim, 1, 0)
layout.addWidget(num_trials, 1, 1)
layout.addWidget(network, 2, 0)
layout.addWidget(subject, 2, 1)
# end initSettingsDialog
def run(self):
"""Run the simulation."""
pass
# end run
# end class Simulator
def main():
"""Run the application."""
app = QtGui.QApplication(sys.argv)
window = SimulatorWindow()
window.show()
return app.exec_()
# end main
if __name__ == "__main__":
sys.exit(main())