def _make_resource(cls, folder, name, *args, **kw):
root = ShopFolder._make_resource(cls, folder, name, **kw)
# Payments module
cls.payments_class._make_resource(cls.payments_class, folder,
'%s/payments' % name,
title={'en': u'Payment module'})
# Modules
Modules._make_resource(Modules, folder,
'%s/modules' % name, title={'en': u'Modules'})
# Suppliers
Suppliers._make_resource(Suppliers, folder,
'%s/suppliers' % name, title={'en': u'Suppliers'})
# Customers
Customers._make_resource(Customers, folder,
'%s/customers' % name, title={'en': u'Customers'})
# Product Models
ProductModels._make_resource(ProductModels, folder, '%s/products-models' % name,
title={'en': u'Product Models'})
# Orders
Orders._make_resource(Orders, folder, '%s/orders' % name,
title={'en': u'Orders'})
# ShopUser_Groups
ShopUser_Groups._make_resource(ShopUser_Groups, folder, '%s/groups' % name,
title={'en': u'User groups'})
# Addresses
Addresses._make_resource(Addresses, folder, '%s/addresses' % name,
title={'en': u'Addresses'})
# Countries
Countries._make_resource(Countries, folder, '%s/countries' % name,
title={'en': u'countries'})
# Countries zone
CountriesZones._make_resource(CountriesZones, folder,
'%s/countries-zones' % name, title={'en': u'Countries Zones'})
# EnumeratesFolder
EnumeratesFolder._make_resource(EnumeratesFolder, folder,
'%s/enumerates' % name, title={'en': u'Enumerates'})
# Shipping
Shippings._make_resource(Shippings, folder, '%s/shippings' % name,
title={'en': u'Shipping'})
# Conditions of users
WebPage._make_resource(WebPage, folder, '%s/terms-and-conditions-of-use' % name,
**{'title': {'fr': u'Conditions Générales de ventes',
'en': u'Terms and conditions of user'},
'state': 'public'})
# Default cross Selling configuration
CrossSellingTable._make_resource(CrossSellingTable, folder,
'%s/cross-selling' % name,
title={'en': u'Cross selling'})
# Taxes
Taxes_TableResource._make_resource(Taxes_TableResource, folder, '%s/taxes' % name,
**{'title': {'fr': u'TVA',
'en': u'Taxes'}})
table = Taxes_TableHandler()
table.add_record({'value': '19.6'})
folder.set_handler('%s/taxes' % name, table)
def build_pipeline(self, modules):
"""
Setup Modules to built the modules pipeline.
Args:
modules ([Module]): list of Module instances
"""
assert isinstance(modules, list), modules
for md in modules:
self.Check_Module(md)
# some final operations that might modify the pipeline
logger.logger.info("Build Modules pipeline ...")
self._modules = Modules(self._modules)
self._modules.register_to_controller(weakref.proxy(self))
self._modules = self._modules.get_modules()
def super_categories(self):
"""
EXAMPLES::
sage: AlgebraModules(QQ[x]).super_categories()
[Category of modules over Univariate Polynomial Ring in x over Rational Field]
"""
R = self.algebra()
return [Modules(R)]
def super_categories(self):
"""
EXAMPLES::
sage: RingIdeals(ZZ).super_categories()
[Category of modules over Integer Ring]
sage: RingIdeals(QQ).super_categories()
[Category of vector spaces over Rational Field]
"""
R = self.ring()
return [Modules(R)]
def start(self):
"""
Starts the Application
:return:
"""
appcontext_tearing_down.connect(self.stop, self.app)
appcontext_pushed.connect(self.app_pushed, self.app)
self.fake_module = Thread(target=run_fake_module,
args=(self.startapp, self.runapp))
self.channels = Channels(self)
self.channels.register_api()
self.sensors = Sensors(self)
# self.sensors.register_api()
self.modules = Modules(self)
self.modules.register_api()
self.website = Website(self)
self.website.register_url()
def init_UI(self):
# Main layout
main_layout = QGridLayout()
main_layout.setSpacing(0)
# Top layout
top_layout = QVBoxLayout()
top_layout.setContentsMargins(5, 0, 0, 0)
self.b1 = QRadioButton(u"ماژول های انتخابی")
self.b1.setChecked(True)
self.b1.setFont(QFont('SansSerif', 15))
self.b1.clicked.connect(partial(self.change_all, False))
path_layout = QHBoxLayout()
lable = QLabel(u"دایرکتوری برای بارگذاری ماژول ها:")
self.location = QLabel()
additional_path = QPushButton(u"انتخاب دایرکتوری")
additional_path.clicked.connect(self.path)
path_layout.addWidget(additional_path)
path_layout.addWidget(self.location, alignment=Qt.AlignRight)
path_layout.addWidget(lable, alignment=Qt.AlignRight)
self.b2 = QRadioButton(u"همه ماژول ها")
self.b2.setFont(QFont('SansSerif', 15))
self.b2.clicked.connect(partial(self.change_all, True))
top_layout.addWidget(self.b1, alignment=Qt.AlignRight)
top_layout.addWidget(self.b2, alignment=Qt.AlignRight)
top_layout.addLayout(path_layout)
# Middle layout
middle_layout = QVBoxLayout()
m = Modules(self)
btn_layout = QHBoxLayout()
btn_layout.setAlignment(Qt.AlignRight)
run_btn = QPushButton("Run")
run_btn.clicked.connect(partial(self.call_run, m))
btn_layout.addWidget(run_btn)
middle_layout.addWidget(m)
middle_layout.addLayout(btn_layout)
main_layout.addLayout(top_layout, 0, 0)
main_layout.addLayout(middle_layout, 1, 0)
self.setLayout(main_layout)
# print("Arduino is not connected")
# exit(1)
# vs = initializationOfWebCamConnection()
# if not vs:
# print("WebCam is not connected")
# exit(1)
# time.sleep(2.0)
# code = getDataFromQrCode()
# if not code:
# print('QrCode is incorrect')
# exit(1)
try:
res = Modules.initializeModules()
if res != None:
print("Error in module {}".format(res))
exit(1)
except:
print("Some error in modules")
Modules.closeConnections()
exit(1)
counter_of_failed_frames = 0
isMoving = False
try:
def do_modules(self, _args):
"""
Interact with custom Mercury modules
"""
subconsole = Modules(self.session)
subconsole.cmdloop()
def modules(self):
modules = []
for module in Modules(self.cfg).enabled().values():
modules.append(module(self))
return modules
def BtnModuleSettingsCB(self): modules = Modules() modules.show()
def __init__(self, *args, **kwargs): sublime_plugin.EventListener.__init__(self, *args, **kwargs) self.modules = Modules(cwd, 'languages').load_all() persist.queue.start(self.lint)
class SublimeLint(sublime_plugin.EventListener):
def __init__(self, *args, **kwargs):
sublime_plugin.EventListener.__init__(self, *args, **kwargs)
self.modules = Modules(cwd, 'languages').load_all()
persist.queue.start(self.lint)
def lint(self, view_id):
view = Linter.get_view(view_id)
if view is not None:
print 'SublimeLint: running on `%s`' % os.path.split(view.file_name() or 'untitled')[1]
code = Linter.text(view)
thread.start_new_thread(Linter.lint_view, (view_id, code, self.finish))
def finish(self, view, linters):
errors = {}
linters[0].clear()
for linter in linters:
linter.draw()
errors.update(linter.errors)
persist.errors[view.id()] = errors
# helpers
def hit(self, view):
persist.queue.hit(view)
# callins
def on_modified(self, view):
self.hit(view)
def on_load(self, view):
self.on_new(view)
def on_activated(self, view):
if ( view.file_name() is not None ):
self.hit(view)
def on_new(self, view):
Linter.assign(view)
settings = view.settings()
syntax = settings.get('syntax')
def on_change():
if settings.get('syntax') != syntax:
Linter.assign(view)
settings.add_on_change('lint-syntax', on_change)
def on_post_save(self, view):
# this will reload submodules if they are saved with sublime text
for name, module in self.modules.modules.items():
if module.__file__ == view.file_name():
self.modules.reload(module)
Linter.reload(name)
break
self.hit(view)
def on_selection_modified(self, view):
vid = view.id()
lineno = view.rowcol(view.sel()[0].end())[0]
if vid in persist.errors and lineno in persist.errors[vid]:
try: # workaround for issue #18
view.set_status('sublimelint', '; '.join(persist.errors[vid][lineno]))
except:
view.erase_status('sublimelint')
else:
view.erase_status('sublimelint')
persist.queue.delay()
class Wlanthermo:
def __init__(self):
self.logger = logging.getLogger(__name__)
self.runapp = True
self.startapp = threading.Event()
self.app = Flask(__name__)
self.app.json_encoder = CustomJSONEncoder
self.set_config_dir()
self.set_database_uri()
self.db = SQLAlchemy(self.app)
Base.metadata.create_all(self.db.engine)
self.channels = None
#lp = threading.Thread(target=logger_thread, args=(q,))
#lp.start()
#q = Queue()
# And now tell the logging thread to finish up, too
#q.put(None)
#lp.join()
def set_database_uri(self):
settings = SystemSettings(self, 'database')
while True:
try:
host = settings['host']
database = settings['database']
user = settings['user']
password = settings['password']
port = settings['port']
except KeyError as error:
failed_key = error.args[0]
self.logger.error(
'Database configuration is missing, adding key "{failed_key}" to config file.'
.format(failed_key=failed_key))
settings.set({failed_key: ''})
else:
break
dialect = 'mysql+pymysql'
self.app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
self.logger.debug(
'Trying to connect to {dialect} database "{database}" as "{user}".'
.format(dialect=dialect, database=database, user=user))
self.app.config[
'SQLALCHEMY_DATABASE_URI'] = '{dialect}://{user}:{password}@{host}:{port}/{database}'.format(
dialect=dialect,
user=user,
password=password,
host=host,
port=port,
database=database)
def set_config_dir(self):
"""
Try to find the right path for configuration files
The following directories are tried:
1. Directory given by app configuration 'WLANTHERMO_CONFIG_DIR'
2. Directory given by enviroment variable 'WLANTHERMO_CONFIG_DIR'
3. Current working directory
The directory is created if it doesn´t exist yet.
"""
try:
config_dir = self.app.config['WLANTHERMO_CONFIG_DIR']
self.logger.info('Config path is global {config_dir}')
except KeyError:
config_dir = os.environ.get('WLANTHERMO_CONFIG_DIR')
if config_dir is not None:
self.logger.info(
'Config path is "{config_dir}" from enviroment'.format(
config_dir=config_dir))
else:
config_dir = os.path.join(os.getcwd(), 'config')
self.logger.info(
'Config path is in current working directory ({config_dir})'
.format(config_dir=config_dir))
self.app.config['WLANTHERMO_CONFIG_DIR'] = config_dir
if not os.path.exists(config_dir):
self.logger.info('Creating config path ({config_dir})'.format(
config_dir=config_dir))
try:
os.makedirs(config_dir)
except OSError:
self.logger.fatal(
'Config path could not be created ({config_dir})'.format(
config_dir=config_dir))
raise
return config_dir
def start(self):
"""
Starts the Application
:return:
"""
appcontext_tearing_down.connect(self.stop, self.app)
appcontext_pushed.connect(self.app_pushed, self.app)
self.fake_module = Thread(target=run_fake_module,
args=(self.startapp, self.runapp))
self.channels = Channels(self)
self.channels.register_api()
self.sensors = Sensors(self)
# self.sensors.register_api()
self.modules = Modules(self)
self.modules.register_api()
self.website = Website(self)
self.website.register_url()
def run(self):
self.fake_module.start()
self.app.run()
def stop(self, sender, **kwarg):
self.runapp = False
def app_pushed(self, sender, **kwarg):
self.startapp.set()
class ModulesController(object):
""" Base class for a ModulesController.
"""
# is_chief = True
# """
# Whether this process is the chief worker in multi-pipeline.
# Certain Modules will only be run by chief worker.
# """
def __init__(self):
self._modules = []
self.ModuleTable = {}
@call_only_once
def build_pipeline(self, modules):
"""
Setup Modules to built the modules pipeline.
Args:
modules ([Module]): list of Module instances
"""
assert isinstance(modules, list), modules
for md in modules:
self.Check_Module(md)
# some final operations that might modify the pipeline
logger.logger.info("Build Modules pipeline ...")
self._modules = Modules(self._modules)
self._modules.register_to_controller(weakref.proxy(self))
self._modules = self._modules.get_modules()
def run_pipeline(self,modules,inputs):
"""
Implemented by two lines:
.. code-block:: python
self.build_pipeline(modules)
self.main_loop(inputs)
You can call those methods by yourself to have better control on details if needed.
"""
self.build_pipeline(modules)
self.main_loop(inputs)
def run_pipeline_with_defaults(self, modules=None, extra_modules=None,inputs=None):
"""
Same as :meth:`run_pipeline()`, except:
1. Add `extra_modules` to modules. The default value for
`extra_modules` is :meth:`DEFAULT_MODULES()`.
"""
modules = copy.copy(modules or [])
extra_modules = DEFAULT_MODULES() if extra_modules is None else extra_modules
modules.extend(extra_modules)
self.run_pipeline(modules,inputs)
@call_only_once
def main_loop(self, inputs):
"""
Run the main piepline loop.
Args:
inputs (tuple): inputs must be a tuple(thus we can treat multi-input and multi-output)
"""
logger.logger.info("Begin Modules pipeline ...")
for index, cb in enumerate(self._modules):
inputs = self.run_step(inputs, index)
self.outputs = inputs
def run_step(self,inputs,index):
"""
Defines what to do in one stage of pipeline. The default is:
'' run one module ''.
The behavior of each iteration can be changed by overriding this method.
"""
#TODO 如何使得当前模块的输入只用到前一个模块的部分输出？
if index != 0:
current_module_input_desc = self.ModuleTable[
self._modules[index].__class__.__name__].get_inputs_desc()
pre_module_output_desc = self.ModuleTable[
self._modules[index-1].__class__.__name__].get_outputs_desc()
if not current_module_input_desc==pre_module_output_desc:
raise Stop(
'module {} and {} can\'t be pipelined ,it may be caused by inconsistent input and output.'
'check description of those modules for details.'
.format(self._modules[index-1].__class__.__name__,self._modules[index].__class__.__name__))
if not type(inputs)==type(tuple):
inputs = (inputs,)
return self._modules[index].run(inputs)
def _Check_Module(self, md):
"""
Check Modules which are passed to ModulesController by Config.
It can only be called before :meth:`ModulesController.run_pipeline()`.
Args:
md (Module or [Module]): a Module or a list of Modules
Returns:
succeed or not
"""
if isinstance(md, (list, tuple)):
for x in md:
self._Check_Module(x)
return
assert isinstance(md, Module), md
assert not isinstance(self._modules, Modules), \
"Cannot append more Modules after ModulesController was setup!"
self._modules.append(md)
return True
Check_Module = _Check_Module
def register_ModuleDesc_to_ModuleTable(self,Module_name,desc):
self.ModuleTable[Module_name] = desc
def __new__(cls, *args, **kwargs):
if (len(args) > 0 and isinstance(args[0], Config)) \
or 'config' in kwargs:
logger.logger.error("Use interface API to launch controller ,do not pass Config directly to a controller!")
import sys
sys.exit(1)
else:
return super(ModulesController, cls).__new__(cls)
def do_modules(self, args): """ Shows all the modules present in the Modules directory """ subconsole = Modules(self.connected, self.session) subconsole.cmdloop()
#construction email subject using configuration
for key in mail_keys:
t_val = document.get(key, "{%s}" % key)
subject = subject.replace("{%s}" % key, str(t_val))
#construction email title using configuration
mail_keys = re.findall("{(.+?)}", mail_title)
for key in mail_keys:
t_val = document.get(key, "{%s}" % key)
mail_title = mail_title.replace("{%s}" % key, str(t_val))
mail_html = ""
#getting list of enrichment modules for the email alert
modu = Modules(mail_config.get("custom_enrichment_data", {}), document)
if mail_config["enrichment"]:
if mail_config["enrichment_conditional"]:
for i, j in mail_config["enrichments"].iteritems():
if eval(i):
any_cond_match = True
for e in j:
e_enable = e.get("enabled", True)
if e_enable:
params = e["e_key"].split(",")
fn_params = []
for p in params:
if p.strip():
fn_params.append(document[p.strip()])
e_func = getattr(modu, e['e_func'])
def _make_resource(cls, folder, name, *args, **kw):
root = ShopFolder._make_resource(cls, folder, name, **kw)
# Payments module
cls.payments_class._make_resource(cls.payments_class,
folder,
'%s/payments' % name,
title={'en': u'Payment module'})
# Modules
Modules._make_resource(Modules,
folder,
'%s/modules' % name,
title={'en': u'Modules'})
# Suppliers
Suppliers._make_resource(Suppliers,
folder,
'%s/suppliers' % name,
title={'en': u'Suppliers'})
# Customers
Customers._make_resource(Customers,
folder,
'%s/customers' % name,
title={'en': u'Customers'})
# Product Models
ProductModels._make_resource(ProductModels,
folder,
'%s/products-models' % name,
title={'en': u'Product Models'})
# Orders
Orders._make_resource(Orders,
folder,
'%s/orders' % name,
title={'en': u'Orders'})
# ShopUser_Groups
ShopUser_Groups._make_resource(ShopUser_Groups,
folder,
'%s/groups' % name,
title={'en': u'User groups'})
# Addresses
Addresses._make_resource(Addresses,
folder,
'%s/addresses' % name,
title={'en': u'Addresses'})
# Countries
Countries._make_resource(Countries,
folder,
'%s/countries' % name,
title={'en': u'countries'})
# Countries zone
CountriesZones._make_resource(CountriesZones,
folder,
'%s/countries-zones' % name,
title={'en': u'Countries Zones'})
# EnumeratesFolder
EnumeratesFolder._make_resource(EnumeratesFolder,
folder,
'%s/enumerates' % name,
title={'en': u'Enumerates'})
# Shipping
Shippings._make_resource(Shippings,
folder,
'%s/shippings' % name,
title={'en': u'Shipping'})
# Conditions of users
WebPage._make_resource(
WebPage, folder, '%s/terms-and-conditions-of-use' % name, **{
'title': {
'fr': u'Conditions Générales de ventes',
'en': u'Terms and conditions of user'
},
'state': 'public'
})
# Default cross Selling configuration
CrossSellingTable._make_resource(CrossSellingTable,
folder,
'%s/cross-selling' % name,
title={'en': u'Cross selling'})
# Taxes
Taxes_TableResource._make_resource(
Taxes_TableResource, folder, '%s/taxes' % name,
**{'title': {
'fr': u'TVA',
'en': u'Taxes'
}})
table = Taxes_TableHandler()
table.add_record({'value': '19.6'})
folder.set_handler('%s/taxes' % name, table)
def __init__(self) -> None:
app = QApplication(sys.argv)
self.modules = Modules()
sys.exit(app.exec_())
def do_modules(self, args):
"""
Shows all the modules present in the Modules directory
"""
subconsole = Modules(self.connected, self.session)
subconsole.cmdloop()
class ModuleExamples:
# def _makeModule(self, name, uses, mtime, ctime, cmode):
# return Modules.makeModule(name, uses, mtime, ctime, cmode)
# a description of a module that's been modified since it was compiled
# and must therefore be compiled again before it is used
foo = Modules.makeModule("Foo", ["Baz"], 1505109465, 1504097449, "LP64")
# a list of modules that have a circular dependency
circularModules = [Modules.makeModule("M1", ["M2", "M3"], 1500, -1, "ILP32"),
Modules.makeModule("M2", ["M3"], 2000, -1, "ILP32"),
Modules.makeModule("M3", ["M2"], 2500, -1, "ILP32")]
# a list of modules, of which only Main needs to be compiled
# (in mode LP64) before Main can be used
modules1 = [Modules.makeModule("Main", ["List", "AList"], 1504188920, -1, "LP64"),
Modules.makeModule(
"List", ["Obj"], 1472652920, 1472658760, "LP64"),
Modules.makeModule(
"AList", ["List", "Obj"], 1472654764, 1472659242, "LP64"),
Modules.makeModule("Obj", [], 1472630256, 1472638841, "LP64")]
# a list of modules, of which List, AList, and Main need to be compiled
# (in that order, in mode ILP32) before Main can be used
modules2 = [Modules.makeModule("Main", ["List", "AList"], 1504188920, -1, "LP64"),
Modules.makeModule(
"List", ["Obj"], 1472652920, 1472658760, "LP64"),
Modules.makeModule(
"AList", ["List", "Obj"], 1472654764, 1472659242, "LP64"),
Modules.makeModule("Obj", [], 1472630256, 1472638841, "ILP32")]
modules3 = [Modules.makeModule("Main", ["List", "AList"], 0, 11, "LP64"),
Modules.makeModule(
"List", ["Obj"], 0, 11, "LP64"),
Modules.makeModule(
"AList", ["List", "Obj"], 0, 11, "LP64"),
Modules.makeModule("Obj", [], 0, 11, "LP64")]
modules4 = [Modules.makeModule("Main", ["List", "AList"], 3, 10, "ILP32"),
Modules.makeModule("List", ["Obj"], 1, 4, "ILP64"),
Modules.makeModule("AList", ["A1", "A2"], 5, 4, "ILP32"),
Modules.makeModule("Obj", ["O1", "O2"], 1, 2, "LP32"),
Modules.makeModule("O1", [], 1, 3, "LP32"),
Modules.makeModule("O2", ["A3"], 1, 4, "LP32"),
Modules.makeModule("A1", [], 1, 2, "LP64"),
Modules.makeModule("A2", ["A3"], 1, 2, "LP64"),
Modules.makeModule("A3", [], 2, -1, "LP64")]
