text
stringlengths 6
947k
| repo_name
stringlengths 5
100
| path
stringlengths 4
231
| language
stringclasses 1
value | license
stringclasses 15
values | size
int64 6
947k
| score
float64 0
0.34
|
|---|---|---|---|---|---|---|
"""
The function cache system allows for data to be stored on the master so it can be easily read by other minions
"""
import logging
import time
import traceback
import salt.channel.client
import salt.crypt
import salt.payload
import salt.transport
import salt.utils.args
import salt.utils.dictupdate
import salt.utils.event
import salt.utils.functools
import salt.utils.mine
import salt.utils.minions
import salt.utils.network
from salt.exceptions import SaltClientError
MINE_INTERNAL_KEYWORDS = frozenset(
[
"__pub_user",
"__pub_arg",
"__pub_fun",
"__pub_jid",
"__pub_tgt",
"__pub_tgt_type",
"__pub_ret",
]
)
__proxyenabled__ = ["*"]
log = logging.getLogger(__name__)
def _auth():
"""
Return the auth object
"""
if "auth" not in __context__:
try:
__context__["auth"] = salt.crypt.SAuth(__opts__)
except SaltClientError:
log.error(
"Could not authenticate with master. Mine data will not be transmitted."
)
return __context__["auth"]
def _mine_function_available(func):
if func not in __salt__:
log.error("Function %s in mine_functions not available", func)
return False
return True
def _mine_send(load, opts):
eventer = salt.utils.event.MinionEvent(opts, listen=False)
event_ret = eventer.fire_event(load, "_minion_mine")
# We need to pause here to allow for the decoupled nature of
# events time to allow the mine to propagate
time.sleep(0.5)
return event_ret
def _mine_get(load, opts):
if opts.get("transport", "") in salt.transport.TRANSPORTS:
try:
load["tok"] = _auth().gen_token(b"salt")
except AttributeError:
log.error(
"Mine could not authenticate with master. Mine could not be retrieved."
)
return False
with salt.channel.client.ReqChannel.factory(opts) as channel:
return channel.send(load)
def _mine_store(mine_data, clear=False):
"""
Helper function to store the provided mine data.
This will store either locally in the cache (for masterless setups), or in
the master's cache.
:param dict mine_data: Dictionary with function_name: function_data to store.
:param bool clear: Whether or not to clear (`True`) the mine data for the
function names present in ``mine_data``, or update it (`False`).
"""
# Store in the salt-minion's local cache
if __opts__["file_client"] == "local":
if not clear:
old = __salt__["data.get"]("mine_cache")
if isinstance(old, dict):
old.update(mine_data)
mine_data = old
return __salt__["data.update"]("mine_cache", mine_data)
# Store on the salt master
load = {
"cmd": "_mine",
"data": mine_data,
"id": __opts__["id"],
"clear": clear,
}
return _mine_send(load, __opts__)
def update(clear=False, mine_functions=None):
"""
Call the configured functions and send the data back up to the master.
The functions to be called are merged from the master config, pillar and
minion config under the option `mine_functions`:
.. code-block:: yaml
mine_functions:
network.ip_addrs:
- eth0
disk.usage: []
This function accepts the following arguments:
:param bool clear: Default: ``False``
Specifies whether updating will clear the existing values (``True``), or
whether it will update them (``False``).
:param dict mine_functions:
Update (or clear, see ``clear``) the mine data on these functions only.
This will need to have the structure as defined on
https://docs.saltproject.io/en/latest/topics/mine/index.html#mine-functions
This feature can be used when updating the mine for functions
that require a refresh at different intervals than the rest of
the functions specified under `mine_functions` in the
minion/master config or pillar.
A potential use would be together with the `scheduler`, for example:
.. code-block:: yaml
schedule:
lldp_mine_update:
function: mine.update
kwargs:
mine_functions:
net.lldp: []
hours: 12
In the example above, the mine for `net.lldp` would be refreshed
every 12 hours, while `network.ip_addrs` would continue to be updated
as specified in `mine_interval`.
The function cache will be populated with information from executing these
functions
CLI Example:
.. code-block:: bash
salt '*' mine.update
"""
if not mine_functions:
mine_functions = __salt__["config.merge"]("mine_functions", {})
# If we don't have any mine functions configured, then we should just bail out
if not mine_functions:
return
elif isinstance(mine_functions, list):
mine_functions = {fun: {} for fun in mine_functions}
elif isinstance(mine_functions, dict):
pass
else:
return
mine_data = {}
for function_alias, function_data in mine_functions.items():
(
function_name,
function_args,
function_kwargs,
minion_acl,
) = salt.utils.mine.parse_function_definition(function_data)
if not _mine_function_available(function_name or function_alias):
continue
try:
res = salt.utils.functools.call_function(
__salt__[function_name or function_alias],
*function_args,
**function_kwargs
)
except Exception: # pylint: disable=broad-except
trace = traceback.format_exc()
log.error(
"Function %s in mine.update failed to execute",
function_name or function_alias,
)
log.debug("Error: %s", trace)
continue
if minion_acl.get("allow_tgt"):
mine_data[function_alias] = salt.utils.mine.wrap_acl_structure(
res, **minion_acl
)
else:
mine_data[function_alias] = res
return _mine_store(mine_data, clear)
def send(name, *args, **kwargs):
"""
Send a specific function and its result to the salt mine.
This gets stored in either the local cache, or the salt master's cache.
:param str name: Name of the function to add to the mine.
The following pameters are extracted from kwargs if present:
:param str mine_function: The name of the execution_module.function to run
and whose value will be stored in the salt mine. Defaults to ``name``.
:param str allow_tgt: Targeting specification for ACL. Specifies which minions
are allowed to access this function. Please note both your master and
minion need to be on, at least, version 3000 for this to work properly.
:param str allow_tgt_type: Type of the targeting specification. This value will
be ignored if ``allow_tgt`` is not specified. Please note both your
master and minion need to be on, at least, version 3000 for this to work
properly.
Remaining args and kwargs will be passed on to the function to run.
:rtype: bool
:return: Whether executing the function and storing the information was successful.
.. versionchanged:: 3000
Added ``allow_tgt``- and ``allow_tgt_type``-parameters to specify which
minions are allowed to access this function.
See :ref:`targeting` for more information about targeting.
CLI Example:
.. code-block:: bash
salt '*' mine.send network.ip_addrs interface=eth0
salt '*' mine.send eth0_ip_addrs mine_function=network.ip_addrs interface=eth0
salt '*' mine.send eth0_ip_addrs mine_function=network.ip_addrs interface=eth0 allow_tgt='G@grain:value' allow_tgt_type=compound
"""
kwargs = salt.utils.args.clean_kwargs(**kwargs)
mine_function = kwargs.pop("mine_function", None)
allow_tgt = kwargs.pop("allow_tgt", None)
allow_tgt_type = kwargs.pop("allow_tgt_type", None)
mine_data = {}
try:
res = salt.utils.functools.call_function(
__salt__[mine_function or name], *args, **kwargs
)
except Exception as exc: # pylint: disable=broad-except
trace = traceback.format_exc()
log.error("Function %s in mine.send failed to execute", mine_function or name)
log.debug("Error: %s", trace)
return False
if allow_tgt:
mine_data[name] = salt.utils.mine.wrap_acl_structure(
res, allow_tgt=allow_tgt, allow_tgt_type=allow_tgt_type
)
else:
mine_data[name] = res
return _mine_store(mine_data)
def get(tgt, fun, tgt_type="glob", exclude_minion=False):
"""
Get data from the mine.
:param str tgt: Target whose mine data to get.
:param fun: Function to get the mine data of. You can specify multiple functions
to retrieve using either a list or a comma-separated string of functions.
:type fun: str or list
:param str tgt_type: Default ``glob``. Target type to use with ``tgt``.
See :ref:`targeting` for more information.
Note that all pillar matches, whether using the compound matching system or
the pillar matching system, will be exact matches, with globbing disabled.
:param bool exclude_minion: Excludes the current minion from the result set.
CLI Example:
.. code-block:: bash
salt '*' mine.get '*' network.interfaces
salt '*' mine.get 'os:Fedora' network.interfaces grain
salt '*' mine.get 'G@os:Fedora and [email protected]/24' network.ipaddrs compound
.. seealso:: Retrieving Mine data from Pillar and Orchestrate
This execution module is intended to be executed on minions.
Master-side operations such as Pillar or Orchestrate that require Mine
data should use the :py:mod:`Mine Runner module <salt.runners.mine>`
instead; it can be invoked from a Pillar SLS file using the
:py:func:`saltutil.runner <salt.modules.saltutil.runner>` module. For
example:
.. code-block:: jinja
{% set minion_ips = salt.saltutil.runner('mine.get',
tgt='*',
fun='network.ip_addrs',
tgt_type='glob') %}
"""
# Load from local minion's cache
if __opts__["file_client"] == "local":
ret = {}
is_target = {
"glob": __salt__["match.glob"],
"pcre": __salt__["match.pcre"],
"list": __salt__["match.list"],
"grain": __salt__["match.grain"],
"grain_pcre": __salt__["match.grain_pcre"],
"ipcidr": __salt__["match.ipcidr"],
"compound": __salt__["match.compound"],
"pillar": __salt__["match.pillar"],
"pillar_pcre": __salt__["match.pillar_pcre"],
}[tgt_type](tgt)
if not is_target:
return ret
data = __salt__["data.get"]("mine_cache")
if not isinstance(data, dict):
return ret
if isinstance(fun, str):
functions = list(set(fun.split(",")))
_ret_dict = len(functions) > 1
elif isinstance(fun, list):
functions = fun
_ret_dict = True
else:
return ret
for function in functions:
if function not in data:
continue
# If this is a mine item with minion_side_ACL, get its data
if salt.utils.mine.MINE_ITEM_ACL_ID in data[function]:
res = data[function][salt.utils.mine.MINE_ITEM_ACL_DATA]
else:
# Backwards compatibility with non-ACL mine data.
res = data[function]
if _ret_dict:
ret.setdefault(function, {})[__opts__["id"]] = res
else:
ret[__opts__["id"]] = res
return ret
# Load from master
load = {
"cmd": "_mine_get",
"id": __opts__["id"],
"tgt": tgt,
"fun": fun,
"tgt_type": tgt_type,
}
ret = _mine_get(load, __opts__)
if exclude_minion and __opts__["id"] in ret:
del ret[__opts__["id"]]
return ret
def delete(fun):
"""
Remove specific function contents of minion.
:param str fun: The name of the function.
:rtype: bool
:return: True on success.
CLI Example:
.. code-block:: bash
salt '*' mine.delete 'network.interfaces'
"""
if __opts__["file_client"] == "local":
data = __salt__["data.get"]("mine_cache")
if isinstance(data, dict) and fun in data:
del data[fun]
return __salt__["data.update"]("mine_cache", data)
load = {
"cmd": "_mine_delete",
"id": __opts__["id"],
"fun": fun,
}
return _mine_send(load, __opts__)
def flush():
"""
Remove all mine contents of minion.
:rtype: bool
:return: True on success
CLI Example:
.. code-block:: bash
salt '*' mine.flush
"""
if __opts__["file_client"] == "local":
return __salt__["data.update"]("mine_cache", {})
load = {
"cmd": "_mine_flush",
"id": __opts__["id"],
}
return _mine_send(load, __opts__)
def get_docker(interfaces=None, cidrs=None, with_container_id=False):
"""
.. versionchanged:: 2017.7.8,2018.3.3
When :conf_minion:`docker.update_mine` is set to ``False`` for a given
minion, no mine data will be populated for that minion, and thus none
will be returned for it.
.. versionchanged:: 2019.2.0
:conf_minion:`docker.update_mine` now defaults to ``False``
Get all mine data for :py:func:`docker.ps <salt.modules.dockermod.ps_>` and
run an aggregation routine. The ``interfaces`` parameter allows for
specifying the network interfaces from which to select IP addresses. The
``cidrs`` parameter allows for specifying a list of subnets which the IP
address must match.
with_container_id
Boolean, to expose container_id in the list of results
.. versionadded:: 2015.8.2
CLI Example:
.. code-block:: bash
salt '*' mine.get_docker
salt '*' mine.get_docker interfaces='eth0'
salt '*' mine.get_docker interfaces='["eth0", "eth1"]'
salt '*' mine.get_docker cidrs='107.170.147.0/24'
salt '*' mine.get_docker cidrs='["107.170.147.0/24", "172.17.42.0/24"]'
salt '*' mine.get_docker interfaces='["eth0", "eth1"]' cidrs='["107.170.147.0/24", "172.17.42.0/24"]'
"""
# Enforce that interface and cidr are lists
if interfaces:
interface_ = []
interface_.extend(interfaces if isinstance(interfaces, list) else [interfaces])
interfaces = interface_
if cidrs:
cidr_ = []
cidr_.extend(cidrs if isinstance(cidrs, list) else [cidrs])
cidrs = cidr_
# Get docker info
cmd = "docker.ps"
docker_hosts = get("*", cmd)
proxy_lists = {}
# Process docker info
for containers in docker_hosts.values():
host = containers.pop("host")
host_ips = []
# Prepare host_ips list
if not interfaces:
for info in host["interfaces"].values():
if "inet" in info:
for ip_ in info["inet"]:
host_ips.append(ip_["address"])
else:
for interface in interfaces:
if interface in host["interfaces"]:
if "inet" in host["interfaces"][interface]:
for item in host["interfaces"][interface]["inet"]:
host_ips.append(item["address"])
host_ips = list(set(host_ips))
# Filter out ips from host_ips with cidrs
if cidrs:
good_ips = []
for cidr in cidrs:
for ip_ in host_ips:
if salt.utils.network.in_subnet(cidr, [ip_]):
good_ips.append(ip_)
host_ips = list(set(good_ips))
# Process each container
for container in containers.values():
container_id = container["Info"]["Id"]
if container["Image"] not in proxy_lists:
proxy_lists[container["Image"]] = {}
for dock_port in container["Ports"]:
# IP exists only if port is exposed
ip_address = dock_port.get("IP")
# If port is 0.0.0.0, then we must get the docker host IP
if ip_address == "0.0.0.0":
for ip_ in host_ips:
containers = (
proxy_lists[container["Image"]]
.setdefault("ipv4", {})
.setdefault(dock_port["PrivatePort"], [])
)
container_network_footprint = "{}:{}".format(
ip_, dock_port["PublicPort"]
)
if with_container_id:
value = (container_network_footprint, container_id)
else:
value = container_network_footprint
if value not in containers:
containers.append(value)
elif ip_address:
containers = (
proxy_lists[container["Image"]]
.setdefault("ipv4", {})
.setdefault(dock_port["PrivatePort"], [])
)
container_network_footprint = "{}:{}".format(
dock_port["IP"], dock_port["PublicPort"]
)
if with_container_id:
value = (container_network_footprint, container_id)
else:
value = container_network_footprint
if value not in containers:
containers.append(value)
return proxy_lists
def valid():
"""
List valid entries in mine configuration.
CLI Example:
.. code-block:: bash
salt '*' mine.valid
"""
mine_functions = __salt__["config.merge"]("mine_functions", {})
# If we don't have any mine functions configured, then we should just bail out
if not mine_functions:
return
mine_data = {}
for function_alias, function_data in mine_functions.items():
(
function_name,
function_args,
function_kwargs,
minion_acl,
) = salt.utils.mine.parse_function_definition(function_data)
if not _mine_function_available(function_name or function_alias):
continue
if function_name:
mine_data[function_alias] = {
function_name: function_args
+ [{key: value} for key, value in function_kwargs.items()]
}
else:
mine_data[function_alias] = function_data
return mine_data
| saltstack/salt | salt/modules/mine.py | Python | apache-2.0 | 19,294 | 0.00114 |
# Copyright (c) 2015-2020 Cloudify Platform Ltd. 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.
from cosmo_tester.framework.handlers import (
BaseHandler,
BaseCloudifyInputsConfigReader)
from pyvcloud.schema.vcd.v1_5.schemas.vcloud import taskType
from pyvcloud import vcloudair
import time
import requests
TEST_VDC = "systest"
class VcloudCleanupContext(BaseHandler.CleanupContext):
def __init__(self, context_name, env):
super(VcloudCleanupContext, self).__init__(context_name, env)
@classmethod
def clean_all(cls, env):
"""
Cleans *all* resources, including resources that were not
created by the test
"""
super(VcloudCleanupContext, cls).clean_all(env)
class CloudifyVcloudInputsConfigReader(BaseCloudifyInputsConfigReader):
def __init__(self, cloudify_config, manager_blueprint_path, **kwargs):
super(CloudifyVcloudInputsConfigReader, self).__init__(
cloudify_config, manager_blueprint_path=manager_blueprint_path,
**kwargs)
@property
def vcloud_username(self):
return self.config['vcloud_username']
@property
def vcloud_password(self):
return self.config['vcloud_password']
@property
def vcloud_url(self):
return self.config['vcloud_url']
@property
def vcloud_service(self):
return self.config['vcloud_service']
@property
def vcloud_org(self):
return self.config['vcloud_org']
@property
def vcloud_vdc(self):
return self.config['vcloud_vdc']
@property
def manager_server_name(self):
return self.config['server_name']
@property
def manager_server_catalog(self):
return self.config['catalog']
@property
def manager_server_template(self):
return self.config['template']
@property
def management_network_use_existing(self):
return self.config['management_network_use_existing']
@property
def management_network_name(self):
return self.config['management_network_name']
@property
def edge_gateway(self):
return self.config['edge_gateway']
@property
def floating_ip_public_ip(self):
return self.config['floating_ip_public_ip']
@property
def ssh_key_filename(self):
return self.config['ssh_key_filename']
@property
def agent_private_key_path(self):
return self.config['agent_private_key_path']
@property
def user_public_key(self):
return self.config['user_public_key']
@property
def agent_public_key(self):
return self.config['user_public_key']
@property
def management_port_ip_allocation_mode(self):
return self.config['management_port_ip_allocation_mode']
@property
def vcloud_service_type(self):
return self.config['vcloud_service_type']
@property
def vcloud_region(self):
return self.config['vcloud_region']
@property
def public_catalog(self):
return 'Public Catalog'
@property
def ubuntu_precise_template(self):
return 'Ubuntu Server 12.04 LTS (amd64 20150127)'
class VcloudHandler(BaseHandler):
CleanupContext = VcloudCleanupContext
CloudifyConfigReader = CloudifyVcloudInputsConfigReader
def before_bootstrap(self):
super(VcloudHandler, self).before_bootstrap()
vca = login(self.env.cloudify_config)
if vca.get_vdc(TEST_VDC):
status, task = vca.delete_vdc(TEST_VDC)
if status:
wait_for_task(vca, task)
else:
raise RuntimeError("Can't delete test VDC")
if vca:
task = vca.create_vdc(TEST_VDC)
wait_for_task(vca, task)
else:
raise RuntimeError("Can't create test VDC")
handler = VcloudHandler
def login(env):
vca = vcloudair.VCA(
host=env['vcloud_url'],
username=env['vcloud_username'],
service_type=env['vcloud_service_type'],
version="5.7",
verify=False)
logined = (vca.login(env['vcloud_password']) and
vca.login_to_instance(env['vcloud_instance'], env['vcloud_password']) and
vca.login_to_instance(env['vcloud_instance'], None,
vca.vcloud_session.token, vca.vcloud_session.org_url))
if logined:
return vca
else:
return None
def wait_for_task(vca_client, task):
TASK_RECHECK_TIMEOUT = 5
TASK_STATUS_SUCCESS = 'success'
TASK_STATUS_ERROR = 'error'
WAIT_TIME_MAX_MINUTES = 30
MAX_ATTEMPTS = WAIT_TIME_MAX_MINUTES * 60 / TASK_RECHECK_TIMEOUT
status = task.get_status()
for attempt in xrange(MAX_ATTEMPTS):
if status == TASK_STATUS_SUCCESS:
return
if status == TASK_STATUS_ERROR:
error = task.get_Error()
raise RuntimeError(
"Error during task execution: {0}".format(error.get_message()))
time.sleep(TASK_RECHECK_TIMEOUT)
response = requests.get(
task.get_href(),
headers=vca_client.vcloud_session.get_vcloud_headers(),
verify=False)
task = taskType.parseString(response.content, True)
status = task.get_status()
raise RuntimeError("Wait for task timeout.")
| cloudify-cosmo/tosca-vcloud-plugin | system_tests/vcloud_handler.py | Python | apache-2.0 | 5,843 | 0.000342 |
#!/bin/true
# -*- coding: utf-8 -*-
#
# This file is part of ypkg2
#
# Copyright 2015-2017 Ikey Doherty <[email protected]>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
from . import console_ui
import os
import hashlib
import subprocess
import fnmatch
import shutil
KnownSourceTypes = {
'tar': [
'*.tar.*',
'*.tgz',
],
'zip': [
'*.zip',
],
}
class YpkgSource:
def __init__(self):
pass
def fetch(self, context):
""" Fetch this source from it's given location """
return False
def verify(self, context):
""" Verify the locally obtained source """
return False
def extract(self, context):
""" Attempt extraction of this source type, if needed """
return False
def remove(self, context):
""" Attempt removal of this source type """
return False
def cached(self, context):
""" Report on whether this source is cached """
return False
class GitSource(YpkgSource):
""" Provides git source support to ypkg """
# Source URI
uri = None
# Tag or branch to check out
tag = None
def __init__(self, uri, tag):
YpkgSource.__init__(self)
self.uri = uri
self.tag = tag
self.filename = self.get_target_name()
def __str__(self):
return "{} ({})".format(self.uri, self.tag)
def is_dumb_transport(self):
""" Http depth cloning = no go """
if self.uri.startswith("http:") or self.uri.startswith("https:"):
return True
return False
def get_target_name(self):
""" Get the target directory base name after its fetched """
uri = str(self.uri)
if uri.endswith(".git"):
uri = uri[:-4]
return os.path.basename(uri) + ".git"
def get_full_path(self, context):
""" Fully qualified target path """
return os.path.join(context.get_sources_directory(),
self.get_target_name())
def fetch(self, context):
""" Clone the actual git repo, favouring efficiency... """
source_dir = context.get_sources_directory()
# Ensure source dir exists
if not os.path.exists(source_dir):
try:
os.makedirs(source_dir, mode=00755)
except Exception as e:
console_ui.emit_error("Source", "Cannot create sources "
"directory: {}".format(e))
return False
cmd = "git -C \"{}\" clone \"{}\" {}".format(
source_dir, self.uri, self.get_target_name())
console_ui.emit_info("Git", "Fetching: {}".format(self.uri))
try:
r = subprocess.check_call(cmd, shell=True)
except Exception as e:
console_ui.emit_error("Git", "Failed to fetch {}".format(
self.uri))
print("Error follows: {}".format(e))
return False
console_ui.emit_info("Git", "Checking out: {}".format(self.tag))
cmd = "git -C \"{}\" checkout \"{}\"".format(
os.path.join(source_dir, self.get_target_name()),
self.tag)
try:
r = subprocess.check_call(cmd, shell=True)
except Exception as e:
console_ui.emit_error("Git", "Failed to checkout {}".format(
self.tag))
return False
ddir = os.path.join(source_dir, self.get_target_name())
if not os.path.exists(os.path.join(ddir, ".gitmodules")):
return True
cmd1 = "git -C \"{}\" submodule init".format(ddir)
cmd2 = "git -C \"{}\" submodule update".format(ddir)
try:
r = subprocess.check_call(cmd1, shell=True)
r = subprocess.check_call(cmd2, shell=True)
except Exception as e:
console_ui.emit_error("Git", "Failed to submodule init {}".format(
e))
return False
return True
def verify(self, context):
""" Verify source = good. """
bpath = self.get_full_path(context)
status_cmd = "git -C {} diff --exit-code"
try:
subprocess.check_call(status_cmd.format(bpath), shell=True)
except Exception:
console_ui.emit_error("Git", "Unexpected diff in source")
return False
return True
def extract(self, context):
""" Extract ~= copy source into build area. Nasty but original source
should not be tainted between runs.
"""
source = self.get_full_path(context)
target = os.path.join(context.get_build_dir(),
self.get_target_name())
if os.path.exists(target):
try:
shutil.rmtree(target)
except Exception as e:
console_ui.emit_error("Git", "Cannot remove stagnant tree")
print(e)
return False
if not os.path.exists(context.get_build_dir()):
try:
os.makedirs(context.get_build_dir(), mode=00755)
except Exception as e:
console_ui.emit_error("Source", "Cannot create sources "
"directory: {}".format(e))
return False
try:
cmd = "cp -Ra \"{}/\" \"{}\"".format(source, target)
subprocess.check_call(cmd, shell=True)
except Exception as e:
console_ui.emit_error("Git", "Failed to copy source to build")
print(e)
return False
return True
def cached(self, context):
bpath = self.get_full_path(context)
return os.path.exists(bpath)
class TarSource(YpkgSource):
""" Represents a simple tarball source """
uri = None
hash = None
filename = None
def __init__(self, uri, hash):
YpkgSource.__init__(self)
self.uri = uri
self.filename = os.path.basename(uri)
self.hash = hash
def __str__(self):
return "%s (%s)" % (self.uri, self.hash)
def _get_full_path(self, context):
bpath = os.path.join(context.get_sources_directory(),
self.filename)
return bpath
def fetch(self, context):
source_dir = context.get_sources_directory()
# Ensure source dir exists
if not os.path.exists(source_dir):
try:
os.makedirs(source_dir, mode=00755)
except Exception as e:
console_ui.emit_error("Source", "Cannot create sources "
"directory: {}".format(e))
return False
console_ui.emit_info("Source", "Fetching: {}".format(self.uri))
fpath = self._get_full_path(context)
cmd = "curl -o \"{}\" --url \"{}\" --location".format(
fpath, self.uri)
try:
r = subprocess.check_call(cmd, shell=True)
except Exception as e:
console_ui.emit_error("Source", "Failed to fetch {}".format(
self.uri))
print("Error follows: {}".format(e))
return False
return True
def verify(self, context):
bpath = self._get_full_path(context)
hash = None
with open(bpath, "r") as inp:
h = hashlib.sha256()
h.update(inp.read())
hash = h.hexdigest()
if hash != self.hash:
console_ui.emit_error("Source", "Incorrect hash for {}".
format(self.filename))
print("Found hash : {}".format(hash))
print("Expected hash : {}".format(self.hash))
return False
return True
target = os.path.join(BallDir, os.path.basename(x))
ext = "unzip" if target.endswith(".zip") else "tar xf"
diropt = "-d" if target.endswith(".zip") else "-C"
cmd = "%s \"%s\" %s \"%s\"" % (ext, target, diropt, bd)
def get_extract_command_zip(self, context, bpath):
""" Get a command tailored for zip usage """
cmd = "unzip \"{}\" -d \"{}/\"".format(bpath, context.get_build_dir())
return cmd
def get_extract_command_tar(self, context, bpath):
""" Get a command tailored for tar usage """
if os.path.exists("/usr/bin/bsdtar"):
frag = "bsdtar"
else:
frag = "tar"
cmd = "{} xf \"{}\" -C \"{}/\"".format(
frag, bpath, context.get_build_dir())
return cmd
def extract(self, context):
""" Extract an archive into the context.get_build_dir() """
bpath = self._get_full_path(context)
# Grab the correct extraction command
fileType = None
for key in KnownSourceTypes:
lglobs = KnownSourceTypes[key]
for lglob in lglobs:
if fnmatch.fnmatch(self.filename, lglob):
fileType = key
break
if fileType:
break
if not fileType:
console_ui.emit_warning("Source", "Type of file {} is unknown, "
"falling back to tar handler".
format(self.filename))
fileType = "tar"
cmd_name = "get_extract_command_{}".format(fileType)
if not hasattr(self, cmd_name):
console_ui.emit_error("Source", "Fatal error: No handler for {}".
format(fileType))
return False
if not os.path.exists(context.get_build_dir()):
try:
os.makedirs(context.get_build_dir(), mode=00755)
except Exception as e:
console_ui.emit_error("Source", "Failed to construct build "
"directory")
print(e)
return False
cmd = getattr(self, cmd_name)(context, bpath)
try:
subprocess.check_call(cmd, shell=True)
except Exception as e:
console_ui.emit_error("Source", "Failed to extract {}".
format(self.filename))
return False
return True
def remove(self, context):
console_ui.emit_error("Source", "Remove not yet implemented")
return False
def cached(self, context):
bpath = self._get_full_path(context)
return os.path.exists(bpath)
class SourceManager:
""" Responsible for identifying, fetching, and verifying sources as listed
within a YpkgSpec. """
sources = None
def __init__(self):
self.sources = list()
def identify_sources(self, spec):
if not spec:
return False
for source in spec.pkg_source:
if not isinstance(source, dict):
console_ui.emit_error("SOURCE",
"Source lines must be of 'key : value' "
"mapping type")
print("Erronous line: {}".format(str(source)))
return False
if len(source.keys()) != 1:
console_ui.emit_error("SOURCE",
"Encountered too many keys in source")
print("Erronous source: {}".format(str(source)))
return False
uri = source.keys()[0]
hash = source[uri]
# Check if its a namespaced support type
if "|" in uri:
brk = uri.split("|")
# It's a git| prefix
if brk[0] == 'git':
uri = "|".join(brk[1:])
self.sources.append(GitSource(uri, hash))
continue
self.sources.append(TarSource(uri, hash))
return True
def _get_working_dir(self, context):
""" Need to make this.. better. It's very tar-type now"""
build_dir = context.get_build_dir()
source0 = self.sources[0].filename
if os.path.exists(build_dir):
items = os.listdir(build_dir)
if len(items) == 1:
return os.path.join(build_dir, items[0])
for item in items:
if source0.startswith(item):
return os.path.join(build_dir, item)
return build_dir
else:
return build_dir
def get_working_dir(self, context):
potential = self._get_working_dir(context)
if not os.path.exists(potential) or not os.path.isdir(potential):
return context.get_build_dir()
return potential
| solus-project/ypkg | ypkg2/sources.py | Python | gpl-3.0 | 12,925 | 0 |
# Determine if a Sudoku is valid, according to: Sudoku Puzzles - The Rules (http://sudoku.com.au/TheRules.aspx).
#
# The Sudoku board could be partially filled, where empty cells are filled with the character '.'.
#
# Note:
# A valid Sudoku board (partially filled) is not necessarily solvable. Only the filled cells need to be validated.
class Solution(object):
def isValidSudoku(self, board):
"""
:type board: List[List[str]]
:rtype: bool
"""
row = {}
column = {}
box = {}
for i in range(len(board)):
for j in range(len(board[i])):
if board[i][j] != '.':
num = int(board[i][j])
if row.get((i, num)) or column.get((j, num)) or box.get((i/3, j/3, num)):
return False
row[i, num] = column[j, num] = box[i/3, j/3, num] = True
return True
# Note:
# We maintain 3 hash maps for rows(i), column(j) and box((i/3,j,3)) and return false if anyone has value true
| jigarkb/CTCI | LeetCode/036-M-ValidSudoku.py | Python | mit | 1,045 | 0.004785 |
#
# timezone.py - timezone install data
#
# Copyright (C) 2001 Red Hat, Inc. All rights reserved.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
import shutil
import iutil
import os
from flags import flags
from anaconda_log import PROGRAM_LOG_FILE
import logging
log = logging.getLogger("anaconda")
class Timezone:
def writeKS(self, f):
f.write("timezone")
if self.utc:
f.write(" --utc")
f.write(" %s\n" % self.tz)
def write(self, instPath):
fromFile = "/usr/share/zoneinfo/" + self.tz
tzfile = instPath + "/etc/localtime"
if os.path.isdir(instPath+"/etc"):
try:
if os.path.lexists(tzfile):
os.remove(tzfile)
os.symlink(fromFile, tzfile)
except OSError, e:
log.error("Error copying timezone (from %s): %s" % (
fromFile, e,))
f = open(instPath + "/etc/timezone", "w")
f.write(self.tz)
f.flush()
f.close()
# all this is ugly, but it's going away
# hopefully soon.
timedatectl = "/usr/bin/timedatectl"
if os.path.lexists(timedatectl):
if self.utc:
iutil.execWithRedirect(
timedatectl, ["set-local-rtc", "0"],
stdout = PROGRAM_LOG_FILE,
stderr = PROGRAM_LOG_FILE)
else:
iutil.execWithRedirect(
timedatectl, ["set-local-rtc", "1"],
stdout = PROGRAM_LOG_FILE,
stderr = PROGRAM_LOG_FILE)
# this writes /etc/adjtime, so copy it over
adjtime = "/etc/adjtime"
if os.path.isfile(adjtime):
shutil.copy2(adjtime, instPath + adjtime)
def getTimezoneInfo(self):
return (self.tz, self.utc)
def setTimezoneInfo(self, timezone, asUtc = 0):
self.tz = timezone
self.utc = asUtc
def __init__(self):
self.tz = "America/New_York"
self.utc = 0
| Rogentos/rogentos-anaconda | timezone.py | Python | gpl-2.0 | 2,650 | 0.004151 |
# Partname: ATmega8535
# generated automatically, do not edit
MCUREGS = {
'ADMUX': '&39',
'ADMUX_REFS': '$C0',
'ADMUX_ADLAR': '$20',
'ADMUX_MUX': '$1F',
'ADCSRA': '&38',
'ADCSRA_ADEN': '$80',
'ADCSRA_ADSC': '$40',
'ADCSRA_ADATE': '$20',
'ADCSRA_ADIF': '$10',
'ADCSRA_ADIE': '$08',
'ADCSRA_ADPS': '$07',
'ADC': '&36',
'SFIOR': '&80',
'SFIOR_ADTS': '$E0',
'ACSR': '&40',
'ACSR_ACD': '$80',
'ACSR_ACBG': '$40',
'ACSR_ACO': '$20',
'ACSR_ACI': '$10',
'ACSR_ACIE': '$08',
'ACSR_ACIC': '$04',
'ACSR_ACIS': '$03',
'TWBR': '&32',
'TWCR': '&86',
'TWCR_TWINT': '$80',
'TWCR_TWEA': '$40',
'TWCR_TWSTA': '$20',
'TWCR_TWSTO': '$10',
'TWCR_TWWC': '$08',
'TWCR_TWEN': '$04',
'TWCR_TWIE': '$01',
'TWSR': '&33',
'TWSR_TWS': '$F8',
'TWSR_TWPS': '$03',
'TWDR': '&35',
'TWAR': '&34',
'TWAR_TWA': '$FE',
'TWAR_TWGCE': '$01',
'UDR': '&44',
'UCSRA': '&43',
'UCSRA_RXC': '$80',
'UCSRA_TXC': '$40',
'UCSRA_UDRE': '$20',
'UCSRA_FE': '$10',
'UCSRA_DOR': '$08',
'UCSRA_UPE': '$04',
'UCSRA_U2X': '$02',
'UCSRA_MPCM': '$01',
'UCSRB': '&42',
'UCSRB_RXCIE': '$80',
'UCSRB_TXCIE': '$40',
'UCSRB_UDRIE': '$20',
'UCSRB_RXEN': '$10',
'UCSRB_TXEN': '$08',
'UCSRB_UCSZ2': '$04',
'UCSRB_RXB8': '$02',
'UCSRB_TXB8': '$01',
'UCSRC': '&64',
'UCSRC_URSEL': '$80',
'UCSRC_UMSEL': '$40',
'UCSRC_UPM': '$30',
'UCSRC_USBS': '$08',
'UCSRC_UCSZ': '$06',
'UCSRC_UCPOL': '$01',
'UBRRH': '&64',
'UBRRH_URSEL': '$80',
'UBRRH_UBRR1': '$0C',
'UBRRH_UBRR': '$03',
'UBRRL': '&41',
'PORTA': '&59',
'DDRA': '&58',
'PINA': '&57',
'PORTB': '&56',
'DDRB': '&55',
'PINB': '&54',
'PORTC': '&53',
'DDRC': '&52',
'PINC': '&51',
'PORTD': '&50',
'DDRD': '&49',
'PIND': '&48',
'SPDR': '&47',
'SPSR': '&46',
'SPSR_SPIF': '$80',
'SPSR_WCOL': '$40',
'SPSR_SPI2X': '$01',
'SPCR': '&45',
'SPCR_SPIE': '$80',
'SPCR_SPE': '$40',
'SPCR_DORD': '$20',
'SPCR_MSTR': '$10',
'SPCR_CPOL': '$08',
'SPCR_CPHA': '$04',
'SPCR_SPR': '$03',
'EEAR': '&62',
'EEDR': '&61',
'EECR': '&60',
'EECR_EERIE': '$08',
'EECR_EEMWE': '$04',
'EECR_EEWE': '$02',
'EECR_EERE': '$01',
'TCCR0': '&83',
'TCCR0_FOC0': '$80',
'TCCR0_WGM00': '$40',
'TCCR0_COM0': '$30',
'TCCR0_WGM01': '$08',
'TCCR0_CS0': '$07',
'TCNT0': '&82',
'OCR0': '&92',
'TIMSK': '&89',
'TIMSK_OCIE0': '$02',
'TIMSK_TOIE0': '$01',
'TIFR': '&88',
'TIFR_OCF0': '$02',
'TIFR_TOV0': '$01',
'TCCR1A': '&79',
'TCCR1A_COM1A': '$C0',
'TCCR1A_COM1B': '$30',
'TCCR1A_FOC1A': '$08',
'TCCR1A_FOC1B': '$04',
'TCCR1A_WGM1': '$03',
'TCCR1B': '&78',
'TCCR1B_ICNC1': '$80',
'TCCR1B_ICES1': '$40',
'TCCR1B_WGM1': '$18',
'TCCR1B_CS1': '$07',
'TCNT1': '&76',
'OCR1A': '&74',
'OCR1B': '&72',
'ICR1': '&70',
'TCCR2': '&69',
'TCCR2_FOC2': '$80',
'TCCR2_WGM20': '$40',
'TCCR2_COM2': '$30',
'TCCR2_WGM21': '$08',
'TCCR2_CS2': '$07',
'TCNT2': '&68',
'OCR2': '&67',
'ASSR': '&66',
'ASSR_AS2': '$08',
'ASSR_TCN2UB': '$04',
'ASSR_OCR2UB': '$02',
'ASSR_TCR2UB': '$01',
'GICR': '&91',
'GICR_INT': '$C0',
'GICR_INT2': '$20',
'GICR_IVSEL': '$02',
'GICR_IVCE': '$01',
'GIFR': '&90',
'GIFR_INTF': '$C0',
'GIFR_INTF2': '$20',
'MCUCR': '&85',
'MCUCR_ISC1': '$0C',
'MCUCR_ISC0': '$03',
'MCUCSR': '&84',
'MCUCSR_ISC2': '$40',
'WDTCR': '&65',
'WDTCR_WDCE': '$10',
'WDTCR_WDE': '$08',
'WDTCR_WDP': '$07',
'SREG': '&95',
'SREG_I': '$80',
'SREG_T': '$40',
'SREG_H': '$20',
'SREG_S': '$10',
'SREG_V': '$08',
'SREG_N': '$04',
'SREG_Z': '$02',
'SREG_C': '$01',
'SP': '&93',
'OSCCAL': '&81',
'SPMCR': '&87',
'SPMCR_SPMIE': '$80',
'SPMCR_RWWSB': '$40',
'SPMCR_RWWSRE': '$10',
'SPMCR_BLBSET': '$08',
'SPMCR_PGWRT': '$04',
'SPMCR_PGERS': '$02',
'SPMCR_SPMEN': '$01',
'INT0Addr': '1',
'INT1Addr': '2',
'TIMER2_COMPAddr': '3',
'TIMER2_OVFAddr': '4',
'TIMER1_CAPTAddr': '5',
'TIMER1_COMPAAddr': '6',
'TIMER1_COMPBAddr': '7',
'TIMER1_OVFAddr': '8',
'TIMER0_OVFAddr': '9',
'SPI_STCAddr': '10',
'USART_RXAddr': '11',
'USART_UDREAddr': '12',
'USART_TXAddr': '13',
'ADCAddr': '14',
'EE_RDYAddr': '15',
'ANA_COMPAddr': '16',
'TWIAddr': '17',
'INT2Addr': '18',
'TIMER0_COMPAddr': '19',
'SPM_RDYAddr': '20'
} | lowfatcomputing/amforth | core/devices/atmega8535/device.py | Python | gpl-2.0 | 4,349 | 0.07404 |
import numpy as np
def empirical_rmt(input_returns):
"""
Empirical RMT computes an empirical correlation matrix and then filters using Random Matrix Theory.
THIS FUNCTION TAKES AS INPUT A CLEAN NUMPY ARRAY (please remove n/a first !)
To compute a correlation matrix, and then apply Wishart RMT, it is required that input variables be as close to a
series of iid Gaussian vectors as possible.
This is why we start by normalizing observations by dispersions (cross-section standard dev, here estimated assuming
zero average)
To check the "Gaussianization":
import matplotlib.pyplot as pp
pp.plot(rets.index ,dispersion)
pp.hist(returns_dispersion_nformalized.reshape(returns_dispersion_normalized.size), bins=1000, range=[-5, 5])
pp.hist(returns_np.reshape(returns_np.size), bins=1000, range=[-.05, .05])
Args:
input_returns (np.array): Input cleaned log-returns.
Returns:
# to compute a correlation we have better start standardizing returns by dispersion
np.array: correlation matrix
"""
# 1. NORMALIZE BY DISPERSIONS
#
# this "Gaussianization" works well as can be seen on the histograms
# (although there is still a peak for the "cleansed" data)
dispersion = np.sqrt(1. / input_returns.shape[1] * np.sum(input_returns * input_returns, axis=1))
returns_dispersion_normalized = input_returns \
/ np.tile(dispersion.reshape(len(dispersion), 1), [1, input_returns.shape[1]])
# 2. COMPUTE THE EMPIRICAL CORRELATION MATRIX
# now returns are gaussian, we can compute a proper correlation matrix
correlation_matrix_raw = np.corrcoef(returns_dispersion_normalized, rowvar=0)
n_time, n_asset = returns_dispersion_normalized.shape
quality = n_asset/n_time
# print('Quality coefficient (the smaller the better)' + str(quality))
# 3. APPLY RMT FILTERING FORMULA
# RMT filter: this formula works for Wishart matrices !!!
w, v = np.linalg.eigh(correlation_matrix_raw)
lambda_plus = (1. + quality) ** 2
# Remove smaller eigen-spaces
v = v[:, w > lambda_plus]
w = w[w > lambda_plus]
# Reconstruct the correlation matrix from eigen-spaces
correlation_matrix = np.zeros_like(correlation_matrix_raw)
number_of_assets = correlation_matrix_raw.shape[0]
for index_eig in range(len(w)):
cur_vect = np.reshape(v[:, index_eig], [number_of_assets, 1])
correlation_matrix += w[index_eig] * cur_vect * np.transpose(cur_vect)
# print(correlation_matrix)
# Fill the remaining eigen-vectors
for index_eig in range(correlation_matrix.shape[0]):
correlation_matrix[index_eig, index_eig] = 1.
return correlation_matrix
| gpostelnicu/fin_data | fin_data/stat/correlation/random_matrix.py | Python | mit | 2,722 | 0.003306 |
import tangelo
import pymongo
import bson.json_util
from ArborFileManagerAPI import ArborFileManager
api = ArborFileManager()
api.initDatabaseConnection()
@tangelo.restful
def get(*pargs, **query_args):
if len(pargs) == 0:
return tangelo.HTTPStatusCode(400, "Missing resource type")
resource_type = pargs[0]
allowed = ["project", "analysis","collection", "workflow"]
if resource_type == "project":
if len(pargs) == 1:
return api.getListOfProjectNames()
elif len(pargs) == 2:
project = pargs[1]
return api.getListOfTypesForProject(project)
elif len(pargs) == 3:
project = pargs[1]
datatype = pargs[2]
return api.getListOfDatasetsByProjectAndType(project, datatype)
elif len(pargs) == 4:
project = pargs[1]
datatype = pargs[2]
dataset = pargs[3]
coll = api.db[api.returnCollectionForObjectByName(project, datatype, dataset)]
return bson.json_util.dumps(list(coll.find()))
elif len(pargs) == 5:
project = pargs[1]
datatype = pargs[2]
dataset = pargs[3]
stringFormat = pargs[4]
string = api.getDatasetAsTextString(project, datatype, dataset, stringFormat)
return string
else:
return tangelo.HTTPStatusCode(400, "Bad request - got %d parameter(s), was expecting between 1 and 5")
elif resource_type == "analysis":
if len(pargs) == 1:
return api.getListOfAnalysisNames()
elif len(pargs) == 2:
analysis_name = pargs[1]
coll = api.db[api.returnCollectionForAnalysisByName(analysis_name)]
return bson.json_util.dumps(list(coll.find()))
elif len(pargs) == 3:
analysis_name = pargs[1]
coll = api.db[api.returnCollectionForAnalysisByName(analysis_name)]
return coll.find_one()["analysis"]["script"]
# add a collection option to return the database and collection name for an object in the
# Arbor treestore. This 'information hiding violation' of the treestore allows for low-level
# clients to connect and work directly with the mongo database, should it be needed. This level
# is used in the phylomap application.
elif resource_type == "collection":
if len(pargs) == 4:
project = pargs[1]
datatype = pargs[2]
dataset = pargs[3]
collname = api.returnCollectionForObjectByName(project, datatype, dataset)
dbname = api.getMongoDatabase()
dbhost = api.getMongoHost()
dbport = api.getMongoPort()
return bson.json_util.dumps({'host':dbhost,'port':dbport,'db': dbname,'collection': collname})
# if workflow is specified as the resource type, then list the workflows in a project or display the
# information about a particular workflow
elif resource_type == "workflow":
if len(pargs) == 2:
project = pargs[1]
return api.getListOfDatasetsByProjectAndType(project,"Workflow")
if len(pargs) == 3:
project = pargs[1]
workflowName = pargs[2]
print("REST: getting status of workflow:",workflowName)
return bson.json_util.dumps(api.getStatusOfWorkflow(workflowName,project))
else:
return tangelo.HTTPStatusCode(400, "Workflow resource requires 2 or 3 positional arguments")
else:
return tangelo.HTTPStatusCode(400, "Bad resource type '%s' - allowed types are: %s" % (resource_type, ", ".join(allowed)))
# Jan 2014 - added support for workflows as a datatype inside projects. new workflow-only named types are
# defined here to allow workflows to be created and run through the REST interface
#
@tangelo.restful
def put(resource, projname, datasetname=None, data=None, filename=None, filetype=None,
workflowName = None, stepName=None, stepType=None, inputStepName=None, outputStepName=None,
inPortName=None,outPortName=None,operation=None, parameterName=None, parameterValue=None,
parameterValueNumber=None,flowType=None,dataType=None, **kwargs):
if (resource != "project") and (resource != "workflow"):
return tangelo.HTTPStatusCode(400, "Bad resource type '%s' - allowed types are: project")
if resource == "project":
if datasetname is None:
api.newProject(projname)
else:
if filename is None:
return tangelo.HTTPStatusCode(400, "Missing argument 'filename'")
if filetype is None:
return tangelo.HTTPStatusCode(400, "Missing argument 'filetype'")
if data is None:
return tangelo.HTTPStatusCode(400, "Missing argument 'data'")
if datasetname is None:
return tangelo.HTTPStatusCode(400, "Missing argument 'datasetname'")
# user wants to upload a tree or a character matrix
if filetype == "newick" or filetype == "phyloxml":
api.newTreeInProjectFromString(datasetname, data, projname, filename, filetype)
if (filetype == "csv" and dataType is None) or (filetype == "csv" and dataType=='CharacterMatrix'):
api.newCharacterMatrixInProjectFromString(datasetname, data, projname, filename)
if filetype == "csv" and dataType=="Occurrences":
api.newOccurrencesInProjectFromString(datasetname, data, projname)
# workflow creation
# arborapi: /workflow/projname/workflowname - creates new empty workflow
# arborapi: /workflow/projname/workflowname//
if resource == "workflow":
# the user wants to create a new, empty workflow
if operation == "newWorkflow":
api.newWorkflowInProject(workflowName, projname)
if operation == "newWorkstepInWorkflow":
api.newWorkstepInWorkflow(workflowName, stepType, stepName, projname)
# allow user to add a parameter to a workstep or update the value of the parameter. There
# is currently a limitation that all values are strings, e.g. "2.4" instead of 2.4.
if operation == "updateWorkstepParameter":
# if a float argument is sent, use this as the value for the parameter, instead of the
# string. A conversion is done to float to assure numberic values
if parameterValueNumber != None:
print "found number filter value"
parameterValue = float(parameterValueNumber)
api.updateWorkstepParameter(workflowName, stepName, parameterName, parameterValue, projname)
if operation == "connectWorksteps":
#api.connectStepsInWorkflow(workflowName,outStepName,outPortName,inStepName,inPortName,projname)
api.connectStepsInWorkflow(workflowName,outputStepName,inputStepName,projname)
if operation == "executeWorkflow":
api.executeWorkflowInProject(workflowName,projname)
if operation == "updateWorkflowFromString":
print "received request to update workflow: ",workflowName
api.updateExistingWorkflowInProject(workflowName,data,projname)
return "OK"
@tangelo.restful
def post(*pargs, **kwargs):
return "projmgr.post()"
@tangelo.restful
def delete(resource, projname, datatype=None, dataset=None):
if resource != "project":
return tangelo.HTTPStatusCode(400, "Bad resource type '%s' - allowed types are: project")
# (This is expressing xor)
if (datatype is None) != (dataset is None):
return tangelo.HTTPStatusCode(400, "Bad arguments - 'datatype' and 'dataset' must both be specified if either one is specified")
if datatype is None:
api.deleteProjectNamed(projname)
else:
api.deleteDataset(projname, datatype, dataset)
return "OK"
| arborworkflows/ProjectManager | tangelo/projmgr.py | Python | apache-2.0 | 7,996 | 0.009005 |
from __future__ import absolute_import
import theano
import theano.tensor as T
import numpy as np
class Constraint(object):
def __call__(self, p):
return p
def get_config(self):
return {"name":self.__class__.__name__}
class MaxNorm(Constraint):
def __init__(self, m=2):
self.m = m
def __call__(self, p):
norms = T.sqrt(T.sum(T.sqr(p), axis=0))
desired = T.clip(norms, 0, self.m)
p = p * (desired / (1e-7 + norms))
return p
def get_config(self):
return {"name":self.__class__.__name__,
"m":self.m}
class NonNeg(Constraint):
def __call__(self, p):
p *= T.ge(p, 0)
return p
class UnitNorm(Constraint):
def __call__(self, p):
return p / T.sqrt(T.sum(p**2, axis=-1, keepdims=True))
identity = Constraint
maxnorm = MaxNorm
nonneg = NonNeg
unitnorm = UnitNorm
from .utils.generic_utils import get_from_module
def get(identifier, kwargs=None):
return get_from_module(identifier, globals(), 'constraint', instantiate=True, kwargs=kwargs) | ypkang/keras | keras/constraints.py | Python | mit | 1,069 | 0.012161 |
# coding=utf-8
# Copyright 2022 The Google Research Authors.
#
# 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.
# Lint as: python3
"""Main hyperparameter optimisation script.
Performs random search to optimize hyperparameters on a single machine. For new
datasets, inputs to the main(...) should be customised.
"""
import argparse
import datetime as dte
import os
import data_formatters.base
import expt_settings.configs
import libs.hyperparam_opt
import libs.tft_model
import libs.utils as utils
import numpy as np
import pandas as pd
import tensorflow.compat.v1 as tf
ExperimentConfig = expt_settings.configs.ExperimentConfig
HyperparamOptManager = libs.hyperparam_opt.HyperparamOptManager
ModelClass = libs.tft_model.TemporalFusionTransformer
def main(expt_name, use_gpu, restart_opt, model_folder, hyperparam_iterations,
data_csv_path, data_formatter):
"""Runs main hyperparameter optimization routine.
Args:
expt_name: Name of experiment
use_gpu: Whether to run tensorflow with GPU operations
restart_opt: Whether to run hyperparameter optimization from scratch
model_folder: Folder path where models are serialized
hyperparam_iterations: Number of iterations of random search
data_csv_path: Path to csv file containing data
data_formatter: Dataset-specific data fromatter (see
expt_settings.dataformatter.GenericDataFormatter)
"""
if not isinstance(data_formatter, data_formatters.base.GenericDataFormatter):
raise ValueError(
"Data formatters should inherit from" +
"AbstractDataFormatter! Type={}".format(type(data_formatter)))
default_keras_session = tf.keras.backend.get_session()
if use_gpu:
tf_config = utils.get_default_tensorflow_config(tf_device="gpu", gpu_id=0)
else:
tf_config = utils.get_default_tensorflow_config(tf_device="cpu")
print("### Running hyperparameter optimization for {} ###".format(expt_name))
print("Loading & splitting data...")
raw_data = pd.read_csv(data_csv_path, index_col=0)
train, valid, test = data_formatter.split_data(raw_data)
train_samples, valid_samples = data_formatter.get_num_samples_for_calibration(
)
# Sets up default params
fixed_params = data_formatter.get_experiment_params()
param_ranges = ModelClass.get_hyperparm_choices()
fixed_params["model_folder"] = model_folder
print("*** Loading hyperparm manager ***")
opt_manager = HyperparamOptManager(param_ranges, fixed_params, model_folder)
success = opt_manager.load_results()
if success and not restart_opt:
print("Loaded results from previous training")
else:
print("Creating new hyperparameter optimisation")
opt_manager.clear()
print("*** Running calibration ***")
while len(opt_manager.results.columns) < hyperparam_iterations:
print("# Running hyperparam optimisation {} of {} for {}".format(
len(opt_manager.results.columns) + 1, hyperparam_iterations, "TFT"))
tf.reset_default_graph()
with tf.Graph().as_default(), tf.Session(config=tf_config) as sess:
tf.keras.backend.set_session(sess)
params = opt_manager.get_next_parameters()
model = ModelClass(params, use_cudnn=use_gpu)
if not model.training_data_cached():
model.cache_batched_data(train, "train", num_samples=train_samples)
model.cache_batched_data(valid, "valid", num_samples=valid_samples)
sess.run(tf.global_variables_initializer())
model.fit()
val_loss = model.evaluate()
if np.allclose(val_loss, 0.) or np.isnan(val_loss):
# Set all invalid losses to infintiy.
# N.b. val_loss only becomes 0. when the weights are nan.
print("Skipping bad configuration....")
val_loss = np.inf
opt_manager.update_score(params, val_loss, model)
tf.keras.backend.set_session(default_keras_session)
print("*** Running tests ***")
tf.reset_default_graph()
with tf.Graph().as_default(), tf.Session(config=tf_config) as sess:
tf.keras.backend.set_session(sess)
best_params = opt_manager.get_best_params()
model = ModelClass(best_params, use_cudnn=use_gpu)
model.load(opt_manager.hyperparam_folder)
print("Computing best validation loss")
val_loss = model.evaluate(valid)
print("Computing test loss")
output_map = model.predict(test, return_targets=True)
targets = data_formatter.format_predictions(output_map["targets"])
p50_forecast = data_formatter.format_predictions(output_map["p50"])
p90_forecast = data_formatter.format_predictions(output_map["p90"])
def extract_numerical_data(data):
"""Strips out forecast time and identifier columns."""
return data[[
col for col in data.columns
if col not in {"forecast_time", "identifier"}
]]
p50_loss = utils.numpy_normalised_quantile_loss(
extract_numerical_data(targets), extract_numerical_data(p50_forecast),
0.5)
p90_loss = utils.numpy_normalised_quantile_loss(
extract_numerical_data(targets), extract_numerical_data(p90_forecast),
0.9)
tf.keras.backend.set_session(default_keras_session)
print("Hyperparam optimisation completed @ {}".format(dte.datetime.now()))
print("Best validation loss = {}".format(val_loss))
print("Params:")
for k in best_params:
print(k, " = ", best_params[k])
print()
print("Normalised Quantile Loss for Test Data: P50={}, P90={}".format(
p50_loss.mean(), p90_loss.mean()))
if __name__ == "__main__":
def get_args():
"""Returns settings from command line."""
experiment_names = ExperimentConfig.default_experiments
parser = argparse.ArgumentParser(description="Data download configs")
parser.add_argument(
"expt_name",
metavar="e",
type=str,
nargs="?",
default="volatility",
choices=experiment_names,
help="Experiment Name. Default={}".format(",".join(experiment_names)))
parser.add_argument(
"output_folder",
metavar="f",
type=str,
nargs="?",
default=".",
help="Path to folder for data download")
parser.add_argument(
"use_gpu",
metavar="g",
type=str,
nargs="?",
choices=["yes", "no"],
default="no",
help="Whether to use gpu for training.")
parser.add_argument(
"restart_hyperparam_opt",
metavar="o",
type=str,
nargs="?",
choices=["yes", "no"],
default="yes",
help="Whether to re-run hyperparameter optimisation from scratch.")
args = parser.parse_known_args()[0]
root_folder = None if args.output_folder == "." else args.output_folder
return args.expt_name, root_folder, args.use_gpu == "yes", \
args.restart_hyperparam_opt
# Load settings for default experiments
name, folder, use_tensorflow_with_gpu, restart = get_args()
print("Using output folder {}".format(folder))
config = ExperimentConfig(name, folder)
formatter = config.make_data_formatter()
# Customise inputs to main() for new datasets.
main(
expt_name=name,
use_gpu=use_tensorflow_with_gpu,
restart_opt=restart,
model_folder=os.path.join(config.model_folder, "main"),
hyperparam_iterations=config.hyperparam_iterations,
data_csv_path=config.data_csv_path,
data_formatter=formatter)
| google-research/google-research | tft/script_hyperparam_opt.py | Python | apache-2.0 | 7,859 | 0.006489 |
#!/usr/bin/env python3
import re
import os
import os.path
import sys
def main():
already_found = []
url_matcher = re.compile(r'(https?://(www.)?)?((youtu.be|youtube.(com|de|ch|at))/watch\?v=[-_0-9A-Za-z]{11}|youtu.be/[-_0-9A-Za-z]{11})')
backup_matcher = re.compile(r'youtu')
argc = len(sys.argv)
if argc == 1:
whole_input = sys.stdin.read()
elif argc == 2:
with open(sys.argv[1], mode='rt', encoding='utf8') as inf:
whole_input = inf.read()
else:
raise Exception()
os.makedirs('./urls', exist_ok=True)
num_found = 0
filename_ctr = 0
for match in url_matcher.finditer(whole_input):
num_found += 1
already_found.append((match.start(), match.end()))
written = False
while (not written) and (filename_ctr < 31337):
try:
with open(os.path.join('./urls/', '{0}.txt'.format(filename_ctr)), mode='xt', encoding='utf8') as outf:
print(match.group(0), file=outf)
written = True
except OSError:
pass
filename_ctr += 1
if filename_ctr >= 31337:
print("Error: hit infinite loop while attempting to create files. Exiting.", file=sys.stderr)
sys.exit(1)
num_backup_candidates = 0
whole_len = len(whole_input)
for match in backup_matcher.finditer(whole_input):
ms = match.start()
me = match.end()
for (s, e) in already_found:
if ms >= s and me <= e:
break
else:
s = max(ms - 33, 0)
e = min(me + 33, whole_len)
num_backup_candidates += 1
print('found unmatched candidate: ' + whole_input[s:e])
print('found {0} unmatched candidates and created {1} URL files'.format(num_backup_candidates, num_found))
print('done')
if __name__ == "__main__":
main()
| sseering/ytdlWrapper | urlfind.py | Python | unlicense | 1,923 | 0.00208 |
#!/usr/bin/env python
#
# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
# Copyright (c) 1997-2015 California Institute of Technology.
# License: 3-clause BSD. The full license text is available at:
# - http://trac.mystic.cacr.caltech.edu/project/mystic/browser/mystic/LICENSE
"""
See test_rosenbrock.py.
This one uses Scipy's CG (Polak-Ribiere) plus viz via matplotlib
cg works well on this problem.
"""
import pylab
from test_rosenbrock import *
from numpy import log
from mystic._scipyoptimize import fmin_cg
import numpy
from mystic.tools import getch
def show():
import pylab, Image
pylab.savefig('cg_rosenbrock_out',dpi=72)
im = Image.open('cg_rosenbrock_out.png')
im.show()
return
def draw_contour():
import numpy
x, y = numpy.mgrid[-1:2.1:0.02,-0.1:2.1:0.02]
c = 0*x
s,t = x.shape
for i in range(s):
for j in range(t):
xx,yy = x[i,j], y[i,j]
c[i,j] = rosen([xx,yy])
pylab.contourf(x,y,log(c*20+1)+2,60)
def run_once(x0,x1,color='w'):
sol = fmin_cg(rosen, [x0, x1], retall = True, full_output=1)
xy = numpy.asarray(sol[-1])
pylab.plot(xy[:,0],xy[:,1],color+'-',linewidth=2)
pylab.plot(xy[:,0],xy[:,1],color+'o',markersize=6)
return sol
if __name__ == '__main__':
draw_contour()
run_once(0.3,0.3,'k')
run_once(0.5,1.3,'y')
run_once(1.8,0.2,'w')
try:
show()
except ImportError:
pylab.show()
# end of file
| jcfr/mystic | examples/cg_rosenbrock.py | Python | bsd-3-clause | 1,478 | 0.023004 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""McGill Robotics ROS Bagger.
This tool can:
1. Record the specified topics into 15 second bags to the specified
directory.
2. Merge previously recorded bags from the specified directory.
By default, all the topics defined in your project's 'topics' file will be
recorded/merged if no arguments are specified. Otherwise, only the topics
specified will be recorded/merged.
"""
import os
import sys
try:
import rosbag
except ImportError:
sys.stderr.write("Could not find rosbag package. Is ROS installed?\n")
sys.exit(-1)
from util import Parser, TopicList
__version__ = "1.3.1"
def main():
"""Runs the CLI."""
try:
topics_path = os.environ["TOPICS_PATH"]
except KeyError:
print("E: TOPICS_PATH environment variable not set")
sys.exit(2)
topics = TopicList(topics_path)
args = Parser(topics, __doc__, __version__)
status = args.cmd(
topics=args.enabled, name=args.name, dir=args.dir, args=args.raw).run()
sys.exit(status)
if __name__ == "__main__":
main()
| mcgill-robotics/compsys | scripts/bag/bag/__main__.py | Python | mit | 1,110 | 0 |
"""GLX context creation and management.
Depends on the binary glxcontext module.
@todo: Include glxcontext in distribution as an optional module.
@author: Stephan Wenger
@date: 2012-08-28
"""
try:
from glxcontext import GLXContext as _GLXContext
from glitter.contexts.context import Context
from glitter.contexts.contextmanager import context_manager
class GLXContext(_GLXContext, Context):
"""Offscreen GLX context."""
def __init__(self, **kwargs):
_GLXContext.__init__(self, **kwargs)
Context.__init__(self)
# TODO the lines below should not be necessary, or should at least be performed automatically by context_manager
# XXX I would have expected it worked without these lines because of "with self._context" around GLObject functions; is this a problem with multiple Contexts?
old_binding = context_manager.current_context
if old_binding:
old_binding._bind()
else:
context_manager.current_context = self
def _bind(self):
return _GLXContext.bind(self)
def bind(self):
return Context.bind(self)
__all__ = ["GLXContext"]
except ImportError:
pass
| swenger/glitter | glitter/contexts/glx.py | Python | mit | 1,256 | 0.002389 |
'''
Jan Camenisch, Markulf Kohlweiss, Alfredo Rial, and Caroline Sheedy (Pairing-based)
| From: "Blind and Anonymous Identity-Based Encryption and
Authorised Private Searches on Public Key Encrypted Data".
| Published in: PKC 2009
| Available from: http://www.iacr.org/archive/pkc2009/54430202/54430202.pdf
| Notes: section 4.1, first blind and anonymous IBE scheme
| Security Assumptions:
|
| type: identity-based encryption (public key)
| setting: Pairing
:Authors: J Ayo Akinyele/Mike Rushanan
:Date: 02/2012
'''
from charm.toolbox.pairinggroup import PairingGroup,ZR,G1,G2,GT,pair
from charm.toolbox.IBEnc import IBEnc
from charm.toolbox.conversion import Conversion
from charm.toolbox.bitstring import Bytes
from charm.toolbox.iterate import dotprod2
from charm.toolbox.hash_module import Waters
import hashlib
debug = False
class IBE_CKRS(IBEnc):
"""
>>> from charm.toolbox.pairinggroup import PairingGroup, GT
>>> group = PairingGroup('SS512')
>>> ibe = IBE_CKRS(group)
>>> (master_public_key, master_secret_key) = ibe.setup()
>>> ID = "[email protected]"
>>> secret_key = ibe.extract(master_public_key, master_secret_key, ID)
>>> msg = group.random(GT)
>>> cipher_text = ibe.encrypt(master_public_key, ID, msg)
>>> decrypted_msg = ibe.decrypt(master_public_key, secret_key, cipher_text)
>>> decrypted_msg == msg
True
"""
def __init__(self, groupObj):
global group,hashObj
group = groupObj
def setup(self, n=5, l=32):
"""n integers with each size l"""
global lam_func, waters
lam_func = lambda i,x,y: x[i] ** y[i]
waters = Waters(group, n, l)
alpha, t1, t2, t3, t4 = group.random(ZR, 5)
z = list(group.random(ZR, n))
g = group.random(G1)
h = group.random(G2)
omega = pair(g, h) ** (t1 * t2 * alpha)
g_l = [g ** i for i in z]
h_l = [h ** i for i in z]
v1, v2 = g ** t1, g ** t2
v3, v4 = g ** t3, g ** t4
msk = { 'alpha':alpha, 't1':t1, 't2':t2, 't3':t3, 't4':t4 }
mpk = { 'omega':omega, 'g':g, 'h':h, 'g_l':g_l, 'h_l':h_l,
'v1':v1, 'v2':v2, 'v3':v3, 'v4':v4, 'n':n, 'l':l }
return (mpk, msk)
def extract(self, mpk, msk, ID):
r1, r2 = group.random(ZR, 2) # should be params of extract
hID = waters.hash(ID)
hashID2 = mpk['h_l'][0] * dotprod2(range(1,mpk['n']), lam_func, mpk['h_l'], hID)
d = {}
d[0] = mpk['h'] ** ((r1 * msk['t1'] * msk['t2']) + (r2 * msk['t3'] * msk['t4']))
d[1] = (mpk['h'] ** (-msk['alpha'] * msk['t2'])) * (hashID2 ** (-r1 * msk['t2']))
d[2] = (mpk['h'] ** (-msk['alpha'] * msk['t1'])) * (hashID2 ** (-r1 * msk['t1']))
d[3] = hashID2 ** (-r2 * msk['t4'])
d[4] = hashID2 ** (-r2 * msk['t3'])
return { 'd':d }
def encrypt(self, mpk, ID, msg):
s, s1, s2 = group.random(ZR, 3)
hID = waters.hash(ID)
hashID1 = mpk['g_l'][0] * dotprod2(range(1,mpk['n']), lam_func, mpk['g_l'], hID)
c = {}
c_pr = (mpk['omega'] ** s) * msg
c[0] = hashID1 ** s
c[1] = mpk['v1'] ** (s - s1)
c[2] = mpk['v2'] ** s1
c[3] = mpk['v3'] ** (s - s2)
c[4] = mpk['v4'] ** s2
return {'c':c, 'c_prime':c_pr }
def decrypt(self, mpk, sk, ct):
c, d = ct['c'], sk['d']
msg = ct['c_prime'] * pair(c[0], d[0]) * pair(c[1], d[1]) * pair(c[2], d[2]) * pair(c[3], d[3]) * pair(c[4], d[4])
return msg
def main():
groupObj = PairingGroup('SS512')
ibe = IBE_CKRS(groupObj)
(mpk, msk) = ibe.setup()
# represents public identity
ID = "[email protected]"
sk = ibe.extract(mpk, msk, ID)
M = groupObj.random(GT)
ct = ibe.encrypt(mpk, ID, M)
m = ibe.decrypt(mpk, sk, ct)
if debug: print('m =>', m)
assert m == M, "FAILED Decryption!"
if debug: print("Successful Decryption!!! m => '%s'" % m)
if __name__ == "__main__":
debug = True
main()
| lferr/charm | charm/schemes/ibenc/ibenc_ckrs09.py | Python | lgpl-3.0 | 4,080 | 0.017157 |
import pytest
import transcode.conf
import transcode.render
def my_callback(source, *args, **kws):
pass
CFG_GOOD = {
'TEXT': {'transcoder': my_callback},
}
CFG_BAD = {
'MARK': {'transcoder': 42}
}
class TestConf:
def test_default_config(self):
for fmt, expected in (
(transcode.conf.HTML_FORMAT, transcode.render.render_html),
(transcode.conf.SIMPLE_TEXT_FORMAT, transcode.render.render_simple),
(transcode.conf.MARKDOWN_FORMAT, transcode.render.render_markdown),
(transcode.conf.RST_FORMAT, transcode.render.render_restructuredtext),
):
handler, args, kwargs = transcode.conf.get_transcoder(fmt)
assert handler is expected
def test_config_with_actual_callback(self):
handler, args, kwargs = transcode.conf.get_transcoder('TEXT', CFG_GOOD)
assert handler == my_callback
assert args == ()
assert kwargs == {}
def test_config_with_bad_callback(self):
try:
transcode.conf.load_config(CFG_BAD)
except TypeError:
assert True
else:
assert False
| OpenTherapeutics/transcode | tests/test_config.py | Python | mit | 1,153 | 0.005204 |
'''
Created on Mar 7, 2016
@author: mike
'''
from patgen.dictionary import parse_dictionary_word, format_dictionary_word,\
Dictionary
import unittest
from patgen.margins import Margins
class TestDictionary(unittest.TestCase):
def test_parse(self):
text, hyphens, missed, false, weights = parse_dictionary_word('hy-phe-2n-a-tion')
self.assertEqual(text, 'hyphenation')
self.assertEqual(hyphens, {2, 5, 6, 7})
self.assertEqual(missed, set())
self.assertEqual(false, set())
self.assertEqual(weights, {0: 1, 1: 1, 2: 1, 3: 1, 4: 1, 5: 2, 6: 1, 7: 1, 8: 1, 9: 1, 10: 1, 11: 1})
def test_format(self):
s = format_dictionary_word('hyphenation', {2, 5, 6, 7})
self.assertEqual(s, 'hy-phe-n-a-tion')
def test_format_weights(self):
s = format_dictionary_word('hyphenation', {2, 5, 6, 7}, weights={0: 3, 1: 3, 2: 3, 3: 3, 4: 3, 5: 3, 6: 3, 7: 3, 8: 3, 9: 3, 10: 3, 11: 3})
self.assertEqual(s, '3hy-phe-n-a-tion')
def test_analysis(self):
dictionary = Dictionary.from_string('''
word
''')
x = set(dictionary.generate_pattern_statistics(False, 3, 1, Margins(1,1)))
self.assertEqual(x, {('wor', 0, 1), ('ord', 0, 1), ('rd.', 0, 1)})
| pgmmpk/pypatgen | patgen/tests/test_dictionary.py | Python | mit | 1,321 | 0.009084 |
# vim: tabstop=4 shiftwidth=4 softtabstop=4
# 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.
import json
import testtools
from tempest.api.orchestration import base
from tempest.common.utils import data_utils
from tempest.common.utils.linux.remote_client import RemoteClient
import tempest.config
from tempest.openstack.common import log as logging
from tempest.test import attr
LOG = logging.getLogger(__name__)
class ServerCfnInitTestJSON(base.BaseOrchestrationTest):
_interface = 'json'
existing_keypair = (tempest.config.TempestConfig().
orchestration.keypair_name is not None)
template = """
HeatTemplateFormatVersion: '2012-12-12'
Description: |
Template which uses a wait condition to confirm that a minimal
cfn-init and cfn-signal has worked
Parameters:
key_name:
Type: String
flavor:
Type: String
image:
Type: String
network:
Type: String
Resources:
CfnUser:
Type: AWS::IAM::User
SmokeSecurityGroup:
Type: AWS::EC2::SecurityGroup
Properties:
GroupDescription: Enable only ping and SSH access
SecurityGroupIngress:
- {CidrIp: 0.0.0.0/0, FromPort: '-1', IpProtocol: icmp, ToPort: '-1'}
- {CidrIp: 0.0.0.0/0, FromPort: '22', IpProtocol: tcp, ToPort: '22'}
SmokeKeys:
Type: AWS::IAM::AccessKey
Properties:
UserName: {Ref: CfnUser}
SmokeServer:
Type: OS::Nova::Server
Metadata:
AWS::CloudFormation::Init:
config:
files:
/tmp/smoke-status:
content: smoke test complete
/etc/cfn/cfn-credentials:
content:
Fn::Join:
- ''
- - AWSAccessKeyId=
- {Ref: SmokeKeys}
- '
'
- AWSSecretKey=
- Fn::GetAtt: [SmokeKeys, SecretAccessKey]
- '
'
mode: '000400'
owner: root
group: root
Properties:
image: {Ref: image}
flavor: {Ref: flavor}
key_name: {Ref: key_name}
security_groups:
- {Ref: SmokeSecurityGroup}
networks:
- uuid: {Ref: network}
user_data:
Fn::Base64:
Fn::Join:
- ''
- - |-
#!/bin/bash -v
/opt/aws/bin/cfn-init
- |-
|| error_exit ''Failed to run cfn-init''
/opt/aws/bin/cfn-signal -e 0 --data "`cat /tmp/smoke-status`" '
- {Ref: WaitHandle}
- '''
'
WaitHandle:
Type: AWS::CloudFormation::WaitConditionHandle
WaitCondition:
Type: AWS::CloudFormation::WaitCondition
DependsOn: SmokeServer
Properties:
Handle: {Ref: WaitHandle}
Timeout: '600'
Outputs:
WaitConditionStatus:
Description: Contents of /tmp/smoke-status on SmokeServer
Value:
Fn::GetAtt: [WaitCondition, Data]
SmokeServerIp:
Description: IP address of server
Value:
Fn::GetAtt: [SmokeServer, first_address]
"""
@classmethod
def setUpClass(cls):
super(ServerCfnInitTestJSON, cls).setUpClass()
if not cls.orchestration_cfg.image_ref:
raise cls.skipException("No image available to test")
cls.client = cls.orchestration_client
stack_name = data_utils.rand_name('heat')
if cls.orchestration_cfg.keypair_name:
keypair_name = cls.orchestration_cfg.keypair_name
else:
cls.keypair = cls._create_keypair()
keypair_name = cls.keypair['name']
# create the stack
cls.stack_identifier = cls.create_stack(
stack_name,
cls.template,
parameters={
'key_name': keypair_name,
'flavor': cls.orchestration_cfg.instance_type,
'image': cls.orchestration_cfg.image_ref,
'network': cls._get_default_network()['id']
})
@attr(type='slow')
@testtools.skipIf(existing_keypair, 'Server ssh tests are disabled.')
def test_can_log_into_created_server(self):
sid = self.stack_identifier
rid = 'SmokeServer'
# wait for server resource create to complete.
self.client.wait_for_resource_status(sid, rid, 'CREATE_COMPLETE')
resp, body = self.client.get_resource(sid, rid)
self.assertEqual('CREATE_COMPLETE', body['resource_status'])
# fetch the IP address from servers client, since we can't get it
# from the stack until stack create is complete
resp, server = self.servers_client.get_server(
body['physical_resource_id'])
# Check that the user can authenticate with the generated password
linux_client = RemoteClient(
server, 'ec2-user', pkey=self.keypair['private_key'])
self.assertTrue(linux_client.can_authenticate())
@attr(type='slow')
def test_stack_wait_condition_data(self):
sid = self.stack_identifier
# wait for create to complete.
self.client.wait_for_stack_status(sid, 'CREATE_COMPLETE')
# fetch the stack
resp, body = self.client.get_stack(sid)
self.assertEqual('CREATE_COMPLETE', body['stack_status'])
# fetch the stack
resp, body = self.client.get_stack(sid)
self.assertEqual('CREATE_COMPLETE', body['stack_status'])
# This is an assert of great significance, as it means the following
# has happened:
# - cfn-init read the provided metadata and wrote out a file
# - a user was created and credentials written to the server
# - a cfn-signal was built which was signed with provided credentials
# - the wait condition was fulfilled and the stack has changed state
wait_status = json.loads(
self.stack_output(body, 'WaitConditionStatus'))
self.assertEqual('smoke test complete', wait_status['00000'])
| eltonkevani/tempest_el_env | tempest/api/orchestration/stacks/test_server_cfn_init.py | Python | apache-2.0 | 6,500 | 0 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
""" markdown-docs markdown documentation reader
APACHE LICENSE 2.0
Copyright 2013 Sebastian Dahlgren
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.
"""
VERSION = '0.2.0'
import os
import sys
import shutil
import tempfile
import argparse
import markdowndocs.generator
import markdowndocs.web_server
from markdowndocs.markdown_file import MarkdownFile
from markdowndocs.log_handler import LOGGER as logger
def main():
""" Main function """
parser = argparse.ArgumentParser(
description='markdown-docs markdown documentation generator')
parser.add_argument('-d', '--directory',
help='Root directory to parse from (default: current dir)')
parser.add_argument('-o', '--output',
help='Output directory to store HTML files in')
parser.add_argument('--version',
action='store_true',
help='Print version information')
parser.add_argument('generate',
nargs='?',
default=False,
help='Generate HTML')
parser.add_argument('serve',
nargs='?',
default=True,
help='Start a local web server to serve the documentation')
args = parser.parse_args()
if args.version:
print_version()
sys.exit(0)
if args.directory:
source_dir = os.path.expandvars(os.path.expanduser(args.directory))
if not os.path.exists(source_dir):
logger.error('{} does not exist'.format(source_dir))
sys.exit(1)
elif not os.path.isdir(source_dir):
logger.error('{} is not a directory'.format(source_dir))
sys.exit(1)
else:
source_dir = os.path.realpath(os.path.curdir)
temp_dir_used = False
if args.output:
destination_root_dir = os.path.expandvars(
os.path.expanduser(args.output))
try:
os.makedirs(destination_root_dir)
except OSError as (errno, errmsg):
if errno == 17:
# Code 17 == File exists
pass
else:
logger.error('Error creating {}: {}'.format(
destination_root_dir, errmsg))
sys.exit(1)
else:
destination_root_dir = tempfile.mkdtemp(prefix='markdown-docs')
logger.debug('Using temporary folder: {}'.format(destination_root_dir))
if not args.generate:
temp_dir_used = True
try:
markdown_files = find_markdown_files(source_dir, destination_root_dir)
logger.info('Generating documentation for {:d} markdown files..'.format(
len(markdown_files)))
markdowndocs.generator.generate_html(markdown_files)
markdowndocs.generator.generate_index_page(markdown_files)
markdowndocs.generator.import_static_files(destination_root_dir)
logger.info('Done with documentation generation!')
if args.serve and not args.generate:
markdowndocs.web_server.run_webserver(destination_root_dir)
if args.generate:
logger.info('HTML output can be found in {}'.format(
destination_root_dir))
finally:
if temp_dir_used:
logger.debug('Removing temporary folder: {}'.format(
destination_root_dir))
shutil.rmtree(destination_root_dir)
def find_markdown_files(source_dir, destination_root_dir):
""" Returns a list of all Markdown files
:type source_dir: str
:param source_dir: Where should the markdown-docs start looking?
:type destination_root_dir: str
:param destination_root_dir: Path to the output dir
:returns: list -- List of MarkdownFile objects
"""
md_files_dict = {}
for dirpath, _, filenames in os.walk(source_dir):
for filename in filenames:
try:
_, extension = filename.rsplit('.', 1)
if extension in ['md', 'mdown', 'markdown']:
md_file = MarkdownFile(
os.path.join(dirpath, filename),
source_dir,
destination_root_dir)
md_files_dict[os.path.join(dirpath, filename)] = md_file
except ValueError:
pass
markdown_files = []
for md_file in sorted(md_files_dict):
markdown_files.append(md_files_dict[md_file])
return markdown_files
def print_version():
""" Prints the version and exits """
print('markdown-doc: {}'.format(VERSION))
| sebdah/markdown-docs | markdowndocs/__init__.py | Python | apache-2.0 | 4,970 | 0.004024 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
# (c) 2018, Simon Dodsley ([email protected])
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
from __future__ import absolute_import, division, print_function
__metaclass__ = type
ANSIBLE_METADATA = {'metadata_version': '1.1',
'status': ['deprecated'],
'supported_by': 'community'}
DOCUMENTATION = r'''
---
module: purefa_facts
version_added: '2.6'
deprecated:
removed_in: '2.13'
why: Deprecated in favor of C(_info) module.
alternative: Use M(purefa_info) instead.
short_description: Collect facts from Pure Storage FlashArray
description:
- Collect facts information from a Pure Storage Flasharray running the
Purity//FA operating system. By default, the module will collect basic
fact information including hosts, host groups, protection
groups and volume counts. Additional fact information can be collected
based on the configured set of arguments.
author:
- Pure Storage ansible Team (@sdodsley) <[email protected]>
options:
gather_subset:
description:
- When supplied, this argument will define the facts to be collected.
Possible values for this include all, minimum, config, performance,
capacity, network, subnet, interfaces, hgroups, pgroups, hosts,
admins, volumes, snapshots, pods, vgroups, offload, apps and arrays.
type: list
required: false
default: minimum
extends_documentation_fragment:
- purestorage.fa
'''
EXAMPLES = r'''
- name: collect default set of facts
purefa_facts:
fa_url: 10.10.10.2
api_token: e31060a7-21fc-e277-6240-25983c6c4592
- name: collect configuration and capacity facts
purefa_facts:
gather_subset:
- config
- capacity
fa_url: 10.10.10.2
api_token: e31060a7-21fc-e277-6240-25983c6c4592
- name: collect all facts
purefa_facts:
gather_subset:
- all
fa_url: 10.10.10.2
api_token: e31060a7-21fc-e277-6240-25983c6c4592
'''
RETURN = r'''
ansible_facts:
description: Returns the facts collected from the FlashArray
returned: always
type: complex
sample: {
"capacity": {},
"config": {
"directory_service": {
"array_admin_group": null,
"base_dn": null,
"bind_password": null,
"bind_user": null,
"check_peer": false,
"enabled": false,
"group_base": null,
"readonly_group": null,
"storage_admin_group": null,
"uri": []
},
"dns": {
"domain": "domain.com",
"nameservers": [
"8.8.8.8",
"8.8.4.4"
]
},
"ntp": [
"0.ntp.pool.org",
"1.ntp.pool.org",
"2.ntp.pool.org",
"3.ntp.pool.org"
],
"smtp": [
{
"enabled": true,
"name": "[email protected]"
},
{
"enabled": true,
"name": "[email protected]"
}
],
"snmp": [
{
"auth_passphrase": null,
"auth_protocol": null,
"community": null,
"host": "localhost",
"name": "localhost",
"privacy_passphrase": null,
"privacy_protocol": null,
"user": null,
"version": "v2c"
}
],
"ssl_certs": {
"country": null,
"email": null,
"issued_by": "",
"issued_to": "",
"key_size": 2048,
"locality": null,
"organization": "Acme Storage, Inc.",
"organizational_unit": "Acme Storage, Inc.",
"state": null,
"status": "self-signed",
"valid_from": "2017-08-11T23:09:06Z",
"valid_to": "2027-08-09T23:09:06Z"
},
"syslog": []
},
"default": {
"array_name": "flasharray1",
"connected_arrays": 1,
"hostgroups": 0,
"hosts": 10,
"pods": 3,
"protection_groups": 1,
"purity_version": "5.0.4",
"snapshots": 1,
"volume_groups": 2
},
"hgroups": {},
"hosts": {
"host1": {
"hgroup": null,
"iqn": [
"iqn.1994-05.com.redhat:2f6f5715a533"
],
"wwn": []
},
"host2": {
"hgroup": null,
"iqn": [
"iqn.1994-05.com.redhat:d17fb13fe0b"
],
"wwn": []
},
"host3": {
"hgroup": null,
"iqn": [
"iqn.1994-05.com.redhat:97b1351bfb2"
],
"wwn": []
},
"host4": {
"hgroup": null,
"iqn": [
"iqn.1994-05.com.redhat:dd84e9a7b2cb"
],
"wwn": [
"10000000C96C48D1",
"10000000C96C48D2"
]
}
},
"interfaces": {
"CT0.ETH4": "iqn.2010-06.com.purestorage:flasharray.2111b767484e4682",
"CT0.ETH5": "iqn.2010-06.com.purestorage:flasharray.2111b767484e4682",
"CT1.ETH4": "iqn.2010-06.com.purestorage:flasharray.2111b767484e4682",
"CT1.ETH5": "iqn.2010-06.com.purestorage:flasharray.2111b767484e4682"
},
"network": {
"ct0.eth0": {
"address": "10.10.10.10",
"gateway": "10.10.10.1",
"hwaddr": "ec:f4:bb:c8:8a:04",
"mtu": 1500,
"netmask": "255.255.255.0",
"services": [
"management"
],
"speed": 1000000000
},
"ct0.eth2": {
"address": "10.10.10.11",
"gateway": null,
"hwaddr": "ec:f4:bb:c8:8a:00",
"mtu": 1500,
"netmask": "255.255.255.0",
"services": [
"replication"
],
"speed": 10000000000
},
"ct0.eth3": {
"address": "10.10.10.12",
"gateway": null,
"hwaddr": "ec:f4:bb:c8:8a:02",
"mtu": 1500,
"netmask": "255.255.255.0",
"services": [
"replication"
],
"speed": 10000000000
},
"ct0.eth4": {
"address": "10.10.10.13",
"gateway": null,
"hwaddr": "90:e2:ba:83:79:0c",
"mtu": 1500,
"netmask": "255.255.255.0",
"services": [
"iscsi"
],
"speed": 10000000000
},
"ct0.eth5": {
"address": "10.10.10.14",
"gateway": null,
"hwaddr": "90:e2:ba:83:79:0d",
"mtu": 1500,
"netmask": "255.255.255.0",
"services": [
"iscsi"
],
"speed": 10000000000
},
"vir0": {
"address": "10.10.10.20",
"gateway": "10.10.10.1",
"hwaddr": "fe:ba:e9:e7:6b:0f",
"mtu": 1500,
"netmask": "255.255.255.0",
"services": [
"management"
],
"speed": 1000000000
}
},
"offload": {
"nfstarget": {
"address": "10.0.2.53",
"mount_options": null,
"mount_point": "/offload",
"protocol": "nfs",
"status": "scanning"
}
},
"performance": {
"input_per_sec": 8191,
"output_per_sec": 0,
"queue_depth": 1,
"reads_per_sec": 0,
"san_usec_per_write_op": 15,
"usec_per_read_op": 0,
"usec_per_write_op": 642,
"writes_per_sec": 2
},
"pgroups": {
"consisgroup-07b6b983-986e-46f5-bdc3-deaa3dbb299e-cinder": {
"hgroups": null,
"hosts": null,
"source": "host1",
"targets": null,
"volumes": [
"volume-1"
]
}
},
"pods": {
"srm-pod": {
"arrays": [
{
"array_id": "52595f7e-b460-4b46-8851-a5defd2ac192",
"mediator_status": "online",
"name": "sn1-405-c09-37",
"status": "online"
},
{
"array_id": "a2c32301-f8a0-4382-949b-e69b552ce8ca",
"mediator_status": "online",
"name": "sn1-420-c11-31",
"status": "online"
}
],
"source": null
}
},
"snapshots": {
"consisgroup.cgsnapshot": {
"created": "2018-03-28T09:34:02Z",
"size": 13958643712,
"source": "volume-1"
}
},
"subnet": {},
"vgroups": {
"vvol--vSphere-HA-0ffc7dd1-vg": {
"volumes": [
"vvol--vSphere-HA-0ffc7dd1-vg/Config-aad5d7c6"
]
}
},
"volumes": {
"ansible_data": {
"bandwidth": null,
"hosts": [
[
"host1",
1
]
],
"serial": "43BE47C12334399B000114A6",
"size": 1099511627776,
"source": null
}
}
}
'''
from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.pure import get_system, purefa_argument_spec
ADMIN_API_VERSION = '1.14'
S3_REQUIRED_API_VERSION = '1.16'
LATENCY_REQUIRED_API_VERSION = '1.16'
AC_REQUIRED_API_VERSION = '1.14'
CAP_REQUIRED_API_VERSION = '1.6'
SAN_REQUIRED_API_VERSION = '1.10'
NVME_API_VERSION = '1.16'
PREFERRED_API_VERSION = '1.15'
CONN_STATUS_API_VERSION = '1.17'
def generate_default_dict(array):
default_facts = {}
defaults = array.get()
api_version = array._list_available_rest_versions()
if AC_REQUIRED_API_VERSION in api_version:
default_facts['volume_groups'] = len(array.list_vgroups())
default_facts['connected_arrays'] = len(array.list_array_connections())
default_facts['pods'] = len(array.list_pods())
default_facts['connection_key'] = array.get(connection_key=True)['connection_key']
hosts = array.list_hosts()
admins = array.list_admins()
snaps = array.list_volumes(snap=True, pending=True)
pgroups = array.list_pgroups(pending=True)
hgroups = array.list_hgroups()
# Old FA arrays only report model from the primary controller
ct0_model = array.get_hardware('CT0')['model']
if ct0_model:
model = ct0_model
else:
ct1_model = array.get_hardware('CT1')['model']
model = ct1_model
default_facts['array_model'] = model
default_facts['array_name'] = defaults['array_name']
default_facts['purity_version'] = defaults['version']
default_facts['hosts'] = len(hosts)
default_facts['snapshots'] = len(snaps)
default_facts['protection_groups'] = len(pgroups)
default_facts['hostgroups'] = len(hgroups)
default_facts['admins'] = len(admins)
return default_facts
def generate_perf_dict(array):
perf_facts = {}
api_version = array._list_available_rest_versions()
if LATENCY_REQUIRED_API_VERSION in api_version:
latency_info = array.get(action='monitor', latency=True)[0]
perf_info = array.get(action='monitor')[0]
# IOPS
perf_facts['writes_per_sec'] = perf_info['writes_per_sec']
perf_facts['reads_per_sec'] = perf_info['reads_per_sec']
# Bandwidth
perf_facts['input_per_sec'] = perf_info['input_per_sec']
perf_facts['output_per_sec'] = perf_info['output_per_sec']
# Latency
if LATENCY_REQUIRED_API_VERSION in api_version:
perf_facts['san_usec_per_read_op'] = latency_info['san_usec_per_read_op']
perf_facts['san_usec_per_write_op'] = latency_info['san_usec_per_write_op']
perf_facts['queue_usec_per_read_op'] = latency_info['queue_usec_per_read_op']
perf_facts['queue_usec_per_write_op'] = latency_info['queue_usec_per_write_op']
perf_facts['qos_rate_limit_usec_per_read_op'] = latency_info['qos_rate_limit_usec_per_read_op']
perf_facts['qos_rate_limit_usec_per_write_op'] = latency_info['qos_rate_limit_usec_per_write_op']
perf_facts['local_queue_usec_per_op'] = perf_info['local_queue_usec_per_op']
perf_facts['usec_per_read_op'] = perf_info['usec_per_read_op']
perf_facts['usec_per_write_op'] = perf_info['usec_per_write_op']
perf_facts['queue_depth'] = perf_info['queue_depth']
return perf_facts
def generate_config_dict(array):
config_facts = {}
api_version = array._list_available_rest_versions()
# DNS
config_facts['dns'] = array.get_dns()
# SMTP
config_facts['smtp'] = array.list_alert_recipients()
# SNMP
config_facts['snmp'] = array.list_snmp_managers()
config_facts['snmp_v3_engine_id'] = array.get_snmp_engine_id()['engine_id']
# DS
config_facts['directory_service'] = array.get_directory_service()
if S3_REQUIRED_API_VERSION in api_version:
config_facts['directory_service_roles'] = {}
roles = array.list_directory_service_roles()
for role in range(0, len(roles)):
role_name = roles[role]['name']
config_facts['directory_service_roles'][role_name] = {
'group': roles[role]['group'],
'group_base': roles[role]['group_base'],
}
else:
config_facts['directory_service'].update(array.get_directory_service(groups=True))
# NTP
config_facts['ntp'] = array.get(ntpserver=True)['ntpserver']
# SYSLOG
config_facts['syslog'] = array.get(syslogserver=True)['syslogserver']
# Phonehome
config_facts['phonehome'] = array.get(phonehome=True)['phonehome']
# Proxy
config_facts['proxy'] = array.get(proxy=True)['proxy']
# Relay Host
config_facts['relayhost'] = array.get(relayhost=True)['relayhost']
# Sender Domain
config_facts['senderdomain'] = array.get(senderdomain=True)['senderdomain']
# SYSLOG
config_facts['syslog'] = array.get(syslogserver=True)['syslogserver']
# Idle Timeout
config_facts['idle_timeout'] = array.get(idle_timeout=True)['idle_timeout']
# SCSI Timeout
config_facts['scsi_timeout'] = array.get(scsi_timeout=True)['scsi_timeout']
# SSL
config_facts['ssl_certs'] = array.get_certificate()
# Global Admin settings
if S3_REQUIRED_API_VERSION in api_version:
config_facts['global_admin'] = array.get_global_admin_attributes()
return config_facts
def generate_admin_dict(array):
api_version = array._list_available_rest_versions()
admin_facts = {}
if ADMIN_API_VERSION in api_version:
admins = array.list_admins()
for admin in range(0, len(admins)):
admin_name = admins[admin]['name']
admin_facts[admin_name] = {
'type': admins[admin]['type'],
'role': admins[admin]['role'],
}
return admin_facts
def generate_subnet_dict(array):
sub_facts = {}
subnets = array.list_subnets()
for sub in range(0, len(subnets)):
sub_name = subnets[sub]['name']
if subnets[sub]['enabled']:
sub_facts[sub_name] = {
'gateway': subnets[sub]['gateway'],
'mtu': subnets[sub]['mtu'],
'vlan': subnets[sub]['vlan'],
'prefix': subnets[sub]['prefix'],
'interfaces': subnets[sub]['interfaces'],
'services': subnets[sub]['services'],
}
return sub_facts
def generate_network_dict(array):
net_facts = {}
ports = array.list_network_interfaces()
for port in range(0, len(ports)):
int_name = ports[port]['name']
net_facts[int_name] = {
'hwaddr': ports[port]['hwaddr'],
'mtu': ports[port]['mtu'],
'enabled': ports[port]['enabled'],
'speed': ports[port]['speed'],
'address': ports[port]['address'],
'slaves': ports[port]['slaves'],
'services': ports[port]['services'],
'gateway': ports[port]['gateway'],
'netmask': ports[port]['netmask'],
}
if ports[port]['subnet']:
subnets = array.get_subnet(ports[port]['subnet'])
if subnets['enabled']:
net_facts[int_name]['subnet'] = {
'name': subnets['name'],
'prefix': subnets['prefix'],
'vlan': subnets['vlan'],
}
return net_facts
def generate_capacity_dict(array):
capacity_facts = {}
api_version = array._list_available_rest_versions()
if CAP_REQUIRED_API_VERSION in api_version:
volumes = array.list_volumes(pending=True)
capacity_facts['provisioned_space'] = sum(item['size'] for item in volumes)
capacity = array.get(space=True)
total_capacity = capacity[0]['capacity']
used_space = capacity[0]["total"]
capacity_facts['free_space'] = total_capacity - used_space
capacity_facts['total_capacity'] = total_capacity
capacity_facts['data_reduction'] = capacity[0]['data_reduction']
capacity_facts['system_space'] = capacity[0]['system']
capacity_facts['volume_space'] = capacity[0]['volumes']
capacity_facts['shared_space'] = capacity[0]['shared_space']
capacity_facts['snapshot_space'] = capacity[0]['snapshots']
capacity_facts['thin_provisioning'] = capacity[0]['thin_provisioning']
capacity_facts['total_reduction'] = capacity[0]['total_reduction']
return capacity_facts
def generate_snap_dict(array):
snap_facts = {}
snaps = array.list_volumes(snap=True)
for snap in range(0, len(snaps)):
snapshot = snaps[snap]['name']
snap_facts[snapshot] = {
'size': snaps[snap]['size'],
'source': snaps[snap]['source'],
'created': snaps[snap]['created'],
}
return snap_facts
def generate_vol_dict(array):
volume_facts = {}
vols = array.list_volumes()
for vol in range(0, len(vols)):
volume = vols[vol]['name']
volume_facts[volume] = {
'source': vols[vol]['source'],
'size': vols[vol]['size'],
'serial': vols[vol]['serial'],
'hosts': [],
'bandwidth': ""
}
api_version = array._list_available_rest_versions()
if AC_REQUIRED_API_VERSION in api_version:
qvols = array.list_volumes(qos=True)
for qvol in range(0, len(qvols)):
volume = qvols[qvol]['name']
qos = qvols[qvol]['bandwidth_limit']
volume_facts[volume]['bandwidth'] = qos
vvols = array.list_volumes(protocol_endpoint=True)
for vvol in range(0, len(vvols)):
volume = vvols[vvol]['name']
volume_facts[volume] = {
'source': vvols[vvol]['source'],
'serial': vvols[vvol]['serial'],
'hosts': []
}
cvols = array.list_volumes(connect=True)
for cvol in range(0, len(cvols)):
volume = cvols[cvol]['name']
voldict = [cvols[cvol]['host'], cvols[cvol]['lun']]
volume_facts[volume]['hosts'].append(voldict)
return volume_facts
def generate_host_dict(array):
api_version = array._list_available_rest_versions()
host_facts = {}
hosts = array.list_hosts()
for host in range(0, len(hosts)):
hostname = hosts[host]['name']
tports = []
host_all_info = array.get_host(hostname, all=True)
if host_all_info:
tports = host_all_info[0]['target_port']
host_facts[hostname] = {
'hgroup': hosts[host]['hgroup'],
'iqn': hosts[host]['iqn'],
'wwn': hosts[host]['wwn'],
'personality': array.get_host(hostname,
personality=True)['personality'],
'target_port': tports
}
if NVME_API_VERSION in api_version:
host_facts[hostname]['nqn'] = hosts[host]['nqn']
if PREFERRED_API_VERSION in api_version:
hosts = array.list_hosts(preferred_array=True)
for host in range(0, len(hosts)):
hostname = hosts[host]['name']
host_facts[hostname]['preferred_array'] = hosts[host]['preferred_array']
return host_facts
def generate_pgroups_dict(array):
pgroups_facts = {}
pgroups = array.list_pgroups()
for pgroup in range(0, len(pgroups)):
protgroup = pgroups[pgroup]['name']
pgroups_facts[protgroup] = {
'hgroups': pgroups[pgroup]['hgroups'],
'hosts': pgroups[pgroup]['hosts'],
'source': pgroups[pgroup]['source'],
'targets': pgroups[pgroup]['targets'],
'volumes': pgroups[pgroup]['volumes'],
}
prot_sched = array.get_pgroup(protgroup, schedule=True)
prot_reten = array.get_pgroup(protgroup, retention=True)
if prot_sched['snap_enabled'] or prot_sched['replicate_enabled']:
pgroups_facts[protgroup]['snap_freqyency'] = prot_sched['snap_frequency']
pgroups_facts[protgroup]['replicate_freqyency'] = prot_sched['replicate_frequency']
pgroups_facts[protgroup]['snap_enabled'] = prot_sched['snap_enabled']
pgroups_facts[protgroup]['replicate_enabled'] = prot_sched['replicate_enabled']
pgroups_facts[protgroup]['snap_at'] = prot_sched['snap_at']
pgroups_facts[protgroup]['replicate_at'] = prot_sched['replicate_at']
pgroups_facts[protgroup]['replicate_blackout'] = prot_sched['replicate_blackout']
pgroups_facts[protgroup]['per_day'] = prot_reten['per_day']
pgroups_facts[protgroup]['target_per_day'] = prot_reten['target_per_day']
pgroups_facts[protgroup]['target_days'] = prot_reten['target_days']
pgroups_facts[protgroup]['days'] = prot_reten['days']
pgroups_facts[protgroup]['all_for'] = prot_reten['all_for']
pgroups_facts[protgroup]['target_all_for'] = prot_reten['target_all_for']
if ":" in protgroup:
snap_transfers = array.get_pgroup(protgroup, snap=True, transfer=True)
pgroups_facts[protgroup]['snaps'] = {}
for snap_transfer in range(0, len(snap_transfers)):
snap = snap_transfers[snap_transfer]['name']
pgroups_facts[protgroup]['snaps'][snap] = {
'created': snap_transfers[snap_transfer]['created'],
'started': snap_transfers[snap_transfer]['started'],
'completed': snap_transfers[snap_transfer]['completed'],
'physical_bytes_written': snap_transfers[snap_transfer]['physical_bytes_written'],
'data_transferred': snap_transfers[snap_transfer]['data_transferred'],
'progress': snap_transfers[snap_transfer]['progress'],
}
return pgroups_facts
def generate_pods_dict(array):
pods_facts = {}
api_version = array._list_available_rest_versions()
if AC_REQUIRED_API_VERSION in api_version:
pods = array.list_pods()
for pod in range(0, len(pods)):
acpod = pods[pod]['name']
pods_facts[acpod] = {
'source': pods[pod]['source'],
'arrays': pods[pod]['arrays'],
}
return pods_facts
def generate_conn_array_dict(array):
conn_array_facts = {}
api_version = array._list_available_rest_versions()
if CONN_STATUS_API_VERSION in api_version:
carrays = array.list_connected_arrays()
for carray in range(0, len(carrays)):
arrayname = carrays[carray]['array_name']
conn_array_facts[arrayname] = {
'array_id': carrays[carray]['id'],
'throtled': carrays[carray]['throtled'],
'version': carrays[carray]['version'],
'type': carrays[carray]['type'],
'mgmt_ip': carrays[carray]['management_address'],
'repl_ip': carrays[carray]['replication_address'],
}
if CONN_STATUS_API_VERSION in api_version:
conn_array_facts[arrayname]['status'] = carrays[carray]['status']
return conn_array_facts
def generate_apps_dict(array):
apps_facts = {}
api_version = array._list_available_rest_versions()
if SAN_REQUIRED_API_VERSION in api_version:
apps = array.list_apps()
for app in range(0, len(apps)):
appname = apps[app]['name']
apps_facts[appname] = {
'version': apps[app]['version'],
'status': apps[app]['status'],
'description': apps[app]['description'],
}
return apps_facts
def generate_vgroups_dict(array):
vgroups_facts = {}
api_version = array._list_available_rest_versions()
if AC_REQUIRED_API_VERSION in api_version:
vgroups = array.list_vgroups()
for vgroup in range(0, len(vgroups)):
virtgroup = vgroups[vgroup]['name']
vgroups_facts[virtgroup] = {
'volumes': vgroups[vgroup]['volumes'],
}
return vgroups_facts
def generate_nfs_offload_dict(array):
offload_facts = {}
api_version = array._list_available_rest_versions()
if AC_REQUIRED_API_VERSION in api_version:
offload = array.list_nfs_offload()
for target in range(0, len(offload)):
offloadt = offload[target]['name']
offload_facts[offloadt] = {
'status': offload[target]['status'],
'mount_point': offload[target]['mount_point'],
'protocol': offload[target]['protocol'],
'mount_options': offload[target]['mount_options'],
'address': offload[target]['address'],
}
return offload_facts
def generate_s3_offload_dict(array):
offload_facts = {}
api_version = array._list_available_rest_versions()
if S3_REQUIRED_API_VERSION in api_version:
offload = array.list_s3_offload()
for target in range(0, len(offload)):
offloadt = offload[target]['name']
offload_facts[offloadt] = {
'status': offload[target]['status'],
'bucket': offload[target]['bucket'],
'protocol': offload[target]['protocol'],
'access_key_id': offload[target]['access_key_id'],
}
return offload_facts
def generate_hgroups_dict(array):
hgroups_facts = {}
hgroups = array.list_hgroups()
for hgroup in range(0, len(hgroups)):
hostgroup = hgroups[hgroup]['name']
hgroups_facts[hostgroup] = {
'hosts': hgroups[hgroup]['hosts'],
'pgs': [],
'vols': [],
}
pghgroups = array.list_hgroups(protect=True)
for pghg in range(0, len(pghgroups)):
pgname = pghgroups[pghg]['name']
hgroups_facts[pgname]['pgs'].append(pghgroups[pghg]['protection_group'])
volhgroups = array.list_hgroups(connect=True)
for pgvol in range(0, len(volhgroups)):
pgname = volhgroups[pgvol]['name']
volpgdict = [volhgroups[pgvol]['vol'], volhgroups[pgvol]['lun']]
hgroups_facts[pgname]['vols'].append(volpgdict)
return hgroups_facts
def generate_interfaces_dict(array):
api_version = array._list_available_rest_versions()
int_facts = {}
ports = array.list_ports()
for port in range(0, len(ports)):
int_name = ports[port]['name']
if ports[port]['wwn']:
int_facts[int_name] = ports[port]['wwn']
if ports[port]['iqn']:
int_facts[int_name] = ports[port]['iqn']
if NVME_API_VERSION in api_version:
if ports[port]['nqn']:
int_facts[int_name] = ports[port]['nqn']
return int_facts
def main():
argument_spec = purefa_argument_spec()
argument_spec.update(dict(
gather_subset=dict(default='minimum', type='list',)
))
module = AnsibleModule(argument_spec, supports_check_mode=False)
array = get_system(module)
subset = [test.lower() for test in module.params['gather_subset']]
valid_subsets = ('all', 'minimum', 'config', 'performance', 'capacity',
'network', 'subnet', 'interfaces', 'hgroups', 'pgroups',
'hosts', 'admins', 'volumes', 'snapshots', 'pods',
'vgroups', 'offload', 'apps', 'arrays')
subset_test = (test in valid_subsets for test in subset)
if not all(subset_test):
module.fail_json(msg="value must gather_subset must be one or more of: %s, got: %s"
% (",".join(valid_subsets), ",".join(subset)))
facts = {}
if 'minimum' in subset or 'all' in subset:
facts['default'] = generate_default_dict(array)
if 'performance' in subset or 'all' in subset:
facts['performance'] = generate_perf_dict(array)
if 'config' in subset or 'all' in subset:
facts['config'] = generate_config_dict(array)
if 'capacity' in subset or 'all' in subset:
facts['capacity'] = generate_capacity_dict(array)
if 'network' in subset or 'all' in subset:
facts['network'] = generate_network_dict(array)
if 'subnet' in subset or 'all' in subset:
facts['subnet'] = generate_subnet_dict(array)
if 'interfaces' in subset or 'all' in subset:
facts['interfaces'] = generate_interfaces_dict(array)
if 'hosts' in subset or 'all' in subset:
facts['hosts'] = generate_host_dict(array)
if 'volumes' in subset or 'all' in subset:
facts['volumes'] = generate_vol_dict(array)
if 'snapshots' in subset or 'all' in subset:
facts['snapshots'] = generate_snap_dict(array)
if 'hgroups' in subset or 'all' in subset:
facts['hgroups'] = generate_hgroups_dict(array)
if 'pgroups' in subset or 'all' in subset:
facts['pgroups'] = generate_pgroups_dict(array)
if 'pods' in subset or 'all' in subset:
facts['pods'] = generate_pods_dict(array)
if 'admins' in subset or 'all' in subset:
facts['admins'] = generate_admin_dict(array)
if 'vgroups' in subset or 'all' in subset:
facts['vgroups'] = generate_vgroups_dict(array)
if 'offload' in subset or 'all' in subset:
facts['nfs_offload'] = generate_nfs_offload_dict(array)
facts['s3_offload'] = generate_s3_offload_dict(array)
if 'apps' in subset or 'all' in subset:
facts['apps'] = generate_apps_dict(array)
if 'arrays' in subset or 'all' in subset:
facts['arrays'] = generate_conn_array_dict(array)
module.exit_json(ansible_facts={'ansible_purefa_facts': facts})
if __name__ == '__main__':
main()
| kvar/ansible | lib/ansible/modules/storage/purestorage/_purefa_facts.py | Python | gpl-3.0 | 32,021 | 0.000999 |
from panda3d.core import *
from panda3d.direct import *
from toontown.toonbase.ToonBaseGlobal import *
from toontown.distributed.ToontownMsgTypes import *
from toontown.hood import ZoneUtil
from direct.directnotify import DirectNotifyGlobal
from toontown.hood import Place
from direct.showbase import DirectObject
from direct.fsm import StateData
from direct.fsm import ClassicFSM, State
from direct.fsm import State
from direct.task import Task
from toontown.launcher import DownloadForceAcknowledge
from toontown.toon import HealthForceAcknowledge
from toontown.toon.Toon import teleportDebug
from toontown.tutorial import TutorialForceAcknowledge
from toontown.toonbase.ToontownGlobals import *
from toontown.building import ToonInterior
from toontown.hood import QuietZoneState
from toontown.dna.DNAParser import *
from direct.stdpy.file import *
class SafeZoneLoader(StateData.StateData):
notify = DirectNotifyGlobal.directNotify.newCategory('SafeZoneLoader')
def __init__(self, hood, parentFSMState, doneEvent):
StateData.StateData.__init__(self, doneEvent)
self.hood = hood
self.parentFSMState = parentFSMState
self.fsm = ClassicFSM.ClassicFSM('SafeZoneLoader', [State.State('start', self.enterStart, self.exitStart, ['quietZone', 'playground', 'toonInterior']),
State.State('playground', self.enterPlayground, self.exitPlayground, ['quietZone']),
State.State('toonInterior', self.enterToonInterior, self.exitToonInterior, ['quietZone']),
State.State('quietZone', self.enterQuietZone, self.exitQuietZone, ['playground', 'toonInterior']),
State.State('golfcourse', self.enterGolfcourse, self.exitGolfcourse, ['quietZone', 'playground']),
State.State('final', self.enterFinal, self.exitFinal, ['start'])], 'start', 'final')
self.placeDoneEvent = 'placeDone'
self.place = None
self.playgroundClass = None
return
def load(self):
self.music = base.loadMusic(self.musicFile)
self.activityMusic = base.loadMusic(self.activityMusicFile)
self.createSafeZone(self.dnaFile)
self.parentFSMState.addChild(self.fsm)
def unload(self):
self.parentFSMState.removeChild(self.fsm)
del self.parentFSMState
self.geom.removeNode()
del self.geom
del self.fsm
del self.hood
del self.nodeList
del self.playgroundClass
del self.music
del self.activityMusic
del self.holidayPropTransforms
self.deleteAnimatedProps()
self.ignoreAll()
ModelPool.garbageCollect()
TexturePool.garbageCollect()
def enter(self, requestStatus):
self.fsm.enterInitialState()
messenger.send('enterSafeZone')
self.setState(requestStatus['where'], requestStatus)
def exit(self):
messenger.send('exitSafeZone')
def setState(self, stateName, requestStatus):
self.fsm.request(stateName, [requestStatus])
def createSafeZone(self, dnaFile):
if self.safeZoneStorageDNAFile:
dnaBulk = DNABulkLoader(self.hood.dnaStore, (self.safeZoneStorageDNAFile,))
dnaBulk.loadDNAFiles()
node = loadDNAFile(self.hood.dnaStore, dnaFile)
if node.getNumParents() == 1:
self.geom = NodePath(node.getParent(0))
self.geom.reparentTo(hidden)
else:
self.geom = hidden.attachNewNode(node)
self.makeDictionaries(self.hood.dnaStore)
self.createAnimatedProps(self.nodeList)
self.holidayPropTransforms = {}
npl = self.geom.findAllMatches('**/=DNARoot=holiday_prop')
for i in xrange(npl.getNumPaths()):
np = npl.getPath(i)
np.setTag('transformIndex', `i`)
self.holidayPropTransforms[i] = np.getNetTransform()
gsg = base.win.getGsg()
if gsg:
self.geom.prepareScene(gsg)
self.geom.flattenMedium()
def makeDictionaries(self, dnaStore):
self.nodeList = []
for i in xrange(dnaStore.getNumDNAVisGroups()):
groupFullName = dnaStore.getDNAVisGroupName(i)
groupName = base.cr.hoodMgr.extractGroupName(groupFullName)
groupNode = self.geom.find('**/' + groupFullName)
if groupNode.isEmpty():
self.notify.error('Could not find visgroup')
groupNode.flattenMedium()
self.nodeList.append(groupNode)
self.removeLandmarkBlockNodes()
self.hood.dnaStore.resetPlaceNodes()
self.hood.dnaStore.resetDNAGroups()
self.hood.dnaStore.resetDNAVisGroups()
self.hood.dnaStore.resetDNAVisGroupsAI()
def removeLandmarkBlockNodes(self):
npc = self.geom.findAllMatches('**/suit_building_origin')
for i in range(npc.getNumPaths()):
npc.getPath(i).removeNode()
def enterStart(self):
pass
def exitStart(self):
pass
def enterPlayground(self, requestStatus):
self.acceptOnce(self.placeDoneEvent, self.handlePlaygroundDone)
self.place = self.playgroundClass(self, self.fsm, self.placeDoneEvent)
self.place.load()
self.place.enter(requestStatus)
base.cr.playGame.setPlace(self.place)
def exitPlayground(self):
self.ignore(self.placeDoneEvent)
self.place.exit()
self.place.unload()
self.place = None
base.cr.playGame.setPlace(self.place)
return
def handlePlaygroundDone(self):
status = self.place.doneStatus
teleportDebug(status, 'handlePlaygroundDone, doneStatus=%s' % (status,))
if ZoneUtil.getBranchZone(status['zoneId']) == self.hood.hoodId and status['shardId'] == None:
teleportDebug(status, 'same branch')
self.fsm.request('quietZone', [status])
else:
self.doneStatus = status
teleportDebug(status, 'different hood')
messenger.send(self.doneEvent)
return
def enterToonInterior(self, requestStatus):
self.acceptOnce(self.placeDoneEvent, self.handleToonInteriorDone)
self.place = ToonInterior.ToonInterior(self, self.fsm.getStateNamed('toonInterior'), self.placeDoneEvent)
base.cr.playGame.setPlace(self.place)
self.place.load()
self.place.enter(requestStatus)
def exitToonInterior(self):
self.ignore(self.placeDoneEvent)
self.place.exit()
self.place.unload()
self.place = None
base.cr.playGame.setPlace(self.place)
return
def handleToonInteriorDone(self):
status = self.place.doneStatus
if ZoneUtil.getBranchZone(status['zoneId']) == self.hood.hoodId and status['shardId'] == None:
self.fsm.request('quietZone', [status])
else:
self.doneStatus = status
messenger.send(self.doneEvent)
return
def enterQuietZone(self, requestStatus):
self.quietZoneDoneEvent = uniqueName('quietZoneDone')
self.acceptOnce(self.quietZoneDoneEvent, self.handleQuietZoneDone)
self.quietZoneStateData = QuietZoneState.QuietZoneState(self.quietZoneDoneEvent)
self.quietZoneStateData.load()
self.quietZoneStateData.enter(requestStatus)
def exitQuietZone(self):
self.ignore(self.quietZoneDoneEvent)
del self.quietZoneDoneEvent
self.quietZoneStateData.exit()
self.quietZoneStateData.unload()
self.quietZoneStateData = None
return
def handleQuietZoneDone(self):
status = self.quietZoneStateData.getRequestStatus()
if status['where'] == 'estate':
self.doneStatus = status
messenger.send(self.doneEvent)
else:
self.fsm.request(status['where'], [status])
def enterFinal(self):
pass
def exitFinal(self):
pass
def createAnimatedProps(self, nodeList):
self.animPropDict = {}
for i in nodeList:
animPropNodes = i.findAllMatches('**/animated_prop_*')
numAnimPropNodes = animPropNodes.getNumPaths()
for j in range(numAnimPropNodes):
animPropNode = animPropNodes.getPath(j)
if animPropNode.getName().startswith('animated_prop_generic'):
className = 'GenericAnimatedProp'
else:
className = animPropNode.getName()[14:-8]
symbols = {}
base.cr.importModule(symbols, 'toontown.hood', [className])
classObj = getattr(symbols[className], className)
animPropObj = classObj(animPropNode)
animPropList = self.animPropDict.setdefault(i, [])
animPropList.append(animPropObj)
def deleteAnimatedProps(self):
for zoneNode, animPropList in self.animPropDict.items():
for animProp in animPropList:
animProp.delete()
del self.animPropDict
def enterAnimatedProps(self, zoneNode):
for animProp in self.animPropDict.get(zoneNode, ()):
animProp.enter()
def exitAnimatedProps(self, zoneNode):
for animProp in self.animPropDict.get(zoneNode, ()):
animProp.exit()
def enterGolfcourse(self, requestStatus):
base.transitions.fadeOut(t=0)
def exitGolfcourse(self):
pass
| silly-wacky-3-town-toon/SOURCE-COD | toontown/safezone/SafeZoneLoader.py | Python | apache-2.0 | 9,369 | 0.001814 |
"""
BinaryTree inter-engine communication class
use from bintree_script.py
Provides parallel [all]reduce functionality
"""
import cPickle as pickle
import re
import socket
import uuid
import zmq
from IPython.parallel.util import disambiguate_url
#----------------------------------------------------------------------------
# bintree-related construction/printing helpers
#----------------------------------------------------------------------------
def bintree(ids, parent=None):
"""construct {child:parent} dict representation of a binary tree
keys are the nodes in the tree, and values are the parent of each node.
The root node has parent `parent`, default: None.
>>> tree = bintree(range(7))
>>> tree
{0: None, 1: 0, 2: 1, 3: 1, 4: 0, 5: 4, 6: 4}
>>> print_bintree(tree)
0
1
2
3
4
5
6
"""
parents = {}
n = len(ids)
if n == 0:
return parents
root = ids[0]
parents[root] = parent
if len(ids) == 1:
return parents
else:
ids = ids[1:]
n = len(ids)
left = bintree(ids[:n/2], parent=root)
right = bintree(ids[n/2:], parent=root)
parents.update(left)
parents.update(right)
return parents
def reverse_bintree(parents):
"""construct {parent:[children]} dict from {child:parent}
keys are the nodes in the tree, and values are the lists of children
of that node in the tree.
reverse_tree[None] is the root node
>>> tree = bintree(range(7))
>>> reverse_bintree(tree)
{None: 0, 0: [1, 4], 4: [5, 6], 1: [2, 3]}
"""
children = {}
for child,parent in parents.iteritems():
if parent is None:
children[None] = child
continue
elif parent not in children:
children[parent] = []
children[parent].append(child)
return children
def depth(n, tree):
"""get depth of an element in the tree"""
d = 0
parent = tree[n]
while parent is not None:
d += 1
parent = tree[parent]
return d
def print_bintree(tree, indent=' '):
"""print a binary tree"""
for n in sorted(tree.keys()):
print "%s%s" % (indent * depth(n,tree), n)
#----------------------------------------------------------------------------
# Communicator class for a binary-tree map
#----------------------------------------------------------------------------
ip_pat = re.compile(r'^\d+\.\d+\.\d+\.\d+$')
def disambiguate_dns_url(url, location):
"""accept either IP address or dns name, and return IP"""
if not ip_pat.match(location):
location = socket.gethostbyname(location)
return disambiguate_url(url, location)
class BinaryTreeCommunicator(object):
id = None
pub = None
sub = None
downstream = None
upstream = None
pub_url = None
tree_url = None
def __init__(self, id, interface='tcp://*', root=False):
self.id = id
self.root = root
# create context and sockets
self._ctx = zmq.Context()
if root:
self.pub = self._ctx.socket(zmq.PUB)
else:
self.sub = self._ctx.socket(zmq.SUB)
self.sub.setsockopt(zmq.SUBSCRIBE, b'')
self.downstream = self._ctx.socket(zmq.PULL)
self.upstream = self._ctx.socket(zmq.PUSH)
# bind to ports
interface_f = interface + ":%i"
if self.root:
pub_port = self.pub.bind_to_random_port(interface)
self.pub_url = interface_f % pub_port
tree_port = self.downstream.bind_to_random_port(interface)
self.tree_url = interface_f % tree_port
self.downstream_poller = zmq.Poller()
self.downstream_poller.register(self.downstream, zmq.POLLIN)
# guess first public IP from socket
self.location = socket.gethostbyname_ex(socket.gethostname())[-1][0]
def __del__(self):
self.downstream.close()
self.upstream.close()
if self.root:
self.pub.close()
else:
self.sub.close()
self._ctx.term()
@property
def info(self):
"""return the connection info for this object's sockets."""
return (self.tree_url, self.location)
def connect(self, peers, btree, pub_url, root_id=0):
"""connect to peers. `peers` will be a dict of 4-tuples, keyed by name.
{peer : (ident, addr, pub_addr, location)}
where peer is the name, ident is the XREP identity, addr,pub_addr are the
"""
# count the number of children we have
self.nchildren = btree.values().count(self.id)
if self.root:
return # root only binds
root_location = peers[root_id][-1]
self.sub.connect(disambiguate_dns_url(pub_url, root_location))
parent = btree[self.id]
tree_url, location = peers[parent]
self.upstream.connect(disambiguate_dns_url(tree_url, location))
def serialize(self, obj):
"""serialize objects.
Must return list of sendable buffers.
Can be extended for more efficient/noncopying serialization of numpy arrays, etc.
"""
return [pickle.dumps(obj)]
def unserialize(self, msg):
"""inverse of serialize"""
return pickle.loads(msg[0])
def publish(self, value):
assert self.root
self.pub.send_multipart(self.serialize(value))
def consume(self):
assert not self.root
return self.unserialize(self.sub.recv_multipart())
def send_upstream(self, value, flags=0):
assert not self.root
self.upstream.send_multipart(self.serialize(value), flags=flags|zmq.NOBLOCK)
def recv_downstream(self, flags=0, timeout=2000.):
# wait for a message, so we won't block if there was a bug
self.downstream_poller.poll(timeout)
msg = self.downstream.recv_multipart(zmq.NOBLOCK|flags)
return self.unserialize(msg)
def reduce(self, f, value, flat=True, all=False):
"""parallel reduce on binary tree
if flat:
value is an entry in the sequence
else:
value is a list of entries in the sequence
if all:
broadcast final result to all nodes
else:
only root gets final result
"""
if not flat:
value = reduce(f, value)
for i in range(self.nchildren):
value = f(value, self.recv_downstream())
if not self.root:
self.send_upstream(value)
if all:
if self.root:
self.publish(value)
else:
value = self.consume()
return value
def allreduce(self, f, value, flat=True):
"""parallel reduce followed by broadcast of the result"""
return self.reduce(f, value, flat=flat, all=True)
| cloud9ers/gurumate | environment/share/doc/ipython/examples/parallel/interengine/bintree.py | Python | lgpl-3.0 | 7,132 | 0.008833 |
# -*- coding: utf-8 -*-
#
# Progdupeupl documentation build configuration file, created by
# sphinx-quickstart on Sat Dec 07 17:25:18 2013.
#
# This file is execfile()d with the current directory set to its containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
import sys, os
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
sys.path.insert(0, os.path.abspath('../'))
# -- General configuration -----------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be extensions
# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = [
'sphinx.ext.autodoc',
'sphinx.ext.todo',
'sphinx.ext.coverage',
'sphinx.ext.pngmath',
'sphinx.ext.mathjax',
'sphinx.ext.viewcode',
'sphinx.ext.napoleon',
]
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix of source filenames.
source_suffix = '.rst'
# The encoding of source files.
#source_encoding = 'utf-8-sig'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = u'Progdupeupl'
copyright = u'2013, Romain Porte'
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = '1.1'
# The full version, including alpha/beta/rc tags.
release = '1.1'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#language = None
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
#today = ''
# Else, today_fmt is used as the format for a strftime call.
#today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = ['_build']
# The reST default role (used for this markup: `text`) to use for all documents.
#default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
#add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# A list of ignored prefixes for module index sorting.
#modindex_common_prefix = []
# -- Options for HTML output ---------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
html_theme = 'default'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#html_theme_options = {}
# Add any paths that contain custom themes here, relative to this directory.
#html_theme_path = []
# The name for this set of Sphinx documents. If None, it defaults to
# "<project> v<release> documentation".
#html_title = None
# A shorter title for the navigation bar. Default is the same as html_title.
#html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
#html_logo = None
# The name of an image file (within the static path) to use as favicon of the
# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
#html_favicon = None
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
#html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
#html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
#html_additional_pages = {}
# If false, no module index is generated.
#html_domain_indices = True
# If false, no index is generated.
#html_use_index = True
# If true, the index is split into individual pages for each letter.
#html_split_index = False
# If true, links to the reST sources are added to the pages.
#html_show_sourcelink = True
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
#html_show_sphinx = True
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
#html_show_copyright = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
#html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. ".xhtml").
#html_file_suffix = None
# Output file base name for HTML help builder.
htmlhelp_basename = 'Progdupeupldoc'
# -- Options for LaTeX output --------------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#'preamble': '',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title, author, documentclass [howto/manual]).
latex_documents = [
('index', 'Progdupeupl.tex', u'Progdupeupl Documentation',
u'Romain Porte', 'manual'),
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
#latex_logo = None
# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
#latex_use_parts = False
# If true, show page references after internal links.
#latex_show_pagerefs = False
# If true, show URL addresses after external links.
#latex_show_urls = False
# Documents to append as an appendix to all manuals.
#latex_appendices = []
# If false, no module index is generated.
#latex_domain_indices = True
# -- Options for manual page output --------------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
('index', 'progdupeupl', u'Progdupeupl Documentation',
[u'Romain Porte'], 1)
]
# If true, show URL addresses after external links.
#man_show_urls = False
# -- Options for Texinfo output ------------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
('index', 'Progdupeupl', u'Progdupeupl Documentation',
u'Romain Porte', 'Progdupeupl', 'One line description of project.',
'Miscellaneous'),
]
# Documents to append as an appendix to all manuals.
#texinfo_appendices = []
# If false, no module index is generated.
#texinfo_domain_indices = True
# How to display URL addresses: 'footnote', 'no', or 'inline'.
#texinfo_show_urls = 'footnote'
autodoc_default_flags = ['members']
| progdupeupl/pdp_website | doc/conf.py | Python | agpl-3.0 | 7,983 | 0.00714 |
# -*- coding: utf-8 -*-
"""
contains definition of models names
"""
PRODUCT_TEMPLATE_TABLE = 'product.template'
PRODUCT_PRODUCT_TABLE = 'product.product'
PRODUCT_TEMPLATE_ID_FIELD = 'product_tmpl_id'
PRODUCT_VIRTUAL_AVAILABLE_FIELD = 'virtual_available'
PRODUCT_OPERATION_TABLE = 'amdeb.product.operation'
MODEL_NAME_FIELD = 'model_name'
RECORD_ID_FIELD = 'record_id'
TEMPLATE_ID_FIELD = 'template_id'
OPERATION_TYPE_FIELD = 'operation_type'
WRITE_FIELD_NAMES_FIELD = 'write_field_names'
FIELD_NAME_DELIMITER = ', '
TIMESTAMP_FIELD = 'timestamp'
| amdeb/amdeb-integrator | amdeb_integrator/shared/model_names.py | Python | gpl-3.0 | 549 | 0 |
#!/usr/bin/python3
from distutils.core import setup
setup(name='PySh',
version='0.0.1',
py_modules=['pysh'],
description="A tiny interface to intuitively access shell commands.",
author="Bede Kelly",
author_email="[email protected]",
url="https://github.com/bedekelly/pysh",
provides=['pysh'])
| bedekelly/pysh | setup.py | Python | gpl-2.0 | 340 | 0 |
registry = {}
def register(model, fields, order='pk', filter=False, results=5):
registry[str(model)] = (model, fields, results, order, filter)
class LoopBreak(Exception): pass
def search_for_string(search_string):
search_string = search_string.lower()
matches = []
for key in registry:
model, fields, results, order, filter_by = registry[key]
# partial application didn't seem sane in python ... so:
if filter_by:
if callable(filter_by):
filter_by = filter_by()
objects = model.objects.filter(filter_by)
else:
objects = model.objects.all()
counter = 0
try:
for object in objects.order_by(order):
for field in fields:
try:
searchee = getattr(object, field)
except AttributeError:
pass
if callable(searchee):
searchee = searchee()
if search_string in searchee.lower():
matches.append(object)
counter += 1
if counter >= results:
raise LoopBreak()
except LoopBreak:
pass
return matches
| UWCS/uwcs-website | uwcs_website/search/__init__.py | Python | agpl-3.0 | 1,310 | 0.003817 |
from browser import window
from preprocess import transform
from reeborg_en import * # NOQA
src = transform(window.editor.getValue())
exec(src)
| code4futuredotorg/reeborg_tw | src/python/editor.py | Python | agpl-3.0 | 145 | 0 |
# coding=utf-8
# Author: Dennis Lutter <[email protected]>
# Author: Jonathon Saine <[email protected]>
# URL: https://sickchill.github.io
#
# This file is part of SickChill.
#
# SickChill is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# SickChill is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with SickChill. If not, see <http://www.gnu.org/licenses/>.
from __future__ import absolute_import, print_function, unicode_literals
# Stdlib Imports
import abc
import datetime
import io
import os
import re
import time
import traceback
# Third Party Imports
import six
# noinspection PyUnresolvedReferences
from six.moves import urllib
from tornado.web import RequestHandler
# First Party Imports
import sickbeard
import sickchill
from sickbeard import classes, db, helpers, image_cache, logger, network_timezones, sbdatetime, search_queue, ui
from sickbeard.common import (ARCHIVED, DOWNLOADED, FAILED, IGNORED, Overview, Quality, SKIPPED, SNATCHED, SNATCHED_PROPER, statusStrings, UNAIRED, UNKNOWN,
WANTED)
from sickbeard.postProcessor import PROCESS_METHODS
from sickbeard.versionChecker import CheckVersion
from sickchill.helper.common import dateFormat, dateTimeFormat, pretty_file_size, sanitize_filename, timeFormat, try_int
from sickchill.helper.encoding import ek
from sickchill.helper.exceptions import CantUpdateShowException, ex, ShowDirectoryNotFoundException
from sickchill.helper.quality import get_quality_string
from sickchill.media.ShowBanner import ShowBanner
from sickchill.media.ShowFanArt import ShowFanArt
from sickchill.media.ShowNetworkLogo import ShowNetworkLogo
from sickchill.media.ShowPoster import ShowPoster
from sickchill.show.ComingEpisodes import ComingEpisodes
from sickchill.show.History import History
from sickchill.show.Show import Show
from sickchill.system.Restart import Restart
from sickchill.system.Shutdown import Shutdown
try:
import json
except ImportError:
# noinspection PyPackageRequirements,PyUnresolvedReferences
import simplejson as json
indexer_ids = ["indexerid", "tvdbid"]
RESULT_SUCCESS = 10 # only use inside the run methods
RESULT_FAILURE = 20 # only use inside the run methods
RESULT_TIMEOUT = 30 # not used yet :(
RESULT_ERROR = 40 # only use outside of the run methods !
RESULT_FATAL = 50 # only use in Api.default() ! this is the "we encountered an internal error" error
RESULT_DENIED = 60 # only use in Api.default() ! this is the access denied error
result_type_map = {
RESULT_SUCCESS: "success",
RESULT_FAILURE: "failure",
RESULT_TIMEOUT: "timeout",
RESULT_ERROR: "error",
RESULT_FATAL: "fatal",
RESULT_DENIED: "denied",
}
# basically everything except RESULT_SUCCESS / success is bad
# noinspection PyAbstractClass
class ApiHandler(RequestHandler):
""" api class that returns json results """
version = 5 # use an int since float-point is unpredictable
def __init__(self, *args, **kwargs):
super(ApiHandler, self).__init__(*args, **kwargs)
# def set_default_headers(self):
# self.set_header('Cache-Control', 'no-store, no-cache, must-revalidate, max-age=0')
def get(self, *args, **kwargs):
kwargs = self.request.arguments
# noinspection PyCompatibility
for arg, value in six.iteritems(kwargs):
if len(value) == 1:
kwargs[arg] = value[0]
args = args[1:]
# set the output callback
# default json
output_callback_dict = {
'default': self._out_as_json,
'image': self._out_as_image,
}
access_msg = "API :: " + self.request.remote_ip + " - gave correct API KEY. ACCESS GRANTED"
logger.log(access_msg, logger.DEBUG)
# set the original call_dispatcher as the local _call_dispatcher
_call_dispatcher = self.call_dispatcher
# if profile was set wrap "_call_dispatcher" in the profile function
if 'profile' in kwargs:
from profilehooks import profile
_call_dispatcher = profile(_call_dispatcher, immediate=True)
del kwargs["profile"]
try:
out_dict = _call_dispatcher(args, kwargs)
except Exception as e: # real internal error oohhh nooo :(
logger.log("API :: " + ex(e), logger.ERROR)
error_data = {
"error_msg": ex(e),
"args": args,
"kwargs": kwargs
}
out_dict = _responds(RESULT_FATAL, error_data,
"SickChill encountered an internal error! Please report to the Devs")
if 'outputType' in out_dict:
output_callback = output_callback_dict[out_dict['outputType']]
else:
output_callback = output_callback_dict['default']
# noinspection PyBroadException
try:
self.finish(output_callback(out_dict))
except Exception:
pass
def _out_as_image(self, _dict):
self.set_header('Content-Type'.encode('utf-8'), _dict['image'].get_media_type())
return _dict['image'].get_media()
def _out_as_json(self, _dict):
self.set_header("Content-Type".encode('utf-8'), "application/json;charset=UTF-8")
try:
out = json.dumps(_dict, ensure_ascii=False, sort_keys=True)
callback = self.get_query_argument('callback', None) or self.get_query_argument('jsonp', None)
if callback:
out = callback + '(' + out + ');' # wrap with JSONP call if requested
except Exception as e: # if we fail to generate the output fake an error
logger.log("API :: " + traceback.format_exc(), logger.DEBUG)
out = '{{"result": "{0}", "message": "error while composing output: {1}"}}'.format(result_type_map[RESULT_ERROR], ex(e))
return out
def call_dispatcher(self, args, kwargs): # pylint:disable=too-many-branches
""" calls the appropriate CMD class
looks for a cmd in args and kwargs
or calls the TVDBShorthandWrapper when the first args element is a number
or returns an error that there is no such cmd
"""
logger.log("API :: all args: '" + str(args) + "'", logger.DEBUG)
logger.log("API :: all kwargs: '" + str(kwargs) + "'", logger.DEBUG)
commands = None
if args:
commands, args = args[0], args[1:]
commands = kwargs.pop("cmd", commands)
out_dict = {}
if commands:
commands = commands.split("|")
multi_commands = len(commands) > 1
for cmd in commands:
cur_args, cur_kwargs = self.filter_params(cmd, args, kwargs)
if len(cmd.split("_")) > 1:
cmd, cmd_index = cmd.split("_")
else:
cmd_index = None
logger.log("API :: " + cmd + ": cur_kwargs " + str(cur_kwargs), logger.DEBUG)
if not (cmd in ('show.getbanner', 'show.getfanart', 'show.getnetworklogo', 'show.getposter') and
multi_commands): # skip these cmd while chaining
try:
if cmd in function_mapper:
func = function_mapper.get(cmd) # map function
to_call = func(cur_args, cur_kwargs)
to_call.rh = self
cur_out_dict = to_call.run() # call function and get response
elif _is_int(cmd):
to_call = TVDBShorthandWrapper(cur_args, cur_kwargs, cmd)
to_call.rh = self
cur_out_dict = to_call.run()
else:
cur_out_dict = _responds(RESULT_ERROR, "No such cmd: '" + cmd + "'")
except ApiError as error: # Api errors that we raised, they are harmless
cur_out_dict = _responds(RESULT_ERROR, msg=ex(error))
else: # if someone chained one of the forbidden commands they will get an error for this one cmd
cur_out_dict = _responds(RESULT_ERROR, msg="The cmd '" + cmd + "' is not supported while chaining")
if multi_commands:
# note: if duplicate commands are issued and one has an index defined it will override
# all others or the other way around, depending on the command order
# THIS IS NOT A BUG!
if cmd_index: # do we need an index dict for this cmd ?
if cmd not in out_dict:
out_dict[cmd] = {}
out_dict[cmd][cmd_index] = cur_out_dict
else:
out_dict[cmd] = cur_out_dict
else:
out_dict = cur_out_dict
if multi_commands: # if we had multiple commands we have to wrap it in a response dict
out_dict = _responds(RESULT_SUCCESS, out_dict)
else: # index / no cmd given
out_dict = CMDSickBeard(args, kwargs).run()
return out_dict
@staticmethod
def filter_params(cmd, args, kwargs):
""" return only params kwargs that are for cmd
and rename them to a clean version (remove "<cmd>_")
args are shared across all commands
all args and kwargs are lowered
cmd are separated by "|" e.g. &cmd=shows|future
kwargs are name-spaced with "." e.g. show.indexerid=101501
if a kwarg has no namespace asking it anyways (global)
full e.g.
/api?apikey=1234&cmd=show.seasonlist_asd|show.seasonlist_2&show.seasonlist_asd.indexerid=101501&show.seasonlist_2.indexerid=79488&sort=asc
two calls of show.seasonlist
one has the index "asd" the other one "2"
the "indexerid" kwargs / params have the indexed cmd as a namespace
and the kwarg / param "sort" is a used as a global
"""
cur_args = []
for arg in args:
cur_args.append(arg.lower())
cur_args = tuple(cur_args)
cur_kwargs = {}
for kwarg in kwargs:
if kwarg.find(cmd + ".") == 0:
clean_key = kwarg.rpartition(".")[2]
cur_kwargs[clean_key] = kwargs[kwarg].lower()
elif "." not in kwarg: # the kwarg was not name-spaced therefore a "global"
cur_kwargs[kwarg] = kwargs[kwarg]
return cur_args, cur_kwargs
# noinspection PyAbstractClass
class ApiCall(ApiHandler):
_help = {"desc": "This command is not documented. Please report this to the developers."}
# noinspection PyMissingConstructor
def __init__(self, args, kwargs):
# TODO: Find out why this buggers up RequestHandler init if called
# super(ApiCall, self).__init__(args, kwargs)
self.rh = None
self.indexer = 1
self._missing = []
self._requiredParams = {}
self._optionalParams = {}
self.check_params(args, kwargs)
def run(self):
raise NotImplementedError()
def return_help(self):
for paramDict, paramType in [(self._requiredParams, "requiredParameters"),
(self._optionalParams, "optionalParameters")]:
if paramType in self._help:
for paramName in paramDict:
if paramName not in self._help[paramType]:
# noinspection PyUnresolvedReferences
self._help[paramType][paramName] = {}
if paramDict[paramName]["allowedValues"]:
# noinspection PyUnresolvedReferences
self._help[paramType][paramName]["allowedValues"] = paramDict[paramName]["allowedValues"]
else:
# noinspection PyUnresolvedReferences
self._help[paramType][paramName]["allowedValues"] = "see desc"
# noinspection PyUnresolvedReferences
self._help[paramType][paramName]["defaultValue"] = paramDict[paramName]["defaultValue"]
# noinspection PyUnresolvedReferences
self._help[paramType][paramName]["type"] = paramDict[paramName]["type"]
elif paramDict:
for paramName in paramDict:
self._help[paramType] = {}
# noinspection PyUnresolvedReferences
self._help[paramType][paramName] = paramDict[paramName]
else:
self._help[paramType] = {}
msg = "No description available"
if "desc" in self._help:
msg = self._help["desc"]
return _responds(RESULT_SUCCESS, self._help, msg)
def return_missing(self):
if len(self._missing) == 1:
msg = "The required parameter: '" + self._missing[0] + "' was not set"
else:
msg = "The required parameters: '" + "','".join(self._missing) + "' where not set"
return _responds(RESULT_ERROR, msg=msg)
def check_params(self, args, kwargs, key=None, default=None, required=None, arg_type=None, allowed_values=None):
""" function to check passed params for the shorthand wrapper
and to detect missing/required params
"""
# auto-select indexer
if key in indexer_ids:
if "tvdbid" in kwargs:
key = "tvdbid"
self.indexer = indexer_ids.index(key)
if key:
missing = True
org_default = default
if arg_type == "bool":
allowed_values = [0, 1]
if args:
default = args[0]
missing = False
args = args[1:]
if kwargs.get(key):
default = kwargs.get(key)
missing = False
key_value = {
"allowedValues": allowed_values,
"defaultValue": org_default,
"type": arg_type
}
if required:
self._requiredParams[key] = key_value
if missing and key not in self._missing:
self._missing.append(key)
else:
self._optionalParams[key] = key_value
if default:
default = self._check_param_type(default, key, arg_type)
self._check_param_value(default, key, allowed_values)
if self._missing:
setattr(self, "run", self.return_missing)
if 'help' in kwargs:
setattr(self, "run", self.return_help)
return default, args
@staticmethod
def _check_param_type(value, name, arg_type):
""" checks if value can be converted / parsed to arg_type
will raise an error on failure
or will convert it to arg_type and return new converted value
can check for:
- int: will be converted into int
- bool: will be converted to False / True
- list: will always return a list
- string: will do nothing for now
- ignore: will ignore it, just like "string"
"""
error = False
if arg_type == "int":
if _is_int(value):
value = int(value)
else:
error = True
elif arg_type == "bool":
if value in ("0", "1"):
value = bool(int(value))
elif value in ("true", "True", "TRUE"):
value = True
elif value in ("false", "False", "FALSE"):
value = False
elif value not in (True, False):
error = True
elif arg_type == "list":
value = value.split("|")
elif arg_type == "string":
pass
elif arg_type == "ignore":
pass
else:
logger.log('API :: Invalid param type: "{0}" can not be checked. Ignoring it.'.format(str(arg_type)), logger.ERROR)
if error:
# this is a real ApiError !!
raise ApiError('param "{0}" with given value "{1}" could not be parsed into "{2}"'.format(str(name), str(value), str(arg_type)))
return value
@staticmethod
def _check_param_value(value, name, allowed_values):
""" will check if value (or all values in it ) are in allowed values
will raise an exception if value is "out of range"
if bool(allowed_value) is False a check is not performed and all values are excepted
"""
if allowed_values:
error = False
if isinstance(value, list):
for item in value:
if item not in allowed_values:
error = True
else:
if value not in allowed_values:
error = True
if error:
# this is kinda a ApiError but raising an error is the only way of quitting here
raise ApiError("param: '" + str(name) + "' with given value: '" + str(
value) + "' is out of allowed range '" + str(allowed_values) + "'")
# noinspection PyAbstractClass
class TVDBShorthandWrapper(ApiCall):
_help = {"desc": "This is an internal function wrapper. Call the help command directly for more information."}
def __init__(self, args, kwargs, sid):
super(TVDBShorthandWrapper, self).__init__(args, kwargs)
self.origArgs = args
self.kwargs = kwargs
self.sid = sid
self.s, args = self.check_params(args, kwargs, "s", None, False, "ignore", [])
self.e, args = self.check_params(args, kwargs, "e", None, False, "ignore", [])
self.args = args
def run(self):
""" internal function wrapper """
args = (self.sid,) + self.origArgs
if self.e:
return CMDEpisode(args, self.kwargs).run()
elif self.s:
return CMDShowSeasons(args, self.kwargs).run()
else:
return CMDShow(args, self.kwargs).run()
# ###############################
# helper functions #
# ###############################
def _is_int(data):
try:
int(data)
except (TypeError, ValueError, OverflowError):
return False
else:
return True
def _rename_element(dict_obj, old_key, new_key):
try:
dict_obj[new_key] = dict_obj[old_key]
del dict_obj[old_key]
except (ValueError, TypeError, NameError):
pass
return dict_obj
def _responds(result_type, data=None, msg=""):
"""
result is a string of given "type" (success/failure/timeout/error)
message is a human readable string, can be empty
data is either a dict or a array, can be a empty dict or empty array
"""
return {
"result": result_type_map[result_type],
"message": msg,
"data": {} if not data else data
}
def _get_status_strings(s):
return statusStrings[s]
def _ordinal_to_datetime_form(ordinal):
# workaround for episodes with no air date
if int(ordinal) != 1:
date = datetime.date.fromordinal(ordinal)
else:
return ""
return date.strftime(dateTimeFormat)
def _ordinal_to_date_form(ordinal):
if int(ordinal) != 1:
date = datetime.date.fromordinal(ordinal)
else:
return ""
return date.strftime(dateFormat)
def _history_date_to_datetime_form(time_string):
date = datetime.datetime.strptime(time_string, History.date_format)
return date.strftime(dateTimeFormat)
QUALITY_MAP = {
Quality.SDTV: 'sdtv',
'sdtv': Quality.SDTV,
Quality.SDDVD: 'sddvd',
'sddvd': Quality.SDDVD,
Quality.HDTV: 'hdtv',
'hdtv': Quality.HDTV,
Quality.RAWHDTV: 'rawhdtv',
'rawhdtv': Quality.RAWHDTV,
Quality.FULLHDTV: 'fullhdtv',
'fullhdtv': Quality.FULLHDTV,
Quality.HDWEBDL: 'hdwebdl',
'hdwebdl': Quality.HDWEBDL,
Quality.FULLHDWEBDL: 'fullhdwebdl',
'fullhdwebdl': Quality.FULLHDWEBDL,
Quality.HDBLURAY: 'hdbluray',
'hdbluray': Quality.HDBLURAY,
Quality.FULLHDBLURAY: 'fullhdbluray',
'fullhdbluray': Quality.FULLHDBLURAY,
Quality.UHD_4K_TV: 'uhd4ktv',
'udh4ktv': Quality.UHD_4K_TV,
Quality.UHD_4K_BLURAY: '4kbluray',
'uhd4kbluray': Quality.UHD_4K_BLURAY,
Quality.UHD_4K_WEBDL: '4kwebdl',
'udh4kwebdl': Quality.UHD_4K_WEBDL,
Quality.UHD_8K_TV: 'uhd8ktv',
'udh8ktv': Quality.UHD_8K_TV,
Quality.UHD_8K_BLURAY: 'uhd8kbluray',
'uhd8kbluray': Quality.UHD_8K_BLURAY,
Quality.UHD_8K_WEBDL: 'udh8kwebdl',
"udh8kwebdl": Quality.UHD_8K_WEBDL,
Quality.UNKNOWN: 'unknown',
'unknown': Quality.UNKNOWN
}
ALLOWED_QUALITY_LIST = [
"sdtv", "sddvd", "hdtv", "rawhdtv", "fullhdtv", "hdwebdl", "fullhdwebdl", "hdbluray", "fullhdbluray",
"udh4ktv", "uhd4kbluray", "udh4kwebdl", "udh8ktv", "uhd8kbluray", "udh8kwebdl", "unknown"
]
PREFERRED_QUALITY_LIST = [
"sdtv", "sddvd", "hdtv", "rawhdtv", "fullhdtv", "hdwebdl", "fullhdwebdl", "hdbluray", "fullhdbluray",
"udh4ktv", "uhd4kbluray", "udh4kwebdl", "udh8ktv", "uhd8kbluray", "udh8kwebdl"
]
def _map_quality(show_quality):
any_qualities = []
best_qualities = []
i_quality_id, a_quality_id = Quality.splitQuality(int(show_quality))
for quality in i_quality_id:
any_qualities.append((QUALITY_MAP[quality], "N/A")[quality is None])
for quality in a_quality_id:
best_qualities.append((QUALITY_MAP[quality], "N/A")[quality is None])
return any_qualities, best_qualities
def _get_root_dirs():
if sickbeard.ROOT_DIRS == "":
return {}
root_dir = {}
root_dirs = sickbeard.ROOT_DIRS.split('|')
default_index = int(sickbeard.ROOT_DIRS.split('|')[0])
root_dir["default_index"] = int(sickbeard.ROOT_DIRS.split('|')[0])
# remove default_index value from list (this fixes the offset)
root_dirs.pop(0)
if len(root_dirs) < default_index:
return {}
# clean up the list - replace %xx escapes by their single-character equivalent
root_dirs = [urllib.parse.unquote_plus(x) for x in root_dirs]
default_dir = root_dirs[default_index]
dir_list = []
for root_dir in root_dirs:
valid = 1
# noinspection PyBroadException
try:
ek(os.listdir, root_dir)
except Exception:
valid = 0
default = 0
if root_dir is default_dir:
default = 1
cur_dir = {
'valid': valid,
'location': root_dir,
'default': default
}
dir_list.append(cur_dir)
return dir_list
class ApiError(Exception):
"""
Generic API error
"""
class IntParseError(Exception):
"""
A value could not be parsed into an int, but should be parse-able to an int
"""
# -------------------------------------------------------------------------------------#
# noinspection PyAbstractClass
class CMDHelp(ApiCall):
_help = {
"desc": "Get help about a given command",
"optionalParameters": {
"subject": {"desc": "The name of the command to get the help of"},
}
}
def __init__(self, args, kwargs):
super(CMDHelp, self).__init__(args, kwargs)
self.subject, args = self.check_params(args, kwargs, "subject", "help", False, "string", function_mapper.keys())
def run(self):
""" Get help about a given command """
if self.subject in function_mapper:
out = _responds(RESULT_SUCCESS, function_mapper.get(self.subject)((), {"help": 1}).run())
else:
out = _responds(RESULT_FAILURE, msg="No such cmd")
return out
# noinspection PyAbstractClass
class CMDComingEpisodes(ApiCall):
_help = {
"desc": "Get the coming episodes",
"optionalParameters": {
"sort": {"desc": "Change the sort order"},
"type": {"desc": "One or more categories of coming episodes, separated by |"},
"paused": {
"desc": "0 to exclude paused shows, 1 to include them, or omitted to use SickChill default value"
},
}
}
def __init__(self, args, kwargs):
super(CMDComingEpisodes, self).__init__(args, kwargs)
self.sort, args = self.check_params(args, kwargs, "sort", "date", False, "string", ComingEpisodes.sorts.keys())
self.type, args = self.check_params(args, kwargs, "type", '|'.join(ComingEpisodes.categories), False, "list",
ComingEpisodes.categories)
self.paused, args = self.check_params(args, kwargs, "paused", bool(sickbeard.COMING_EPS_DISPLAY_PAUSED), False,
"bool", [])
def run(self):
""" Get the coming episodes """
grouped_coming_episodes = ComingEpisodes.get_coming_episodes(self.type, self.sort, True, self.paused)
data = {section: [] for section in grouped_coming_episodes.keys()}
# noinspection PyCompatibility
for section, coming_episodes in six.iteritems(grouped_coming_episodes):
for coming_episode in coming_episodes:
data[section].append({
'airdate': coming_episode[b'airdate'],
'airs': coming_episode[b'airs'],
'ep_name': coming_episode[b'name'],
'ep_plot': coming_episode[b'description'],
'episode': coming_episode[b'episode'],
'indexerid': coming_episode[b'indexer_id'],
'network': coming_episode[b'network'],
'paused': coming_episode[b'paused'],
'quality': coming_episode[b'quality'],
'season': coming_episode[b'season'],
'show_name': coming_episode[b'show_name'],
'show_status': coming_episode[b'status'],
'tvdbid': coming_episode[b'tvdbid'],
'weekday': coming_episode[b'weekday']
})
return _responds(RESULT_SUCCESS, data)
# noinspection PyAbstractClass
class CMDEpisode(ApiCall):
_help = {
"desc": "Get detailed information about an episode",
"requiredParameters": {
"indexerid": {"desc": "Unique ID of a show"},
"season": {"desc": "The season number"},
"episode": {"desc": "The episode number"},
},
"optionalParameters": {
"tvdbid": {"desc": "thetvdb.com unique ID of a show"},
"full_path": {
"desc": "Return the full absolute show location (if valid, and True), or the relative show location"
},
}
}
def __init__(self, args, kwargs):
super(CMDEpisode, self).__init__(args, kwargs)
self.indexerid, args = self.check_params(args, kwargs, "indexerid", None, True, "int", [])
self.s, args = self.check_params(args, kwargs, "season", None, True, "int", [])
self.e, args = self.check_params(args, kwargs, "episode", None, True, "int", [])
self.fullPath, args = self.check_params(args, kwargs, "full_path", False, False, "bool", [])
def run(self):
""" Get detailed information about an episode """
show_obj = Show.find(sickbeard.showList, int(self.indexerid))
if not show_obj:
return _responds(RESULT_FAILURE, msg="Show not found")
main_db_con = db.DBConnection(row_type="dict")
# noinspection PyPep8
sql_results = main_db_con.select(
"SELECT name, description, airdate, status, location, file_size, release_name, subtitles FROM tv_episodes WHERE showid = ? AND episode = ? AND season = ?",
[self.indexerid, self.e, self.s])
if not len(sql_results) == 1:
raise ApiError("Episode not found")
episode = sql_results[0]
# handle path options
# absolute vs relative vs broken
show_path = None
try:
show_path = show_obj.location
except ShowDirectoryNotFoundException:
pass
if not show_path: # show dir is broken ... episode path will be empty
episode[b"location"] = ""
elif not self.fullPath:
# using the length because lstrip() removes to much
show_path_length = len(show_path) + 1 # the / or \ yeah not that nice i know
episode[b"location"] = episode[b"location"][show_path_length:]
# convert stuff to human form
if try_int(episode[b'airdate'], 1) > 693595: # 1900
episode[b'airdate'] = sbdatetime.sbdatetime.sbfdate(sbdatetime.sbdatetime.convert_to_setting(
network_timezones.parse_date_time(int(episode[b'airdate']), show_obj.airs, show_obj.network)), d_preset=dateFormat)
else:
episode[b'airdate'] = 'Never'
status, quality = Quality.splitCompositeStatus(int(episode[b"status"]))
episode[b"status"] = _get_status_strings(status)
episode[b"quality"] = get_quality_string(quality)
episode[b"file_size_human"] = pretty_file_size(episode[b"file_size"])
return _responds(RESULT_SUCCESS, episode)
# noinspection PyAbstractClass
class CMDEpisodeSearch(ApiCall):
_help = {
"desc": "Search for an episode. The response might take some time.",
"requiredParameters": {
"indexerid": {"desc": "Unique ID of a show"},
"season": {"desc": "The season number"},
"episode": {"desc": "The episode number"},
},
"optionalParameters": {
"tvdbid": {"desc": "thetvdb.com unique ID of a show"},
}
}
def __init__(self, args, kwargs):
super(CMDEpisodeSearch, self).__init__(args, kwargs)
self.indexerid, args = self.check_params(args, kwargs, "indexerid", None, True, "int", [])
self.s, args = self.check_params(args, kwargs, "season", None, True, "int", [])
self.e, args = self.check_params(args, kwargs, "episode", None, True, "int", [])
def run(self):
""" Search for an episode """
show_obj = Show.find(sickbeard.showList, int(self.indexerid))
if not show_obj:
return _responds(RESULT_FAILURE, msg="Show not found")
# retrieve the episode object and fail if we can't get one
ep_obj = show_obj.getEpisode(self.s, self.e)
if isinstance(ep_obj, str):
return _responds(RESULT_FAILURE, msg="Episode not found")
# make a queue item for it and put it on the queue
ep_queue_item = search_queue.ManualSearchQueueItem(show_obj, ep_obj)
sickbeard.searchQueueScheduler.action.add_item(ep_queue_item) # @UndefinedVariable
# wait until the queue item tells us whether it worked or not
while ep_queue_item.success is None: # @UndefinedVariable
time.sleep(1)
# return the correct json value
if ep_queue_item.success:
status, quality = Quality.splitCompositeStatus(ep_obj.status) # @UnusedVariable
# TODO: split quality and status?
return _responds(RESULT_SUCCESS, {"quality": get_quality_string(quality)},
"Snatched (" + get_quality_string(quality) + ")")
return _responds(RESULT_FAILURE, msg='Unable to find episode')
class AbstractStartScheduler(ApiCall):
@property
@abc.abstractmethod
def scheduler(self):
raise NotImplementedError
@property
@abc.abstractmethod
def scheduler_class_str(self):
raise NotImplementedError
def run(self):
error_str = 'Start scheduler failed'
if not isinstance(self.scheduler, sickbeard.scheduler.Scheduler):
error_str = '{0}: {1} is not initialized as a static variable'.format(error_str, self.scheduler_class_str)
return _responds(RESULT_FAILURE, msg=error_str)
if not self.scheduler.enable:
error_str = '{0}: {1} is not enabled'.format(error_str, self.scheduler_class_str)
return _responds(RESULT_FAILURE, msg=error_str)
if not hasattr(self.scheduler.action, 'amActive'):
error_str = '{0}: {1} is not a valid action'.format(error_str, self.scheduler.action)
return _responds(RESULT_FAILURE, msg=error_str)
time_remain = self.scheduler.timeLeft()
# Force the search to start in order to skip the search interval check
if self.scheduler.forceRun():
cycle_time = self.scheduler.cycleTime
next_run = datetime.datetime.now() + cycle_time
result_str = 'Force run successful: {0} search underway. Time Remaining: {1}. ' \
'Next Run: {2}'.format(self.scheduler_class_str, time_remain, next_run)
return _responds(RESULT_SUCCESS, msg=result_str)
else:
# Scheduler is currently active
error_str = '{0}: {1} search underway. Time remaining: {}.'.format(
error_str, self.scheduler_class_str, time_remain)
return _responds(RESULT_FAILURE, msg=error_str)
class CMDFullSubtitleSearch(AbstractStartScheduler):
def data_received(self, chunk):
pass
_help = {"desc": "Force a subtitle search for all shows."}
@property
def scheduler(self):
return sickbeard.subtitlesFinderScheduler
@property
def scheduler_class_str(self):
return 'sickbeard.subtitlesFinderScheduler'
class CMDProperSearch(AbstractStartScheduler):
def data_received(self, chunk):
pass
_help = {"desc": "Force a proper search for all shows."}
@property
def scheduler(self):
return sickbeard.properFinderScheduler
@property
def scheduler_class_str(self):
return 'sickbeard.properFinderScheduler'
class CMDDailySearch(AbstractStartScheduler):
def data_received(self, chunk):
pass
_help = {"desc": "Force a daily search for all shows."}
@property
def scheduler(self):
return sickbeard.dailySearchScheduler
@property
def scheduler_class_str(self):
return 'sickbeard.dailySearchScheduler'
# noinspection PyAbstractClass
class CMDEpisodeSetStatus(ApiCall):
_help = {
"desc": "Set the status of an episode or a season (when no episode is provided)",
"requiredParameters": {
"indexerid": {"desc": "Unique ID of a show"},
"season": {"desc": "The season number"},
"status": {"desc": "The status of the episode or season"}
},
"optionalParameters": {
"episode": {"desc": "The episode number"},
"force": {"desc": "True to replace existing downloaded episode or season, False otherwise"},
"tvdbid": {"desc": "thetvdb.com unique ID of a show"},
}
}
def __init__(self, args, kwargs):
super(CMDEpisodeSetStatus, self).__init__(args, kwargs)
self.indexerid, args = self.check_params(args, kwargs, "indexerid", None, True, "int", [])
self.s, args = self.check_params(args, kwargs, "season", None, True, "int", [])
self.status, args = self.check_params(args, kwargs, "status", None, True, "string",
["wanted", "skipped", "ignored", "failed"])
self.e, args = self.check_params(args, kwargs, "episode", None, False, "int", [])
self.force, args = self.check_params(args, kwargs, "force", False, False, "bool", [])
def run(self):
""" Set the status of an episode or a season (when no episode is provided) """
show_obj = Show.find(sickbeard.showList, int(self.indexerid))
if not show_obj:
return _responds(RESULT_FAILURE, msg="Show not found")
# convert the string status to a int
for status in statusStrings:
if str(statusStrings[status]).lower() == str(self.status).lower():
self.status = status
break
else: # if we don't break out of the for loop we got here.
# the allowed values has at least one item that could not be matched against the internal status strings
raise ApiError("The status string could not be matched to a status. Report to Devs!")
if self.e:
ep_obj = show_obj.getEpisode(self.s, self.e)
if not ep_obj:
return _responds(RESULT_FAILURE, msg="Episode not found")
ep_list = [ep_obj]
else:
# get all episode numbers from self, season
ep_list = show_obj.getAllEpisodes(season=self.s)
def _ep_result(result_code, ep, msg=""):
return {
'season': ep.season, 'episode': ep.episode, 'status': _get_status_strings(ep.status),
'result': result_type_map[result_code], 'message': msg
}
ep_results = []
failure = False
start_backlog = False
segments = {}
sql_l = []
for ep_obj in ep_list:
with ep_obj.lock:
if self.status == WANTED:
# figure out what episodes are wanted so we can backlog them
if ep_obj.season in segments:
segments[ep_obj.season].append(ep_obj)
else:
segments[ep_obj.season] = [ep_obj]
# don't let them mess up UN-AIRED episodes
if ep_obj.status == UNAIRED:
# noinspection PyPep8
if self.e is not None: # setting the status of an un-aired is only considered a failure if we directly wanted this episode, but is ignored on a season request
ep_results.append(
_ep_result(RESULT_FAILURE, ep_obj, "Refusing to change status because it is UN-AIRED"))
failure = True
continue
if self.status == FAILED and not sickbeard.USE_FAILED_DOWNLOADS:
ep_results.append(_ep_result(RESULT_FAILURE, ep_obj, "Refusing to change status to FAILED because failed download handling is disabled"))
failure = True
continue
# allow the user to force setting the status for an already downloaded episode
if ep_obj.status in Quality.DOWNLOADED + Quality.ARCHIVED and not self.force:
ep_results.append(_ep_result(RESULT_FAILURE, ep_obj, "Refusing to change status because it is already marked as DOWNLOADED"))
failure = True
continue
ep_obj.status = self.status
sql_l.append(ep_obj.get_sql())
if self.status == WANTED:
start_backlog = True
ep_results.append(_ep_result(RESULT_SUCCESS, ep_obj))
if sql_l:
main_db_con = db.DBConnection()
main_db_con.mass_action(sql_l)
extra_msg = ""
if start_backlog:
# noinspection PyCompatibility
for season, segment in six.iteritems(segments):
cur_backlog_queue_item = search_queue.BacklogQueueItem(show_obj, segment)
sickbeard.searchQueueScheduler.action.add_item(cur_backlog_queue_item) # @UndefinedVariable
logger.log("API :: Starting backlog for " + show_obj.name + " season " + str(
season) + " because some episodes were set to WANTED")
extra_msg = " Backlog started"
if failure:
return _responds(RESULT_FAILURE, ep_results, 'Failed to set all or some status. Check data.' + extra_msg)
else:
return _responds(RESULT_SUCCESS, msg='All status set successfully.' + extra_msg)
# noinspection PyAbstractClass
class CMDSubtitleSearch(ApiCall):
_help = {
"desc": "Search for an episode subtitles. The response might take some time.",
"requiredParameters": {
"indexerid": {"desc": "Unique ID of a show"},
"season": {"desc": "The season number"},
"episode": {"desc": "The episode number"},
},
"optionalParameters": {
"tvdbid": {"desc": "thetvdb.com unique ID of a show"},
}
}
def __init__(self, args, kwargs):
super(CMDSubtitleSearch, self).__init__(args, kwargs)
self.indexerid, args = self.check_params(args, kwargs, "indexerid", None, True, "int", [])
self.s, args = self.check_params(args, kwargs, "season", None, True, "int", [])
self.e, args = self.check_params(args, kwargs, "episode", None, True, "int", [])
def run(self):
""" Search for an episode subtitles """
show_obj = Show.find(sickbeard.showList, int(self.indexerid))
if not show_obj:
return _responds(RESULT_FAILURE, msg="Show not found")
# retrieve the episode object and fail if we can't get one
ep_obj = show_obj.getEpisode(self.s, self.e)
if isinstance(ep_obj, str):
return _responds(RESULT_FAILURE, msg="Episode not found")
# noinspection PyBroadException
try:
new_subtitles = ep_obj.download_subtitles()
except Exception:
return _responds(RESULT_FAILURE, msg='Unable to find subtitles')
if new_subtitles:
new_languages = [sickbeard.subtitles.name_from_code(code) for code in new_subtitles]
status = 'New subtitles downloaded: {0}'.format(', '.join(new_languages))
response = _responds(RESULT_SUCCESS, msg='New subtitles found')
else:
status = 'No subtitles downloaded'
response = _responds(RESULT_FAILURE, msg='Unable to find subtitles')
ui.notifications.message('Subtitles Search', status)
return response
# noinspection PyAbstractClass
class CMDExceptions(ApiCall):
_help = {
"desc": "Get the scene exceptions for all or a given show",
"optionalParameters": {
"indexerid": {"desc": "Unique ID of a show"},
"tvdbid": {"desc": "thetvdb.com unique ID of a show"},
}
}
def __init__(self, args, kwargs):
super(CMDExceptions, self).__init__(args, kwargs)
self.indexerid, args = self.check_params(args, kwargs, "indexerid", None, False, "int", [])
self.tvdbid, args = self.check_params(args, kwargs, "tvdbid", None, False, "int", [])
def run(self):
""" Get the scene exceptions for all or a given show """
cache_db_con = db.DBConnection('cache.db', row_type='dict')
if self.indexerid is None:
sql_results = cache_db_con.select("SELECT show_name, indexer_id AS 'indexerid' FROM scene_exceptions")
scene_exceptions = {}
for row in sql_results:
indexerid = row[b"indexerid"]
if indexerid not in scene_exceptions:
scene_exceptions[indexerid] = []
scene_exceptions[indexerid].append(row[b"show_name"])
else:
show_obj = Show.find(sickbeard.showList, int(self.indexerid))
if not show_obj:
return _responds(RESULT_FAILURE, msg="Show not found")
sql_results = cache_db_con.select(
"SELECT show_name, indexer_id AS 'indexerid' FROM scene_exceptions WHERE indexer_id = ?",
[self.indexerid])
scene_exceptions = []
for row in sql_results:
scene_exceptions.append(row[b"show_name"])
return _responds(RESULT_SUCCESS, scene_exceptions)
# noinspection PyAbstractClass
class CMDHistory(ApiCall):
_help = {
"desc": "Get the downloaded and/or snatched history",
"optionalParameters": {
"limit": {"desc": "The maximum number of results to return"},
"type": {"desc": "Only get some entries. No value will returns every type"},
}
}
def __init__(self, args, kwargs):
super(CMDHistory, self).__init__(args, kwargs)
self.limit, args = self.check_params(args, kwargs, "limit", 100, False, "int", [])
self.type, args = self.check_params(args, kwargs, "type", None, False, "string", ["downloaded", "snatched"])
self.type = self.type.lower() if isinstance(self.type, str) else ''
def run(self):
""" Get the downloaded and/or snatched history """
data = History().get(self.limit, self.type)
results = []
for row in data:
status, quality = Quality.splitCompositeStatus(int(row[b"action"]))
status = _get_status_strings(status)
if self.type and not status.lower() == self.type:
continue
row[b"status"] = status
row[b"quality"] = get_quality_string(quality)
row[b"date"] = _history_date_to_datetime_form(str(row[b"date"]))
del row[b"action"]
_rename_element(row, "show_id", "indexerid")
row[b"resource_path"] = ek(os.path.dirname, row[b"resource"])
row[b"resource"] = ek(os.path.basename, row[b"resource"])
# Add tvdbid for backward compatibility
row[b'tvdbid'] = row[b'indexerid']
results.append(row)
return _responds(RESULT_SUCCESS, results)
# noinspection PyAbstractClass
class CMDHistoryClear(ApiCall):
_help = {"desc": "Clear the entire history"}
def __init__(self, args, kwargs):
super(CMDHistoryClear, self).__init__(args, kwargs)
def run(self):
""" Clear the entire history """
History().clear()
return _responds(RESULT_SUCCESS, msg="History cleared")
# noinspection PyAbstractClass
class CMDHistoryTrim(ApiCall):
_help = {"desc": "Trim history entries older than 30 days"}
def __init__(self, args, kwargs):
super(CMDHistoryTrim, self).__init__(args, kwargs)
def run(self):
""" Trim history entries older than 30 days """
History().trim()
return _responds(RESULT_SUCCESS, msg='Removed history entries older than 30 days')
# noinspection PyAbstractClass
class CMDFailed(ApiCall):
_help = {
"desc": "Get the failed downloads",
"optionalParameters": {
"limit": {"desc": "The maximum number of results to return"},
}
}
def __init__(self, args, kwargs):
super(CMDFailed, self).__init__(args, kwargs)
self.limit, args = self.check_params(args, kwargs, "limit", 100, False, "int", [])
def run(self):
""" Get the failed downloads """
failed_db_con = db.DBConnection('failed.db', row_type="dict")
u_limit = min(int(self.limit), 100)
if u_limit == 0:
sql_results = failed_db_con.select("SELECT * FROM failed")
else:
sql_results = failed_db_con.select("SELECT * FROM failed LIMIT ?", [u_limit])
return _responds(RESULT_SUCCESS, sql_results)
# noinspection PyAbstractClass
class CMDBacklog(ApiCall):
_help = {"desc": "Get the backlogged episodes"}
def __init__(self, args, kwargs):
super(CMDBacklog, self).__init__(args, kwargs)
def run(self):
""" Get the backlogged episodes """
shows = []
main_db_con = db.DBConnection(row_type="dict")
for curShow in sickbeard.showList:
show_eps = []
# noinspection PyPep8
sql_results = main_db_con.select(
"SELECT tv_episodes.*, tv_shows.paused FROM tv_episodes INNER JOIN tv_shows ON tv_episodes.showid = tv_shows.indexer_id WHERE showid = ? AND paused = 0 ORDER BY season DESC, episode DESC",
[curShow.indexerid])
for curResult in sql_results:
cur_ep_cat = curShow.getOverview(curResult[b"status"])
if cur_ep_cat and cur_ep_cat in (Overview.WANTED, Overview.QUAL):
show_eps.append(curResult)
if show_eps:
shows.append({
"indexerid": curShow.indexerid,
"show_name": curShow.name,
"status": curShow.status,
"episodes": show_eps
})
return _responds(RESULT_SUCCESS, shows)
# noinspection PyAbstractClass
class CMDLogs(ApiCall):
_help = {
"desc": "Get the logs",
"optionalParameters": {
"min_level": {
"desc":
"The minimum level classification of log entries to return. "
"Each level inherits its above levels: debug < info < warning < error"
},
}
}
def __init__(self, args, kwargs):
super(CMDLogs, self).__init__(args, kwargs)
self.min_level, args = self.check_params(args, kwargs, "min_level", "error", False, "string",
["error", "warning", "info", "debug"])
def run(self):
""" Get the logs """
# 10 = Debug / 20 = Info / 30 = Warning / 40 = Error
min_level = logger.LOGGING_LEVELS[str(self.min_level).upper()]
data = []
if ek(os.path.isfile, logger.log_file):
with io.open(logger.log_file, 'r', encoding='utf-8') as f:
data = f.readlines()
regex = r"^(\d\d\d\d)\-(\d\d)\-(\d\d)\s*(\d\d)\:(\d\d):(\d\d)\s*([A-Z]+)\s*(.+?)\s*\:\:\s*(.*)$"
final_data = []
num_lines = 0
last_line = False
num_to_show = min(50, len(data))
for x in reversed(data):
match = re.match(regex, x)
if match:
level = match.group(7)
if level not in logger.LOGGING_LEVELS:
last_line = False
continue
if logger.LOGGING_LEVELS[level] >= min_level:
last_line = True
final_data.append(x.rstrip("\n"))
else:
last_line = False
continue
elif last_line:
final_data.append("AA" + x)
num_lines += 1
if num_lines >= num_to_show:
break
return _responds(RESULT_SUCCESS, final_data)
# noinspection PyAbstractClass
class CMDLogsClear(ApiCall):
_help = {
"desc": "Clear the logs",
"optionalParameters": {
"level": {"desc": "The level of logs to clear"},
},
}
def __init__(self, args, kwargs):
super(CMDLogsClear, self).__init__(args, kwargs)
self.level, args = self.check_params(args, kwargs, "level", "warning", False, "string", ["warning", "error"])
def run(self):
""" Clear the logs """
if self.level == "error":
msg = "Error logs cleared"
classes.ErrorViewer.clear()
elif self.level == "warning":
msg = "Warning logs cleared"
classes.WarningViewer.clear()
else:
return _responds(RESULT_FAILURE, msg="Unknown log level: {0}".format(self.level))
return _responds(RESULT_SUCCESS, msg=msg)
# noinspection PyAbstractClass
class CMDPostProcess(ApiCall):
_help = {
"desc": "Manually post-process the files in the download folder",
"optionalParameters": {
"path": {"desc": "The path to the folder to post-process"},
"force_replace": {"desc": "Force already post-processed files to be post-processed again"},
"force_next": {"desc": "Waits for the current processing queue item to finish and returns result of this request"},
"return_data": {"desc": "Returns the result of the post-process"},
"process_method": {"desc": "How should valid post-processed files be handled"},
"is_priority": {"desc": "Replace the file even if it exists in a higher quality"},
"failed": {"desc": "Mark download as failed"},
"delete": {"desc": "Delete processed files and folders"},
"type": {"desc": "The type of post-process being requested"},
}
}
def __init__(self, args, kwargs):
super(CMDPostProcess, self).__init__(args, kwargs)
self.path, args = self.check_params(args, kwargs, "path", None, False, "string", [])
self.force_replace, args = self.check_params(args, kwargs, "force_replace", False, False, "bool", [])
self.force_next, args = self.check_params(args, kwargs, "force_next", False, False, "bool", [])
self.return_data, args = self.check_params(args, kwargs, "return_data", False, False, "bool", [])
self.process_method, args = self.check_params(args, kwargs, "process_method", False, False, "string",
PROCESS_METHODS)
self.is_priority, args = self.check_params(args, kwargs, "is_priority", False, False, "bool", [])
self.failed, args = self.check_params(args, kwargs, "failed", False, False, "bool", [])
self.delete, args = self.check_params(args, kwargs, "delete", False, False, "bool", [])
self.type, args = self.check_params(args, kwargs, "type", "auto", None, "string", ["auto", "manual"])
def run(self):
""" Manually post-process the files in the download folder """
if not self.path and not sickbeard.TV_DOWNLOAD_DIR:
return _responds(RESULT_FAILURE, msg="You need to provide a path or set TV Download Dir")
if not self.path:
self.path = sickbeard.TV_DOWNLOAD_DIR
if not self.type:
self.type = 'manual'
data = sickbeard.postProcessorTaskScheduler.action.add_item(
self.path, method=self.process_method, force=self.force_replace,
is_priority=self.is_priority, failed=self.failed, delete=self.delete,
mode=self.type, force_next=self.force_next
)
if not self.return_data:
data = ""
return _responds(RESULT_SUCCESS, data=data, msg="Started post-process for {0}".format(self.path))
# noinspection PyAbstractClass
class CMDSickBeard(ApiCall):
_help = {"desc": "Get miscellaneous information about SickChill"}
def __init__(self, args, kwargs):
super(CMDSickBeard, self).__init__(args, kwargs)
def run(self):
""" dGet miscellaneous information about SickChill """
data = {
"sr_version": sickbeard.BRANCH, "api_version": self.version,
"api_commands": sorted(function_mapper.keys())
}
return _responds(RESULT_SUCCESS, data)
# noinspection PyAbstractClass
class CMDSickBeardAddRootDir(ApiCall):
_help = {
"desc": "Add a new root (parent) directory to SickChill",
"requiredParameters": {
"location": {"desc": "The full path to the new root (parent) directory"},
},
"optionalParameters": {
"default": {"desc": "Make this new location the default root (parent) directory"},
}
}
def __init__(self, args, kwargs):
super(CMDSickBeardAddRootDir, self).__init__(args, kwargs)
self.location, args = self.check_params(args, kwargs, "location", None, True, "string", [])
self.default, args = self.check_params(args, kwargs, "default", False, False, "bool", [])
def run(self):
""" Add a new root (parent) directory to SickChill """
self.location = urllib.parse.unquote_plus(self.location)
location_matched = 0
index = 0
# disallow adding/setting an invalid dir
if not ek(os.path.isdir, self.location):
return _responds(RESULT_FAILURE, msg="Location is invalid")
root_dirs = []
if sickbeard.ROOT_DIRS == "":
self.default = 1
else:
root_dirs = sickbeard.ROOT_DIRS.split('|')
index = int(sickbeard.ROOT_DIRS.split('|')[0])
root_dirs.pop(0)
# clean up the list - replace %xx escapes by their single-character equivalent
root_dirs = [urllib.parse.unquote_plus(x) for x in root_dirs]
for x in root_dirs:
if x == self.location:
location_matched = 1
if self.default == 1:
index = root_dirs.index(self.location)
break
if location_matched == 0:
if self.default == 1:
root_dirs.insert(0, self.location)
else:
root_dirs.append(self.location)
root_dirs_new = [urllib.parse.unquote_plus(x) for x in root_dirs]
root_dirs_new.insert(0, index)
# noinspection PyCompatibility
root_dirs_new = '|'.join(six.text_type(x) for x in root_dirs_new)
sickbeard.ROOT_DIRS = root_dirs_new
return _responds(RESULT_SUCCESS, _get_root_dirs(), msg="Root directories updated")
# noinspection PyAbstractClass
class CMDSickBeardCheckVersion(ApiCall):
_help = {"desc": "Check if a new version of SickChill is available"}
def __init__(self, args, kwargs):
super(CMDSickBeardCheckVersion, self).__init__(args, kwargs)
def run(self):
check_version = CheckVersion()
needs_update = check_version.check_for_new_version()
data = {
"current_version": {
"branch": check_version.get_branch(),
"commit": check_version.updater.get_cur_commit_hash(),
"version": check_version.updater.get_cur_version(),
},
"latest_version": {
"branch": check_version.get_branch(),
"commit": check_version.updater.get_newest_commit_hash(),
"version": check_version.updater.get_newest_version(),
},
"commits_offset": check_version.updater.get_num_commits_behind(),
"needs_update": needs_update,
}
return _responds(RESULT_SUCCESS, data)
# noinspection PyAbstractClass
class CMDSickBeardCheckScheduler(ApiCall):
_help = {"desc": "Get information about the scheduler"}
def __init__(self, args, kwargs):
super(CMDSickBeardCheckScheduler, self).__init__(args, kwargs)
def run(self):
""" Get information about the scheduler """
main_db_con = db.DBConnection(row_type="dict")
sql_results = main_db_con.select("SELECT last_backlog FROM info")
backlog_paused = sickbeard.searchQueueScheduler.action.is_backlog_paused() # @UndefinedVariable
backlog_running = sickbeard.searchQueueScheduler.action.is_backlog_in_progress() # @UndefinedVariable
next_backlog = sickbeard.backlogSearchScheduler.nextRun().strftime(dateFormat).decode(sickbeard.SYS_ENCODING)
data = {
"backlog_is_paused": int(backlog_paused), "backlog_is_running": int(backlog_running),
"last_backlog": _ordinal_to_date_form(sql_results[0][b"last_backlog"]),
"next_backlog": next_backlog
}
return _responds(RESULT_SUCCESS, data)
# noinspection PyAbstractClass
class CMDSickBeardDeleteRootDir(ApiCall):
_help = {
"desc": "Delete a root (parent) directory from SickChill",
"requiredParameters": {
"location": {"desc": "The full path to the root (parent) directory to remove"},
}
}
def __init__(self, args, kwargs):
super(CMDSickBeardDeleteRootDir, self).__init__(args, kwargs)
self.location, args = self.check_params(args, kwargs, "location", None, True, "string", [])
def run(self):
""" Delete a root (parent) directory from SickChill """
if sickbeard.ROOT_DIRS == "":
return _responds(RESULT_FAILURE, _get_root_dirs(), msg="No root directories detected")
new_index = 0
root_dirs_new = []
root_dirs = sickbeard.ROOT_DIRS.split('|')
index = int(root_dirs[0])
root_dirs.pop(0)
# clean up the list - replace %xx escapes by their single-character equivalent
root_dirs = [urllib.parse.unquote_plus(x) for x in root_dirs]
old_root_dir = root_dirs[index]
for curRootDir in root_dirs:
if not curRootDir == self.location:
root_dirs_new.append(curRootDir)
else:
new_index = 0
for curIndex, curNewRootDir in enumerate(root_dirs_new):
if curNewRootDir is old_root_dir:
new_index = curIndex
break
root_dirs_new = [urllib.parse.unquote_plus(x) for x in root_dirs_new]
if len(root_dirs_new) > 0:
root_dirs_new.insert(0, new_index)
# noinspection PyCompatibility
root_dirs_new = "|".join(six.text_type(x) for x in root_dirs_new)
sickbeard.ROOT_DIRS = root_dirs_new
# what if the root dir was not found?
return _responds(RESULT_SUCCESS, _get_root_dirs(), msg="Root directory deleted")
# noinspection PyAbstractClass
class CMDSickBeardGetDefaults(ApiCall):
_help = {"desc": "Get SickChill's user default configuration value"}
def __init__(self, args, kwargs):
super(CMDSickBeardGetDefaults, self).__init__(args, kwargs)
def run(self):
""" Get SickChill's user default configuration value """
any_qualities, best_qualities = _map_quality(sickbeard.QUALITY_DEFAULT)
data = {
"status": statusStrings[sickbeard.STATUS_DEFAULT].lower(),
"flatten_folders": int(not sickbeard.SEASON_FOLDERS_DEFAULT),
"season_folders": int(sickbeard.SEASON_FOLDERS_DEFAULT),
"initial": any_qualities, "archive": best_qualities,
"future_show_paused": int(sickbeard.COMING_EPS_DISPLAY_PAUSED)
}
return _responds(RESULT_SUCCESS, data)
# noinspection PyAbstractClass
class CMDSickBeardGetMessages(ApiCall):
_help = {"desc": "Get all messages"}
def __init__(self, args, kwargs):
super(CMDSickBeardGetMessages, self).__init__(args, kwargs)
def run(self):
messages = []
for cur_notification in ui.notifications.get_notifications(self.rh.request.remote_ip):
messages.append({
"title": cur_notification.title,
"message": cur_notification.message,
"type": cur_notification.type
})
return _responds(RESULT_SUCCESS, messages)
# noinspection PyAbstractClass
class CMDSickBeardGetRootDirs(ApiCall):
_help = {"desc": "Get all root (parent) directories"}
def __init__(self, args, kwargs):
super(CMDSickBeardGetRootDirs, self).__init__(args, kwargs)
def run(self):
""" Get all root (parent) directories """
return _responds(RESULT_SUCCESS, _get_root_dirs())
# noinspection PyAbstractClass
class CMDSickBeardPauseBacklog(ApiCall):
_help = {
"desc": "Pause or un-pause the backlog search",
"optionalParameters": {
"pause": {"desc": "True to pause the backlog search, False to un-pause it"}
}
}
def __init__(self, args, kwargs):
super(CMDSickBeardPauseBacklog, self).__init__(args, kwargs)
self.pause, args = self.check_params(args, kwargs, "pause", False, False, "bool", [])
def run(self):
""" Pause or un-pause the backlog search """
if self.pause:
sickbeard.searchQueueScheduler.action.pause_backlog() # @UndefinedVariable
return _responds(RESULT_SUCCESS, msg="Backlog paused")
else:
sickbeard.searchQueueScheduler.action.unpause_backlog() # @UndefinedVariable
return _responds(RESULT_SUCCESS, msg="Backlog un-paused")
# noinspection PyAbstractClass
class CMDSickBeardPing(ApiCall):
_help = {"desc": "Ping SickChill to check if it is running"}
def __init__(self, args, kwargs):
super(CMDSickBeardPing, self).__init__(args, kwargs)
def run(self):
""" Ping SickChill to check if it is running """
if sickbeard.started:
return _responds(RESULT_SUCCESS, {"pid": sickbeard.PID}, "Pong")
else:
return _responds(RESULT_SUCCESS, msg="Pong")
# noinspection PyAbstractClass
class CMDSickBeardRestart(ApiCall):
_help = {"desc": "Restart SickChill"}
def __init__(self, args, kwargs):
super(CMDSickBeardRestart, self).__init__(args, kwargs)
def run(self):
""" Restart SickChill """
if not Restart.restart(sickbeard.PID):
return _responds(RESULT_FAILURE, msg='SickChill can not be restarted')
return _responds(RESULT_SUCCESS, msg="SickChill is restarting...")
# noinspection PyAbstractClass
class CMDSickBeardSearchIndexers(ApiCall):
_help = {
"desc": "Search for a show with a given name on all the indexers, in a specific language",
"optionalParameters": {
"name": {"desc": "The name of the show you want to search for"},
"indexerid": {"desc": "Unique ID of a show"},
"lang": {"desc": "The 2-letter language code of the desired show"},
"only_new": {"desc": "Discard shows that are already in your show list"},
}
}
def __init__(self, args, kwargs):
super(CMDSickBeardSearchIndexers, self).__init__(args, kwargs)
self.valid_languages = sickchill.indexer.lang_dict()
self.name, args = self.check_params(args, kwargs, "name", None, False, "string", [])
self.lang, args = self.check_params(args, kwargs, "lang", sickbeard.INDEXER_DEFAULT_LANGUAGE, False, "string",
self.valid_languages.keys())
self.indexerid, args = self.check_params(args, kwargs, "indexerid", None, False, "int", [])
self.only_new, args = self.check_params(args, kwargs, "only_new", True, False, "bool", [])
def run(self):
""" Search for a show with a given name on all the indexers, in a specific language """
results = []
lang_id = self.valid_languages[self.lang]
if self.name and not self.indexerid: # only name was given
search_results = sickchill.indexer.search_indexers_for_series_name(str(self.name).encode(), self.lang)
for indexer, indexer_results in six.iteritems(search_results):
for result in indexer_results:
# Skip it if it's in our show list already, and we only want new shows
# noinspection PyUnresolvedReferences
in_show_list = sickbeard.tv.Show.find(sickbeard.showList, int(result.id))
if in_show_list and self.only_new:
continue
results.append({
indexer_ids[indexer]: result['id'],
"name": result['seriesName'],
"first_aired": result['firstAired'],
"indexer": indexer,
"in_show_list": in_show_list
})
return _responds(RESULT_SUCCESS, {"results": results, "langid": lang_id})
elif self.indexerid:
indexer, result = sickchill.indexer.search_indexers_for_series_id(indexerid=self.indexerid, language=self.lang)
if not indexer:
logger.log("API :: Unable to find show with id " + str(self.indexerid), logger.WARNING)
return _responds(RESULT_SUCCESS, {"results": [], "langid": lang_id})
if not result.seriesName:
logger.log(
"API :: Found show with indexerid: " + str(self.indexerid) + ", however it contained no show name", logger.DEBUG)
return _responds(RESULT_FAILURE, msg="Show contains no name, invalid result")
results = [{
indexer_ids[indexer]: result.id,
"name": six.text_type(result.seriesName),
"first_aired": result.firstAired,
"indexer": indexer
}]
return _responds(RESULT_SUCCESS, {"results": results, "langid": lang_id})
else:
return _responds(RESULT_FAILURE, msg="Either a unique id or name is required!")
# noinspection PyAbstractClass
class CMDSickBeardSearchTVDB(CMDSickBeardSearchIndexers):
_help = {
"desc": "Search for a show with a given name on The TVDB, in a specific language",
"optionalParameters": {
"name": {"desc": "The name of the show you want to search for"},
"tvdbid": {"desc": "thetvdb.com unique ID of a show"},
"lang": {"desc": "The 2-letter language code of the desired show"},
}
}
def __init__(self, args, kwargs):
CMDSickBeardSearchIndexers.__init__(self, args, kwargs)
self.indexerid, args = self.check_params(args, kwargs, "tvdbid", None, False, "int", [])
# noinspection PyAbstractClass
class CMDSickBeardSearchTVRAGE(CMDSickBeardSearchIndexers):
"""
Deprecated, TVRage is no more.
"""
_help = {
"desc":
"Search for a show with a given name on TVRage, in a specific language. "
"This command should not longer be used, as TVRage was shut down.",
"optionalParameters": {
"name": {"desc": "The name of the show you want to search for"},
"lang": {"desc": "The 2-letter language code of the desired show"},
}
}
def __init__(self, args, kwargs):
super(CMDSickBeardSearchTVRAGE, self).__init__(args, kwargs)
def run(self):
return _responds(RESULT_FAILURE, msg="TVRage is no more, invalid result")
# noinspection PyAbstractClass
class CMDSickBeardSetDefaults(ApiCall):
_help = {
"desc": "Set SickChill's user default configuration value",
"optionalParameters": {
"initial": {"desc": "The initial quality of a show"},
"archive": {"desc": "The archive quality of a show"},
"future_show_paused": {"desc": "True to list paused shows in the coming episode, False otherwise"},
"season_folders": {"desc": "Group episodes in season folders within the show directory"},
"status": {"desc": "Status of missing episodes"},
}
}
def __init__(self, args, kwargs):
super(CMDSickBeardSetDefaults, self).__init__(args, kwargs)
self.initial, args = self.check_params(args, kwargs, "initial", [], False, "list", ALLOWED_QUALITY_LIST)
self.archive, args = self.check_params(args, kwargs, "archive", [], False, "list", PREFERRED_QUALITY_LIST)
self.future_show_paused, args = self.check_params(args, kwargs, "future_show_paused", None, False, "bool", [])
self.season_folders, args = self.check_params(args, kwargs, "flatten_folders", not bool(sickbeard.SEASON_FOLDERS_DEFAULT), False, "bool", [])
self.season_folders, args = self.check_params(args, kwargs, "season_folders", self.season_folders, False, "bool", [])
self.status, args = self.check_params(args, kwargs, "status", None, False, "string",
["wanted", "skipped", "ignored"])
def run(self):
""" Set SickChill's user default configuration value """
i_quality_id = []
a_quality_id = []
if self.initial:
# noinspection PyTypeChecker
for quality in self.initial:
i_quality_id.append(QUALITY_MAP[quality])
if self.archive:
# noinspection PyTypeChecker
for quality in self.archive:
a_quality_id.append(QUALITY_MAP[quality])
if i_quality_id or a_quality_id:
sickbeard.QUALITY_DEFAULT = Quality.combineQualities(i_quality_id, a_quality_id)
if self.status:
# convert the string status to a int
for status in statusStrings:
if statusStrings[status].lower() == str(self.status).lower():
self.status = status
break
# this should be obsolete because of the above
if self.status not in statusStrings:
raise ApiError("Invalid Status")
# only allow the status options we want
if int(self.status) not in (3, 5, 6, 7):
raise ApiError("Status Prohibited")
sickbeard.STATUS_DEFAULT = self.status
if self.season_folders is not None:
sickbeard.SEASON_FOLDERS_DEFAULT = int(self.season_folders)
if self.future_show_paused is not None:
sickbeard.COMING_EPS_DISPLAY_PAUSED = int(self.future_show_paused)
return _responds(RESULT_SUCCESS, msg="Saved defaults")
# noinspection PyAbstractClass
class CMDSickBeardShutdown(ApiCall):
_help = {"desc": "Shutdown SickChill"}
def __init__(self, args, kwargs):
super(CMDSickBeardShutdown, self).__init__(args, kwargs)
def run(self):
""" Shutdown SickChill """
if not Shutdown.stop(sickbeard.PID):
return _responds(RESULT_FAILURE, msg='SickChill can not be shut down')
return _responds(RESULT_SUCCESS, msg="SickChill is shutting down...")
# noinspection PyAbstractClass
class CMDSickBeardUpdate(ApiCall):
_help = {"desc": "Update SickChill to the latest version available"}
def __init__(self, args, kwargs):
super(CMDSickBeardUpdate, self).__init__(args, kwargs)
def run(self):
check_version = CheckVersion()
if check_version.check_for_new_version():
if check_version.run_backup_if_safe():
check_version.update()
return _responds(RESULT_SUCCESS, msg="SickChill is updating ...")
return _responds(RESULT_FAILURE, msg="SickChill could not backup config ...")
return _responds(RESULT_FAILURE, msg="SickChill is already up to date")
# noinspection PyAbstractClass
class CMDShow(ApiCall):
_help = {
"desc": "Get detailed information about a show",
"requiredParameters": {
"indexerid": {"desc": "Unique ID of a show"},
},
"optionalParameters": {
"tvdbid": {"desc": "thetvdb.com unique ID of a show"},
}
}
def __init__(self, args, kwargs):
super(CMDShow, self).__init__(args, kwargs)
self.indexerid, args = self.check_params(args, kwargs, "indexerid", None, True, "int", [])
def run(self):
""" Get detailed information about a show """
show_obj = Show.find(sickbeard.showList, int(self.indexerid))
if not show_obj:
return _responds(RESULT_FAILURE, msg="Show not found")
show_dict = {
"season_list": CMDShowSeasonList((), {"indexerid": self.indexerid}).run()["data"],
"cache": CMDShowCache((), {"indexerid": self.indexerid}).run()["data"],
"genre": show_obj.genre, "quality": get_quality_string(show_obj.quality)
}
any_qualities, best_qualities = _map_quality(show_obj.quality)
show_dict["quality_details"] = {"initial": any_qualities, "archive": best_qualities}
try:
show_dict["location"] = show_obj.location
except ShowDirectoryNotFoundException:
show_dict["location"] = ""
show_dict["language"] = show_obj.lang
show_dict["show_name"] = show_obj.name
show_dict["paused"] = (0, 1)[show_obj.paused]
show_dict["subtitles"] = (0, 1)[show_obj.subtitles]
show_dict["air_by_date"] = (0, 1)[show_obj.air_by_date]
show_dict["season_folders"] = (0, 1)[show_obj.season_folders]
show_dict["sports"] = (0, 1)[show_obj.sports]
show_dict["anime"] = (0, 1)[show_obj.anime]
show_dict["airs"] = str(show_obj.airs).replace('am', ' AM').replace('pm', ' PM').replace(' ', ' ')
show_dict["dvdorder"] = (0, 1)[show_obj.dvdorder]
if show_obj.rls_require_words:
show_dict["rls_require_words"] = show_obj.rls_require_words.split(", ")
else:
show_dict["rls_require_words"] = []
if show_obj.rls_prefer_words:
show_dict["rls_prefer_words"] = show_obj.rls_prefer_words.split(", ")
else:
show_dict["rls_prefer_words"] = []
if show_obj.rls_ignore_words:
show_dict["rls_ignore_words"] = show_obj.rls_ignore_words.split(", ")
else:
show_dict["rls_ignore_words"] = []
show_dict["scene"] = (0, 1)[show_obj.scene]
# show_dict["archive_firstmatch"] = (0, 1)[show_obj.archive_firstmatch]
# This might need to be here for 3rd part apps?
show_dict["archive_firstmatch"] = 1
show_dict["indexerid"] = show_obj.indexerid
show_dict["tvdbid"] = show_obj.indexerid
show_dict["imdbid"] = show_obj.imdbid
show_dict["network"] = show_obj.network
if not show_dict["network"]:
show_dict["network"] = ""
show_dict["status"] = show_obj.status
if try_int(show_obj.nextaired, 1) > 693595:
dt_episode_airs = sbdatetime.sbdatetime.convert_to_setting(
network_timezones.parse_date_time(show_obj.nextaired, show_dict['airs'], show_dict['network']))
show_dict['airs'] = sbdatetime.sbdatetime.sbftime(dt_episode_airs, t_preset=timeFormat).lstrip('0').replace(
' 0', ' ')
show_dict['next_ep_airdate'] = sbdatetime.sbdatetime.sbfdate(dt_episode_airs, d_preset=dateFormat)
else:
show_dict['next_ep_airdate'] = ''
return _responds(RESULT_SUCCESS, show_dict)
# noinspection PyAbstractClass
class CMDShowAddExisting(ApiCall):
_help = {
"desc": "Add an existing show in SickChill",
"requiredParameters": {
"indexerid": {"desc": "Unique ID of a show"},
"location": {"desc": "Full path to the existing shows's folder"},
},
"optionalParameters": {
"tvdbid": {"desc": "thetvdb.com unique ID of a show"},
"initial": {"desc": "The initial quality of the show"},
"archive": {"desc": "The archive quality of the show"},
"season_folders": {"desc": "True to group episodes in season folders, False otherwise"},
"subtitles": {"desc": "True to search for subtitles, False otherwise"},
}
}
def __init__(self, args, kwargs):
super(CMDShowAddExisting, self).__init__(args, kwargs)
self.indexerid, args = self.check_params(args, kwargs, "indexerid", None, True, "", [])
self.location, args = self.check_params(args, kwargs, "location", None, True, "string", [])
self.initial, args = self.check_params(args, kwargs, "initial", [], False, "list", ALLOWED_QUALITY_LIST)
self.archive, args = self.check_params(args, kwargs, "archive", [], False, "list", PREFERRED_QUALITY_LIST)
self.season_folders, args = self.check_params(args, kwargs, "flatten_folders",
bool(sickbeard.SEASON_FOLDERS_DEFAULT), False, "bool", [])
self.season_folders, args = self.check_params(args, kwargs, "season_folders",
self.season_folders, False, "bool", [])
self.subtitles, args = self.check_params(args, kwargs, "subtitles", int(sickbeard.USE_SUBTITLES),
False, "int", [])
def run(self):
""" Add an existing show in SickChill """
show_obj = Show.find(sickbeard.showList, int(self.indexerid))
if show_obj:
return _responds(RESULT_FAILURE, msg="An existing indexerid already exists in the database")
if not ek(os.path.isdir, self.location):
return _responds(RESULT_FAILURE, msg='Not a valid location')
indexer_name = None
indexer_result = CMDSickBeardSearchIndexers([], {indexer_ids[self.indexer]: self.indexerid}).run()
if indexer_result[b'result'] == result_type_map[RESULT_SUCCESS]:
if not indexer_result[b'data']['results']:
return _responds(RESULT_FAILURE, msg="Empty results returned, check indexerid and try again")
if len(indexer_result[b'data']['results']) == 1 and 'name' in indexer_result[b'data']['results'][0]:
indexer_name = indexer_result[b'data']['results'][0]['name']
if not indexer_name:
return _responds(RESULT_FAILURE, msg="Unable to retrieve information from indexer")
# set indexer so we can pass it along when adding show to SR
indexer = indexer_result[b'data']['results'][0]['indexer']
# use default quality as a fail-safe
new_quality = int(sickbeard.QUALITY_DEFAULT)
i_quality_id = []
a_quality_id = []
if self.initial:
# noinspection PyTypeChecker
for quality in self.initial:
i_quality_id.append(QUALITY_MAP[quality])
if self.archive:
# noinspection PyTypeChecker
for quality in self.archive:
a_quality_id.append(QUALITY_MAP[quality])
if i_quality_id or a_quality_id:
new_quality = Quality.combineQualities(i_quality_id, a_quality_id)
sickbeard.showQueueScheduler.action.add_show(
int(indexer), int(self.indexerid), self.location,
default_status=sickbeard.STATUS_DEFAULT, quality=new_quality,
season_folders=int(self.season_folders), subtitles=self.subtitles,
default_status_after=sickbeard.STATUS_DEFAULT_AFTER
)
return _responds(RESULT_SUCCESS, {"name": indexer_name}, indexer_name + " has been queued to be added")
# noinspection PyAbstractClass
class CMDShowAddNew(ApiCall):
_help = {
"desc": "Add a new show to SickChill",
"requiredParameters": {
"indexerid": {"desc": "Unique ID of a show"},
},
"optionalParameters": {
"tvdbid": {"desc": "thetvdb.com unique ID of a show"},
"initial": {"desc": "The initial quality of the show"},
"location": {"desc": "The path to the folder where the show should be created"},
"archive": {"desc": "The archive quality of the show"},
"season_folders": {"desc": "True to group episodes in season folders, False otherwise"},
"status": {"desc": "The status of missing episodes"},
"lang": {"desc": "The 2-letter language code of the desired show"},
"subtitles": {"desc": "True to search for subtitles, False otherwise"},
"anime": {"desc": "True to mark the show as an anime, False otherwise"},
"scene": {"desc": "True if episodes search should be made by scene numbering, False otherwise"},
"future_status": {"desc": "The status of future episodes"},
}
}
def __init__(self, args, kwargs):
super(CMDShowAddNew, self).__init__(args, kwargs)
self.valid_languages = sickchill.indexer.lang_dict()
self.indexerid, args = self.check_params(args, kwargs, "indexerid", None, True, "int", [])
self.location, args = self.check_params(args, kwargs, "location", None, False, "string", [])
self.initial, args = self.check_params(
args, kwargs, "initial", None, False, "list", ALLOWED_QUALITY_LIST)
self.archive, args = self.check_params(
args, kwargs, "archive", None, False, "list", PREFERRED_QUALITY_LIST)
self.season_folders, args = self.check_params(args, kwargs, "flatten_folders",
bool(sickbeard.SEASON_FOLDERS_DEFAULT), False, "bool", [])
self.season_folders, args = self.check_params(args, kwargs, "season_folders",
self.season_folders, False, "bool", [])
self.status, args = self.check_params(args, kwargs, "status", None, False, "string",
["wanted", "skipped", "ignored"])
self.lang, args = self.check_params(args, kwargs, "lang", sickbeard.INDEXER_DEFAULT_LANGUAGE, False, "string",
self.valid_languages.keys())
self.subtitles, args = self.check_params(args, kwargs, "subtitles", bool(sickbeard.USE_SUBTITLES),
False, "bool", [])
self.anime, args = self.check_params(args, kwargs, "anime", bool(sickbeard.ANIME_DEFAULT), False,
"bool", [])
self.scene, args = self.check_params(args, kwargs, "scene", bool(sickbeard.SCENE_DEFAULT), False,
"bool", [])
self.future_status, args = self.check_params(args, kwargs, "future_status", None, False, "string",
["wanted", "skipped", "ignored"])
def run(self):
""" Add a new show to SickChill """
show_obj = Show.find(sickbeard.showList, int(self.indexerid))
if show_obj:
return _responds(RESULT_FAILURE, msg="An existing indexerid already exists in database")
if not self.location:
if sickbeard.ROOT_DIRS != "":
root_dirs = sickbeard.ROOT_DIRS.split('|')
root_dirs.pop(0)
default_index = int(sickbeard.ROOT_DIRS.split('|')[0])
self.location = root_dirs[default_index]
else:
return _responds(RESULT_FAILURE, msg="Root directory is not set, please provide a location")
if not ek(os.path.isdir, self.location):
return _responds(RESULT_FAILURE, msg="'" + self.location + "' is not a valid location")
# use default quality as a fail-safe
new_quality = int(sickbeard.QUALITY_DEFAULT)
i_quality_id = []
a_quality_id = []
if self.initial:
# noinspection PyTypeChecker
for quality in self.initial:
i_quality_id.append(QUALITY_MAP[quality])
if self.archive:
# noinspection PyTypeChecker
for quality in self.archive:
a_quality_id.append(QUALITY_MAP[quality])
if i_quality_id or a_quality_id:
new_quality = Quality.combineQualities(i_quality_id, a_quality_id)
# use default status as a fail-safe
new_status = sickbeard.STATUS_DEFAULT
if self.status:
# convert the string status to a int
for status in statusStrings:
if statusStrings[status].lower() == str(self.status).lower():
self.status = status
break
if self.status not in statusStrings:
raise ApiError("Invalid Status")
# only allow the status options we want
if int(self.status) not in (WANTED, SKIPPED, IGNORED):
return _responds(RESULT_FAILURE, msg="Status prohibited")
new_status = self.status
# use default status as a fail-safe
default_ep_status_after = sickbeard.STATUS_DEFAULT_AFTER
if self.future_status:
# convert the string status to a int
for status in statusStrings:
if statusStrings[status].lower() == str(self.future_status).lower():
self.future_status = status
break
if self.future_status not in statusStrings:
raise ApiError("Invalid Status")
# only allow the status options we want
if int(self.future_status) not in (WANTED, SKIPPED, IGNORED):
return _responds(RESULT_FAILURE, msg="Status prohibited")
default_ep_status_after = self.future_status
indexer_name = None
indexer_result = CMDSickBeardSearchIndexers([], {indexer_ids[self.indexer]: self.indexerid, 'lang': self.lang}).run()
if indexer_result[b'result'] == result_type_map[RESULT_SUCCESS]:
if not indexer_result[b'data']['results']:
return _responds(RESULT_FAILURE, msg="Empty results returned, check indexerid and try again")
if len(indexer_result[b'data']['results']) == 1 and 'name' in indexer_result[b'data']['results'][0]:
indexer_name = indexer_result[b'data']['results'][0]['name']
if not indexer_name:
return _responds(RESULT_FAILURE, msg="Unable to retrieve information from indexer")
# set indexer for found show so we can pass it along
indexer = indexer_result[b'data']['results'][0]['indexer']
# moved the logic check to the end in an attempt to eliminate empty directory being created from previous errors
show_path = ek(os.path.join, self.location, sanitize_filename(indexer_name))
# don't create show dir if config says not to
if sickbeard.ADD_SHOWS_WO_DIR:
logger.log("Skipping initial creation of " + show_path + " due to config.ini setting")
else:
dir_exists = helpers.makeDir(show_path)
if not dir_exists:
logger.log("API :: Unable to create the folder " + show_path + ", can't add the show", logger.ERROR)
return _responds(RESULT_FAILURE, {"path": show_path},
"Unable to create the folder " + show_path + ", can't add the show")
else:
helpers.chmodAsParent(show_path)
sickbeard.showQueueScheduler.action.add_show(
int(indexer), int(self.indexerid), show_path, default_status=new_status,
quality=new_quality, season_folders=int(self.season_folders),
lang=self.lang, subtitles=self.subtitles, anime=self.anime,
scene=self.scene, default_status_after=default_ep_status_after
)
return _responds(RESULT_SUCCESS, {"name": indexer_name}, indexer_name + " has been queued to be added")
# noinspection PyAbstractClass
class CMDShowCache(ApiCall):
_help = {
"desc": "Check SickChill's cache to see if the images (poster, banner, fanart) for a show are valid",
"requiredParameters": {
"indexerid": {"desc": "Unique ID of a show"},
},
"optionalParameters": {
"tvdbid": {"desc": "thetvdb.com unique ID of a show"},
}
}
def __init__(self, args, kwargs):
super(CMDShowCache, self).__init__(args, kwargs)
self.indexerid, args = self.check_params(args, kwargs, "indexerid", None, True, "int", [])
def run(self):
""" Check SickChill's cache to see if the images (poster, banner, fanart) for a show are valid """
show_obj = Show.find(sickbeard.showList, int(self.indexerid))
if not show_obj:
return _responds(RESULT_FAILURE, msg="Show not found")
# TODO: catch if cache dir is missing/invalid.. so it doesn't break show/show.cache
# return {"poster": 0, "banner": 0}
cache_obj = image_cache.ImageCache()
has_poster = 0
has_banner = 0
if ek(os.path.isfile, cache_obj.poster_path(show_obj.indexerid)):
has_poster = 1
if ek(os.path.isfile, cache_obj.banner_path(show_obj.indexerid)):
has_banner = 1
return _responds(RESULT_SUCCESS, {"poster": has_poster, "banner": has_banner})
# noinspection PyAbstractClass
class CMDShowDelete(ApiCall):
_help = {
"desc": "Delete a show in SickChill",
"requiredParameters": {
"indexerid": {"desc": "Unique ID of a show"},
},
"optionalParameters": {
"tvdbid": {"desc": "thetvdb.com unique ID of a show"},
"removefiles": {
"desc": "True to delete the files associated with the show, False otherwise. This can not be undone!"
},
}
}
def __init__(self, args, kwargs):
super(CMDShowDelete, self).__init__(args, kwargs)
self.indexerid, args = self.check_params(args, kwargs, "indexerid", None, True, "int", [])
self.removefiles, args = self.check_params(args, kwargs, "removefiles", False, False, "bool", [])
def run(self):
""" Delete a show in SickChill """
error, show = Show.delete(self.indexerid, self.removefiles)
if error:
return _responds(RESULT_FAILURE, msg=error)
return _responds(RESULT_SUCCESS, msg='{0} has been queued to be deleted'.format(show.name))
# noinspection PyAbstractClass
class CMDShowGetQuality(ApiCall):
_help = {
"desc": "Get the quality setting of a show",
"requiredParameters": {
"indexerid": {"desc": "Unique ID of a show"},
},
"optionalParameters": {
"tvdbid": {"desc": "thetvdb.com unique ID of a show"},
}
}
def __init__(self, args, kwargs):
super(CMDShowGetQuality, self).__init__(args, kwargs)
self.indexerid, args = self.check_params(args, kwargs, "indexerid", None, True, "int", [])
def run(self):
""" Get the quality setting of a show """
show_obj = Show.find(sickbeard.showList, int(self.indexerid))
if not show_obj:
return _responds(RESULT_FAILURE, msg="Show not found")
any_qualities, best_qualities = _map_quality(show_obj.quality)
return _responds(RESULT_SUCCESS, {"initial": any_qualities, "archive": best_qualities})
# noinspection PyAbstractClass
class CMDShowGetPoster(ApiCall):
_help = {
"desc": "Get the poster of a show",
"requiredParameters": {
"indexerid": {"desc": "Unique ID of a show"},
},
"optionalParameters": {
"tvdbid": {"desc": "thetvdb.com unique ID of a show"},
"media_format": {"desc": '"normal" for normal size poster (default), "thumb" for small size poster'},
}
}
def __init__(self, args, kwargs):
super(CMDShowGetPoster, self).__init__(args, kwargs)
self.indexerid, args = self.check_params(args, kwargs, "indexerid", None, True, "int", [])
self.media_format, args = self.check_params(args, kwargs, "media_format", "normal", False, "string", ["normal", "thumb"])
def run(self):
""" Get the poster a show """
return {
'outputType': 'image',
'image': ShowPoster(self.indexerid, self.media_format),
}
# noinspection PyAbstractClass
class CMDShowGetBanner(ApiCall):
_help = {
"desc": "Get the banner of a show",
"requiredParameters": {
"indexerid": {"desc": "Unique ID of a show"},
},
"optionalParameters": {
"tvdbid": {"desc": "thetvdb.com unique ID of a show"},
"media_format": {"desc": '"normal" for normal size banner (default), "thumb" for small size banner'},
}
}
def __init__(self, args, kwargs):
super(CMDShowGetBanner, self).__init__(args, kwargs)
self.indexerid, args = self.check_params(args, kwargs, "indexerid", None, True, "int", [])
self.media_format, args = self.check_params(args, kwargs, "media_format", "normal", False, "string", ["normal", "thumb"])
def run(self):
""" Get the banner of a show """
return {
'outputType': 'image',
'image': ShowBanner(self.indexerid, self.media_format),
}
# noinspection PyAbstractClass
class CMDShowGetNetworkLogo(ApiCall):
_help = {
"desc": "Get the network logo of a show",
"requiredParameters": {
"indexerid": {"desc": "Unique ID of a show"},
},
"optionalParameters": {
"tvdbid": {"desc": "thetvdb.com unique ID of a show"},
}
}
def __init__(self, args, kwargs):
super(CMDShowGetNetworkLogo, self).__init__(args, kwargs)
self.indexerid, args = self.check_params(args, kwargs, "indexerid", None, True, "int", [])
def run(self):
"""
:return: Get the network logo of a show
"""
return {
'outputType': 'image',
'image': ShowNetworkLogo(self.indexerid),
}
# noinspection PyAbstractClass
class CMDShowGetFanArt(ApiCall):
_help = {
"desc": "Get the fan art of a show",
"requiredParameters": {
"indexerid": {"desc": "Unique ID of a show"},
},
"optionalParameters": {
"tvdbid": {"desc": "thetvdb.com unique ID of a show"},
}
}
def __init__(self, args, kwargs):
super(CMDShowGetFanArt, self).__init__(args, kwargs)
self.indexerid, args = self.check_params(args, kwargs, "indexerid", None, True, "int", [])
def run(self):
""" Get the fan art of a show """
return {
'outputType': 'image',
'image': ShowFanArt(self.indexerid),
}
# noinspection PyAbstractClass
class CMDShowPause(ApiCall):
_help = {
"desc": "Pause or un-pause a show",
"requiredParameters": {
"indexerid": {"desc": "Unique ID of a show"},
},
"optionalParameters": {
"tvdbid": {"desc": "thetvdb.com unique ID of a show"},
"pause": {"desc": "True to pause the show, False otherwise"},
}
}
def __init__(self, args, kwargs):
super(CMDShowPause, self).__init__(args, kwargs)
self.indexerid, args = self.check_params(args, kwargs, "indexerid", None, True, "int", [])
self.pause, args = self.check_params(args, kwargs, "pause", False, False, "bool", [])
def run(self):
""" Pause or un-pause a show """
error, show = Show.pause(self.indexerid, self.pause)
if error:
return _responds(RESULT_FAILURE, msg=error)
return _responds(RESULT_SUCCESS, msg='{0} has been {1}'.format(show.name, ('resumed', 'paused')[show.paused]))
# noinspection PyAbstractClass
class CMDShowRefresh(ApiCall):
_help = {
"desc": "Refresh a show in SickChill",
"requiredParameters": {
"indexerid": {"desc": "Unique ID of a show"},
},
"optionalParameters": {
"tvdbid": {"desc": "thetvdb.com unique ID of a show"},
}
}
def __init__(self, args, kwargs):
super(CMDShowRefresh, self).__init__(args, kwargs)
self.indexerid, args = self.check_params(args, kwargs, "indexerid", None, True, "int", [])
def run(self):
""" Refresh a show in SickChill """
error, show = Show.refresh(self.indexerid)
if error:
return _responds(RESULT_FAILURE, msg=error)
return _responds(RESULT_SUCCESS, msg='{0} has queued to be refreshed'.format(show.name))
# noinspection PyAbstractClass
class CMDShowSeasonList(ApiCall):
_help = {
"desc": "Get the list of seasons of a show",
"requiredParameters": {
"indexerid": {"desc": "Unique ID of a show"},
},
"optionalParameters": {
"tvdbid": {"desc": "thetvdb.com unique ID of a show"},
"sort": {"desc": "Return the seasons in ascending or descending order"}
}
}
def __init__(self, args, kwargs):
super(CMDShowSeasonList, self).__init__(args, kwargs)
self.indexerid, args = self.check_params(args, kwargs, "indexerid", None, True, "int", [])
self.sort, args = self.check_params(args, kwargs, "sort", "desc", False, "string", ["asc", "desc"])
def run(self):
""" Get the list of seasons of a show """
show_obj = Show.find(sickbeard.showList, int(self.indexerid))
if not show_obj:
return _responds(RESULT_FAILURE, msg="Show not found")
main_db_con = db.DBConnection(row_type="dict")
if self.sort == "asc":
sql_results = main_db_con.select("SELECT DISTINCT season FROM tv_episodes WHERE showid = ? ORDER BY season ASC",
[self.indexerid])
else:
sql_results = main_db_con.select("SELECT DISTINCT season FROM tv_episodes WHERE showid = ? ORDER BY season DESC",
[self.indexerid])
season_list = [] # a list with all season numbers
for row in sql_results:
season_list.append(int(row[b"season"]))
return _responds(RESULT_SUCCESS, season_list)
# noinspection PyAbstractClass
class CMDShowSeasons(ApiCall):
_help = {
"desc": "Get the list of episodes for one or all seasons of a show",
"requiredParameters": {
"indexerid": {"desc": "Unique ID of a show"},
},
"optionalParameters": {
"tvdbid": {"desc": "thetvdb.com unique ID of a show"},
"season": {"desc": "The season number"},
}
}
def __init__(self, args, kwargs):
super(CMDShowSeasons, self).__init__(args, kwargs)
self.indexerid, args = self.check_params(args, kwargs, "indexerid", None, True, "int", [])
self.season, args = self.check_params(args, kwargs, "season", None, False, "int", [])
def run(self):
""" Get the list of episodes for one or all seasons of a show """
sho_obj = Show.find(sickbeard.showList, int(self.indexerid))
if not sho_obj:
return _responds(RESULT_FAILURE, msg="Show not found")
main_db_con = db.DBConnection(row_type="dict")
if self.season is None:
sql_results = main_db_con.select(
"SELECT name, episode, airdate, status, release_name, season, location, file_size, subtitles FROM tv_episodes WHERE showid = ?",
[self.indexerid])
seasons = {}
for row in sql_results:
status, quality = Quality.splitCompositeStatus(int(row[b"status"]))
row[b"status"] = _get_status_strings(status)
row[b"quality"] = get_quality_string(quality)
if try_int(row[b'airdate'], 1) > 693595: # 1900
dt_episode_airs = sbdatetime.sbdatetime.convert_to_setting(
network_timezones.parse_date_time(row[b'airdate'], sho_obj.airs, sho_obj.network))
row[b'airdate'] = sbdatetime.sbdatetime.sbfdate(dt_episode_airs, d_preset=dateFormat)
else:
row[b'airdate'] = 'Never'
cur_season = int(row[b"season"])
cur_episode = int(row[b"episode"])
del row[b"season"]
del row[b"episode"]
if cur_season not in seasons:
seasons[cur_season] = {}
seasons[cur_season][cur_episode] = row
else:
sql_results = main_db_con.select(
"SELECT name, episode, airdate, status, location, file_size, release_name, subtitles FROM tv_episodes WHERE showid = ? AND season = ?",
[self.indexerid, self.season])
if not sql_results:
return _responds(RESULT_FAILURE, msg="Season not found")
seasons = {}
for row in sql_results:
cur_episode = int(row[b"episode"])
del row[b"episode"]
status, quality = Quality.splitCompositeStatus(int(row[b"status"]))
row[b"status"] = _get_status_strings(status)
row[b"quality"] = get_quality_string(quality)
if try_int(row[b'airdate'], 1) > 693595: # 1900
dt_episode_airs = sbdatetime.sbdatetime.convert_to_setting(
network_timezones.parse_date_time(row[b'airdate'], sho_obj.airs, sho_obj.network))
row[b'airdate'] = sbdatetime.sbdatetime.sbfdate(dt_episode_airs, d_preset=dateFormat)
else:
row[b'airdate'] = 'Never'
if cur_episode not in seasons:
seasons[cur_episode] = {}
seasons[cur_episode] = row
return _responds(RESULT_SUCCESS, seasons)
# noinspection PyAbstractClass
class CMDShowSetQuality(ApiCall):
_help = {
"desc": "Set the quality setting of a show. If no quality is provided, the default user setting is used.",
"requiredParameters": {
"indexerid": {"desc": "Unique ID of a show"},
},
"optionalParameters": {
"tvdbid": {"desc": "thetvdb.com unique ID of a show"},
"initial": {"desc": "The initial quality of the show"},
"archive": {"desc": "The archive quality of the show"},
}
}
def __init__(self, args, kwargs):
super(CMDShowSetQuality, self).__init__(args, kwargs)
self.indexerid, args = self.check_params(args, kwargs, "indexerid", None, True, "int", [])
self.initial, args = self.check_params(args, kwargs, "initial", [], False, "list", ALLOWED_QUALITY_LIST)
self.archive, args = self.check_params(args, kwargs, "archive", [], False, "list", PREFERRED_QUALITY_LIST)
def run(self):
""" Set the quality setting of a show. If no quality is provided, the default user setting is used. """
show_obj = Show.find(sickbeard.showList, int(self.indexerid))
if not show_obj:
return _responds(RESULT_FAILURE, msg="Show not found")
# use default quality as a fail-safe
new_quality = int(sickbeard.QUALITY_DEFAULT)
i_quality_id = []
a_quality_id = []
if self.initial:
# noinspection PyTypeChecker
for quality in self.initial:
i_quality_id.append(QUALITY_MAP[quality])
if self.archive:
# noinspection PyTypeChecker
for quality in self.archive:
a_quality_id.append(QUALITY_MAP[quality])
if i_quality_id or a_quality_id:
new_quality = Quality.combineQualities(i_quality_id, a_quality_id)
show_obj.quality = new_quality
return _responds(RESULT_SUCCESS,
msg=show_obj.name + " quality has been changed to " + get_quality_string(show_obj.quality))
# noinspection PyAbstractClass
class CMDShowStats(ApiCall):
_help = {
"desc": "Get episode statistics for a given show",
"requiredParameters": {
"indexerid": {"desc": "Unique ID of a show"},
},
"optionalParameters": {
"tvdbid": {"desc": "thetvdb.com unique ID of a show"},
}
}
def __init__(self, args, kwargs):
super(CMDShowStats, self).__init__(args, kwargs)
self.indexerid, args = self.check_params(args, kwargs, "indexerid", None, True, "int", [])
def run(self):
""" Get episode statistics for a given show """
show_obj = Show.find(sickbeard.showList, int(self.indexerid))
if not show_obj:
return _responds(RESULT_FAILURE, msg="Show not found")
# show stats
episode_status_counts_total = {"total": 0}
for status in statusStrings:
if status in [UNKNOWN, DOWNLOADED, SNATCHED, SNATCHED_PROPER, ARCHIVED]:
continue
episode_status_counts_total[status] = 0
# add all the downloaded qualities
episode_qualities_counts_download = {"total": 0}
for statusCode in Quality.DOWNLOADED + Quality.ARCHIVED:
status, quality = Quality.splitCompositeStatus(statusCode)
if quality in [Quality.NONE]:
continue
episode_qualities_counts_download[statusCode] = 0
# add all snatched qualities
episode_qualities_counts_snatch = {"total": 0}
for statusCode in Quality.SNATCHED + Quality.SNATCHED_PROPER:
status, quality = Quality.splitCompositeStatus(statusCode)
if quality in [Quality.NONE]:
continue
episode_qualities_counts_snatch[statusCode] = 0
main_db_con = db.DBConnection(row_type="dict")
sql_results = main_db_con.select("SELECT status, season FROM tv_episodes WHERE season != 0 AND showid = ?",
[self.indexerid])
# the main loop that goes through all episodes
for row in sql_results:
status, quality = Quality.splitCompositeStatus(int(row[b"status"]))
episode_status_counts_total["total"] += 1
if status in Quality.DOWNLOADED + Quality.ARCHIVED:
episode_qualities_counts_download["total"] += 1
# noinspection PyTypeChecker
episode_qualities_counts_download[int(row[b"status"])] += 1
elif status in Quality.SNATCHED + Quality.SNATCHED_PROPER:
episode_qualities_counts_snatch["total"] += 1
# noinspection PyTypeChecker
episode_qualities_counts_snatch[int(row[b"status"])] += 1
elif status > 0: # we don't count NONE = 0 = N/A
episode_status_counts_total[status] += 1
# the outgoing container
episodes_stats = {"downloaded": {}}
# turning codes into strings
for statusCode in episode_qualities_counts_download:
if statusCode == "total":
episodes_stats["downloaded"]["total"] = episode_qualities_counts_download[statusCode]
continue
status, quality = Quality.splitCompositeStatus(int(statusCode))
status_string = Quality.qualityStrings[quality].lower().replace(" ", "_").replace("(", "").replace(")", "")
episodes_stats["downloaded"][status_string] = episode_qualities_counts_download[statusCode]
episodes_stats["snatched"] = {}
# turning codes into strings
# and combining proper and normal
for statusCode in episode_qualities_counts_snatch:
if statusCode == "total":
episodes_stats["snatched"]["total"] = episode_qualities_counts_snatch[statusCode]
continue
status, quality = Quality.splitCompositeStatus(int(statusCode))
status_string = Quality.qualityStrings[quality].lower().replace(" ", "_").replace("(", "").replace(")", "")
if Quality.qualityStrings[quality] in episodes_stats["snatched"]:
episodes_stats["snatched"][status_string] += episode_qualities_counts_snatch[statusCode]
else:
episodes_stats["snatched"][status_string] = episode_qualities_counts_snatch[statusCode]
for statusCode in episode_status_counts_total:
if statusCode == "total":
episodes_stats["total"] = episode_status_counts_total[statusCode]
continue
# status, quality = Quality.splitCompositeStatus(int(statusCode))
status_string = statusStrings[statusCode].lower().replace(" ", "_").replace("(", "").replace(
")", "")
episodes_stats[status_string] = episode_status_counts_total[statusCode]
return _responds(RESULT_SUCCESS, episodes_stats)
# noinspection PyAbstractClass
class CMDShowUpdate(ApiCall):
_help = {
"desc": "Update a show in SickChill",
"requiredParameters": {
"indexerid": {"desc": "Unique ID of a show"},
},
"optionalParameters": {
"tvdbid": {"desc": "thetvdb.com unique ID of a show"},
}
}
def __init__(self, args, kwargs):
super(CMDShowUpdate, self).__init__(args, kwargs)
self.indexerid, args = self.check_params(args, kwargs, "indexerid", None, True, "int", [])
def run(self):
""" Update a show in SickChill """
show_obj = Show.find(sickbeard.showList, int(self.indexerid))
if not show_obj:
return _responds(RESULT_FAILURE, msg="Show not found")
try:
sickbeard.showQueueScheduler.action.update_show(show_obj, True) # @UndefinedVariable
return _responds(RESULT_SUCCESS, msg=str(show_obj.name) + " has queued to be updated")
except CantUpdateShowException as e:
logger.log("API::Unable to update show: {0}".format(e), logger.DEBUG)
return _responds(RESULT_FAILURE, msg="Unable to update " + str(show_obj.name))
# noinspection PyAbstractClass
class CMDShows(ApiCall):
_help = {
"desc": "Get all shows in SickChill",
"optionalParameters": {
"sort": {"desc": "The sorting strategy to apply to the list of shows"},
"paused": {"desc": "True: show paused, False: show un-paused, otherwise show all"},
},
}
def __init__(self, args, kwargs):
super(CMDShows, self).__init__(args, kwargs)
self.sort, args = self.check_params(args, kwargs, "sort", "id", False, "string", ["id", "name"])
self.paused, args = self.check_params(args, kwargs, "paused", None, False, "bool", [])
def run(self):
""" Get all shows in SickChill """
shows = {}
for curShow in sickbeard.showList:
# If self.paused is None: show all, 0: show un-paused, 1: show paused
if self.paused is not None and self.paused != curShow.paused:
continue
show_dict = {
"paused": (0, 1)[curShow.paused],
"quality": get_quality_string(curShow.quality),
"language": curShow.lang,
"air_by_date": (0, 1)[curShow.air_by_date],
"sports": (0, 1)[curShow.sports],
"anime": (0, 1)[curShow.anime],
"indexerid": curShow.indexerid,
"tvdbid": curShow.indexerid,
"network": curShow.network,
"show_name": curShow.name,
"status": curShow.status,
"subtitles": (0, 1)[curShow.subtitles],
}
if try_int(curShow.nextaired, 1) > 693595: # 1900
dt_episode_airs = sbdatetime.sbdatetime.convert_to_setting(
network_timezones.parse_date_time(curShow.nextaired, curShow.airs, show_dict['network']))
show_dict['next_ep_airdate'] = sbdatetime.sbdatetime.sbfdate(dt_episode_airs, d_preset=dateFormat)
else:
show_dict['next_ep_airdate'] = ''
show_dict["cache"] = CMDShowCache((), {"indexerid": curShow.indexerid}).run()["data"]
if not show_dict["network"]:
show_dict["network"] = ""
if self.sort == "name":
shows[curShow.name] = show_dict
else:
shows[curShow.indexerid] = show_dict
return _responds(RESULT_SUCCESS, shows)
# noinspection PyAbstractClass
class CMDShowsStats(ApiCall):
_help = {"desc": "Get the global shows and episodes statistics"}
def __init__(self, args, kwargs):
super(CMDShowsStats, self).__init__(args, kwargs)
def run(self):
""" Get the global shows and episodes statistics """
stats = Show.overall_stats()
return _responds(RESULT_SUCCESS, {
'ep_downloaded': stats['episodes']['downloaded'],
'ep_snatched': stats['episodes']['snatched'],
'ep_total': stats['episodes']['total'],
'shows_active': stats['shows']['active'],
'shows_total': stats['shows']['total'],
})
# WARNING: never define a cmd call string that contains a "_" (underscore)
# this is reserved for cmd indexes used while cmd chaining
# WARNING: never define a param name that contains a "." (dot)
# this is reserved for cmd namespaces used while cmd chaining
function_mapper = {
"help": CMDHelp,
"future": CMDComingEpisodes,
"episode": CMDEpisode,
"episode.search": CMDEpisodeSearch,
"episode.setstatus": CMDEpisodeSetStatus,
"episode.subtitlesearch": CMDSubtitleSearch,
"exceptions": CMDExceptions,
"history": CMDHistory,
"history.clear": CMDHistoryClear,
"history.trim": CMDHistoryTrim,
"failed": CMDFailed,
"backlog": CMDBacklog,
"logs": CMDLogs,
"logs.clear": CMDLogsClear,
"sb": CMDSickBeard,
"postprocess": CMDPostProcess,
"sb.addrootdir": CMDSickBeardAddRootDir,
"sb.checkversion": CMDSickBeardCheckVersion,
"sb.checkscheduler": CMDSickBeardCheckScheduler,
"sb.deleterootdir": CMDSickBeardDeleteRootDir,
"sb.getdefaults": CMDSickBeardGetDefaults,
"sb.getmessages": CMDSickBeardGetMessages,
"sb.getrootdirs": CMDSickBeardGetRootDirs,
"sb.pausebacklog": CMDSickBeardPauseBacklog,
"sb.ping": CMDSickBeardPing,
"sb.restart": CMDSickBeardRestart,
"sb.dailysearch": CMDDailySearch,
"sb.propersearch": CMDProperSearch,
"sb.subtitlesearch": CMDFullSubtitleSearch,
"sb.searchindexers": CMDSickBeardSearchIndexers,
"sb.searchtvdb": CMDSickBeardSearchTVDB,
"sb.searchtvrage": CMDSickBeardSearchTVRAGE,
"sb.setdefaults": CMDSickBeardSetDefaults,
"sb.update": CMDSickBeardUpdate,
"sb.shutdown": CMDSickBeardShutdown,
"show": CMDShow,
"show.addexisting": CMDShowAddExisting,
"show.addnew": CMDShowAddNew,
"show.cache": CMDShowCache,
"show.delete": CMDShowDelete,
"show.getquality": CMDShowGetQuality,
"show.getposter": CMDShowGetPoster,
"show.getbanner": CMDShowGetBanner,
"show.getnetworklogo": CMDShowGetNetworkLogo,
"show.getfanart": CMDShowGetFanArt,
"show.pause": CMDShowPause,
"show.refresh": CMDShowRefresh,
"show.seasonlist": CMDShowSeasonList,
"show.seasons": CMDShowSeasons,
"show.setquality": CMDShowSetQuality,
"show.stats": CMDShowStats,
"show.update": CMDShowUpdate,
"shows": CMDShows,
"shows.stats": CMDShowsStats
}
| coderbone/SickRage-alt | sickchill/views/api/webapi.py | Python | gpl-3.0 | 118,111 | 0.002879 |
from math import sqrt
def sq_dist(p, q):
return((p[0] - q[0])**2 + (p[1] - q[1])**2)
def linear_search(points, query):
sqd = float("inf")
for point in points:
d = sq_dist(point, query)
if d < sqd:
nearest = point
sqd = d
return(nearest, sqd)
point_list = [(2, 3), (5, 4), (9, 6), (4, 7), (8, 1), (7, 2)]
n = linear_search(point_list, (9, 2))
print('nearest:', n[0], 'dist:', sqrt(n[1]))
# nearest: (8, 1) dist: 1.4142135623730951
| o-kei/design-computing-aij | ch4_1/nearest_liner.py | Python | mit | 491 | 0.002037 |
"""
Tests for manager.py
"""
from nose.plugins.attrib import attr
from unittest import TestCase
from ..block_structure import BlockStructureBlockData
from ..exceptions import UsageKeyNotInBlockStructure
from ..manager import BlockStructureManager
from ..transformers import BlockStructureTransformers
from .helpers import (
MockModulestoreFactory, MockCache, MockTransformer, ChildrenMapTestMixin, mock_registered_transformers
)
class TestTransformer1(MockTransformer):
"""
Test Transformer class with basic functionality to verify collected and
transformed data.
"""
collect_data_key = 't1.collect'
transform_data_key = 't1.transform'
collect_call_count = 0
@classmethod
def collect(cls, block_structure):
"""
Collects block data for the block structure.
"""
cls._set_block_values(block_structure, cls.collect_data_key)
cls.collect_call_count += 1
def transform(self, usage_info, block_structure):
"""
Transforms the block structure.
"""
self._set_block_values(block_structure, self.transform_data_key)
@classmethod
def assert_collected(cls, block_structure):
"""
Asserts data was collected for the block structure.
"""
cls._assert_block_values(block_structure, cls.collect_data_key)
@classmethod
def assert_transformed(cls, block_structure):
"""
Asserts the block structure was transformed.
"""
cls._assert_block_values(block_structure, cls.transform_data_key)
@classmethod
def _set_block_values(cls, block_structure, data_key):
"""
Sets a value for each block in the given structure, using the given
data key.
"""
for block_key in block_structure.topological_traversal():
block_structure.set_transformer_block_field(
block_key, cls, data_key, cls._create_block_value(block_key, data_key)
)
@classmethod
def _assert_block_values(cls, block_structure, data_key):
"""
Verifies the value for each block in the given structure, for the given
data key.
"""
for block_key in block_structure.topological_traversal():
assert (
block_structure.get_transformer_block_field(
block_key,
cls,
data_key,
) == cls._create_block_value(block_key, data_key)
)
@classmethod
def _create_block_value(cls, block_key, data_key):
"""
Returns a unique deterministic value for the given block key
and data key.
"""
return data_key + 't1.val1.' + unicode(block_key)
@attr('shard_2')
class TestBlockStructureManager(TestCase, ChildrenMapTestMixin):
"""
Test class for BlockStructureManager.
"""
def setUp(self):
super(TestBlockStructureManager, self).setUp()
TestTransformer1.collect_call_count = 0
self.registered_transformers = [TestTransformer1()]
with mock_registered_transformers(self.registered_transformers):
self.transformers = BlockStructureTransformers(self.registered_transformers)
self.children_map = self.SIMPLE_CHILDREN_MAP
self.modulestore = MockModulestoreFactory.create(self.children_map)
self.cache = MockCache()
self.bs_manager = BlockStructureManager(
root_block_usage_key=0,
modulestore=self.modulestore,
cache=self.cache,
)
def collect_and_verify(self, expect_modulestore_called, expect_cache_updated):
"""
Calls the manager's get_collected method and verifies its result
and behavior.
"""
self.modulestore.get_items_call_count = 0
self.cache.set_call_count = 0
with mock_registered_transformers(self.registered_transformers):
block_structure = self.bs_manager.get_collected()
self.assert_block_structure(block_structure, self.children_map)
TestTransformer1.assert_collected(block_structure)
if expect_modulestore_called:
self.assertGreater(self.modulestore.get_items_call_count, 0)
else:
self.assertEquals(self.modulestore.get_items_call_count, 0)
self.assertEquals(self.cache.set_call_count, 1 if expect_cache_updated else 0)
def test_get_transformed(self):
with mock_registered_transformers(self.registered_transformers):
block_structure = self.bs_manager.get_transformed(self.transformers)
self.assert_block_structure(block_structure, self.children_map)
TestTransformer1.assert_collected(block_structure)
TestTransformer1.assert_transformed(block_structure)
def test_get_transformed_with_starting_block(self):
with mock_registered_transformers(self.registered_transformers):
block_structure = self.bs_manager.get_transformed(self.transformers, starting_block_usage_key=1)
substructure_of_children_map = [[], [3, 4], [], [], []]
self.assert_block_structure(block_structure, substructure_of_children_map, missing_blocks=[0, 2])
TestTransformer1.assert_collected(block_structure)
TestTransformer1.assert_transformed(block_structure)
def test_get_transformed_with_nonexistent_starting_block(self):
with mock_registered_transformers(self.registered_transformers):
with self.assertRaises(UsageKeyNotInBlockStructure):
self.bs_manager.get_transformed(self.transformers, starting_block_usage_key=100)
def test_get_collected_cached(self):
self.collect_and_verify(expect_modulestore_called=True, expect_cache_updated=True)
self.collect_and_verify(expect_modulestore_called=False, expect_cache_updated=False)
self.assertEquals(TestTransformer1.collect_call_count, 1)
def test_get_collected_outdated_data(self):
self.collect_and_verify(expect_modulestore_called=True, expect_cache_updated=True)
TestTransformer1.VERSION += 1
self.collect_and_verify(expect_modulestore_called=True, expect_cache_updated=True)
self.assertEquals(TestTransformer1.collect_call_count, 2)
def test_get_collected_version_update(self):
self.collect_and_verify(expect_modulestore_called=True, expect_cache_updated=True)
BlockStructureBlockData.VERSION += 1
self.collect_and_verify(expect_modulestore_called=True, expect_cache_updated=True)
self.assertEquals(TestTransformer1.collect_call_count, 2)
def test_clear(self):
self.collect_and_verify(expect_modulestore_called=True, expect_cache_updated=True)
self.bs_manager.clear()
self.collect_and_verify(expect_modulestore_called=True, expect_cache_updated=True)
self.assertEquals(TestTransformer1.collect_call_count, 2)
| Learningtribes/edx-platform | openedx/core/lib/block_structure/tests/test_manager.py | Python | agpl-3.0 | 6,900 | 0.002464 |
import UserDict
import copy
import grokcore.component as grok
import sys
import zeit.cms.content.sources
import zeit.content.image.interfaces
import zeit.edit.body
import zope.schema
class Variants(grok.Adapter, UserDict.DictMixin):
grok.context(zeit.content.image.interfaces.IImageGroup)
grok.implements(zeit.content.image.interfaces.IVariants)
def __init__(self, context):
super(Variants, self).__init__(context)
self.__parent__ = context
def __getitem__(self, key):
"""Retrieve Variant for JSON Requests"""
if key in self.context.variants:
variant = Variant(id=key, **self.context.variants[key])
config = VARIANT_SOURCE.factory.find(self.context, key)
self._copy_missing_fields(config, variant)
else:
variant = VARIANT_SOURCE.factory.find(self.context, key)
if not variant.is_default:
self._copy_missing_fields(self.default_variant, variant)
variant.__parent__ = self
return variant
def _copy_missing_fields(self, source, target):
for key in zope.schema.getFieldNames(
zeit.content.image.interfaces.IVariant):
if hasattr(target, key) and getattr(target, key) is not None:
continue
if hasattr(source, key):
setattr(target, key, getattr(source, key))
def keys(self):
keys = [x.id for x in VARIANT_SOURCE(self.context)]
for key in self.context.variants.keys():
if key not in keys:
keys.append(key)
return keys
@property
def default_variant(self):
if Variant.DEFAULT_NAME in self.context.variants:
default = self[Variant.DEFAULT_NAME]
else:
default = VARIANT_SOURCE.factory.find(
self.context, Variant.DEFAULT_NAME)
return default
class Variant(object):
DEFAULT_NAME = 'default'
interface = zeit.content.image.interfaces.IVariant
grok.implements(interface)
max_size = None
legacy_name = None
aspect_ratio = None
def __init__(self, **kw):
"""Set attributes that are part of the Schema and convert their type"""
fields = zope.schema.getFields(self.interface)
for key, value in kw.items():
if key not in fields:
continue # ignore attributes that aren't part of the schema
value = fields[key].fromUnicode(unicode(value))
setattr(self, key, value)
@property
def ratio(self):
if self.is_default:
image = zeit.content.image.interfaces.IMasterImage(
zeit.content.image.interfaces.IImageGroup(self))
xratio, yratio = image.getImageSize()
return float(xratio) / float(yratio)
if self.aspect_ratio is None:
return None
xratio, yratio = self.aspect_ratio.split(':')
return float(xratio) / float(yratio)
@property
def max_width(self):
if self.max_size is None:
return sys.maxint
width, height = self.max_size.split('x')
return int(width)
@property
def max_height(self):
if self.max_size is None:
return sys.maxint
width, height = self.max_size.split('x')
return int(height)
@property
def is_default(self):
return self.id == self.DEFAULT_NAME
@property
def relative_image_path(self):
if self.is_default:
thumbnails = zeit.content.image.interfaces.IThumbnails(
zeit.content.image.interfaces.IImageGroup(self))
return thumbnails.source_image.__name__
if self.max_size is None:
return '%s/%s' % (
zeit.content.image.imagegroup.Thumbnails.NAME, self.name)
return '{}/{}__{}'.format(
zeit.content.image.imagegroup.Thumbnails.NAME,
self.name, self.max_size)
class VariantSource(zeit.cms.content.sources.XMLSource):
product_configuration = 'zeit.content.image'
config_url = 'variant-source'
def getTitle(self, context, value):
return value.id
def getToken(self, context, value):
return value.id
def getValues(self, context):
tree = self._get_tree()
result = []
for node in tree.iterchildren('*'):
if not self.isAvailable(node, context):
continue
sizes = list(node.iterchildren('size'))
if not sizes:
# If there are no children, create a Variant from parent node
attributes = dict(node.attrib)
attributes['id'] = attributes['name']
result.append(Variant(**attributes))
for size in sizes:
# Create Variant for each given size
result.append(Variant(**self._merge_attributes(
node.attrib, size.attrib)))
return result
def find(self, context, id):
for value in self.getValues(context):
if value.id == id:
return value
raise KeyError(id)
def _merge_attributes(self, parent_attr, child_attr):
"""Merge attributes from parent with those from child.
Attributes from child are more specific and therefore may overwrite
attributes from parent. Create the child `id` via concatenation, since
it should be unique among variants and respects the parent / child
hierarchy.
"""
result = copy.copy(parent_attr)
result.update(child_attr)
if 'name' in parent_attr and 'id' in child_attr:
result['id'] = '{}-{}'.format(
parent_attr['name'], child_attr['id'])
return result
VARIANT_SOURCE = VariantSource()
class VariantsTraverser(zeit.edit.body.Traverser):
grok.context(zeit.content.image.interfaces.IRepositoryImageGroup)
body_name = 'variants'
body_interface = zeit.content.image.interfaces.IVariants
@grok.adapter(zeit.content.image.interfaces.IVariants)
@grok.implementer(zeit.content.image.interfaces.IImageGroup)
def imagegroup_for_variants(context):
return zeit.content.image.interfaces.IImageGroup(context.__parent__)
@grok.adapter(zeit.content.image.interfaces.IVariant)
@grok.implementer(zeit.content.image.interfaces.IImageGroup)
def imagegroup_for_variant(context):
return zeit.content.image.interfaces.IImageGroup(context.__parent__)
class LegacyVariantSource(zeit.cms.content.sources.XMLSource):
product_configuration = 'zeit.content.image'
config_url = 'legacy-variant-source'
def getValues(self, context):
tree = self._get_tree()
result = []
for node in tree.iterchildren('*'):
result.append({'old': node.get('old'), 'new': node.get('new')})
return result
LEGACY_VARIANT_SOURCE = LegacyVariantSource()
| cutoffthetop/zeit.content.image | src/zeit/content/image/variant.py | Python | bsd-3-clause | 6,899 | 0.00029 |
# coding: utf-8
from __future__ import unicode_literals
from .common import InfoExtractor
from ..utils import (
ExtractorError,
int_or_none,
update_url_query,
)
class NaverIE(InfoExtractor):
_VALID_URL = r'https?://(?:m\.)?tv(?:cast)?\.naver\.com/v/(?P<id>\d+)'
_TESTS = [{
'url': 'http://tv.naver.com/v/81652',
'info_dict': {
'id': '81652',
'ext': 'mp4',
'title': '[9월 모의고사 해설강의][수학_김상희] 수학 A형 16~20번',
'description': '합격불변의 법칙 메가스터디 | 메가스터디 수학 김상희 선생님이 9월 모의고사 수학A형 16번에서 20번까지 해설강의를 공개합니다.',
'upload_date': '20130903',
},
}, {
'url': 'http://tv.naver.com/v/395837',
'md5': '638ed4c12012c458fefcddfd01f173cd',
'info_dict': {
'id': '395837',
'ext': 'mp4',
'title': '9년이 지나도 아픈 기억, 전효성의 아버지',
'description': 'md5:5bf200dcbf4b66eb1b350d1eb9c753f7',
'upload_date': '20150519',
},
'skip': 'Georestricted',
}, {
'url': 'http://tvcast.naver.com/v/81652',
'only_matching': True,
}]
def _real_extract(self, url):
video_id = self._match_id(url)
webpage = self._download_webpage(url, video_id)
vid = self._search_regex(
r'videoId["\']\s*:\s*(["\'])(?P<value>(?:(?!\1).)+)\1', webpage,
'video id', fatal=None, group='value')
in_key = self._search_regex(
r'inKey["\']\s*:\s*(["\'])(?P<value>(?:(?!\1).)+)\1', webpage,
'key', default=None, group='value')
if not vid or not in_key:
error = self._html_search_regex(
r'(?s)<div class="(?:nation_error|nation_box|error_box)">\s*(?:<!--.*?-->)?\s*<p class="[^"]+">(?P<msg>.+?)</p>\s*</div>',
webpage, 'error', default=None)
if error:
raise ExtractorError(error, expected=True)
raise ExtractorError('couldn\'t extract vid and key')
video_data = self._download_json(
'http://play.rmcnmv.naver.com/vod/play/v2.0/' + vid,
video_id, query={
'key': in_key,
})
meta = video_data['meta']
title = meta['subject']
formats = []
def extract_formats(streams, stream_type, query={}):
for stream in streams:
stream_url = stream.get('source')
if not stream_url:
continue
stream_url = update_url_query(stream_url, query)
encoding_option = stream.get('encodingOption', {})
bitrate = stream.get('bitrate', {})
formats.append({
'format_id': '%s_%s' % (stream.get('type') or stream_type, encoding_option.get('id') or encoding_option.get('name')),
'url': stream_url,
'width': int_or_none(encoding_option.get('width')),
'height': int_or_none(encoding_option.get('height')),
'vbr': int_or_none(bitrate.get('video')),
'abr': int_or_none(bitrate.get('audio')),
'filesize': int_or_none(stream.get('size')),
'protocol': 'm3u8_native' if stream_type == 'HLS' else None,
})
extract_formats(video_data.get('videos', {}).get('list', []), 'H264')
for stream_set in video_data.get('streams', []):
query = {}
for param in stream_set.get('keys', []):
query[param['name']] = param['value']
stream_type = stream_set.get('type')
videos = stream_set.get('videos')
if videos:
extract_formats(videos, stream_type, query)
elif stream_type == 'HLS':
stream_url = stream_set.get('source')
if not stream_url:
continue
formats.extend(self._extract_m3u8_formats(
update_url_query(stream_url, query), video_id,
'mp4', 'm3u8_native', m3u8_id=stream_type, fatal=False))
self._sort_formats(formats)
subtitles = {}
for caption in video_data.get('captions', {}).get('list', []):
caption_url = caption.get('source')
if not caption_url:
continue
subtitles.setdefault(caption.get('language') or caption.get('locale'), []).append({
'url': caption_url,
})
upload_date = self._search_regex(
r'<span[^>]+class="date".*?(\d{4}\.\d{2}\.\d{2})',
webpage, 'upload date', fatal=False)
if upload_date:
upload_date = upload_date.replace('.', '')
return {
'id': video_id,
'title': title,
'formats': formats,
'subtitles': subtitles,
'description': self._og_search_description(webpage),
'thumbnail': meta.get('cover', {}).get('source') or self._og_search_thumbnail(webpage),
'view_count': int_or_none(meta.get('count')),
'upload_date': upload_date,
}
| epitron/youtube-dl | youtube_dl/extractor/naver.py | Python | unlicense | 5,293 | 0.001171 |
"""
Django settings for voks project.
Generated by 'django-admin startproject' using Django 1.11.
For more information on this file, see
https://docs.djangoproject.com/en/1.11/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/1.11/ref/settings/
"""
import os
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.11/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
#SECRET_KEY = ''
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True
ALLOWED_HOSTS = ['127.0.0.1']
# Application definition
INSTALLED_APPS = [
'blockchain.apps.BlockchainConfig',
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'rest_framework',
'graphene_django'
]
REST_FRAMEWORK = {
'DEFAULT_PERMISSION_CLASSES': [
# 'rest_framework.permissions.IsAdminUser',
],
# 'PAGE_SIZE': 2
}
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
ROOT_URLCONF = 'voks.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
WSGI_APPLICATION = 'voks.wsgi.application'
# Database
# https://docs.djangoproject.com/en/1.11/ref/settings/#databases
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
}
}
# Password validation
# https://docs.djangoproject.com/en/1.11/ref/settings/#auth-password-validators
AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
# Internationalization
# https://docs.djangoproject.com/en/1.11/topics/i18n/
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.11/howto/static-files/
STATIC_URL = '/static/'
STATIC_ROOT = 'static/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'uploads/')
MEDIA_URL = "/uploads/"
GRAPHENE = {
'SCHEMA': 'blockchain.schema.schema'
} | ExsonumChain/ProtoServer | voks/settings.py | Python | mit | 3,423 | 0.001753 |
from PIL import Image
from PIL import ImageDraw
from PIL import ImageChops
import random
def message_transition(func):
func.is_message_transition = True
func.is_display_transition = False
def display_transition(func):
func.is_message_transition = False
func.is_display_transition = True
def FlashStarsTransition(current_state,desired_state):
"""
This transition function flashes all asterisks, then blanks, then asterisks, then the desired message.
:param current_state: the current state of the display - again ignored by this function
:param desired_state: the desired display state
:return: a list containing the display states to be passed through
"""
assert type(current_state) == list
num_lines = len(current_state)
num_chars = len(current_state[0])
return [['*'*num_chars]*num_lines, [' '*num_chars]*num_lines, ['*'*num_chars]*num_lines, desired_state]
message_transition(FlashStarsTransition)
def SimpleTransition(current_state,desired_state):
"""
The simplest possible transition -- go to the desired state directly with no fancy stuff.
:param current_state: the current display state -- ignored by this function but included for consistency with other
transition functions.
:param desired_state: the desired display state
:return: in this case, just a single-element list containing the desired state
"""
return [desired_state]
display_transition(SimpleTransition)
def center_wipe(currentstate, desiredstate):
"""
Transition function that wipes from currentstate to desiredstate out from the center in both directions.
:param currentstate: a PIL image object representing the current display state
:param desiredstate: a PIL image object representing the eventual desired display state
:return: a list of PIL image objects representing a transition of display states to get from current to desired
"""
assert isinstance(currentstate, Image.Image)
assert isinstance(desiredstate, Image.Image)
assert currentstate.size == desiredstate.size
# initialize list for transition
output = []
# set initial columns for wipe (possibly same if odd number of pixels)
if desiredstate.size[0] % 2 == 0: # if the number of columns of pixels is even
# set the right and left columns as the middle ones - assuming the indices start at 0
left_column = desiredstate.size[0] / 2 - 1
right_column = desiredstate.size[0] / 2
else: # if the number of columns of pixels is odd
left_column = desiredstate.size[0] / 2 - 0.5
right_column = left_column
# iterate until the wipe has passed the edge
while left_column >= -1:
# create a mask with the right amount of interior area transparent
# note - Image.composite(image1, image2, mask) yields image1 where mask is 1 and image2 where mask is 0
image_mask = Image.new('1',desiredstate.size,1)
ImageDraw.Draw(image_mask).rectangle([left_column, 0, right_column, desiredstate.size[1]-1], fill=0)
# composite the initial image with the desired state using the layer mask
composite = Image.composite(currentstate, desiredstate, image_mask)
# draw vertical lines of all white to create the line doing the wiping
draw = ImageDraw.Draw(composite)
draw.line(xy=[left_column, 0, left_column, desiredstate.size[1]-1], fill=1, width=1)
draw.line(xy=[right_column, 0, right_column, desiredstate.size[1]-1], fill=1, width=1)
# append this new image to the list of images
output.append(composite)
left_column -= 1
right_column += 1
# return the list of images for transition
return output
display_transition(center_wipe)
def dissolve_changes_only(currentstate, desiredstate):
"""
A transition function that changes pixels one by one at random between currentstate and desiredstate. Pixels that
are the same in both images are skipped (no time taken)
:param currentstate: a PIL image object representing the current display state
:param desiredstate: a PIL image object representing the eventual desired display state
:return: a list of PIL image objects representing a transition of display states to get from current to desired
"""
assert isinstance(currentstate, Image.Image)
assert isinstance(desiredstate, Image.Image)
assert currentstate.size == desiredstate.size
# generate a list of all pixel addresses in the image and shuffle it
pixel_addresses = []
for column in range(currentstate.size[0]):
for row in range(currentstate.size[1]):
pixel_addresses.append((column, row))
random.shuffle(pixel_addresses)
output = []
next_image = currentstate.copy()
# for each pixel in the image
for pixel in pixel_addresses:
# if the pixel is different between the input image and the desired one
if currentstate.getpixel(pixel) != desiredstate.getpixel(pixel):
# take the previous image in the output list and change that pixel (currentstate if list is empty)
ImageDraw.Draw(next_image).point(pixel, fill=desiredstate.getpixel(pixel))
# append that image to the output list
output.append(next_image.copy())
return output
display_transition(dissolve_changes_only)
def push_up(current_state, desired_state):
"""
A transition function that raises the desired state up from the bottom of the screen, "pushing" the current state
off the top. One blank line is inserted between.
:param current_state: a PIL image object representing the current display state
:param desired_state: a PIL image object representing the eventual desired display state
:return: a list of PIL image objects representing a transition of display states to get from current to desired
"""
assert isinstance(current_state, Image.Image)
assert isinstance(desired_state, Image.Image)
assert current_state.size == desired_state.size
output = []
current_state_y_val = -1
desired_state_y_val = current_state.size[1]
# while the desired image has not reached the top
while desired_state_y_val >= 0:
# initialize next image
next = Image.new("1", current_state.size, color=0)
# paste current state at its y valute
next.paste(current_state, (0, current_state_y_val))
# paste desired state at its y value
next.paste(desired_state, (0, desired_state_y_val))
# increment y vales
current_state_y_val -= 1
desired_state_y_val -= 1
# append output
output.append(next)
output.append(desired_state)
# return the output
return output
display_transition(push_up)
def push_down(current_state, desired_state):
"""
A transition function that raises the desired state down from the top of the screen, "pushing" the current state
off the bottom. One blank line is inserted between.
:param current_state: a PIL image object representing the current display state
:param desired_state: a PIL image object representing the eventual desired display state
:return: a list of PIL image objects representing a transition of display states to get from current to desired
"""
assert isinstance(current_state, Image.Image)
assert isinstance(desired_state, Image.Image)
assert current_state.size == desired_state.size
output = []
current_state_y_val = 1
desired_state_y_val = 0 - current_state.size[1]
# while the desired image has not reached the top
while desired_state_y_val <= 0:
# initialize next image
next = Image.new("1", current_state.size, color=0)
# paste current state at its y valute
next.paste(current_state, (0, current_state_y_val))
# paste desired state at its y value
next.paste(desired_state, (0, desired_state_y_val))
# increment y vales
current_state_y_val += 1
desired_state_y_val += 1
# append output
output.append(next)
# return the output
return output
display_transition(push_down)
def push_right(current_state, desired_state):
"""
A transition function that raises the desired state right from the left of the screen, "pushing" the current state
off the right. One blank line is inserted between.
:param current_state: a PIL image object representing the current display state
:param desired_state: a PIL image object representing the eventual desired display state
:return: a list of PIL image objects representing a transition of display states to get from current to desired
"""
assert isinstance(current_state, Image.Image)
assert isinstance(desired_state, Image.Image)
assert current_state.size == desired_state.size
output = []
current_state_x_val = 1
desired_state_x_val = 0 - current_state.size[0]
# while the desired image has not reached the top
while desired_state_x_val <= 0:
# initialize next image
next = Image.new("1", current_state.size, color=0)
# paste current state at its y valute
next.paste(current_state, (current_state_x_val,0))
# paste desired state at its y value
next.paste(desired_state, (desired_state_x_val,0))
# increment y vales
current_state_x_val += 1
desired_state_x_val += 1
# append output
output.append(next)
# return the output
return output
display_transition(push_right)
def push_left(current_state, desired_state):
"""
A transition function that raises the desired state right from the left of the screen, "pushing" the current state
off the right. One blank line is inserted between.
:param current_state: a PIL image object representing the current display state
:param desired_state: a PIL image object representing the eventual desired display state
:return: a list of PIL image objects representing a transition of display states to get from current to desired
"""
assert isinstance(current_state, Image.Image)
assert isinstance(desired_state, Image.Image)
assert current_state.size == desired_state.size
output = []
current_state_x_val = -1
desired_state_x_val = current_state.size[0]
# while the desired image has not reached the top
while desired_state_x_val >= 0:
# initialize next image
next = Image.new("1", current_state.size, color=0)
# paste current state at its y valute
next.paste(current_state, (current_state_x_val,0))
# paste desired state at its y value
next.paste(desired_state, (desired_state_x_val,0))
# increment y vales
current_state_x_val -= 1
desired_state_x_val -= 1
# append output
output.append(next)
# return the output
return output
display_transition(push_left)
def ellipse_wipe(current_state, desired_state):
"""
A transition function that draws an ellipse which gradually grows, revealing the desired state inside the ellipse.
:param current_state: a PIL image object representing the current display state. Must be larger than 4x4.
:param desired_state: a PIL image object representing the eventual desired display state. Must be larger than 4x4.
:return: a list of PIL image objects representing a transition of display states to get from current to desired
"""
assert isinstance(current_state, Image.Image)
assert isinstance(desired_state, Image.Image)
assert current_state.size == desired_state.size
assert current_state.size[0] > 4 and current_state.size[1] > 4 #needs to be larger to make the loop work properly
# initialize list for transition
output = []
# generate starting values for top, bottom, left and right
if desired_state.size[0] % 2 == 0: # if the number of columns of pixels is even
# set the right and left columns as the middle ones - assuming the indices start at 0
left_column = desired_state.size[0] / 2 - 1
right_column = desired_state.size[0] / 2
else: # if the number of columns of pixels is odd
left_column = desired_state.size[0] / 2 - 0.5
right_column = left_column
if desired_state.size[1] % 2 == 0: # if the number of rows of pixels is even
# set the top and bottom rows as the middle ones - assuming the indices start at 0
top_row = desired_state.size[1] / 2 - 1
bottom_row = desired_state.size[1] / 2
else: # if the number of rows of pixels is odd
top_row = desired_state.size[1] / 2 - 0.5
bottom_row = top_row
# Start off the while loop operator as True to get into looping
keep_going = True
# while we haven't reached the left edge yet
while keep_going:
# create a mask with the right amount of interior area transparent
image_mask = Image.new('1',desired_state.size,1)
ImageDraw.Draw(image_mask).ellipse([left_column, top_row, right_column, bottom_row], fill=0, outline=0)
# create a composite image of the desired and current states using the mask
composite = Image.composite(current_state, desired_state, image_mask)
# draw the ellipse
draw = ImageDraw.Draw(composite)
draw.ellipse([left_column, top_row, right_column, bottom_row], fill=None, outline=1)
# add the image the output list
output.append(composite)
# increment the ellipse size
if current_state.size[0] > current_state.size[1]: # if there are more columns than rows
left_column -= 1
right_column += 1
top_row = min(top_row, int(left_column / current_state.size[0] * current_state.size[1]))
bottom_row = max(bottom_row, int(right_column / current_state.size[0] * current_state.size[1]))
else: # there must be more rows than columns, or there are an equal number in which case either algo is fine
top_row -= 1
bottom_row += 1
left_column = min(left_column, int(top_row / current_state.size[1] * current_state.size[0]))
right_column = max(left_column, int(bottom_row / current_state.size[1] * current_state.size[0]))
# determine whether we are done
try:
# this is a quick way to see if the two images are the same
# if the two images are the same, the difference image will be all zeros and the bounding box will be None
keep_going = ImageChops.difference(output[-2], output[-1]).getbbox() is not None
except IndexError: # indexerror means we don't have 2 images in the outputs list yet
keep_going = True
# return the output list, except the last one which we know is the same as the one before
return output[:-1]
display_transition(ellipse_wipe) | Kiganshee/Flip-Sign | TransitionFunctions.py | Python | cc0-1.0 | 14,898 | 0.006511 |
from tornado.options import define, options
define('mongodb', default='localhost:27017', help='mongodb host name or ip address +port', type=str)
define('mongod_name', default='project_hours', help='Project hours database name', type=str)
define('auth_db', default='project_hours', help='authentication database', type=str)
define('auth_driver', default='auth.ldap_auth.LdapAuth', help='authentication driver', type=str)
define('app_port', default=8181, help='application port', type=int)
# LDAP authentication
define("active_directory_server", default='server_name', help="Active directory server", type=str)
define("active_directory_username", default='user_name', help="Active directory username", type=str)
define("active_directory_password", default='password', help="Active directory password", type=str)
define("active_directory_search_def", default='ou=Crow,dc=Crow,dc=local', help="active directory search definition",
type=str)
#user cookie
define("auth_cookie_name", default='project_hours', help="name of the cookie to use for authentication", type=str)
| miooim/project_hours | src/config.py | Python | mit | 1,076 | 0.009294 |
# -*- coding: utf-8 -*-
# Copyright 2022 Google LLC
#
# 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.
#
# Generated code. DO NOT EDIT!
#
# Snippet for DeleteInstance
# NOTE: This snippet has been automatically generated for illustrative purposes only.
# It may require modifications to work in your environment.
# To install the latest published package dependency, execute the following:
# python3 -m pip install google-cloud-appengine-admin
# [START appengine_v1_generated_Instances_DeleteInstance_sync]
from google.cloud import appengine_admin_v1
def sample_delete_instance():
# Create a client
client = appengine_admin_v1.InstancesClient()
# Initialize request argument(s)
request = appengine_admin_v1.DeleteInstanceRequest(
)
# Make the request
operation = client.delete_instance(request=request)
print("Waiting for operation to complete...")
response = operation.result()
# Handle the response
print(response)
# [END appengine_v1_generated_Instances_DeleteInstance_sync]
| googleapis/python-appengine-admin | samples/generated_samples/appengine_v1_generated_instances_delete_instance_sync.py | Python | apache-2.0 | 1,530 | 0.000654 |
# Copyright 2015 The Meson development 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.
'''This module provides helper functions for Gnome/GLib related
functionality such as gobject-introspection and gresources.'''
import build
import os, sys
import subprocess
from coredata import MesonException
import mlog
class GnomeModule:
def compile_resources(self, state, args, kwargs):
cmd = ['glib-compile-resources', '@INPUT@', '--generate']
if 'source_dir' in kwargs:
d = os.path.join(state.build_to_src, state.subdir, kwargs.pop('source_dir'))
cmd += ['--sourcedir', d]
if 'c_name' in kwargs:
cmd += ['--c-name', kwargs.pop('c_name')]
cmd += ['--target', '@OUTPUT@']
kwargs['command'] = cmd
output_c = args[0] + '.c'
output_h = args[0] + '.h'
kwargs['input'] = args[1]
kwargs['output'] = output_c
target_c = build.CustomTarget(args[0]+'_c', state.subdir, kwargs)
kwargs['output'] = output_h
target_h = build.CustomTarget(args[0] + '_h', state.subdir, kwargs)
return [target_c, target_h]
def generate_gir(self, state, args, kwargs):
if len(args) != 1:
raise MesonException('Gir takes one argument')
girtarget = args[0]
while hasattr(girtarget, 'held_object'):
girtarget = girtarget.held_object
if not isinstance(girtarget, (build.Executable, build.SharedLibrary)):
raise MesonException('Gir target must be an executable or shared library')
pkgstr = subprocess.check_output(['pkg-config', '--cflags', 'gobject-introspection-1.0'])
pkgargs = pkgstr.decode().strip().split()
ns = kwargs.pop('namespace')
nsversion = kwargs.pop('nsversion')
libsources = kwargs.pop('sources')
girfile = '%s-%s.gir' % (ns, nsversion)
depends = [girtarget]
scan_command = ['g-ir-scanner', '@INPUT@']
scan_command += pkgargs
scan_command += ['--namespace='+ns, '--nsversion=' + nsversion, '--warn-all',
'--output', '@OUTPUT@']
for incdirs in girtarget.include_dirs:
for incdir in incdirs.get_incdirs():
scan_command += ['-I%s' % os.path.join(state.environment.get_source_dir(), incdir)]
if 'link_with' in kwargs:
link_with = kwargs.pop('link_with')
for link in link_with:
lib = link.held_object
scan_command += ['-l%s' % lib.name]
if isinstance(lib, build.SharedLibrary):
scan_command += ['-L%s' %
os.path.join(state.environment.get_build_dir(),
lib.subdir)]
depends.append(lib)
if 'includes' in kwargs:
includes = kwargs.pop('includes')
if isinstance(includes, str):
scan_command += ['--include=%s' % includes]
elif isinstance(includes, list):
scan_command += ['--include=%s' % inc for inc in includes]
else:
raise MesonException('Gir includes must be str or list')
if state.global_args.get('c'):
scan_command += ['--cflags-begin']
scan_command += state.global_args['c']
scan_command += ['--cflags-end']
if kwargs.get('symbol_prefix'):
sym_prefix = kwargs.pop('symbol_prefix')
if not isinstance(sym_prefix, str):
raise MesonException('Gir symbol prefix must be str')
scan_command += ['--symbol-prefix=%s' % sym_prefix]
if kwargs.get('identifier_prefix'):
identifier_prefix = kwargs.pop('identifier_prefix')
if not isinstance(identifier_prefix, str):
raise MesonException('Gir identifier prefix must be str')
scan_command += ['--identifier-prefix=%s' % identifier_prefix]
if kwargs.get('export_packages'):
pkgs = kwargs.pop('export_packages')
if isinstance(pkgs, str):
scan_command += ['--pkg-export=%s' % pkgs]
elif isinstance(pkgs, list):
scan_command += ['--pkg-export=%s' % pkg for pkg in pkgs]
else:
raise MesonException('Gir export packages must be str or list')
deps = None
if 'dependencies' in kwargs:
deps = kwargs.pop('dependencies')
if not isinstance (deps, list):
deps = [deps]
for dep in deps:
girdir = dep.held_object.get_variable ("girdir")
if girdir:
scan_command += ["--add-include-path=%s" % girdir]
inc_dirs = None
if kwargs.get('include_directories'):
inc_dirs = kwargs.pop('include_directories')
if isinstance(inc_dirs.held_object, build.IncludeDirs):
scan_command += ['--add-include-path=%s' % inc for inc in inc_dirs.held_object.get_incdirs()]
else:
raise MesonException('Gir include dirs should be include_directories()')
if isinstance(girtarget, build.Executable):
scan_command += ['--program', girtarget]
elif isinstance(girtarget, build.SharedLibrary):
scan_command += ["-L", os.path.join (state.environment.get_build_dir(), girtarget.subdir)]
libname = girtarget.get_basename()
scan_command += ['--library', libname]
scankwargs = {'output' : girfile,
'input' : libsources,
'command' : scan_command,
'depends' : depends,
}
if kwargs.get('install'):
scankwargs['install'] = kwargs['install']
scankwargs['install_dir'] = os.path.join(state.environment.get_datadir(), 'gir-1.0')
scan_target = GirTarget(girfile, state.subdir, scankwargs)
typelib_output = '%s-%s.typelib' % (ns, nsversion)
typelib_cmd = ['g-ir-compiler', scan_target, '--output', '@OUTPUT@']
if inc_dirs:
typelib_cmd += ['--includedir=%s' % inc for inc in
inc_dirs.held_object.get_incdirs()]
if deps:
for dep in deps:
girdir = dep.held_object.get_variable ("girdir")
if girdir:
typelib_cmd += ["--includedir=%s" % girdir]
kwargs['output'] = typelib_output
kwargs['command'] = typelib_cmd
# Note that this can't be libdir, because e.g. on Debian it points to
# lib/x86_64-linux-gnu but the girepo dir is always under lib.
kwargs['install_dir'] = 'lib/girepository-1.0'
typelib_target = TypelibTarget(typelib_output, state.subdir, kwargs)
return [scan_target, typelib_target]
def compile_schemas(self, state, args, kwargs):
if len(args) != 0:
raise MesonException('Compile_schemas does not take positional arguments.')
srcdir = os.path.join(state.build_to_src, state.subdir)
outdir = state.subdir
cmd = ['glib-compile-schemas', '--targetdir', outdir, srcdir]
kwargs['command'] = cmd
kwargs['input'] = []
kwargs['output'] = 'gschemas.compiled'
if state.subdir == '':
targetname = 'gsettings-compile'
else:
targetname = 'gsettings-compile-' + state.subdir
target_g = build.CustomTarget(targetname, state.subdir, kwargs)
return target_g
def gtkdoc(self, state, args, kwargs):
if len(args) != 1:
raise MesonException('Gtkdoc must have one positional argument.')
modulename = args[0]
if not isinstance(modulename, str):
raise MesonException('Gtkdoc arg must be string.')
if not 'src_dir' in kwargs:
raise MesonException('Keyword argument src_dir missing.')
main_file = kwargs.get('main_sgml', '')
if not isinstance(main_file, str):
raise MesonException('Main sgml keyword argument must be a string.')
main_xml = kwargs.get('main_xml', '')
if not isinstance(main_xml, str):
raise MesonException('Main xml keyword argument must be a string.')
if main_xml != '':
if main_file != '':
raise MesonException('You can only specify main_xml or main_sgml, not both.')
main_file = main_xml
src_dir = kwargs['src_dir']
targetname = modulename + '-doc'
command = os.path.normpath(os.path.join(os.path.split(__file__)[0], "../gtkdochelper.py"))
args = [state.environment.get_source_dir(),
state.environment.get_build_dir(),
state.subdir,
os.path.normpath(os.path.join(state.subdir, src_dir)),
main_file,
modulename]
res = [build.RunTarget(targetname, command, args, state.subdir)]
if kwargs.get('install', True):
res.append(build.InstallScript([command] + args))
return res
def gdbus_codegen(self, state, args, kwargs):
if len(args) != 2:
raise MesonException('Gdbus_codegen takes two arguments, name and xml file.')
namebase = args[0]
xml_file = args[1]
cmd = ['gdbus-codegen']
if 'interface_prefix' in kwargs:
cmd += ['--interface-prefix', kwargs.pop('interface_prefix')]
if 'namespace' in kwargs:
cmd += ['--c-namespace', kwargs.pop('namespace')]
cmd += ['--generate-c-code', os.path.join(state.subdir, namebase), '@INPUT@']
outputs = [namebase + '.c', namebase + '.h']
custom_kwargs = {'input' : xml_file,
'output' : outputs,
'command' : cmd
}
return build.CustomTarget(namebase + '-gdbus', state.subdir, custom_kwargs)
def initialize():
mlog.log('Warning, glib compiled dependencies will not work until this upstream issue is fixed:',
mlog.bold('https://bugzilla.gnome.org/show_bug.cgi?id=745754'))
return GnomeModule()
class GirTarget(build.CustomTarget):
def __init__(self, name, subdir, kwargs):
super().__init__(name, subdir, kwargs)
class TypelibTarget(build.CustomTarget):
def __init__(self, name, subdir, kwargs):
super().__init__(name, subdir, kwargs)
| evgenyz/meson | modules/gnome.py | Python | apache-2.0 | 10,923 | 0.003662 |
# -*- coding: utf-8 -*-
##
## Copyright © 2007, Matthias Urlichs <[email protected]>
##
## This program is free software: you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation, either version 3 of the License, or
## (at your option) any later version.
##
## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License (included; see the file LICENSE)
## for more details.
##
"""\
This code implements primitive "if true" and "if false" checks.
"""
from homevent.check import Check,register_condition,unregister_condition
from homevent.module import Module
class TrueCheck(Check):
name="true"
doc="always true."
def check(self,*args):
assert not args,"Truth doesn't have arguments"
return True
class FalseCheck(Check):
name="false"
doc="always false."
def check(self,*args):
assert not args,"Falsehood doesn't have arguments"
return False
class NoneCheck(Check):
name="null"
doc="check if the argument has a value."
def check(self,*args):
assert len(args)==1,u"The ‹null› check requires one argument"
return args[0] is None
class EqualCheck(Check):
name="equal"
doc="check if the arguments are the same."
def check(self,*args):
assert len(args)==2,u"The ‹equal› check requires two arguments"
a,b = args
if a is None: return b is None
try:
return float(a) == float(b)
except (ValueError,TypeError):
return str(a) == str(b)
class LessCheck(Check):
name="less"
doc="check if the first argument is smaller."
def check(self,*args):
assert len(args)==2,u"The ‹less› check requires two arguments"
a,b = args
if a is None or b is None: return False
try:
return float(a) < float(b)
except (ValueError,TypeError):
return str(a) < str(b)
class GreaterCheck(Check):
name="greater"
doc="check if the first argument is larger."
def check(self,*args):
assert len(args)==2,u"The ‹greater› check requires two arguments"
a,b = args
if a is None or b is None: return False
try:
return float(a) > float(b)
except (ValueError,TypeError):
return str(a) > str(b)
class BoolModule(Module):
"""\
This module implements basic boolean conditions
"""
info = u"Boolean conditions. There can be only … two."
def load(self):
register_condition(TrueCheck)
register_condition(FalseCheck)
register_condition(NoneCheck)
register_condition(EqualCheck)
register_condition(LessCheck)
register_condition(GreaterCheck)
def unload(self):
unregister_condition(TrueCheck)
unregister_condition(FalseCheck)
unregister_condition(NoneCheck)
unregister_condition(EqualCheck)
unregister_condition(LessCheck)
unregister_condition(GreaterCheck)
init = BoolModule
| smurfix/HomEvenT | modules/bool.py | Python | gpl-3.0 | 2,922 | 0.044781 |
from ga_utils import *
from random import randint, gauss, random, seed
import unittest
def generate_xover(population, midpoint_dist='uniform'):
"""
Generates a new value using crossover mutation
:param population: sorted iterable of current population
:param midpoint_dist: 'uniform' or 'normal' distributions for selecting midpoint
:return: new value
"""
if midpoint_dist is 'uniform':
midpoint = randint(0, len(population[0]))
elif midpoint_dist is 'normal':
midpoint = max(min(int(gauss(0.5 * len(population[0]), 0.5 * len(population[0]))), len(population[0])), 0)
else:
raise ValueError('Midpoint distribution must be uniform or normal')
mom, dad = ranked_selection(population), ranked_selection(population)
return midpoint_xover(mom, dad, midpoint)
def generate_lmutate(population, locate_dist='uniform'):
"""
Generates a new value using location mutation
:param population: sorted iterable of current population
:param locate_dist: 'uniform' or 'normal' distributions for selecting locations
:return: new value
"""
if locate_dist is 'uniform':
a = randint(0, len(population[0]))
b = randint(0, len(population[0]))
elif locate_dist is 'normal':
a = max(min(int(gauss(0.5 * len(population[0]), 0.5 * len(population[0]))), len(population[0])), 0)
b = max(min(int(gauss(0.5 * len(population[0]), 0.5 * len(population[0]))), len(population[0])), 0)
else:
raise ValueError('Location distribution must be uniform or normal')
if a == b:
if randint(1, 2) == 1:
return location_mutation(ranked_selection(population), a, None)
else:
return location_mutation(ranked_selection(population), 0, a)
else:
return location_mutation(ranked_selection(population), min(a, b), max(a, b))
def generate_pmutate(population, locate_dist='uniform', pflip_dist='uniform'):
"""
Generates a new value using location mutation
:param population: sorted iterable of current population
:param locate_dist: 'uniform' or 'normal' distributions for selecting locations
:param pflip_dist: 'uniform' or 'normal' distributions for selecting pflip
:return: new value
"""
if locate_dist is 'uniform':
a = randint(0, len(population[0]))
b = randint(0, len(population[0]))
elif locate_dist is 'normal':
a = max(min(int(gauss(0.5 * len(population[0]), 0.5 * len(population[0]))), len(population[0])), 0)
b = max(min(int(gauss(0.5 * len(population[0]), 0.5 * len(population[0]))), len(population[0])), 0)
else:
raise ValueError('Location distribution must be uniform or normal')
if pflip_dist is 'uniform':
p = random()
elif pflip_dist is 'normal':
p = max(min(gauss(0.5, 0.5), 1.0), 0.0)
else:
raise ValueError('Pflip distribution must be uniform or normal')
if a == b:
if randint(1, 2) == 1:
return probability_mutation(ranked_selection(population), p, a, None)
else:
return probability_mutation(ranked_selection(population), p, 0, a)
else:
return probability_mutation(ranked_selection(population), p, min(a, b), max(a, b))
class TestGenFns(unittest.TestCase):
def setUp(self):
pass
def test_generate_xover(self):
population = [BitArray(bin='00000001'), BitArray(bin='00000011'),
BitArray(bin='00000111'), BitArray(bin='00001111'),
BitArray(bin='00011111'), BitArray(bin='00111111'),
BitArray(bin='01111111'), BitArray(bin='11111111')]
self.assertRaises(ValueError, lambda: generate_xover(population, midpoint_dist='error'))
seed(1)
uniform_xover = generate_xover(population, midpoint_dist='uniform')
normal_xover = generate_xover(population, midpoint_dist='normal')
self.assertEqual(type(uniform_xover), BitArray)
self.assertEqual(uniform_xover.bin, '00000011')
self.assertEqual(type(normal_xover), BitArray)
self.assertEqual(normal_xover.bin, '00000011')
def test_generate_lmutate(self):
population = [BitArray(bin='00000001'), BitArray(bin='00000011'),
BitArray(bin='00000111'), BitArray(bin='00001111'),
BitArray(bin='00011111'), BitArray(bin='00111111'),
BitArray(bin='01111111'), BitArray(bin='11111111')]
self.assertRaises(ValueError, lambda: generate_lmutate(population, locate_dist='error'))
seed(1)
uniform_lmutate = generate_lmutate(population, locate_dist='uniform')
normal_lmutate = generate_lmutate(population, locate_dist='normal')
self.assertEqual(type(uniform_lmutate), BitArray)
self.assertEqual(uniform_lmutate.bin, '01000011')
self.assertEqual(type(normal_lmutate), BitArray)
self.assertEqual(normal_lmutate.bin, '11111111')
def test_generate_pmutate(self):
population = [BitArray(bin='00000001'), BitArray(bin='00000011'),
BitArray(bin='00000111'), BitArray(bin='00001111'),
BitArray(bin='00011111'), BitArray(bin='00111111'),
BitArray(bin='01111111'), BitArray(bin='11111111')]
self.assertRaises(ValueError,
lambda: generate_pmutate(population, locate_dist='error', pflip_dist='uniform'))
self.assertRaises(ValueError,
lambda: generate_pmutate(population, locate_dist='uniform', pflip_dist='error'))
seed(2)
uu_pmutate = generate_pmutate(population, locate_dist='uniform', pflip_dist='uniform')
un_pmutate = generate_pmutate(population, locate_dist='uniform', pflip_dist='normal')
nu_pmutate = generate_pmutate(population, locate_dist='normal', pflip_dist='uniform')
nn_pmutate = generate_pmutate(population, locate_dist='normal', pflip_dist='normal')
self.assertEqual(type(uu_pmutate), BitArray)
self.assertEqual(uu_pmutate.bin, '10000111')
self.assertEqual(type(un_pmutate), BitArray)
self.assertEqual(un_pmutate.bin, '10011111')
self.assertEqual(type(nu_pmutate), BitArray)
self.assertEqual(nu_pmutate.bin, '01000001')
self.assertEqual(type(nn_pmutate), BitArray)
self.assertEqual(nn_pmutate.bin, '00000110')
def tearDown(self):
pass
if __name__ == '__main__':
unittest.main(verbosity=2)
| gioGats/GeneticText | generation_functions.py | Python | gpl-3.0 | 6,538 | 0.002906 |
field_dict={'ROME-FIELD-01':[ 267.835895375 , -30.0608178195 , '17:51:20.6149','-30:03:38.9442' ],
'ROME-FIELD-02':[ 269.636745458 , -27.9782661111 , '17:58:32.8189','-27:58:41.758' ],
'ROME-FIELD-03':[ 268.000049542 , -28.8195573333 , '17:52:00.0119','-28:49:10.4064' ],
'ROME-FIELD-04':[ 268.180171708 , -29.27851275 , '17:52:43.2412','-29:16:42.6459' ],
'ROME-FIELD-05':[ 268.35435 , -30.2578356389 , '17:53:25.044','-30:15:28.2083' ],
'ROME-FIELD-06':[ 268.356124833 , -29.7729819283 , '17:53:25.47','-29:46:22.7349' ],
'ROME-FIELD-07':[ 268.529571333 , -28.6937071111 , '17:54:07.0971','-28:41:37.3456' ],
'ROME-FIELD-08':[ 268.709737083 , -29.1867251944 , '17:54:50.3369','-29:11:12.2107' ],
'ROME-FIELD-09':[ 268.881108542 , -29.7704673333 , '17:55:31.4661','-29:46:13.6824' ],
'ROME-FIELD-10':[ 269.048498333 , -28.6440675 , '17:56:11.6396','-28:38:38.643' ],
'ROME-FIELD-11':[ 269.23883225 , -29.2716684211 , '17:56:57.3197','-29:16:18.0063' ],
'ROME-FIELD-12':[ 269.39478875 , -30.0992361667 , '17:57:34.7493','-30:05:57.2502' ],
'ROME-FIELD-13':[ 269.563719375 , -28.4422328996 , '17:58:15.2927','-28:26:32.0384' ],
'ROME-FIELD-14':[ 269.758843 , -29.1796030365 , '17:59:02.1223','-29:10:46.5709' ],
'ROME-FIELD-15':[ 269.78359875 , -29.63940425 , '17:59:08.0637','-29:38:21.8553' ],
'ROME-FIELD-16':[ 270.074981708 , -28.5375585833 , '18:00:17.9956','-28:32:15.2109' ],
'ROME-FIELD-17':[ 270.81 , -28.0978333333 , '18:03:14.4','-28:05:52.2' ],
'ROME-FIELD-18':[ 270.290886667 , -27.9986032778 , '18:01:09.8128','-27:59:54.9718' ],
'ROME-FIELD-19':[ 270.312763708 , -29.0084241944 , '18:01:15.0633','-29:00:30.3271' ],
'ROME-FIELD-20':[ 270.83674125 , -28.8431573889 , '18:03:20.8179','-28:50:35.3666' ]}
| ytsapras/robonet_site | scripts/rome_fields_dict.py | Python | gpl-2.0 | 1,964 | 0.071792 |
import os
TELEGRAM_TOKEN = os.environ['TELEGRAM_TOKEN']
DATABASE = {
'HOST': os.getenv('DB_PORT_3306_TCP_ADDR', 'localhost'),
'USER': os.getenv('DB_MYSQL_USER', 'root'),
'PASSWORD': os.getenv('DB_MYSQL_PASSWORD', ''),
'NAME': 'aurora',
}
| synteny/AuroraBot | sessioncontroller/settings.py | Python | mit | 256 | 0 |
import os
def root_dir():
"""
:return: root folder path
"""
return os.path.dirname(os.path.abspath(__file__))
def db_path(db_name):
if db_name == 'forecast':
return os.path.join(root_dir(), "data", "forecast.sqlite")
else:
return None
| JavierGarciaD/banking | definitions.py | Python | mit | 279 | 0 |
from core import FM
import traceback
class ReadFile(FM.BaseAction):
def __init__(self, request, path, session, **kwargs):
super(ReadFile, self).__init__(request=request, **kwargs)
self.path = path
self.session = session
def run(self):
request = self.get_rpc_request()
result = request.request_bytes('webdav/read_file', login=self.request.get_current_user(),
password=self.request.get_current_password(), path=self.path,
session=self.session)
answer = self.process_result(result)
if 'data' in answer.keys():
data = answer['data']
if 'content' in data.keys() and 'encoding' in data.keys():
data['encoding'] = data['encoding'].decode('utf-8').lower()
data['content'] = str(data['content'], data['encoding'], 'replace')
data['item'] = self.byte_to_unicode_dict(data['item'])
answer['data'] = data
if 'error' in answer.keys():
# FIXME
answer["error"] = answer['error'] if answer['error'] is not None else True
if 'message' in answer.keys():
try:
message = answer['message'].decode('utf-8') if answer['message'] is not None else ''
answer['message'] = message
except Exception as e:
self.application.logger.error(
"Handled exception in action ReadFile: " + str(e) + "Traceback:" + traceback.format_exc())
if 'traceback' in answer.keys():
try:
trace = answer['traceback'].decode('utf-8') if answer['traceback'] is not None else ''
answer['traceback'] = trace
except Exception as e:
self.application.logger.error(
"Handled exception in action ReadFile: " + str(e) + "Traceback:" + traceback.format_exc())
return answer
def byte_to_unicode_dict(self, answer):
decoded = {}
for key in answer:
if isinstance(key, bytes):
unicode_key = key.decode("utf-8")
else:
unicode_key = key
if isinstance(answer[key], dict):
decoded[unicode_key] = self.byte_to_unicode_dict(answer[key])
elif isinstance(answer[key], list):
decoded[unicode_key] = self.byte_to_unicode_list(answer[key])
elif isinstance(answer[key], int):
decoded[unicode_key] = answer[key]
elif isinstance(answer[key], float):
decoded[unicode_key] = answer[key]
elif isinstance(answer[key], str):
decoded[unicode_key] = answer[key]
elif answer[key] is None:
decoded[unicode_key] = answer[key]
else:
try:
decoded[unicode_key] = answer[key].decode("utf-8")
except UnicodeDecodeError:
# Костыль для кракозябр
decoded[unicode_key] = answer[key].decode("ISO-8859-1")
return decoded
def byte_to_unicode_list(self, answer):
decoded = []
for item in answer:
if isinstance(item, dict):
decoded_item = self.byte_to_unicode_dict(item)
decoded.append(decoded_item)
elif isinstance(item, list):
decoded_item = self.byte_to_unicode_list(item)
decoded.append(decoded_item)
elif isinstance(item, int):
decoded.append(item)
elif isinstance(item, float):
decoded.append(item)
elif item is None:
decoded.append(item)
else:
try:
decoded_item = item.decode("utf-8")
except UnicodeDecodeError:
# Костыль для кракозябр
decoded_item = item.decode("ISO-8859-1")
decoded.append(decoded_item)
return decoded
| f-andrey/sprutio | app/modules/webdav/actions/files/read.py | Python | gpl-3.0 | 4,120 | 0.002205 |
from __future__ import absolute_import
from __future__ import print_function
from copy import deepcopy
from six.moves import range
def get_formulae(mass,tol=5,charge=0,tol_type='ppm',max_tests=1e7,
min_h=0,max_h=200,
min_c=0,max_c=200,
min_n=0,max_n=6,
min_o=0,max_o=20,
min_p=0,max_p=4,
min_s=0,max_s=4,
min_na=0,max_na=0,
min_k=0,max_k=0,
min_cl=0,max_cl=0):
"""
performs brute force chemical formula generation. enumerate all possible matches within bounds.
Considers only [C,H,N,O,P,S,Na,K,Cl]
returns list of tuples (error,formula).
use it like this:
from metatlas.helpers import formula_generator as formulae
out = formulae.get_formulae(634.13226,1,min_c=20,min_h=15)
(4.457399995771993e-06, 'H26C32O14')
(9.535900062473956e-06, 'H29C34N5P1S3')
(3.076309997140925e-05, 'H151C24N6O3P2')
(5.4717500006518094e-05, 'H35C33N1O2P3S2')
....
"""
elements = [
{'num':0,'symbol':"H",'mass': 1.0078250321,'min':min_h,'max':max_h,'guess':0},
{'num':1,'symbol':"C",'mass': 12.000000000,'min':min_c,'max':max_c,'guess':0},
{'num':2,'symbol':"N",'mass': 14.003074005,'min':min_n,'max':max_n,'guess':0},
{'num':3,'symbol':"O",'mass': 15.994914622,'min':min_o,'max':max_o,'guess':0},
{'num':4,'symbol':"P",'mass': 30.97376151,'min':min_p,'max':max_p,'guess':0},
{'num':5,'symbol':"S",'mass': 31.97207069,'min':min_s,'max':max_s,'guess':0},
{'num':6,'symbol':"Na",'mass':22.989770,'min':min_na,'max':max_na,'guess':0},
{'num':7,'symbol':"K",'mass': 38.963708,'min':min_k,'max':max_k,'guess':0},
{'num':8,'symbol':"Cl",'mass':34.968852682,'min':min_cl,'max':max_cl,'guess':0}
]
electron=0.0005485799094
mass=mass+charge*electron #neutralize the molecule if charge is provided
if tol_type=='ppm':
tol=tol*mass/1e6
hits = do_calculations(mass,tol,elements,max_tests);
hits = sorted(hits,key=lambda x:x[0])
formulae = [] #store all formulae
for hit in hits:
formula = [] #store list of elements and stoichiometry
for element in hit[1]:
if element['guess'] != 0:
formula.append('%s%d'%(element['symbol'],element['guess']))
formulae.append((hit[0],''.join(formula)))
return formulae
def calc_mass(elements):
"""
?
"""
sum = 0.0
for el in elements:
sum += el['mass'] * el['guess']
return sum
def do_calculations(mass,tol,elements,max_tests):
"""
?
"""
limit_low = mass - tol
limit_high = mass + tol
test_counter = 0
hits = []
for n8 in range(elements[8]['min'],elements[8]['max']+1):
elements[8]['guess'] = n8
for n7 in range(elements[7]['min'],elements[7]['max']+1):
elements[7]['guess'] = n7
for n6 in range(elements[6]['min'],elements[6]['max']+1):
elements[6]['guess'] = n6
for n5 in range(elements[5]['min'],elements[5]['max']+1):
elements[5]['guess'] = n5
for n4 in range(elements[4]['min'],elements[4]['max']+1):
elements[4]['guess'] = n4
for n3 in range(elements[3]['min'],elements[3]['max']+1):
elements[3]['guess'] = n3
for n2 in range(elements[2]['min'],elements[2]['max']+1):
elements[2]['guess'] = n2
for n1 in range(elements[1]['min'],elements[1]['max']+1):
elements[1]['guess'] = n1
for n0 in range(elements[0]['min'],elements[0]['max']+1):
elements[0]['guess'] = n0
test_counter += 1
if test_counter > max_tests:
print('ERROR test limit exceeded')
return
theoretical_mass = calc_mass(elements)
if ((theoretical_mass >= limit_low) & (theoretical_mass <= limit_high)):
hits.append((abs(theoretical_mass-mass),deepcopy(elements)))
if theoretical_mass > limit_high: # n0
break
if (theoretical_mass > limit_high) & (n0==elements[0]['min']):
break
if (theoretical_mass > limit_high) & (n1==elements[1]['min']):
break
if (theoretical_mass > limit_high) & (n2==elements[2]['min']):
break
if (theoretical_mass > limit_high) & (n3==elements[3]['min']):
break
if (theoretical_mass > limit_high) & (n4==elements[4]['min']):
break
if (theoretical_mass > limit_high) & (n5==elements[5]['min']):
break
if (theoretical_mass > limit_high) & (n6==elements[6]['min']):
break
if (theoretical_mass > limit_high) & (n7==elements[7]['min']):
break
return hits | metabolite-atlas/metatlas | metatlas/tools/formula_generator.py | Python | bsd-3-clause | 4,342 | 0.066099 |
# *-* coding=utf-8 *-*
from django.conf import settings
from django import forms
from django.utils.translation import ugettext_lazy as _
from django.template.defaultfilters import slugify
from django.forms.widgets import flatatt
from django.utils.encoding import smart_unicode, force_unicode
from django.template.loader import render_to_string
from django.utils.html import escape, conditional_escape
from django.utils.safestring import mark_safe
from djblog.models import Post, Category
class PreviewContentWidget(forms.Textarea):
def render(self, name, value, attrs=None):
if value is None:
value = ''
value = smart_unicode(value)
final_attrs = self.build_attrs(attrs, name=name)
context = {
'id':final_attrs['id'],
'id_content':final_attrs['id_content'],
'attrs':flatatt(final_attrs),
'content':value,
'name': name,
'STATIC_URL':settings.STATIC_URL
}
return mark_safe(render_to_string('djeditor/djeditor_widget.html', context))
class PostAdminForm(forms.ModelForm):
#slug = forms.SlugField(required=False)
content_rendered = forms.CharField(widget=PreviewContentWidget(attrs={'id_content':'id_content'}), required=False)
category = forms.ModelMultipleChoiceField(widget=forms.CheckboxSelectMultiple(), queryset=Category.objects.all(), required=False)
def __init__(self, *args, **kwargs):
super(PostAdminForm, self).__init__(*args, **kwargs)
if 'instance' in kwargs:
obj = kwargs['instance']
#self.fields['category'].queryset = Category.objects.filter(blog_category = not obj.is_page)
class Meta:
model = Post
exclude = []
| ninjaotoko/djblog | djblog/forms.py | Python | bsd-3-clause | 1,755 | 0.011966 |
import json
import sys
import falcon
def body_checker(required_params=(), documentation_link=None):
def hook(req, resp, resource, params):
if req.content_length in (None, 0, ):
raise falcon.HTTPBadRequest('Bad request',
'В запросе деолжны быть параметры, дружок.',
href=documentation_link)
#todo: https://github.com/falconry/falcon/pull/748
try:
body = json.loads(req.stream.read(sys.maxsize).decode('utf-8'))
except (ValueError, UnicodeDecodeError):
raise falcon.HTTPBadRequest('Bad request',
'Ты прислал плохой json, няша, попробуй прислать другой.',
href=documentation_link)
params = {}
description = "Ты забыл параметр '%s', няша."
for key in required_params:
if key not in body:
raise falcon.HTTPBadRequest('Bad request', description % key, href=documentation_link)
params[key] = body[key]
req.context['parsed_body'] = params
return hook
| sketchturnerr/WaifuSim-backend | resources/middlewares/body_checker.py | Python | cc0-1.0 | 1,251 | 0.003457 |
# flake8: noqa
from .client import Client
from .compatpatch import ClientCompatPatch
from .errors import (
ClientError, ClientLoginError, ClientCookieExpiredError,
ClientConnectionError, ClientForbiddenError,
ClientThrottledError,ClientBadRequestError,
)
from .common import ClientDeprecationWarning
__version__ = '1.6.0'
| ping/instagram_private_api | instagram_web_api/__init__.py | Python | mit | 337 | 0.002967 |
import datetime
import unittest
from assertpy import assert_that
from blitzortung_server.influxdb import DataPoint
class TestAS(unittest.TestCase):
def testEmptyDataPoint(self):
timestamp = datetime.datetime.utcnow()
data_point = DataPoint("meas", time=timestamp)
json_repr = data_point.get()
assert_that(json_repr).is_equal_to({
"measurement": "meas",
"time": timestamp,
"tags": {},
"fields": {}
})
def testDataPoint(self):
timestamp = datetime.datetime.utcnow()
data_point = DataPoint("meas", time=timestamp)
data_point.fields['foo'] = 1.5
data_point.tags['bar'] = "qux"
data_point.tags['baz'] = 1234
json_repr = data_point.get()
assert_that(json_repr).is_equal_to({
"measurement": "meas",
"time": timestamp,
"tags": {'bar': 'qux', 'baz': 1234},
"fields": {'foo': 1.5}
})
| wuan/bo-server | tests/test_influxdb.py | Python | apache-2.0 | 989 | 0 |
import _plotly_utils.basevalidators
class ThicknessmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator):
def __init__(
self, plotly_name="thicknessmode", parent_name="surface.colorbar", **kwargs
):
super(ThicknessmodeValidator, self).__init__(
plotly_name=plotly_name,
parent_name=parent_name,
edit_type=kwargs.pop("edit_type", "calc"),
values=kwargs.pop("values", ["fraction", "pixels"]),
**kwargs
)
| plotly/plotly.py | packages/python/plotly/plotly/validators/surface/colorbar/_thicknessmode.py | Python | mit | 506 | 0.001976 |
from __future__ import print_function
from __future__ import division
from builtins import str
from past.utils import old_div
import logging
from datetime import datetime , time ,timedelta
import _strptime
import hardwaremod
import os
import subprocess
import emailmod
import interruptdbmod
import sensordbmod
import actuatordbmod
import autofertilizermod
import statusdataDBmod
import threading
import time as t
import ActuatorControllermod
ACTIONPRIORITYLEVEL=5
NONBLOCKINGPRIORITY=0
SAVEBLOCKINGBUSY=False
SAVEBLOCKINGDIFFBUSY=False
NOWTIMELIST=[]
#In hardware, an internal 10K resistor between the input channel and 3.3V (pull-up) or 0V (pull-down) is commonly used.
#https://sourceforge.net/p/raspberry-gpio-python/wiki/Inputs/
logger = logging.getLogger("hydrosys4."+__name__)
# status array, required to check the ongoing actions
elementlist= interruptdbmod.getelementlist()
waitingtime=1200
# ///////////////// -- STATUS VARIABLES -- ///////////////////////////////
AUTO_data={} # dictionary of dictionary
AUTO_data["default"]={"lasteventtime":datetime.utcnow()- timedelta(minutes=waitingtime),"lastinterrupttime":datetime.utcnow(),"validinterruptcount":0,"eventactivated":False,"lastactiontime":datetime.utcnow()- timedelta(minutes=waitingtime),"actionvalue":0, "alertcounter":0, "infocounter":0, "status":"ok" , "threadID":None , "blockingstate":False}
SENSOR_data={} # used for the associated sensor in a separate hardwareSetting Row
SENSOR_data["default"]={"Startcounttime":datetime.utcnow(),"InterruptCount":0}
PIN_attributes={} # to speed up the operation during interurpt
PIN_attributes["default"]={"logic":"pos","refsensor":"","bouncetimeSec":0.001}
BLOCKING_data={} # to speed up the operation during interurpt
BLOCKING_data["default"]={"BlockingNumbers":0,"BlockingNumbersThreadID":None}
def readstatus(element,item):
return statusdataDBmod.read_status_data(AUTO_data,element,item)
def savedata(sensorname,sensorvalue):
sensorvalue_str=str(sensorvalue)
sensorvalue_norm=hardwaremod.normalizesensordata(sensorvalue_str,sensorname)
sensordbmod.insertdataintable(sensorname,sensorvalue_norm)
return
def eventcallback(PIN):
bouncetimeSec=statusdataDBmod.read_status_data(PIN_attributes,PIN,"bouncetimeSec")
t.sleep(bouncetimeSec)
reading=hardwaremod.readinputpin(PIN)
refsensor=statusdataDBmod.read_status_data(PIN_attributes,PIN,"refsensor")
logic=statusdataDBmod.read_status_data(PIN_attributes,PIN,"logic")
#print "reference sensor:" , refsensor, "logic ", logic
#print PIN_attributes
# first Edge detection, can have two impleemntations depend on the "logic" setting
# in case logic=pos we have pull-down resistor, so the normal state is LOW, the first edge will be from LOW to HIGH
# in case logic<>pos we have pull-up resistor, so the normal state is High, the first edge will be from HIGH to LOW
if refsensor!="":
#["First Edge" , "First Edge + Level", "Second Edge" , "Second Edge + Level (inv)", "both Edges"]
#print "Logic " , logic , " reading ", reading , " bouncetimeSec " , bouncetimeSec
#detecting first edge
if logic=="pos":
if reading=="1":
#print "************************* First edge detected on PIN:", PIN
mode="First Edge"
elif reading=="0":
#print "************************* Second edge detected on PIN:", PIN
mode="Second Edge"
else:
if reading=="0":
#print "************************* First edge detected on PIN:", PIN
mode="First Edge"
elif reading=="1":
#print "************************* Second edge detected on PIN:", PIN
mode="Second Edge"
#print "interrupt --------------------> ", mode
interruptcheck(refsensor,mode,PIN)
# update status variables for the frequency sensor ----
sensorinterruptcount=statusdataDBmod.read_status_data(SENSOR_data,PIN,"InterruptCount")
sensorinterruptcount=sensorinterruptcount+1
statusdataDBmod.write_status_data(SENSOR_data,PIN,"InterruptCount",sensorinterruptcount)
#if refsensor!="":
# x = threading.Thread(target=savedata, args=(refsensor,reading))
# x.start()
def setinterruptevents():
hardwaremod.removeallinterruptevents()
print("load interrupt list ")
interruptlist=interruptdbmod.sensorlist()
print("len interrupt list " , len(interruptlist))
for item in interruptlist:
print("got into the loop ")
# get PIN number
recordkey=hardwaremod.HW_INFO_NAME
recordvalue=item
keytosearch=hardwaremod.HW_CTRL_PIN
PINstr=hardwaremod.searchdata(recordkey,recordvalue,keytosearch)
print("set event for the PIN ", PINstr)
if not PINstr=="":
keytosearch=hardwaremod.HW_CTRL_LOGIC
logic=hardwaremod.searchdata(recordkey,recordvalue,keytosearch)
# set Sw pull up / down mode
if logic=="pos":
hardwaremod.GPIO_setup(PINstr, "in", "pull_down")
evenslopetype="both"
else:
hardwaremod.GPIO_setup(PINstr, "in" , "pull_up")
evenslopetype="both"
#GPIO.RISING, GPIO.FALLING or GPIO.BOTH.
# link to the callback function
# the bouncetime is set by the frequency parameter, if this parameter is empty, the default bouncetime would be 200
keytosearch=hardwaremod.HW_CTRL_FREQ
frequency=hardwaremod.searchdata(recordkey,recordvalue,keytosearch)
if frequency=="":
bouncetimeINT=200
else:
frequencyINT=hardwaremod.toint(frequency,5)
bouncetimeINT=old_div(1000,frequencyINT) # in ms. this is ok to be trunk of the int. For frequencies higher than 1000 the bouncetime is exactly zero
# RPI.GPIO library does not accept bouncetime=0, it gives runtime error
if bouncetimeINT<=0:
bouncetimeINT=1 #ms
hardwaremod.GPIO_add_event_detect(PINstr, evenslopetype, eventcallback, bouncetimeINT)
# set fast reference call indexed with the PIN number which is the variable used when interrupt is called:
# search now to avoid searching later
global PIN_attributes
PIN=hardwaremod.toint(PINstr,0)
statusdataDBmod.write_status_data(PIN_attributes,PIN,"logic",logic)
recordkey=hardwaremod.HW_CTRL_PIN
recordvalue=PINstr
keytosearch=hardwaremod.HW_INFO_NAME
refsensor=hardwaremod.searchdata(recordkey,recordvalue,keytosearch) # return first occurence
statusdataDBmod.write_status_data(PIN_attributes,PIN,"refsensor",refsensor)
statusdataDBmod.write_status_data(PIN_attributes,PIN,"bouncetimeSec",0.4*float(bouncetimeINT)/1000)
# code below to enable blocking for N sec, it is necessary to trigger the bloccking status in case of levels already present when starting.
elementlist= interruptdbmod.getelementlist()
#print elementlist
for element in elementlist:
workmode=checkworkmode(element)
if (workmode!="None")and(workmode!=""):
sensor=interruptdbmod.searchdata("element",element,"sensor")
#saveblockingdiff(sensor)
print(" what a sensor ", sensor)
if sensor!="":
startblockingstate(element,10,False)
t.sleep(0.02)
return ""
def cyclereset(element):
#AUTO_data["default"]={"lasteventtime":datetime.utcnow()- timedelta(minutes=waitingtime),"lastinterrupttime":datetime.utcnow(),
#"validinterruptcount":0,"eventactivated":False,"lastactiontime":datetime.utcnow()- timedelta(minutes=waitingtime),
#"actionvalue":0, "alertcounter":0, "infocounter":0, "status":"ok" , "threadID":None , "blockingstate":False}
#SENSOR_data["default"]={"Startcounttime":datetime.utcnow(),"InterruptCount":0} # this is for the actual frequency sensor
#PIN_attributes["default"]={"logic":"pos","refsensor":"","bouncetimeSec":0.001} # this is relebant to the PINs
#BLOCKING_data["default"]={"BlockingNumbers":0,"BlockingNumbersThreadID":None} # tihs is relenat to the Interrupt trigger
global AUTO_data
waitingtime=hardwaremod.toint(interruptdbmod.searchdata("element",element,"preemptive_period"),0)
statusdataDBmod.write_status_data(AUTO_data,element,"lastactiontime",datetime.utcnow() - timedelta(minutes=waitingtime))
statusdataDBmod.write_status_data(AUTO_data,element,"lasteventtime",datetime.utcnow() - timedelta(minutes=waitingtime))
statusdataDBmod.write_status_data(AUTO_data,element,"status","ok")
statusdataDBmod.write_status_data(AUTO_data,element,"actionvalue",0)
statusdataDBmod.write_status_data(AUTO_data,element,"alertcounter",0)
statusdataDBmod.write_status_data(AUTO_data,element,"infocounter",0)
statusdataDBmod.write_status_data(AUTO_data,element,"validinterruptcount",0)
# start procedure to stop blocking on this element
endblocking(element)
# reassess all the interrupt sensor related shit
elementlist= interruptdbmod.getelementlist()
sensorblockingcounter={}
#print "elementlist" , elementlist
#print elementlist
for element in elementlist:
#print " ELEMENT " , element
workmode=checkworkmode(element)
if (workmode!="None")and(workmode!=""):
sensor=interruptdbmod.searchdata("element",element,"sensor")
#print " SENSOR " , sensor
if sensor!="":
#print "Blocking starte " , statusdataDBmod.read_status_data(AUTO_data,element,"blockingstate")
if statusdataDBmod.read_status_data(AUTO_data,element,"blockingstate"): # blocking state is TRUE
#print " TRUE ------------------------------------------------------- " , element
if sensor in sensorblockingcounter:
sensorblockingcounter[sensor]=sensorblockingcounter[sensor]+1
else:
sensorblockingcounter[sensor]=1
print(sensorblockingcounter)
global BLOCKING_data
for sensor in sensorblockingcounter:
statusdataDBmod.write_status_data(BLOCKING_data,sensor,"BlockingNumbers",sensorblockingcounter[sensor])
def cycleresetall():
global AUTO_data
elementlist= interruptdbmod.getelementlist()
for element in elementlist:
cyclereset(element)
def interruptcheck(refsensor,mode, PIN):
#logger.info('Starting Interrupt Evaluation, Sensor: %s' , refsensor)
# iterate among the actuators
elementlist= interruptdbmod.getelementlist()
#print elementlist
for element in elementlist:
sensor=interruptdbmod.searchdata("element",element,"sensor")
#print sensor
if sensor==refsensor:
sensormode=interruptdbmod.searchdata("element",element,"sensor_mode")
#print "mode ", mode , "sensormode ", sensormode
if (mode in sensormode) or ("both" in sensormode):
interruptexecute(refsensor,element)
return
def ReadInterruptFrequency(PIN):
sensorinterruptcount=statusdataDBmod.read_status_data(SENSOR_data,PIN,"InterruptCount")
Startcounttime=statusdataDBmod.read_status_data(SENSOR_data,PIN,"Startcounttime")
nowtime=datetime.utcnow()
diffseconds=(nowtime-Startcounttime).total_seconds()
if diffseconds>0:
Frequency=old_div(sensorinterruptcount,diffseconds)
else:
Frequency = 0
# azzera timer e counter
statusdataDBmod.write_status_data(SENSOR_data,PIN,"InterruptCount",0)
statusdataDBmod.write_status_data(SENSOR_data,PIN,"Startcounttime",nowtime)
return Frequency
def interruptexecute(refsensor,element):
sensor=refsensor
#logger.info('interrupt Pairing OK ---> Actuator: %s , Sensor: %s', element, sensor)
workmode=checkworkmode(element)
if (workmode=="None"):
# None case
print("No Action required, workmode set to None, element: " , element)
logger.info("No Action required, workmode set to None, element: %s " , element)
return
if (workmode==""):
logger.info("Not able to get the workmode: %s " , element)
return
#logger.info('Interrupt, Get all the parameters')
interrupt_validinterval=hardwaremod.tonumber(interruptdbmod.searchdata("element",element,"interrupt_validinterval"),0)
#"Counter Only"
if workmode=="Counter Only":
CounterOnlyNew(element,sensor,interrupt_validinterval)
return
interrupt_triggernumber=hardwaremod.tonumber(interruptdbmod.searchdata("element",element,"interrupt_triggernumber"),1)
actuatoroutput=hardwaremod.tonumber(interruptdbmod.searchdata("element",element,"actuator_output"),0)
# evaluate variables for operational period check
starttime = datetime.strptime(interruptdbmod.searchdata("element",element,"allowedperiod")[0], '%H:%M').time()
endtime = datetime.strptime(interruptdbmod.searchdata("element",element,"allowedperiod")[1], '%H:%M').time()
# get other parameters
seonsormode=interruptdbmod.searchdata("element",element,"sensor_mode")
triggermode=interruptdbmod.searchdata("element",element,"trigger_mode")
preemptiontime=hardwaremod.toint(interruptdbmod.searchdata("element",element,"preemptive_period"),0)
mailtype=interruptdbmod.searchdata("element",element,"mailalerttype")
actionmodeafterfirst=interruptdbmod.searchdata("element",element,"actionmode_afterfirst")
# time check
# ------------------------ interrupt alghoritm
if workmode=="Pre-emptive Blocking":
# check if inside the allowed time period
#print "Pre-emptive Blocking Mode"
#logger.info('Pre-emptive Blocking mode --> %s', element)
timeok=isNowInTimePeriod(starttime, endtime, datetime.now().time()) # don't use UTC here!
#print "inside allowed time ", timeok , " starttime ", starttime , " endtime ", endtime
if timeok:
CheckActivateNotify(element,sensor,preemptiontime,actuatoroutput,actionmodeafterfirst,mailtype,interrupt_triggernumber,interrupt_validinterval,triggermode)
else:
logger.info('out of allowed operational time')
# implment Critical alert message in case the sensor value is one interval more than Max_threshold
return
def CounterOnly(element,sensor,interrupt_validinterval): # this one should be dismissed, anyway it works
isok=False
global AUTO_data
lastinterrupttime=statusdataDBmod.read_status_data(AUTO_data,element,"lastinterrupttime")
nowtime=datetime.utcnow()
#print ' Previous interrupt: ' , lastinterrupttime , ' Now: ', nowtime
diffseconds=(nowtime-lastinterrupttime).total_seconds()
statusdataDBmod.write_status_data(AUTO_data,element,"lastinterrupttime",nowtime)
validinterruptcount=statusdataDBmod.read_status_data(AUTO_data,element,"validinterruptcount")
if diffseconds<=interrupt_validinterval: #valid interval between interrupt, increase counter
validinterruptcount=validinterruptcount+1
statusdataDBmod.write_status_data(AUTO_data,element,"validinterruptcount",validinterruptcount)
else: # time between interrupt too long, restart counter
# save on database
#x = threading.Thread(target=savedata, args=(sensor,validinterruptcount))
#x.start()
#reset counter and events
validinterruptcount=1
statusdataDBmod.write_status_data(AUTO_data,element,"validinterruptcount",validinterruptcount)
WaitandRegister(element, sensor, interrupt_validinterval, validinterruptcount)
return isok
def WaitandRegister(element, sensor, periodsecond, counter): # this one should be dismissed, working with previous procedure
if periodsecond>0:
global AUTO_data
t.sleep(0.05)
# in case another timer is active on this element, cancel it
threadID=statusdataDBmod.read_status_data(AUTO_data,element+sensor,"RegisterID")
if threadID!=None and threadID!="":
threadID.cancel()
# activate a new time, in cas this is not cancelled then the data will be saved callin the savedata procedure
threadID = threading.Timer(periodsecond, savedata, [sensor , counter])
threadID.start()
statusdataDBmod.write_status_data(AUTO_data,element+sensor,"RegisterID",threadID)
else:
x = threading.Thread(target=savedata, args=(sensor,counter))
x.start()
def CounterOnlyNew(element,sensor,periodsecond): # this one should be dismissed
isok=False
global AUTO_data
if periodsecond>0:
# in case another timer is active on this element, cancel it
threadID=statusdataDBmod.read_status_data(AUTO_data,element+sensor,"RegisterID")
if threadID!=None and threadID!="":
threadID.cancel()
validinterruptcount=statusdataDBmod.read_status_data(AUTO_data,element,"validinterruptcount")
validinterruptcount=validinterruptcount+1
statusdataDBmod.write_status_data(AUTO_data,element,"validinterruptcount",validinterruptcount)
else: # time between interrupt exceeded, restart counter
validinterruptcount=1
statusdataDBmod.write_status_data(AUTO_data,element,"validinterruptcount",validinterruptcount)
# activate a new time, in cas this is not cancelled then the data will be saved callin the savedata procedure
threadID = threading.Timer(periodsecond, WaitandRegisterNew, [element , sensor , validinterruptcount])
threadID.start()
statusdataDBmod.write_status_data(AUTO_data,element+sensor,"RegisterID",threadID)
return isok
def WaitandRegisterNew(element, sensor, counter):
global AUTO_data
savedata(sensor , counter)
statusdataDBmod.write_status_data(AUTO_data,element+sensor,"RegisterID",None)
#t.sleep(0.1)
#savedata(sensor , 0)
def CheckActivateNotify(element,sensor,preemptiontime,actuatoroutput,actionmodeafterfirst,mailtype,interrupt_triggernumber,interrupt_validinterval,triggermode):
value=actuatoroutput
isok=False
global AUTO_data
# check if in blocking state
lasteventtime=statusdataDBmod.read_status_data(AUTO_data,element,"lasteventtime")
blockingstate=statusdataDBmod.read_status_data(AUTO_data,element,"blockingstate")
#print ' Previous event: ' , lasteventtime , ' Now: ', datetime.utcnow()
#timedifference=sensordbmod.timediffinminutes(lasteventtime,datetime.utcnow())
#print 'Time interval between actions', timedifference ,'. threshold', preemptiontime
#logger.info('Time interval between Actions %d threshold %d', timedifference,preemptiontime)
# count the interrupt that are fast enough to stay in the valid interrupt period
#print "autodata" ,AUTO_data[element]
lastinterrupttime=statusdataDBmod.read_status_data(AUTO_data,element,"lastinterrupttime")
nowtime=datetime.utcnow()
# ------------ Frequency
if triggermode=="Frequency": # triggermode=="Frequency":
NOWTIMELIST.append(nowtime)
validinterruptcount=statusdataDBmod.read_status_data(AUTO_data,element,"validinterruptcount")
diffseconds=(nowtime-NOWTIMELIST[0]).total_seconds()
if diffseconds<=interrupt_validinterval: #valid interval between interrupt, increase counter
validinterruptcount=validinterruptcount+1
else:
while (diffseconds>interrupt_validinterval)and(len(NOWTIMELIST)>1):
validinterruptcount=validinterruptcount-1
diffseconds=(nowtime-NOWTIMELIST.pop(0)).total_seconds()
validinterruptcount=len(NOWTIMELIST)
statusdataDBmod.write_status_data(AUTO_data,element,"validinterruptcount",validinterruptcount)
#-------------Counter
else: # triggermode=="Counter":
#print ' Previous interrupt: ' , lastinterrupttime , ' Now: ', nowtime
diffseconds=(nowtime-lastinterrupttime).total_seconds()
statusdataDBmod.write_status_data(AUTO_data,element,"lastinterrupttime",nowtime)
validinterruptcount=statusdataDBmod.read_status_data(AUTO_data,element,"validinterruptcount")
if diffseconds<=interrupt_validinterval: #valid interval between interrupt, increase counter
validinterruptcount=validinterruptcount+1
else: # time between interrupt too long, restart counter
# save on database
#x = threading.Thread(target=savedata, args=(sensor,validinterruptcount))
#x.start()
#reset counter and events
validinterruptcount=1
statusdataDBmod.write_status_data(AUTO_data,element,"validinterruptcount",validinterruptcount)
#print(" validinterruptcount --------------------->", validinterruptcount)
#print "********" ,validinterruptcount , "******"
if validinterruptcount>=interrupt_triggernumber:
# set the validinterruptcount to zero
statusdataDBmod.write_status_data(AUTO_data,element,"validinterruptcount",0)
if not blockingstate: # outside the preemption period , first activation
#print " outside the preemption period "
#logger.info('outside the preemption period')
# before action, evaluate if trigger number is reached
print("Implement Actuator Value ", value)
logger.info('Procedure to start actuator %s, for value = %s', element, value)
msg , isok=activateactuator(element, value)
if isok:
statusdataDBmod.write_status_data(AUTO_data,element,"lasteventtime",datetime.utcnow())
statusdataDBmod.write_status_data(AUTO_data,element,"lastactiontime",datetime.utcnow())
statusdataDBmod.write_status_data(AUTO_data,element,"actionvalue",value)
# invia mail, considered as info, not as alert
if mailtype!="none":
if mailtype!="warningonly":
textmessage="INFO: " + sensor + " event , activating:" + element + " with Value " + str(value)
#send mail using thread to avoid blocking
x = threading.Thread(target=emailmod.sendallmail, args=("alert", textmessage))
x.start()
#emailmod.sendallmail("alert", textmessage)
# start the blocking state
print("Start blocking state")
startblockingstate(element,preemptiontime)
else:
# inside blocking state, when the event is activated
#print " inside the preemption period, starting followup actions: " , actionmodeafterfirst
#logger.info('inside the preemption period, check followup actions %s :', actionmodeafterfirst)
if actionmodeafterfirst=="None":
return
# Extend blocking state
if actionmodeafterfirst=="Extend blocking state" or actionmodeafterfirst=="Extend and Follow-up": # extend only the pre-emption blocking period, no action
print("Extend blocking state")
startblockingstate(element,preemptiontime)
# Remove blocking state
if actionmodeafterfirst=="Remove blocking state" or actionmodeafterfirst=="Remove and Follow-up": # remove the pre-emption blocking period, no action
print("Remove blocking state")
endblocking(element)
# section below is the follow-up
isok=CheckandFollowup(element)
# invia mail, considered as info, not as alert
if isok:
if mailtype!="none":
if mailtype!="warningonly":
textmessage="INFO: " + sensor + " event , activating:" + element + " with Value " + str(value)
x = threading.Thread(target=emailmod.sendallmail, args=("alert", textmessage))
x.start()
#emailmod.sendallmail("alert", textmessage)
return isok
def CheckandFollowup(element):
global AUTO_data
actionmodeafterfirst=interruptdbmod.searchdata("element",element,"actionmode_afterfirst")
actuatoroutputfollowup=hardwaremod.tonumber(interruptdbmod.searchdata("element",element,"folloup_output"),0)
# section below is the follow-up
if actionmodeafterfirst=="Follow-up action" or actionmodeafterfirst=="Remove and Follow-up" or actionmodeafterfirst=="Extend and Follow-up": # execute the action followup, no variation in the preemption period
value=actuatoroutputfollowup
# followup action
print("Implement Actuator Value followup", value)
logger.info('Procedure to start actuator followup %s, for value = %s', element, value)
msg , isok=activateactuator(element, value)
if isok:
statusdataDBmod.write_status_data(AUTO_data,element,"lastactiontime",datetime.utcnow())
statusdataDBmod.write_status_data(AUTO_data,element,"actionvalue",value)
return True
return False
def startblockingstate(element,periodsecond,saveend=True):
#logger.warning("StartBOLCKINGSTATE Started ---> Period %d", periodsecond)
global BLOCKING_data
sensor=interruptdbmod.searchdata("element",element,"sensor")
#save data
print("first save in database")
if saveend:
saveblockingdiff(sensor)
#--
if periodsecond>0:
global AUTO_data
# in case another timer is active on this element, cancel it
threadID=statusdataDBmod.read_status_data(AUTO_data,element,"threadID")
if threadID!=None and threadID!="":
#print "cancel the Thread of element=",element
threadID.cancel()
else:
# change blocking counter
BlockingNumbers=statusdataDBmod.read_status_data(BLOCKING_data,sensor,"BlockingNumbers")
BlockingNumbers=BlockingNumbers+1
statusdataDBmod.write_status_data(BLOCKING_data,sensor,"BlockingNumbers",BlockingNumbers)
#--
#save data
if saveend:
saveblockingdiff(sensor)
#--
statusdataDBmod.write_status_data(AUTO_data,element,"blockingstate",True)
statusdataDBmod.write_status_data(hardwaremod.Blocking_Status,element,"priority",ACTIONPRIORITYLEVEL) #increse the priority to execute a command
nonblockingpriority=0
#logger.warning("Trigger EndblockingStart ---> Period %d", periodsecond)
threadID = threading.Timer(periodsecond, endblocking, [element , saveend])
threadID.start()
statusdataDBmod.write_status_data(AUTO_data,element,"threadID",threadID)
def endblocking(element, saveend=True):
sensor=interruptdbmod.searchdata("element",element,"sensor")
if checkstopcondition(element):
global AUTO_data
#save data
if saveend:
saveblockingdiff(sensor)
#--
threadID=statusdataDBmod.read_status_data(AUTO_data,element,"threadID")
if threadID!=None and threadID!="":
#print "cancel the Thread of element=",element
threadID.cancel()
global BLOCKING_data
# change blocking counter
BlockingNumbers=statusdataDBmod.read_status_data(BLOCKING_data,sensor,"BlockingNumbers")
BlockingNumbers=BlockingNumbers-1
statusdataDBmod.write_status_data(BLOCKING_data,sensor,"BlockingNumbers",BlockingNumbers)
#--
#save data
saveblockingdiff(sensor)
#--
#print "Start removing blocking status"
statusdataDBmod.write_status_data(hardwaremod.Blocking_Status,element,"priority",NONBLOCKINGPRIORITY) #put the priority to lower levels
statusdataDBmod.write_status_data(AUTO_data,element,"threadID",None)
statusdataDBmod.write_status_data(AUTO_data,element,"blockingstate",False)
else: # renew the blocking status
print("Interrupt LEVEL High, Do not stop blocking period, Extend it")
# reload the period in case this is chnaged
preemptiontime=hardwaremod.toint(interruptdbmod.searchdata("element",element,"preemptive_period"),0)
if preemptiontime>0:
startblockingstate(element,preemptiontime)
#follow-up
CheckandFollowup(element)
def checkstopcondition(element):
#print "Evaluating End of Blocking period ++++++++++++"
actionmodeafterfirst=interruptdbmod.searchdata("element",element,"actionmode_afterfirst")
#print "actionafter " , actionmodeafterfirst
sensor=interruptdbmod.searchdata("element",element,"sensor")
if actionmodeafterfirst=="Extend blocking state" or actionmodeafterfirst=="Extend and Follow-up": # extend the pre-emption blocking period
seonsormode=interruptdbmod.searchdata("element",element,"sensor_mode")
#print "SENSORMODE" , seonsormode
recordkey=hardwaremod.HW_INFO_NAME
recordvalue=sensor
keytosearch=hardwaremod.HW_CTRL_PIN
PIN=hardwaremod.searchdata(recordkey,recordvalue,keytosearch)
reading=hardwaremod.readinputpin(PIN)
if seonsormode=="First Edge + Level":
keytosearch=hardwaremod.HW_CTRL_LOGIC
logic=hardwaremod.searchdata(recordkey,recordvalue,keytosearch)
# pin high according to the set logic
#print "logic:", logic , " reading:" ,reading
if (logic=="pos" and reading=="1")or(logic=="neg" and reading=="0"):
return False
elif seonsormode=="Second Edge + Level (inv)":
keytosearch=hardwaremod.HW_CTRL_LOGIC
logic=hardwaremod.searchdata(recordkey,recordvalue,keytosearch)
#pin LOW according to the set logic
#print "logic:", logic , " reading:" ,reading
if (logic=="pos" and reading=="0")or(logic=="neg" and reading=="1"):
return False
return True
def saveblockingdiff(sensor): # this function minimize the writing over the database, keep them at 1 sec distance and provides a visual pleasant graph :)
global BLOCKING_data
global SAVEBLOCKINGDIFFBUSY
if not SAVEBLOCKINGDIFFBUSY:
SAVEBLOCKINGDIFFBUSY=True
threadID=statusdataDBmod.read_status_data(BLOCKING_data,sensor,"BlockingNumbersThreadID")
print(" threadID ", threadID)
if (threadID!=None) and (threadID!=""): # thread already present
print("thread present already, remove it")
threadID.cancel()
else:
# no thread present already
print("no thread present already ")
x = threading.Thread(target=saveblocking, args=(sensor,False))
x.start()
#logger.warning("SaveBlockDIFF ---> Sensor %s", sensor)
threadID = threading.Timer(1, saveblocking, [sensor])
threadID.start()
statusdataDBmod.write_status_data(BLOCKING_data,sensor,"BlockingNumbersThreadID",threadID)
SAVEBLOCKINGDIFFBUSY=False
else:
print(" BUSYYYYY")
def saveblocking(sensor,cleanThreadID=True):
global SAVEBLOCKINGBUSY
global BLOCKING_data
if not SAVEBLOCKINGBUSY:
SAVEBLOCKINGBUSY=True
BlockingNumbers=statusdataDBmod.read_status_data(BLOCKING_data,sensor,"BlockingNumbers")
print("SAVING :::::: sensor ",sensor," BlockingNumbers " ,BlockingNumbers)
savedata(sensor,BlockingNumbers)
if cleanThreadID:
statusdataDBmod.write_status_data(BLOCKING_data,sensor,"BlockingNumbersThreadID",None)
SAVEBLOCKINGBUSY=False
def activateactuator(target, value): # return true in case the state change: activation is >0 or a different position from prevoius position.
return ActuatorControllermod.activateactuator(target,value)
def isNowInTimePeriod(startTime, endTime, nowTime):
#print "iNSIDE pERIOD" ,startTime," ", endTime," " , nowTime
if startTime < endTime:
return nowTime >= startTime and nowTime <= endTime
else: #Over midnight
return nowTime >= startTime or nowTime <= endTime
def checkworkmode(element):
return interruptdbmod.searchdata("element",element,"workmode")
if __name__ == '__main__':
"""
prova functions
"""
| Hydrosys4/Master | interruptmod.py | Python | gpl-3.0 | 29,482 | 0.054949 |
import logging
from django.core.urlresolvers import reverse
from django.utils.translation import ugettext as _, ungettext
from mss.lib.xmlrpc import XmlRpc
xmlrpc = XmlRpc()
logger = logging.getLogger(__name__)
class Steps:
PREINST = "preinst"
DOWNLOAD = "download"
MEDIAS_AUTH = "medias_auth"
MEDIAS_ADD = "medias_add"
INSTALL = "install"
CONFIG = "config"
END = "end"
class State:
DISABLED = -1
TODO = 0
DONE = 1
class Transaction(object):
def __init__(self, request, modules_list=None):
if modules_list is not None:
self.modules_list = modules_list
self.setup()
else:
self.modules_list = request.session['modules_list']
self.steps = request.session['steps']
self.update()
self.save(request)
def setup(self):
result = xmlrpc.call('preinstall_modules', self.modules_list)
self.modules_info = result
self.modules_list = [m['slug'] for m in self.modules_info]
self.steps = [
{
'id': Steps.PREINST,
'state': State.TODO,
'title': _("Installation summary"),
'info': ungettext(
"The following addon will be installed.",
"The following addons will be installed.",
len(self.modules_list)
),
'show_modules': True,
'current': False
},
{
'id': Steps.DOWNLOAD,
'state': State.DISABLED,
'title': _("Addon download"),
'info': _("Download addons from the ServicePlace"),
'current': False,
},
{
'id': Steps.MEDIAS_AUTH,
'state': State.DISABLED,
'title': _("Medias authentication"),
'info': _("One or more medias need authentication"),
'current': False,
},
{
'id': Steps.MEDIAS_ADD,
'state': State.DISABLED,
'title': _("Medias add"),
'info': "",
'current': False,
},
{
'id': Steps.INSTALL,
'state': State.DISABLED,
'title': _("Installation"),
'info': "",
'current': False,
},
{
'id': Steps.CONFIG,
'state': State.DISABLED,
'title': _("Initial configuration"),
'info': "",
'current': False
},
{
'id': Steps.END,
'state': State.TODO,
'title': _("End of installation"),
'info': _("The installation is finished."),
'reboot': False,
'current': False
}
]
for module in self.modules_info:
if not module['installed'] or not module["downloaded"]:
self.todo_step(Steps.INSTALL)
if not module["downloaded"]:
self.todo_step(Steps.DOWNLOAD)
if module["has_repositories"]:
self.todo_step(Steps.MEDIAS_ADD)
if module["has_restricted_repositories"]:
self.todo_step(Steps.MEDIAS_AUTH)
if module["has_configuration"] or module["has_configuration_script"] or not module["downloaded"]:
self.todo_step(Steps.CONFIG)
if module['reboot']:
self.update_step({'id': Steps.END,
'title': _("Reboot"),
'reboot': True,
'info': _("The installation is finished. The server must be rebooted. The reboot can take a few minutes.")})
def update(self):
self.modules_info = xmlrpc.call('get_modules_details', self.modules_list)
downloaded = True
has_repositories = False
has_restricted_repositories = False
installed = True
configured = True
for module in self.modules_info:
if not module['downloaded']:
downloaded = False
if module['has_repositories']:
has_repositories = True
if module['has_restricted_repositories']:
has_restricted_repositories = True
if not module['installed']:
installed = False
if module["has_configuration_script"] and module['can_configure']:
configured = False
if not module['downloaded']:
configured = False
if self.get_state_step(Steps.DOWNLOAD) == State.TODO and downloaded:
self.done_step(Steps.DOWNLOAD)
if self.get_state_step(Steps.INSTALL) == State.TODO and installed:
self.done_step(Steps.INSTALL)
if self.get_state_step(Steps.MEDIAS_AUTH) == State.TODO and not has_restricted_repositories:
self.done_step(Steps.MEDIAS_AUTH)
if self.get_state_step(Steps.MEDIAS_ADD) == State.TODO and not has_repositories:
self.done_step(Steps.MEDIAS_ADD)
if self.get_state_step(Steps.CONFIG) == State.TODO and configured:
self.done_step(Steps.CONFIG)
def save(self, request):
request.session['modules_list'] = self.modules_list
request.session['steps'] = self.steps
def find_step(self, step):
for s in self.steps:
if s['id'] == step:
return s
raise Exception("Step does not exist ?!")
def get_state_step(self, step):
return self.find_step(step)['state']
def todo_step(self, step):
self.find_step(step)['state'] = State.TODO
def done_step(self, step):
self.find_step(step)['state'] = State.DONE
def update_step(self, step):
for s in self.steps:
if s['id'] == step['id']:
for key, value in step.items():
s[key] = value
def current_step(self):
for s in self.steps:
if s['current']:
return s
def set_current_step(self, step):
for s in self.steps:
if s['id'] == step:
s['current'] = True
else:
s['current'] = False
def first_step(self):
for step in self.steps:
if not step['state'] in (State.DONE, State.DISABLED):
return step
def next_step(self):
next = False
for step in self.steps:
if next and not step['state'] in (State.DONE, State.DISABLED):
return step
if step['current']:
next = True
# no next step, return home
return {'id': 'sections'}
def next_step_url(self):
return reverse(self.next_step()['id'])
def first_step_url(self):
return reverse(self.first_step()['id'])
def current_step_url(self):
return reverse(self.current_step()['id'])
| pulse-project/mss | mss/www/wizard/transaction.py | Python | gpl-3.0 | 7,120 | 0.000702 |
import math
import os
import sys
sys.path.append(os.path.dirname(sys.argv[0])+"/../TensorFlowScripts")
import train_GED
from hyperopt import hp, fmin, rand, tpe, STATUS_OK, Trials
space = {
'lr': hp.loguniform('lr', math.log(1e-5), math.log(30)),
'wd' : hp.choice('wd', [1e-1, 1e-2, 1e-3, 1e-4, 1e-5, 1e-6, 1e-7, 1e-8, 1e-9, 1e-10, 0.0]),
'hsize': hp.choice('hsize', [2048]),
'nlayers': hp.choice('nlayers', [3]),
'Lambda': hp.choice('Lambda', [0.0]),
'gamma': hp.choice('gamma', [0.999])
}
def objective(params):
train_loss,val_loss = train_GED.main(params)
print "LOSSES: ",train_loss,val_loss
return {
'loss': train_loss,
'loss_variance': train_loss * (1.0 - train_loss),
'true_loss': val_loss,
'true_loss_variance': val_loss * (1.0 - val_loss),
'status': STATUS_OK,
# # -- store other results like this
# 'eval_time': time.time(),
# 'other_stuff': {'type': None, 'value': [0, 1, 2]},
# # -- attachments are handled differently
# 'attachments':
# {'time_module': pickle.dumps(time.time)}
}
trials = Trials()
best = fmin(objective, space=space, algo=tpe.suggest, max_evals=100)
print best
| pakozm/DNNJ | HyperoptScripts/hyperopt_mlp.py | Python | mit | 1,224 | 0.007353 |
import os
os.environ["qwiejioqwjeioqwjeioqwje"]
| supercheetah/diceroller | pyinstaller/buildtests/import/error_during_import2.py | Python | artistic-2.0 | 48 | 0 |
from subprocess import Popen, PIPE
import itertools
ITERATORS_NUM = [0, 1, 4]
UPDATERS_NUM = [1, 2, 4, 8]
DURATION = [2]
PERCENTAGES = [(25, 25)]
KEY_RANGE = [65536]
INIT_SIZE = [1024]
PARAMETER_COMBINATIONS = [ITERATORS_NUM, UPDATERS_NUM, DURATION, PERCENTAGES, KEY_RANGE, INIT_SIZE]
for param in itertools.product(*PARAMETER_COMBINATIONS):
args = ["java", "-cp", ".:lib/java-getopt-1.0.13.jar" , "IteratorTest"]
args += ["-i", str(param[0])]
args += ["-u", str(param[1])]
args += ["-d", str(param[2])]
args += ["-I", str(param[3][0])]
args += ["-R", str(param[3][1])]
args += ["-M", str(param[4])]
args += ["-s", str(param[5])]
pTest = Popen(args, stdout=PIPE)
result = pTest.communicate()[0]
print result
| ezrosent/iterators-etc | hash/runTests.py | Python | mit | 722 | 0.018006 |
from src.utils import glove
import numpy as np
import string
class jester_vectorize():
def __init__(self, user_interactions, content, user_vector_type, content_vector_type, **support_files):
"""Set up the Jester Vectorizer.
Args:
user_interactions (rdd): The raw data of users interactions with
the system. For Jester, each "row" is as follows:
Row(joke_id, rating, user_id)
content (rdd): The raw data about the items in the dataset. For
Jester, each row is as follows: Row(joke_id, joke_text)
user_vector_type (str): The type of user vector desired. One of
'ratings', 'pos_ratings', 'ratings_to_interact', or None.
content_vector_type: The type of content vector desired. One of
'glove' or None.
support_files: Only one support file is used for this class:
glove_model: An instantiated glove model.
"""
self.user_vector_type = user_vector_type
self.content_vector_type = content_vector_type
self.user_interactions = user_interactions
self.content = content
# If no support files were passed in, initialize an empty support file
if support_files:
self.support_files = support_files
else:
self.support_files = {}
def get_user_vector(self):
"""Produce an RDD containing tuples of the form (user, item, rating).
There are three options when producing these user vectors:
ratings: The ratings the users assigned
pos_ratings: Only ratings > 0, all others are discarded
ratings_to_interact: Positive ratings are mapped to 1, negative to -1.
"""
uir = self.user_interactions.map(lambda row: (row.user_id, row.joke_id, row.rating))
if self.user_vector_type == 'ratings':
return uir
elif self.user_vector_type == 'pos_ratings':
return uir.filter(lambda (u, i, r): r > 0)
elif self.user_vector_type == 'ratings_to_interact':
return uir.map(lambda (u, i, r): (u, i, 1 if r > 0 else -1))
elif self.user_vector_type == 'none' or self.user_vector_type is None:
return None
else:
print "Please choose a user_vector_type between 'ratings', 'pos_ratings', 'ratings_to_interact', and 'none'"
return None
def get_content_vector(self):
"""Produce an RDD containing tuples of the form (item, content_vector).
There is one method of producing content vectors:
glove: Use the Stanford GloVe model to sum vector ratings of all
the words in the joke.
"""
if self.content_vector_type == 'glove':
# The model is initialized by the user and passed in via the
# support_file object
glove_model = self.support_files["glove_model"]
# Transformation function
def joke_to_glove(row, glove):
vector = np.zeros(glove.vector_size)
for chunk in row.joke_text.split():
word = chunk.lower().strip(string.punctuation)
vector += glove[word]
return (row.joke_id, vector)
# Run the transformation function over the data
return self.content.map(lambda row: joke_to_glove(row, glove_model))
elif self.content_vector_type == 'none' or self.content_vector_type is None:
return None
else:
print "Please choose a content_vector_type between 'glove' or None"
return None
| tiffanyj41/hermes | src/data_prep/jester_vectorize.py | Python | apache-2.0 | 3,684 | 0.001629 |
# Copyright (C) 2008-2009 Open Society Institute
# Thomas Moroz: [email protected]
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License Version 2 as published
# by the Free Software Foundation. You may not use, modify or distribute
# this program under any other version of the GNU General Public License.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
# a package
| boothead/karl | karl/views/__init__.py | Python | gpl-2.0 | 864 | 0.001157 |
# -*- coding: utf-8 -*-
###############################################################################
#
# TollFreeList
# Returns a list of toll-free available phone numbers that match the specified filters.
#
# Python version 2.6
#
###############################################################################
from temboo.core.choreography import Choreography
from temboo.core.choreography import InputSet
from temboo.core.choreography import ResultSet
from temboo.core.choreography import ChoreographyExecution
import json
class TollFreeList(Choreography):
def __init__(self, temboo_session):
"""
Create a new instance of the TollFreeList Choreo. A TembooSession object, containing a valid
set of Temboo credentials, must be supplied.
"""
Choreography.__init__(self, temboo_session, '/Library/Twilio/AvailablePhoneNumbers/TollFreeList')
def new_input_set(self):
return TollFreeListInputSet()
def _make_result_set(self, result, path):
return TollFreeListResultSet(result, path)
def _make_execution(self, session, exec_id, path):
return TollFreeListChoreographyExecution(session, exec_id, path)
class TollFreeListInputSet(InputSet):
"""
An InputSet with methods appropriate for specifying the inputs to the TollFreeList
Choreo. The InputSet object is used to specify input parameters when executing this Choreo.
"""
def set_AccountSID(self, value):
"""
Set the value of the AccountSID input for this Choreo. ((required, string) The AccountSID provided when you signed up for a Twilio account.)
"""
InputSet._set_input(self, 'AccountSID', value)
def set_AreaCode(self, value):
"""
Set the value of the AreaCode input for this Choreo. ((optional, integer) Find phone numbers in the specified area code. (US and Canada only).)
"""
InputSet._set_input(self, 'AreaCode', value)
def set_AuthToken(self, value):
"""
Set the value of the AuthToken input for this Choreo. ((required, string) The authorization token provided when you signed up for a Twilio account.)
"""
InputSet._set_input(self, 'AuthToken', value)
def set_Contains(self, value):
"""
Set the value of the Contains input for this Choreo. ((optional, string) A pattern to match phone numbers on. Valid characters are '*' and [0-9a-zA-Z]. The '*' character will match any single digit.)
"""
InputSet._set_input(self, 'Contains', value)
def set_IsoCountryCode(self, value):
"""
Set the value of the IsoCountryCode input for this Choreo. ((optional, string) The country code to search within. Defaults to US.)
"""
InputSet._set_input(self, 'IsoCountryCode', value)
def set_PageSize(self, value):
"""
Set the value of the PageSize input for this Choreo. ((optional, integer) The number of results per page.)
"""
InputSet._set_input(self, 'PageSize', value)
def set_Page(self, value):
"""
Set the value of the Page input for this Choreo. ((optional, integer) The page of results to retrieve. Defaults to 0.)
"""
InputSet._set_input(self, 'Page', value)
def set_ResponseFormat(self, value):
"""
Set the value of the ResponseFormat input for this Choreo. ((optional, string) The format that the response should be in. Valid values are: json (the default) and xml.)
"""
InputSet._set_input(self, 'ResponseFormat', value)
class TollFreeListResultSet(ResultSet):
"""
A ResultSet with methods tailored to the values returned by the TollFreeList Choreo.
The ResultSet object is used to retrieve the results of a Choreo execution.
"""
def getJSONFromString(self, str):
return json.loads(str)
def get_Response(self):
"""
Retrieve the value for the "Response" output from this Choreo execution. (The response from Twilio.)
"""
return self._output.get('Response', None)
class TollFreeListChoreographyExecution(ChoreographyExecution):
def _make_result_set(self, response, path):
return TollFreeListResultSet(response, path)
| egetzel/wecrow | truehand2014/temboo/Library/Twilio/AvailablePhoneNumbers/TollFreeList.py | Python | apache-2.0 | 4,256 | 0.007519 |
#! /usr/bin/env python
# Hi There!
# You may be wondering what this giant blob of binary data here is, you might
# even be worried that we're up to something nefarious (good for you for being
# paranoid!). This is a base64 encoding of a zip file, this zip file contains
# a fully functional basic pytest script.
#
# Pytest is a thing that tests packages, pytest itself is a package that some-
# one might want to install, especially if they're looking to run tests inside
# some package they want to install. Pytest has a lot of code to collect and
# execute tests, and other such sort of "tribal knowledge" that has been en-
# coded in its code base. Because of this we basically include a basic copy
# of pytest inside this blob. We do this because it let's you as a maintainer
# or application developer who wants people who don't deal with python much to
# easily run tests without installing the complete pytest package.
#
# If you're wondering how this is created: you can create it yourself if you
# have a complete pytest installation by using this command on the command-
# line: ``py.test --genscript=runtests.py``.
sources = """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"""
import sys
import base64
import zlib
class DictImporter(object):
def __init__(self, sources):
self.sources = sources
def find_module(self, fullname, path=None):
if fullname == "argparse" and sys.version_info >= (2,7):
# we were generated with <python2.7 (which pulls in argparse)
# but we are running now on a stdlib which has it, so use that.
return None
if fullname in self.sources:
return self
if fullname + '.__init__' in self.sources:
return self
return None
def load_module(self, fullname):
# print "load_module:", fullname
from types import ModuleType
try:
s = self.sources[fullname]
is_pkg = False
except KeyError:
s = self.sources[fullname + '.__init__']
is_pkg = True
co = compile(s, fullname, 'exec')
module = sys.modules.setdefault(fullname, ModuleType(fullname))
module.__file__ = "%s/%s" % (__file__, fullname)
module.__loader__ = self
if is_pkg:
module.__path__ = [fullname]
do_exec(co, module.__dict__) # noqa
return sys.modules[fullname]
def get_source(self, name):
res = self.sources.get(name)
if res is None:
res = self.sources.get(name + '.__init__')
return res
if __name__ == "__main__":
if sys.version_info >= (3, 0):
exec("def do_exec(co, loc): exec(co, loc)\n")
import pickle
sources = sources.encode("ascii") # ensure bytes
sources = pickle.loads(zlib.decompress(base64.decodebytes(sources)))
else:
import cPickle as pickle
exec("def do_exec(co, loc): exec co in loc\n")
sources = pickle.loads(zlib.decompress(base64.decodestring(sources)))
importer = DictImporter(sources)
sys.meta_path.insert(0, importer)
entry = "import pytest; raise SystemExit(pytest.cmdline.main())"
do_exec(entry, locals()) # noqa
| mmolero/pyqode.python | runtests.py | Python | mit | 236,912 | 0.000038 |
import parmed.unit as units
from intermol.decorators import accepts_compatible_units
from intermol.forces.abstract_dihedral_type import AbstractDihedralType
class ProperPeriodicDihedralType(AbstractDihedralType):
__slots__ = ['phi', 'k', 'multiplicity', 'weight', 'improper']
@accepts_compatible_units(None, None, None, None,
phi=units.degrees,
k=units.kilojoules_per_mole,
multiplicity=units.dimensionless,
weight=units.dimensionless,
improper=None)
def __init__(self, bondingtype1, bondingtype2, bondingtype3, bondingtype4,
phi=0.0 * units.degrees,
k=0.0 * units.kilojoules_per_mole,
multiplicity=0.0 * units.dimensionless,
weight=0.0 * units.dimensionless,
improper=False):
AbstractDihedralType.__init__(self, bondingtype1, bondingtype2, bondingtype3, bondingtype4, improper)
self.phi = phi
self.k = k
self.multiplicity = multiplicity
self.weight = weight
class ProperPeriodicDihedral(ProperPeriodicDihedralType):
"""
stub documentation
"""
def __init__(self, atom1, atom2, atom3, atom4, bondingtype1=None, bondingtype2=None, bondingtype3=None, bondingtype4=None,
phi=0.0 * units.degrees,
k=0.0 * units.kilojoules_per_mole,
multiplicity=0.0 * units.dimensionless,
weight=0.0 * units.dimensionless,
improper=False):
self.atom1 = atom1
self.atom2 = atom2
self.atom3 = atom3
self.atom4 = atom4
ProperPeriodicDihedralType.__init__(self, bondingtype1, bondingtype2, bondingtype3, bondingtype4,
phi=phi,
k=k,
multiplicity=multiplicity,
weight=weight,
improper=improper) | shirtsgroup/InterMol | intermol/forces/proper_periodic_dihedral_type.py | Python | mit | 1,984 | 0.006552 |
# -*- coding: utf-8 -*-
#
# http://www.privacyidea.org
# (c) cornelius kölbel, privacyidea.org
#
# 2020-01-30 Jean-Pierre Höhmann <[email protected]>
# Add WebAuthn token
# 2018-01-22 Cornelius Kölbel <[email protected]>
# Add offline refill
# 2016-12-20 Cornelius Kölbel <[email protected]>
# Add triggerchallenge endpoint
# 2016-10-23 Cornelius Kölbel <[email protected]>
# Add subscription decorator
# 2016-09-05 Cornelius Kölbel <[email protected]>
# SAML attributes on fail
# 2016-08-30 Cornelius Kölbel <[email protected]>
# save client application type to database
# 2016-08-09 Cornelius Kölbel <[email protected]>
# Add possibility to check OTP only
# 2015-11-19 Cornelius Kölbel <[email protected]>
# Add support for transaction_id to saml_check
# 2015-06-17 Cornelius Kölbel <[email protected]>
# Add policy decorator for API key requirement
# 2014-12-08 Cornelius Kölbel, <[email protected]>
# Complete rewrite during flask migration
# Try to provide REST API
#
# This code is free software; you can redistribute it and/or
# modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
# License as published by the Free Software Foundation; either
# version 3 of the License, or any later version.
#
# This code is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU AFFERO GENERAL PUBLIC LICENSE for more details.
#
# You should have received a copy of the GNU Affero General Public
# License along with this program. If not, see <http://www.gnu.org/licenses/>.
#
__doc__ = """This module contains the REST API for doing authentication.
The methods are tested in the file tests/test_api_validate.py
Authentication is either done by providing a username and a password or a
serial number and a password.
**Authentication workflow**
Authentication workflow is like this:
In case of authenticating a user:
* :func:`privacyidea.lib.token.check_user_pass`
* :func:`privacyidea.lib.token.check_token_list`
* :func:`privacyidea.lib.tokenclass.TokenClass.authenticate`
* :func:`privacyidea.lib.tokenclass.TokenClass.check_pin`
* :func:`privacyidea.lib.tokenclass.TokenClass.check_otp`
In case if authenticating a serial number:
* :func:`privacyidea.lib.token.check_serial_pass`
* :func:`privacyidea.lib.token.check_token_list`
* :func:`privacyidea.lib.tokenclass.TokenClass.authenticate`
* :func:`privacyidea.lib.tokenclass.TokenClass.check_pin`
* :func:`privacyidea.lib.tokenclass.TokenClass.check_otp`
"""
from flask import (Blueprint, request, g, current_app)
from privacyidea.lib.user import get_user_from_param, log_used_user
from .lib.utils import send_result, getParam
from ..lib.decorators import (check_user_or_serial_in_request)
from .lib.utils import required
from privacyidea.lib.error import ParameterError
from privacyidea.lib.token import (check_user_pass, check_serial_pass,
check_otp, create_challenges_from_tokens, get_one_token)
from privacyidea.api.lib.utils import get_all_params
from privacyidea.lib.config import (return_saml_attributes, get_from_config,
return_saml_attributes_on_fail,
SYSCONF, ensure_no_config_object)
from privacyidea.lib.audit import getAudit
from privacyidea.api.lib.decorators import add_serial_from_response_to_g
from privacyidea.api.lib.prepolicy import (prepolicy, set_realm,
api_key_required, mangle,
save_client_application_type,
check_base_action, pushtoken_wait, webauthntoken_auth, webauthntoken_authz,
webauthntoken_request, check_application_tokentype)
from privacyidea.api.lib.postpolicy import (postpolicy,
check_tokentype, check_serial,
check_tokeninfo,
no_detail_on_fail,
no_detail_on_success, autoassign,
offline_info,
add_user_detail_to_response, construct_radius_response,
mangle_challenge_response, is_authorized)
from privacyidea.lib.policy import PolicyClass
from privacyidea.lib.event import EventConfiguration
import logging
from privacyidea.api.register import register_blueprint
from privacyidea.api.recover import recover_blueprint
from privacyidea.lib.utils import get_client_ip
from privacyidea.lib.event import event
from privacyidea.lib.challenge import get_challenges, extract_answered_challenges
from privacyidea.lib.subscriptions import CheckSubscription
from privacyidea.api.auth import admin_required
from privacyidea.lib.policy import ACTION
from privacyidea.lib.token import get_tokens
from privacyidea.lib.machine import list_machine_tokens
from privacyidea.lib.applications.offline import MachineApplication
import json
log = logging.getLogger(__name__)
validate_blueprint = Blueprint('validate_blueprint', __name__)
@validate_blueprint.before_request
@register_blueprint.before_request
@recover_blueprint.before_request
def before_request():
"""
This is executed before the request
"""
ensure_no_config_object()
request.all_data = get_all_params(request)
request.User = get_user_from_param(request.all_data)
privacyidea_server = current_app.config.get("PI_AUDIT_SERVERNAME") or \
request.host
# Create a policy_object, that reads the database audit settings
# and contains the complete policy definition during the request.
# This audit_object can be used in the postpolicy and prepolicy and it
# can be passed to the innerpolicies.
g.policy_object = PolicyClass()
g.audit_object = getAudit(current_app.config, g.startdate)
g.event_config = EventConfiguration()
# access_route contains the ip addresses of all clients, hops and proxies.
g.client_ip = get_client_ip(request, get_from_config(SYSCONF.OVERRIDECLIENT))
# Save the HTTP header in the localproxy object
g.request_headers = request.headers
g.serial = getParam(request.all_data, "serial", default=None)
g.audit_object.log({"success": False,
"action_detail": "",
"client": g.client_ip,
"client_user_agent": request.user_agent.browser,
"privacyidea_server": privacyidea_server,
"action": "{0!s} {1!s}".format(request.method, request.url_rule),
"info": ""})
@validate_blueprint.route('/offlinerefill', methods=['POST'])
@check_user_or_serial_in_request(request)
@event("validate_offlinerefill", request, g)
def offlinerefill():
"""
This endpoint allows to fetch new offline OTP values for a token,
that is already offline.
According to the definition it will send the missing OTP values, so that
the client will have as much otp values as defined.
:param serial: The serial number of the token, that should be refilled.
:param refilltoken: The authorization token, that allows refilling.
:param pass: the last password (maybe password+OTP) entered by the user
:return:
"""
serial = getParam(request.all_data, "serial", required)
refilltoken = getParam(request.all_data, "refilltoken", required)
password = getParam(request.all_data, "pass", required)
tokenobj_list = get_tokens(serial=serial)
if len(tokenobj_list) != 1:
raise ParameterError("The token does not exist")
else:
tokenobj = tokenobj_list[0]
tokenattachments = list_machine_tokens(serial=serial, application="offline")
if tokenattachments:
# TODO: Currently we do not distinguish, if a token had more than one offline attachment
# We need the options to pass the count and the rounds for the next offline OTP values,
# which could have changed in the meantime.
options = tokenattachments[0].get("options")
# check refill token:
if tokenobj.get_tokeninfo("refilltoken") == refilltoken:
# refill
otps = MachineApplication.get_refill(tokenobj, password, options)
refilltoken = MachineApplication.generate_new_refilltoken(tokenobj)
response = send_result(True)
content = response.json
content["auth_items"] = {"offline": [{"refilltoken": refilltoken,
"response": otps}]}
response.set_data(json.dumps(content))
return response
raise ParameterError("Token is not an offline token or refill token is incorrect")
@validate_blueprint.route('/check', methods=['POST', 'GET'])
@validate_blueprint.route('/radiuscheck', methods=['POST', 'GET'])
@validate_blueprint.route('/samlcheck', methods=['POST', 'GET'])
@postpolicy(is_authorized, request=request)
@postpolicy(mangle_challenge_response, request=request)
@postpolicy(construct_radius_response, request=request)
@postpolicy(no_detail_on_fail, request=request)
@postpolicy(no_detail_on_success, request=request)
@postpolicy(add_user_detail_to_response, request=request)
@postpolicy(offline_info, request=request)
@postpolicy(check_tokeninfo, request=request)
@postpolicy(check_tokentype, request=request)
@postpolicy(check_serial, request=request)
@postpolicy(autoassign, request=request)
@add_serial_from_response_to_g
@prepolicy(check_application_tokentype, request=request)
@prepolicy(pushtoken_wait, request=request)
@prepolicy(set_realm, request=request)
@prepolicy(mangle, request=request)
@prepolicy(save_client_application_type, request=request)
@prepolicy(webauthntoken_request, request=request)
@prepolicy(webauthntoken_authz, request=request)
@prepolicy(webauthntoken_auth, request=request)
@check_user_or_serial_in_request(request)
@CheckSubscription(request)
@prepolicy(api_key_required, request=request)
@event("validate_check", request, g)
def check():
"""
check the authentication for a user or a serial number.
Either a ``serial`` or a ``user`` is required to authenticate.
The PIN and OTP value is sent in the parameter ``pass``.
In case of successful authentication it returns ``result->value: true``.
In case of a challenge response authentication a parameter ``exception=1``
can be passed. This would result in a HTTP 500 Server Error response if
an error occurred during sending of SMS or Email.
In case ``/validate/radiuscheck`` is requested, the responses are
modified as follows: A successful authentication returns an empty ``HTTP
204`` response. An unsuccessful authentication returns an empty ``HTTP
400`` response. Error responses are the same responses as for the
``/validate/check`` endpoint.
:param serial: The serial number of the token, that tries to authenticate.
:param user: The loginname/username of the user, who tries to authenticate.
:param realm: The realm of the user, who tries to authenticate. If the
realm is omitted, the user is looked up in the default realm.
:param type: The tokentype of the tokens, that are taken into account during
authentication. Requires the *authz* policy :ref:`application_tokentype_policy`.
It is ignored when a distinct serial is given.
:param pass: The password, that consists of the OTP PIN and the OTP value.
:param otponly: If set to 1, only the OTP value is verified. This is used
in the management UI. Only used with the parameter serial.
:param transaction_id: The transaction ID for a response to a challenge
request
:param state: The state ID for a response to a challenge request
:return: a json result with a boolean "result": true
**Example Validation Request**:
.. sourcecode:: http
POST /validate/check HTTP/1.1
Host: example.com
Accept: application/json
user=user
realm=realm1
pass=s3cret123456
**Example response** for a successful authentication:
.. sourcecode:: http
HTTP/1.1 200 OK
Content-Type: application/json
{
"detail": {
"message": "matching 1 tokens",
"serial": "PISP0000AB00",
"type": "spass"
},
"id": 1,
"jsonrpc": "2.0",
"result": {
"status": true,
"value": true
},
"version": "privacyIDEA unknown"
}
**Example response** for this first part of a challenge response authentication:
.. sourcecode:: http
HTTP/1.1 200 OK
Content-Type: application/json
{
"detail": {
"serial": "PIEM0000AB00",
"type": "email",
"transaction_id": "12345678901234567890",
"multi_challenge: [ {"serial": "PIEM0000AB00",
"transaction_id": "12345678901234567890",
"message": "Please enter otp from your email",
"client_mode": "interactive"},
{"serial": "PISM12345678",
"transaction_id": "12345678901234567890",
"message": "Please enter otp from your SMS",
"client_mode": "interactive"}
]
},
"id": 2,
"jsonrpc": "2.0",
"result": {
"status": true,
"value": false
},
"version": "privacyIDEA unknown"
}
In this example two challenges are triggered, one with an email and one
with an SMS. The application and thus the user has to decide, which one
to use. They can use either.
The challenges also contain the information of the "client_mode". This
tells the plugin, whether it should display an input field to ask for the
OTP value or e.g. to poll for an answered authentication.
Read more at :ref:`client_modes`.
.. note:: All challenge response tokens have the same ``transaction_id`` in
this case.
**Example response** for a successful authentication with ``/samlcheck``:
.. sourcecode:: http
HTTP/1.1 200 OK
Content-Type: application/json
{
"detail": {
"message": "matching 1 tokens",
"serial": "PISP0000AB00",
"type": "spass"
},
"id": 1,
"jsonrpc": "2.0",
"result": {
"status": true,
"value": {"attributes": {
"username": "koelbel",
"realm": "themis",
"mobile": null,
"phone": null,
"myOwn": "/data/file/home/koelbel",
"resolver": "themis",
"surname": "Kölbel",
"givenname": "Cornelius",
"email": null},
"auth": true}
},
"version": "privacyIDEA unknown"
}
The response in ``value->attributes`` can contain additional attributes
(like "myOwn") which you can define in the LDAP resolver in the attribute
mapping.
"""
user = request.User
serial = getParam(request.all_data, "serial")
password = getParam(request.all_data, "pass", required)
otp_only = getParam(request.all_data, "otponly")
token_type = getParam(request.all_data, "type")
options = {"g": g,
"clientip": g.client_ip,
"user": user}
# Add all params to the options
for key, value in request.all_data.items():
if value and key not in ["g", "clientip", "user"]:
options[key] = value
g.audit_object.log({"user": user.login,
"resolver": user.resolver,
"realm": user.realm})
if serial:
if user:
# check if the given token belongs to the user
if not get_tokens(user=user, serial=serial, count=True):
raise ParameterError('Given serial does not belong to given user!')
if not otp_only:
success, details = check_serial_pass(serial, password, options=options)
else:
success, details = check_otp(serial, password)
result = success
else:
options["token_type"] = token_type
success, details = check_user_pass(user, password, options=options)
result = success
if request.path.endswith("samlcheck"):
ui = user.info
result = {"auth": success,
"attributes": {}}
if return_saml_attributes():
if success or return_saml_attributes_on_fail():
# privacyIDEA's own attribute map
result["attributes"] = {"username": ui.get("username"),
"realm": user.realm,
"resolver": user.resolver,
"email": ui.get("email"),
"surname": ui.get("surname"),
"givenname": ui.get("givenname"),
"mobile": ui.get("mobile"),
"phone": ui.get("phone")}
# additional attributes
for k, v in ui.items():
result["attributes"][k] = v
g.audit_object.log({"info": log_used_user(user, details.get("message")),
"success": success,
"serial": serial or details.get("serial"),
"token_type": details.get("type")})
return send_result(result, rid=2, details=details)
@validate_blueprint.route('/triggerchallenge', methods=['POST', 'GET'])
@admin_required
@postpolicy(is_authorized, request=request)
@postpolicy(mangle_challenge_response, request=request)
@add_serial_from_response_to_g
@check_user_or_serial_in_request(request)
@prepolicy(check_application_tokentype, request=request)
@prepolicy(check_base_action, request, action=ACTION.TRIGGERCHALLENGE)
@prepolicy(webauthntoken_request, request=request)
@prepolicy(webauthntoken_auth, request=request)
@event("validate_triggerchallenge", request, g)
def trigger_challenge():
"""
An administrator can call this endpoint if he has the right of
``triggerchallenge`` (scope: admin).
He can pass a ``user`` name and or a ``serial`` number.
privacyIDEA will trigger challenges for all native challenges response
tokens, possessed by this user or only for the given serial number.
The request needs to contain a valid PI-Authorization header.
:param user: The loginname/username of the user, who tries to authenticate.
:param realm: The realm of the user, who tries to authenticate. If the
realm is omitted, the user is looked up in the default realm.
:param serial: The serial number of the token.
:param type: The tokentype of the tokens, that are taken into account during
authentication. Requires authz policy application_tokentype.
Is ignored when a distinct serial is given.
:return: a json result with a "result" of the number of matching
challenge response tokens
**Example response** for a successful triggering of challenge:
.. sourcecode:: http
HTTP/1.1 200 OK
Content-Type: application/json
{
"detail": {
"client_mode": "interactive",
"message": "please enter otp: , please enter otp: ",
"messages": [
"please enter otp: ",
"please enter otp: "
],
"multi_challenge": [
{
"client_mode": "interactive",
"message": "please enter otp: ",
"serial": "TOTP000026CB",
"transaction_id": "11451135673179897001",
"type": "totp"
},
{
"client_mode": "interactive",
"message": "please enter otp: ",
"serial": "OATH0062752C",
"transaction_id": "11451135673179897001",
"type": "hotp"
}
],
"serial": "OATH0062752C",
"threadid": 140329819764480,
"transaction_id": "11451135673179897001",
"transaction_ids": [
"11451135673179897001",
"11451135673179897001"
],
"type": "hotp"
},
"id": 2,
"jsonrpc": "2.0",
"result": {
"status": true,
"value": 2
}
**Example response** for response, if the user has no challenge token:
.. sourcecode:: http
HTTP/1.1 200 OK
Content-Type: application/json
{
"detail": {"messages": [],
"threadid": 140031212377856,
"transaction_ids": []},
"id": 1,
"jsonrpc": "2.0",
"result": {"status": true,
"value": 0},
"signature": "205530282...54508",
"time": 1484303812.346576,
"version": "privacyIDEA 2.17",
"versionnumber": "2.17"
}
**Example response** for a failed triggering of a challenge. In this case
the ``status`` will be ``false``.
.. sourcecode:: http
HTTP/1.1 200 OK
Content-Type: application/json
{
"detail": null,
"id": 1,
"jsonrpc": "2.0",
"result": {"error": {"code": 905,
"message": "ERR905: The user can not be
found in any resolver in this realm!"},
"status": false},
"signature": "14468...081555",
"time": 1484303933.72481,
"version": "privacyIDEA 2.17"
}
"""
user = request.User
serial = getParam(request.all_data, "serial")
token_type = getParam(request.all_data, "type")
details = {"messages": [],
"transaction_ids": []}
options = {"g": g,
"clientip": g.client_ip,
"user": user}
# Add all params to the options
for key, value in request.all_data.items():
if value and key not in ["g", "clientip", "user"]:
options[key] = value
token_objs = get_tokens(serial=serial, user=user, active=True, revoked=False, locked=False, tokentype=token_type)
# Only use the tokens, that are allowed to do challenge response
chal_resp_tokens = [token_obj for token_obj in token_objs if "challenge" in token_obj.mode]
create_challenges_from_tokens(chal_resp_tokens, details, options)
result_obj = len(details.get("multi_challenge"))
challenge_serials = [challenge_info["serial"] for challenge_info in details["multi_challenge"]]
g.audit_object.log({
"user": user.login,
"resolver": user.resolver,
"realm": user.realm,
"success": result_obj > 0,
"info": log_used_user(user, "triggered {0!s} challenges".format(result_obj)),
"serial": ",".join(challenge_serials),
})
return send_result(result_obj, rid=2, details=details)
@validate_blueprint.route('/polltransaction', methods=['GET'])
@validate_blueprint.route('/polltransaction/<transaction_id>', methods=['GET'])
@prepolicy(mangle, request=request)
@CheckSubscription(request)
@prepolicy(api_key_required, request=request)
def poll_transaction(transaction_id=None):
"""
Given a mandatory transaction ID, check if any non-expired challenge for this transaction ID
has been answered. In this case, return true. If this is not the case, return false.
This endpoint also returns false if no challenge with the given transaction ID exists.
This is mostly useful for out-of-band tokens that should poll this endpoint
to determine when to send an authentication request to ``/validate/check``.
:jsonparam transaction_id: a transaction ID
"""
if transaction_id is None:
transaction_id = getParam(request.all_data, "transaction_id", required)
# Fetch a list of non-exired challenges with the given transaction ID
# and determine whether it contains at least one non-expired answered challenge.
matching_challenges = [challenge for challenge in get_challenges(transaction_id=transaction_id)
if challenge.is_valid()]
answered_challenges = extract_answered_challenges(matching_challenges)
if answered_challenges:
result = True
log_challenges = answered_challenges
else:
result = False
log_challenges = matching_challenges
# We now determine the information that should be written to the audit log:
# * If there are no answered valid challenges, we log all token serials of challenges matching
# the transaction ID and the corresponding token owner
# * If there are any answered valid challenges, we log their token serials and the corresponding user
if log_challenges:
g.audit_object.log({
"serial": ",".join(challenge.serial for challenge in log_challenges),
})
# The token owner should be the same for all matching transactions
user = get_one_token(serial=log_challenges[0].serial).user
if user:
g.audit_object.log({
"user": user.login,
"resolver": user.resolver,
"realm": user.realm,
})
# In any case, we log the transaction ID
g.audit_object.log({
"info": u"transaction_id: {}".format(transaction_id),
"success": result
})
return send_result(result)
| privacyidea/privacyidea | privacyidea/api/validate.py | Python | agpl-3.0 | 27,219 | 0.001397 |
from cse.util import Util
from collections import OrderedDict
from cse.pipeline import Handler
class WpApiParser(Handler):
def __init__(self):
super()
def parse(self, comments, url, assetId, parentId):
data = self.__buildDataSkeleton(url, assetId)
data["comments"] = self.__iterateComments(comments, parentId)
return data
def __buildDataSkeleton(self, url, assetId):
return {
"article_url" : url,
"article_id" : assetId,
"comments" : None
}
def __iterateComments(self, comments, parentId=None):
commentList = OrderedDict()
for comment in comments:
votes = 0
for action_summary in comment["action_summaries"]:
if action_summary["__typename"] == "LikeActionSummary":
votes = action_summary["count"]
commentObject = {
"comment_author": comment["user"]["username"],
"comment_text" : comment["body"],
"timestamp" : comment["created_at"],
"parent_comment_id" : parentId,
"upvotes" : votes,
"downvotes": 0
}
commentList[comment["id"]] = commentObject
try:
commentReplies = self.__iterateComments(comment["replies"]["nodes"], comment["id"])
except KeyError: # There may be a limit of the nesting level of comments on wp
commentReplies = {}
commentList.update(commentReplies)
return commentList
# inherited from cse.pipeline.Handler
def registeredAt(self, ctx):
pass
def process(self, ctx, data):
result = self.parse(
comments=data["comments"],
url=data["url"],
assetId=data["assetId"],
parentId=data["parentId"]
)
ctx.write(result)
| CodeLionX/CommentSearchEngine | cse/WpApiParser.py | Python | mit | 1,919 | 0.00938 |
from django.conf.urls.defaults import *
from django.conf.urls.i18n import i18n_patterns
from django.contrib import admin
from django.conf import settings
admin.autodiscover()
urlpatterns = i18n_patterns(
'',
url(r'^admin/', include(admin.site.urls)),
url(r'^', include('cms.urls')),
)
if settings.DEBUG:
urlpatterns = patterns(
'',
url(r'^media/(?P<path>.*)$', 'django.views.static.serve',
{'document_root': settings.MEDIA_ROOT, 'show_indexes': True}),
url(r'', include('django.contrib.staticfiles.urls')),
) + urlpatterns
| MagicSolutions/cmsplugin-carousel | example/example/urls.py | Python | mit | 582 | 0 |
def change_counter():
print("Determine the value of your pocket change.")
quarters = int(input("Enter the number of quarters: "))
dimes = int(input("Enter the number of dimes: "))
nickels = int(input("Enter the number of nickels: "))
pennies = int(input("Enter the number of pennies: "))
value = quarters * 0.25 + dimes * 0.10 + nickels * 0.05 + pennies * 0.01
print("You have ${0} in pocket change!".format(round(value, 2)))
if __name__ == '__main__':
change_counter()
| SeattleCentral/ITC110 | examples/lecture04b.py | Python | mit | 508 | 0 |
def fact_iter(n):
"""This function will find the Factorial of the given number by iterative
method. This function is coded in Pyhton 3.5."""
# check for integer
if not isinstance(n, int):
raise TypeError("Please only enter integer")
if n <= 0:
raise ValueError("Kindly Enter positive integer only ")
temp = 1
for num in range(1,n):
temp += temp * num
return temp
def fact_recu(n):
# check for integer
if not isinstance(n, int):
raise TypeError("Please only enter integer")
if n <= 0:
raise ValueError("Kindly Enter positive integer only ")
if n == 1:
return 1
else:
return n * fact_recu(n-1)
if __name__ == "__main__":
print("""Enter your choice
1 - factorial Iterative
2 - factorial Recursive""")
choice = int(input())
print("Enter the number")
number = int(input())
if choice == 1:
number = fact_iter(number)
if choice == 2:
number = fact_recu(number)
print(number) | rvsingh011/NitK_Assignments | Sem1/Algorithm/Factorial_iter.py | Python | mit | 1,055 | 0.001896 |
# -*- coding: utf-8 -*-
from __future__ import absolute_import, unicode_literals
from google.appengine.ext import ndb
from gaegraph.model import Node
from gaeforms.ndb import property
class Quero(Node):
item = ndb.StringProperty(required=True)
nome = ndb.StringProperty(required=True)
descricao = ndb.StringProperty(required=True)
| gutooliveira/progScript | tekton/backend/apps/quero_app/model.py | Python | mit | 346 | 0.00289 |
"""Support for tracking which astronomical or meteorological season it is."""
from datetime import datetime
import logging
import ephem
import voluptuous as vol
from homeassistant import util
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import CONF_NAME, CONF_TYPE
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entity import Entity
import homeassistant.util.dt as dt_util
_LOGGER = logging.getLogger(__name__)
DEFAULT_NAME = "Season"
EQUATOR = "equator"
NORTHERN = "northern"
SOUTHERN = "southern"
STATE_AUTUMN = "autumn"
STATE_SPRING = "spring"
STATE_SUMMER = "summer"
STATE_WINTER = "winter"
TYPE_ASTRONOMICAL = "astronomical"
TYPE_METEOROLOGICAL = "meteorological"
VALID_TYPES = [TYPE_ASTRONOMICAL, TYPE_METEOROLOGICAL]
HEMISPHERE_SEASON_SWAP = {
STATE_WINTER: STATE_SUMMER,
STATE_SPRING: STATE_AUTUMN,
STATE_AUTUMN: STATE_SPRING,
STATE_SUMMER: STATE_WINTER,
}
SEASON_ICONS = {
STATE_SPRING: "mdi:flower",
STATE_SUMMER: "mdi:sunglasses",
STATE_AUTUMN: "mdi:leaf",
STATE_WINTER: "mdi:snowflake",
}
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
{
vol.Optional(CONF_TYPE, default=TYPE_ASTRONOMICAL): vol.In(VALID_TYPES),
vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
}
)
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Display the current season."""
if None in (hass.config.latitude, hass.config.longitude):
_LOGGER.error("Latitude or longitude not set in Home Assistant config")
return False
latitude = util.convert(hass.config.latitude, float)
_type = config.get(CONF_TYPE)
name = config.get(CONF_NAME)
if latitude < 0:
hemisphere = SOUTHERN
elif latitude > 0:
hemisphere = NORTHERN
else:
hemisphere = EQUATOR
_LOGGER.debug(_type)
add_entities([Season(hass, hemisphere, _type, name)])
return True
def get_season(date, hemisphere, season_tracking_type):
"""Calculate the current season."""
if hemisphere == "equator":
return None
if season_tracking_type == TYPE_ASTRONOMICAL:
spring_start = ephem.next_equinox(str(date.year)).datetime()
summer_start = ephem.next_solstice(str(date.year)).datetime()
autumn_start = ephem.next_equinox(spring_start).datetime()
winter_start = ephem.next_solstice(summer_start).datetime()
else:
spring_start = datetime(2017, 3, 1).replace(year=date.year)
summer_start = spring_start.replace(month=6)
autumn_start = spring_start.replace(month=9)
winter_start = spring_start.replace(month=12)
if spring_start <= date < summer_start:
season = STATE_SPRING
elif summer_start <= date < autumn_start:
season = STATE_SUMMER
elif autumn_start <= date < winter_start:
season = STATE_AUTUMN
elif winter_start <= date or spring_start > date:
season = STATE_WINTER
# If user is located in the southern hemisphere swap the season
if hemisphere == NORTHERN:
return season
return HEMISPHERE_SEASON_SWAP.get(season)
class Season(Entity):
"""Representation of the current season."""
def __init__(self, hass, hemisphere, season_tracking_type, name):
"""Initialize the season."""
self.hass = hass
self._name = name
self.hemisphere = hemisphere
self.datetime = dt_util.utcnow().replace(tzinfo=None)
self.type = season_tracking_type
self.season = get_season(self.datetime, self.hemisphere, self.type)
@property
def name(self):
"""Return the name."""
return self._name
@property
def state(self):
"""Return the current season."""
return self.season
@property
def icon(self):
"""Icon to use in the frontend, if any."""
return SEASON_ICONS.get(self.season, "mdi:cloud")
def update(self):
"""Update season."""
self.datetime = dt_util.utcnow().replace(tzinfo=None)
self.season = get_season(self.datetime, self.hemisphere, self.type)
| leppa/home-assistant | homeassistant/components/season/sensor.py | Python | apache-2.0 | 4,134 | 0.000242 |
#!/usr/bin/python3
### rev: 5.0
### author: <zhq>
### features:
### errors included
### up to 63 bases (2 to 64)
### caps recognition and same output format (deprecated)
### for the function parameters, `cur` represents the current (input) base, `res` represents the result (output) base, and `num` represents the current (input) number.
def scale(cur, res, num):
# int, int, str -> str
# Default Settings
num = str(num)
iscaps = False
positive = True
# Input
if cur == res: return num
if num == "0": return "0"
assert cur in range(2, 65) and res in range(2, 65), "Base not defined."
if num[0] == "-":
positive = False
num = num[1:]
result = 0
unit = 1
if cur != 10:
for i in num[::-1]:
value = ord(i)
if value in range(48, 58): value -= 48
elif value in range(65, 92): value -= 55
elif value in range(97, 123): value -= 61
elif value == 64: value = 62
elif value == 95: value = 63
assert value <= cur, "Digit larger than original base. v:%d(%s) b:%d\nCall: scale(%d, %d, %s)" % (value, i, cur, cur, res, num)
result += value * unit
unit *= cur
result = str(result)
# Output
if res != 10:
num = int(result or num)
result = ""
while num > 0:
num, value = divmod(num, res)
if value < 10: digit = value + 48
elif value < 36: digit = value + 55
elif value < 62: digit = value + 61
elif value == 62: digit = 64
elif value == 63: digit = 95
result = chr(digit) + result
if not positive: result = "-" + result
return result
| Irides-Chromium/cipher | scale_strict.py | Python | gpl-3.0 | 1,750 | 0.013714 |
"""
Serializer for user API
"""
from rest_framework import serializers
from rest_framework.reverse import reverse
from django.template import defaultfilters
from courseware.access import has_access
from student.models import CourseEnrollment, User
from certificates.models import certificate_status_for_student, CertificateStatuses
from xmodule.course_module import DEFAULT_START_DATE
class CourseOverviewField(serializers.RelatedField):
"""Custom field to wrap a CourseDescriptor object. Read-only."""
def to_representation(self, course_overview):
course_id = unicode(course_overview.id)
request = self.context.get('request', None)
if request:
video_outline_url = reverse(
'video-summary-list',
kwargs={'course_id': course_id},
request=request
)
course_updates_url = reverse(
'course-updates-list',
kwargs={'course_id': course_id},
request=request
)
course_handouts_url = reverse(
'course-handouts-list',
kwargs={'course_id': course_id},
request=request
)
discussion_url = reverse(
'discussion_course',
kwargs={'course_id': course_id},
request=request
) if course_overview.is_discussion_tab_enabled() else None
else:
video_outline_url = None
course_updates_url = None
course_handouts_url = None
discussion_url = None
if course_overview.advertised_start is not None:
start_type = "string"
start_display = course_overview.advertised_start
elif course_overview.start != DEFAULT_START_DATE:
start_type = "timestamp"
start_display = defaultfilters.date(course_overview.start, "DATE_FORMAT")
else:
start_type = "empty"
start_display = None
return {
"id": course_id,
"name": course_overview.display_name,
"number": course_overview.display_number_with_default,
"org": course_overview.display_org_with_default,
"start": course_overview.start,
"start_display": start_display,
"start_type": start_type,
"end": course_overview.end,
"course_image": course_overview.course_image_url,
"social_urls": {
"facebook": course_overview.facebook_url,
},
"latest_updates": {
"video": None
},
"video_outline": video_outline_url,
"course_updates": course_updates_url,
"course_handouts": course_handouts_url,
"discussion_url": discussion_url,
"subscription_id": course_overview.clean_id(padding_char='_'),
"courseware_access": has_access(request.user, 'load_mobile', course_overview).to_json() if request else None
}
class CourseEnrollmentSerializer(serializers.ModelSerializer):
"""
Serializes CourseEnrollment models
"""
course = CourseOverviewField(source="course_overview", read_only=True)
certificate = serializers.SerializerMethodField()
def get_certificate(self, model):
"""Returns the information about the user's certificate in the course."""
certificate_info = certificate_status_for_student(model.user, model.course_id)
if certificate_info['status'] == CertificateStatuses.downloadable:
return {
"url": certificate_info['download_url'],
}
else:
return {}
class Meta(object):
model = CourseEnrollment
fields = ('created', 'mode', 'is_active', 'course', 'certificate')
lookup_field = 'username'
class UserSerializer(serializers.HyperlinkedModelSerializer):
"""
Serializes User models
"""
name = serializers.ReadOnlyField(source='profile.name')
course_enrollments = serializers.HyperlinkedIdentityField(
view_name='courseenrollment-detail',
lookup_field='username'
)
class Meta(object):
model = User
fields = ('id', 'username', 'email', 'name', 'course_enrollments')
lookup_field = 'username'
| xingyepei/edx-platform | lms/djangoapps/mobile_api/users/serializers.py | Python | agpl-3.0 | 4,342 | 0.001152 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
from migrate.versioning import cfgparse
from migrate.versioning.repository import *
from migrate.versioning.template import Template
from migrate.tests import fixture
class TestConfigParser(fixture.Base):
def test_to_dict(self):
"""Correctly interpret config results as dictionaries"""
parser = cfgparse.Parser(dict(default_value=42))
self.assertTrue(len(parser.sections()) == 0)
parser.add_section('section')
parser.set('section','option','value')
self.assertEqual(parser.get('section', 'option'), 'value')
self.assertEqual(parser.to_dict()['section']['option'], 'value')
def test_table_config(self):
"""We should be able to specify the table to be used with a repository"""
default_text = Repository.prepare_config(Template().get_repository(),
'repository_name', {})
specified_text = Repository.prepare_config(Template().get_repository(),
'repository_name', {'version_table': '_other_table'})
self.assertNotEqual(default_text, specified_text)
| odubno/microblog | venv/lib/python2.7/site-packages/migrate/tests/versioning/test_cfgparse.py | Python | bsd-3-clause | 1,112 | 0.004496 |
# Copyright (c) 2014 Scality
#
# 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.
"""
Volume driver for the Scality REST Block storage system
This driver provisions Linux SRB volumes leveraging RESTful storage platforms
(e.g. Scality CDMI).
"""
import contextlib
import functools
import re
import sys
import time
from oslo_concurrency import lockutils
from oslo_concurrency import processutils as putils
from oslo_config import cfg
from oslo_log import log as logging
from oslo_utils import excutils
from oslo_utils import units
import six
from six.moves import range
from cinder.brick.local_dev import lvm
from cinder import exception
from cinder.i18n import _, _LI, _LE, _LW
from cinder.image import image_utils
from cinder import utils
from cinder.volume import driver
from cinder.volume import utils as volutils
LOG = logging.getLogger(__name__)
srb_opts = [
cfg.StrOpt('srb_base_urls',
default=None,
help='Comma-separated list of REST servers IP to connect to. '
'(eg http://IP1/,http://IP2:81/path'),
]
CONF = cfg.CONF
CONF.register_opts(srb_opts)
ACCEPTED_REST_SERVER = re.compile(r'^http://'
'(\d{1,3}\.){3}\d{1,3}'
'(:\d+)?/[a-zA-Z0-9\-_\/]*$')
class retry(object):
SLEEP_NONE = 'none'
SLEEP_DOUBLE = 'double'
SLEEP_INCREMENT = 'increment'
def __init__(self, exceptions, count, sleep_mechanism=SLEEP_INCREMENT,
sleep_factor=1):
if sleep_mechanism not in [self.SLEEP_NONE,
self.SLEEP_DOUBLE,
self.SLEEP_INCREMENT]:
raise ValueError('Invalid value for `sleep_mechanism` argument')
self._exceptions = exceptions
self._count = count
self._sleep_mechanism = sleep_mechanism
self._sleep_factor = sleep_factor
def __call__(self, fun):
func_name = fun.func_name
@functools.wraps(fun)
def wrapped(*args, **kwargs):
sleep_time = self._sleep_factor
exc_info = None
for attempt in range(self._count):
if attempt != 0:
LOG.warning(_LW('Retrying failed call to %(func)s, '
'attempt %(attempt)i.'),
{'func': func_name,
'attempt': attempt})
try:
return fun(*args, **kwargs)
except self._exceptions:
exc_info = sys.exc_info()
if attempt != self._count - 1:
if self._sleep_mechanism == self.SLEEP_NONE:
continue
elif self._sleep_mechanism == self.SLEEP_INCREMENT:
time.sleep(sleep_time)
sleep_time += self._sleep_factor
elif self._sleep_mechanism == self.SLEEP_DOUBLE:
time.sleep(sleep_time)
sleep_time *= 2
else:
raise ValueError('Unknown sleep mechanism: %r'
% self._sleep_mechanism)
six.reraise(exc_info[0], exc_info[1], exc_info[2])
return wrapped
class LVM(lvm.LVM):
def activate_vg(self):
"""Activate the Volume Group associated with this instantiation.
:raises: putils.ProcessExecutionError
"""
cmd = ['vgchange', '-ay', self.vg_name]
try:
self._execute(*cmd,
root_helper=self._root_helper,
run_as_root=True)
except putils.ProcessExecutionError as err:
LOG.exception(_LE('Error activating Volume Group'))
LOG.error(_LE('Cmd :%s'), err.cmd)
LOG.error(_LE('StdOut :%s'), err.stdout)
LOG.error(_LE('StdErr :%s'), err.stderr)
raise
def deactivate_vg(self):
"""Deactivate the Volume Group associated with this instantiation.
This forces LVM to release any reference to the device.
:raises: putils.ProcessExecutionError
"""
cmd = ['vgchange', '-an', self.vg_name]
try:
self._execute(*cmd,
root_helper=self._root_helper,
run_as_root=True)
except putils.ProcessExecutionError as err:
LOG.exception(_LE('Error deactivating Volume Group'))
LOG.error(_LE('Cmd :%s'), err.cmd)
LOG.error(_LE('StdOut :%s'), err.stdout)
LOG.error(_LE('StdErr :%s'), err.stderr)
raise
def destroy_vg(self):
"""Destroy the Volume Group associated with this instantiation.
:raises: putils.ProcessExecutionError
"""
cmd = ['vgremove', '-f', self.vg_name]
try:
self._execute(*cmd,
root_helper=self._root_helper,
run_as_root=True)
except putils.ProcessExecutionError as err:
LOG.exception(_LE('Error destroying Volume Group'))
LOG.error(_LE('Cmd :%s'), err.cmd)
LOG.error(_LE('StdOut :%s'), err.stdout)
LOG.error(_LE('StdErr :%s'), err.stderr)
raise
def pv_resize(self, pv_name, new_size_str):
"""Extend the size of an existing PV (for virtual PVs).
:raises: putils.ProcessExecutionError
"""
try:
self._execute('pvresize',
'--setphysicalvolumesize', new_size_str,
pv_name,
root_helper=self._root_helper,
run_as_root=True)
except putils.ProcessExecutionError as err:
LOG.exception(_LE('Error resizing Physical Volume'))
LOG.error(_LE('Cmd :%s'), err.cmd)
LOG.error(_LE('StdOut :%s'), err.stdout)
LOG.error(_LE('StdErr :%s'), err.stderr)
raise
def extend_thin_pool(self):
"""Extend the size of the thin provisioning pool.
This method extends the size of a thin provisioning pool to 95% of the
size of the VG, if the VG is configured as thin and owns a thin
provisioning pool.
:raises: putils.ProcessExecutionError
"""
if self.vg_thin_pool is None:
return
new_size_str = self._calculate_thin_pool_size()
try:
self._execute('lvextend',
'-L', new_size_str,
"%s/%s-pool" % (self.vg_name, self.vg_name),
root_helper=self._root_helper,
run_as_root=True)
except putils.ProcessExecutionError as err:
LOG.exception(_LE('Error extending thin provisioning pool'))
LOG.error(_LE('Cmd :%s'), err.cmd)
LOG.error(_LE('StdOut :%s'), err.stdout)
LOG.error(_LE('StdErr :%s'), err.stderr)
raise
@contextlib.contextmanager
def patched(obj, attr, fun):
'''Context manager to locally patch a method.
Within the managed context, the `attr` method of `obj` will be replaced by
a method which calls `fun` passing in the original `attr` attribute of
`obj` as well as any positional and keyword arguments.
At the end of the context, the original method is restored.
'''
orig = getattr(obj, attr)
def patch(*args, **kwargs):
return fun(orig, *args, **kwargs)
setattr(obj, attr, patch)
try:
yield
finally:
setattr(obj, attr, orig)
@contextlib.contextmanager
def handle_process_execution_error(message, info_message, reraise=True):
'''Consistently handle `putils.ProcessExecutionError` exceptions
This context-manager will catch any `putils.ProcessExecutionError`
exceptions raised in the managed block, and generate logging output
accordingly.
The value of the `message` argument will be logged at `logging.ERROR`
level, and the `info_message` argument at `logging.INFO` level. Finally
the command string, exit code, standard output and error output of the
process will be logged at `logging.DEBUG` level.
The `reraise` argument specifies what should happen when a
`putils.ProcessExecutionError` is caught. If it's equal to `True`, the
exception will be re-raised. If it's some other non-`False` object, this
object will be raised instead (so you most likely want it to be some
`Exception`). Any `False` value will result in the exception to be
swallowed.
'''
try:
yield
except putils.ProcessExecutionError as exc:
LOG.error(message)
LOG.info(info_message)
LOG.debug('Command : %s', exc.cmd)
LOG.debug('Exit Code : %r', exc.exit_code)
LOG.debug('StdOut : %s', exc.stdout)
LOG.debug('StdErr : %s', exc.stderr)
if reraise is True:
raise
elif reraise:
raise reraise # pylint: disable=E0702
@contextlib.contextmanager
def temp_snapshot(driver, volume, src_vref):
snapshot = {'volume_name': src_vref['name'],
'volume_id': src_vref['id'],
'volume_size': src_vref['size'],
'name': 'snapshot-clone-%s' % volume['id'],
'id': 'tmp-snap-%s' % volume['id'],
'size': src_vref['size']}
driver.create_snapshot(snapshot)
try:
yield snapshot
finally:
driver.delete_snapshot(snapshot)
@contextlib.contextmanager
def temp_raw_device(driver, volume):
driver._attach_file(volume)
try:
yield
finally:
driver._detach_file(volume)
@contextlib.contextmanager
def temp_lvm_device(driver, volume):
with temp_raw_device(driver, volume):
vg = driver._get_lvm_vg(volume)
vg.activate_vg()
yield vg
class SRBDriver(driver.VolumeDriver):
"""Scality SRB volume driver
This driver manages volumes provisioned by the Scality REST Block driver
Linux kernel module, backed by RESTful storage providers (e.g. Scality
CDMI).
"""
VERSION = '1.1.0'
# Over-allocation ratio (multiplied with requested size) for thin
# provisioning
OVER_ALLOC_RATIO = 2
SNAPSHOT_PREFIX = 'snapshot'
def __init__(self, *args, **kwargs):
super(SRBDriver, self).__init__(*args, **kwargs)
self.configuration.append_config_values(srb_opts)
self.urls_setup = False
self.backend_name = None
self.base_urls = None
self.root_helper = utils.get_root_helper()
self._attached_devices = {}
def _setup_urls(self):
if not self.base_urls:
message = _("No url configured")
raise exception.VolumeBackendAPIException(data=message)
with handle_process_execution_error(
message=_LE('Cound not setup urls on the Block Driver.'),
info_message=_LI('Error creating Volume'),
reraise=False):
cmd = self.base_urls
path = '/sys/class/srb/add_urls'
putils.execute('tee', path, process_input=cmd,
root_helper=self.root_helper, run_as_root=True)
self.urls_setup = True
def do_setup(self, context):
"""Any initialization the volume driver does while starting."""
self.backend_name = self.configuration.safe_get('volume_backend_name')
base_urls = self.configuration.safe_get('srb_base_urls')
sane_urls = []
if base_urls:
for url in base_urls.split(','):
stripped_url = url.strip()
if ACCEPTED_REST_SERVER.match(stripped_url):
sane_urls.append(stripped_url)
else:
LOG.warning(_LW("%s is not an accepted REST server "
"IP address"), stripped_url)
self.base_urls = ','.join(sane_urls)
self._setup_urls()
def check_for_setup_error(self):
"""Returns an error if prerequisites aren't met."""
if not self.base_urls:
LOG.warning(_LW("Configuration variable srb_base_urls"
" not set or empty."))
if self.urls_setup is False:
message = _("Could not setup urls properly")
raise exception.VolumeBackendAPIException(data=message)
@classmethod
def _is_snapshot(cls, volume):
return volume['name'].startswith(cls.SNAPSHOT_PREFIX)
@classmethod
def _get_volname(cls, volume):
"""Returns the name of the actual volume
If the volume is a snapshot, it returns the name of the parent volume.
otherwise, returns the volume's name.
"""
name = volume['name']
if cls._is_snapshot(volume):
name = "volume-%s" % (volume['volume_id'])
return name
@classmethod
def _get_volid(cls, volume):
"""Returns the ID of the actual volume
If the volume is a snapshot, it returns the ID of the parent volume.
otherwise, returns the volume's id.
"""
volid = volume['id']
if cls._is_snapshot(volume):
volid = volume['volume_id']
return volid
@classmethod
def _device_name(cls, volume):
volume_id = cls._get_volid(volume)
name = 'cinder-%s' % volume_id
# Device names can't be longer than 32 bytes (incl. \0)
return name[:31]
@classmethod
def _device_path(cls, volume):
return "/dev/" + cls._device_name(volume)
@classmethod
def _escape_snapshot(cls, snapshot_name):
# Linux LVM reserves name that starts with snapshot, so that
# such volume name can't be created. Mangle it.
if not snapshot_name.startswith(cls.SNAPSHOT_PREFIX):
return snapshot_name
return '_' + snapshot_name
@classmethod
def _mapper_path(cls, volume):
groupname = cls._get_volname(volume)
name = volume['name']
if cls._is_snapshot(volume):
name = cls._escape_snapshot(name)
# NOTE(vish): stops deprecation warning
groupname = groupname.replace('-', '--')
name = name.replace('-', '--')
return "/dev/mapper/%s-%s" % (groupname, name)
@staticmethod
def _size_int(size_in_g):
try:
return max(int(size_in_g), 1)
except ValueError:
message = (_("Invalid size parameter '%s': Cannot be interpreted"
" as an integer value.")
% size_in_g)
LOG.error(message)
raise exception.VolumeBackendAPIException(data=message)
@classmethod
def _set_device_path(cls, volume):
volume['provider_location'] = cls._get_volname(volume)
return {
'provider_location': volume['provider_location'],
}
@staticmethod
def _activate_lv(orig, *args, **kwargs):
'''Use with `patched` to patch `lvm.LVM.activate_lv` to ignore `EEXIST`
'''
try:
orig(*args, **kwargs)
except putils.ProcessExecutionError as exc:
if exc.exit_code != 5:
raise
else:
LOG.debug('`activate_lv` returned 5, ignored')
def _get_lvm_vg(self, volume, create_vg=False):
# NOTE(joachim): One-device volume group to manage thin snapshots
# Get origin volume name even for snapshots
volume_name = self._get_volname(volume)
physical_volumes = [self._device_path(volume)]
with patched(lvm.LVM, 'activate_lv', self._activate_lv):
return LVM(volume_name, utils.get_root_helper(),
create_vg=create_vg,
physical_volumes=physical_volumes,
lvm_type='thin', executor=self._execute)
@staticmethod
def _volume_not_present(vg, volume_name):
# Used to avoid failing to delete a volume for which
# the create operation partly failed
return vg.get_volume(volume_name) is None
def _create_file(self, volume):
message = _('Could not create volume on any configured REST server.')
with handle_process_execution_error(
message=message,
info_message=_LI('Error creating Volume %s.') % volume['name'],
reraise=exception.VolumeBackendAPIException(data=message)):
size = self._size_int(volume['size']) * self.OVER_ALLOC_RATIO
cmd = volume['name']
cmd += ' %dG' % size
path = '/sys/class/srb/create'
putils.execute('tee', path, process_input=cmd,
root_helper=self.root_helper, run_as_root=True)
return self._set_device_path(volume)
def _extend_file(self, volume, new_size):
message = _('Could not extend volume on any configured REST server.')
with handle_process_execution_error(
message=message,
info_message=(_LI('Error extending Volume %s.')
% volume['name']),
reraise=exception.VolumeBackendAPIException(data=message)):
size = self._size_int(new_size) * self.OVER_ALLOC_RATIO
cmd = volume['name']
cmd += ' %dG' % size
path = '/sys/class/srb/extend'
putils.execute('tee', path, process_input=cmd,
root_helper=self.root_helper, run_as_root=True)
@staticmethod
def _destroy_file(volume):
message = _('Could not destroy volume on any configured REST server.')
volname = volume['name']
with handle_process_execution_error(
message=message,
info_message=_LI('Error destroying Volume %s.') % volname,
reraise=exception.VolumeBackendAPIException(data=message)):
cmd = volume['name']
path = '/sys/class/srb/destroy'
putils.execute('tee', path, process_input=cmd,
root_helper=utils.get_root_helper(),
run_as_root=True)
# NOTE(joachim): Must only be called within a function decorated by:
# @lockutils.synchronized('devices', 'cinder-srb-')
def _increment_attached_count(self, volume):
"""Increments the attach count of the device"""
volid = self._get_volid(volume)
if volid not in self._attached_devices:
self._attached_devices[volid] = 1
else:
self._attached_devices[volid] += 1
# NOTE(joachim): Must only be called within a function decorated by:
# @lockutils.synchronized('devices', 'cinder-srb-')
def _decrement_attached_count(self, volume):
"""Decrements the attach count of the device"""
volid = self._get_volid(volume)
if volid not in self._attached_devices:
raise exception.VolumeBackendAPIException(
(_("Internal error in srb driver: "
"Trying to detach detached volume %s."))
% (self._get_volname(volume))
)
self._attached_devices[volid] -= 1
if self._attached_devices[volid] == 0:
del self._attached_devices[volid]
# NOTE(joachim): Must only be called within a function decorated by:
# @lockutils.synchronized('devices', 'cinder-srb-')
def _get_attached_count(self, volume):
volid = self._get_volid(volume)
return self._attached_devices.get(volid, 0)
@lockutils.synchronized('devices', 'cinder-srb-')
def _is_attached(self, volume):
return self._get_attached_count(volume) > 0
@lockutils.synchronized('devices', 'cinder-srb-')
def _attach_file(self, volume):
name = self._get_volname(volume)
devname = self._device_name(volume)
LOG.debug('Attaching volume %(name)s as %(devname)s',
{'name': name, 'devname': devname})
count = self._get_attached_count(volume)
if count == 0:
message = (_('Could not attach volume %(vol)s as %(dev)s '
'on system.')
% {'vol': name, 'dev': devname})
with handle_process_execution_error(
message=message,
info_message=_LI('Error attaching Volume'),
reraise=exception.VolumeBackendAPIException(data=message)):
cmd = name + ' ' + devname
path = '/sys/class/srb/attach'
putils.execute('tee', path, process_input=cmd,
root_helper=self.root_helper, run_as_root=True)
else:
LOG.debug('Volume %s already attached', name)
self._increment_attached_count(volume)
@retry(exceptions=(putils.ProcessExecutionError, ),
count=3, sleep_mechanism=retry.SLEEP_INCREMENT, sleep_factor=5)
def _do_deactivate(self, volume, vg):
vg.deactivate_vg()
@retry(exceptions=(putils.ProcessExecutionError, ),
count=5, sleep_mechanism=retry.SLEEP_DOUBLE, sleep_factor=1)
def _do_detach(self, volume, vg):
devname = self._device_name(volume)
volname = self._get_volname(volume)
cmd = devname
path = '/sys/class/srb/detach'
try:
putils.execute('tee', path, process_input=cmd,
root_helper=self.root_helper, run_as_root=True)
except putils.ProcessExecutionError:
with excutils.save_and_reraise_exception(reraise=True):
try:
with patched(lvm.LVM, 'activate_lv', self._activate_lv):
vg.activate_lv(volname)
self._do_deactivate(volume, vg)
except putils.ProcessExecutionError:
LOG.warning(_LW('All attempts to recover failed detach '
'of %(volume)s failed.'),
{'volume': volname})
@lockutils.synchronized('devices', 'cinder-srb-')
def _detach_file(self, volume):
name = self._get_volname(volume)
devname = self._device_name(volume)
vg = self._get_lvm_vg(volume)
LOG.debug('Detaching device %s', devname)
count = self._get_attached_count(volume)
if count > 1:
LOG.info(_LI('Reference count of %(volume)s is %(count)d, '
'not detaching.'),
{'volume': volume['name'], 'count': count})
return
message = (_('Could not detach volume %(vol)s from device %(dev)s.')
% {'vol': name, 'dev': devname})
with handle_process_execution_error(
message=message,
info_message=_LI('Error detaching Volume'),
reraise=exception.VolumeBackendAPIException(data=message)):
try:
if vg is not None:
self._do_deactivate(volume, vg)
except putils.ProcessExecutionError:
LOG.error(_LE('Could not deactivate volume group %s'),
self._get_volname(volume))
raise
try:
self._do_detach(volume, vg=vg)
except putils.ProcessExecutionError:
LOG.error(_LE('Could not detach volume %(vol)s from device '
'%(dev)s.'), {'vol': name, 'dev': devname})
raise
self._decrement_attached_count(volume)
def _setup_lvm(self, volume):
# NOTE(joachim): One-device volume group to manage thin snapshots
size = self._size_int(volume['size']) * self.OVER_ALLOC_RATIO
size_str = '%dg' % size
vg = self._get_lvm_vg(volume, create_vg=True)
vg.create_volume(volume['name'], size_str, lv_type='thin')
def _destroy_lvm(self, volume):
vg = self._get_lvm_vg(volume)
if vg.lv_has_snapshot(volume['name']):
LOG.error(_LE('Unable to delete due to existing snapshot '
'for volume: %s.'),
volume['name'])
raise exception.VolumeIsBusy(volume_name=volume['name'])
vg.destroy_vg()
# NOTE(joachim) Force lvm vg flush through a vgs command
vgs = vg.get_all_volume_groups(root_helper=self.root_helper,
vg_name=vg.vg_name)
if len(vgs) != 0:
LOG.warning(_LW('Removed volume group %s still appears in vgs.'),
vg.vg_name)
def _create_and_copy_volume(self, dstvol, srcvol):
"""Creates a volume from a volume or a snapshot."""
updates = self._create_file(dstvol)
# We need devices attached for IO operations.
with temp_lvm_device(self, srcvol) as vg, \
temp_raw_device(self, dstvol):
self._setup_lvm(dstvol)
# Some configurations of LVM do not automatically activate
# ThinLVM snapshot LVs.
with patched(lvm.LVM, 'activate_lv', self._activate_lv):
vg.activate_lv(srcvol['name'], True)
# copy_volume expects sizes in MiB, we store integer GiB
# be sure to convert before passing in
volutils.copy_volume(self._mapper_path(srcvol),
self._mapper_path(dstvol),
srcvol['volume_size'] * units.Ki,
self.configuration.volume_dd_blocksize,
execute=self._execute)
return updates
def create_volume(self, volume):
"""Creates a volume.
Can optionally return a Dictionary of changes to the volume object to
be persisted.
"""
updates = self._create_file(volume)
# We need devices attached for LVM operations.
with temp_raw_device(self, volume):
self._setup_lvm(volume)
return updates
def create_volume_from_snapshot(self, volume, snapshot):
"""Creates a volume from a snapshot."""
return self._create_and_copy_volume(volume, snapshot)
def create_cloned_volume(self, volume, src_vref):
"""Creates a clone of the specified volume."""
LOG.info(_LI('Creating clone of volume: %s'), src_vref['id'])
updates = None
with temp_lvm_device(self, src_vref):
with temp_snapshot(self, volume, src_vref) as snapshot:
updates = self._create_and_copy_volume(volume, snapshot)
return updates
def delete_volume(self, volume):
"""Deletes a volume."""
attached = False
if self._is_attached(volume):
attached = True
with temp_lvm_device(self, volume):
self._destroy_lvm(volume)
self._detach_file(volume)
LOG.debug('Deleting volume %(volume_name)s, attached=%(attached)s',
{'volume_name': volume['name'], 'attached': attached})
self._destroy_file(volume)
def create_snapshot(self, snapshot):
"""Creates a snapshot."""
with temp_lvm_device(self, snapshot) as vg:
# NOTE(joachim) we only want to support thin lvm_types
vg.create_lv_snapshot(self._escape_snapshot(snapshot['name']),
snapshot['volume_name'],
lv_type='thin')
def delete_snapshot(self, snapshot):
"""Deletes a snapshot."""
with temp_lvm_device(self, snapshot) as vg:
if self._volume_not_present(
vg, self._escape_snapshot(snapshot['name'])):
# If the snapshot isn't present, then don't attempt to delete
LOG.warning(_LW("snapshot: %s not found, "
"skipping delete operations"),
snapshot['name'])
return
vg.delete(self._escape_snapshot(snapshot['name']))
def get_volume_stats(self, refresh=False):
"""Return the current state of the volume service."""
stats = {
'vendor_name': 'Scality',
'driver_version': self.VERSION,
'storage_protocol': 'Scality Rest Block Device',
'total_capacity_gb': 'infinite',
'free_capacity_gb': 'infinite',
'reserved_percentage': 0,
'volume_backend_name': self.backend_name,
}
return stats
def copy_image_to_volume(self, context, volume, image_service, image_id):
"""Fetch the image from image_service and write it to the volume."""
with temp_lvm_device(self, volume):
image_utils.fetch_to_volume_format(context,
image_service,
image_id,
self._mapper_path(volume),
'qcow2',
self.configuration.
volume_dd_blocksize,
size=volume['size'])
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
with temp_lvm_device(self, volume):
image_utils.upload_volume(context,
image_service,
image_meta,
self._mapper_path(volume))
def extend_volume(self, volume, new_size):
new_alloc_size = self._size_int(new_size) * self.OVER_ALLOC_RATIO
new_size_str = '%dg' % new_alloc_size
self._extend_file(volume, new_size)
with temp_lvm_device(self, volume) as vg:
vg.pv_resize(self._device_path(volume), new_size_str)
vg.extend_thin_pool()
vg.extend_volume(volume['name'], new_size_str)
class SRBISCSIDriver(SRBDriver, driver.ISCSIDriver):
"""Scality SRB volume driver with ISCSI support
This driver manages volumes provisioned by the Scality REST Block driver
Linux kernel module, backed by RESTful storage providers (e.g. Scality
CDMI), and exports them through ISCSI to Nova.
"""
VERSION = '1.0.0'
def __init__(self, *args, **kwargs):
self.db = kwargs.get('db')
self.target_driver = \
self.target_mapping[self.configuration.safe_get('iscsi_helper')]
super(SRBISCSIDriver, self).__init__(*args, **kwargs)
self.backend_name =\
self.configuration.safe_get('volume_backend_name') or 'SRB_iSCSI'
self.protocol = 'iSCSI'
def set_execute(self, execute):
super(SRBISCSIDriver, self).set_execute(execute)
if self.target_driver is not None:
self.target_driver.set_execute(execute)
def ensure_export(self, context, volume):
device_path = self._mapper_path(volume)
model_update = self.target_driver.ensure_export(context,
volume,
device_path)
if model_update:
self.db.volume_update(context, volume['id'], model_update)
def create_export(self, context, volume):
"""Creates an export for a logical volume."""
self._attach_file(volume)
vg = self._get_lvm_vg(volume)
vg.activate_vg()
# SRB uses the same name as the volume for the VG
volume_path = self._mapper_path(volume)
data = self.target_driver.create_export(context,
volume,
volume_path)
return {
'provider_location': data['location'],
'provider_auth': data['auth'],
}
def remove_export(self, context, volume):
# NOTE(joachim) Taken from iscsi._ExportMixin.remove_export
# This allows us to avoid "detaching" a device not attached by
# an export, and avoid screwing up the device attach refcount.
try:
# Raises exception.NotFound if export not provisioned
iscsi_target = self.target_driver._get_iscsi_target(context,
volume['id'])
# Raises an Exception if currently not exported
location = volume['provider_location'].split(' ')
iqn = location[1]
self.target_driver.show_target(iscsi_target, iqn=iqn)
self.target_driver.remove_export(context, volume)
self._detach_file(volume)
except exception.NotFound:
LOG.warning(_LW('Volume %r not found while trying to remove.'),
volume['id'])
except Exception as exc:
LOG.warning(_LW('Error while removing export: %r'), exc)
| saeki-masaki/cinder | cinder/volume/drivers/srb.py | Python | apache-2.0 | 33,594 | 0.000179 |
# Copyright (C) 2013 Nippon Telegraph and Telephone Corporation.
# Copyright (C) 2013 YAMAMOTO Takashi <yamamoto at valinux co jp>
#
# 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.
from abc import ABCMeta, abstractmethod
import six
@six.add_metaclass(ABCMeta)
class StreamParser(object):
"""Streaming parser base class.
An instance of a subclass of this class is used to extract messages
from a raw byte stream.
It's designed to be used for data read from a transport which doesn't
preserve message boundaries. A typical example of such a transport
is TCP.
"""
class TooSmallException(Exception):
pass
def __init__(self):
self._q = bytearray()
def parse(self, data):
"""Tries to extract messages from a raw byte stream.
The data argument would be python bytes newly read from the input
stream.
Returns an ordered list of extracted messages.
It can be an empty list.
The rest of data which doesn't produce a complete message is
kept internally and will be used when more data is come.
I.e. next time this method is called again.
"""
self._q.append(data)
msgs = []
while True:
try:
msg, self._q = self.try_parse(self._q)
except self.TooSmallException:
break
msgs.append(msg)
return msgs
@abstractmethod
def try_parse(self, q):
"""Try to extract a message from the given bytes.
This is an override point for subclasses.
This method tries to extract a message from bytes given by the
argument.
Raises TooSmallException if the given data is not enough to
extract a complete message but there's still a chance to extract
a message if more data is come later.
"""
pass
| halexan/Headquarters | src/headquarters/packet/stream_parser.py | Python | mit | 2,384 | 0 |
"""I'm a different package, but I'm in demopackage.__all__!"""
x = 42
| BurntSushi/pdoc | test/testdata/demopackage2.py | Python | unlicense | 70 | 0 |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('compose', '0010_auto_20151026_1126'),
]
operations = [
migrations.RenameField(
model_name='slideshow',
old_name='slideshow',
new_name='temp_slideshow',
),
]
| pkimber/compose | compose/migrations/0011_auto_20151026_1203.py | Python | apache-2.0 | 401 | 0 |
# -*- coding: utf-8 -*-
"""
API for submitting background tasks by an instructor for a course.
Also includes methods for getting information about tasks that have
already been submitted, filtered either by running state or input
arguments.
"""
from ga_instructor_task.tasks import (
generate_score_detail_report,
generate_playback_status_report,
)
from instructor_task.api_helper import submit_task
def submit_generate_score_detail_report(request, course_key):
"""
Submits a task to generate a CSV score detail report.
"""
task_type = 'generate_score_detail_report'
task_class = generate_score_detail_report
task_input = {}
task_key = ""
return submit_task(request, task_type, task_class, course_key, task_input, task_key)
def submit_generate_playback_status_report(request, course_key):
"""
Submits a task to generate a CSV playback status report.
"""
task_type = 'generate_playback_status_report'
task_class = generate_playback_status_report
task_input = {}
task_key = ""
return submit_task(request, task_type, task_class, course_key, task_input, task_key)
| nttks/edx-platform | lms/djangoapps/ga_instructor_task/api.py | Python | agpl-3.0 | 1,136 | 0.001761 |
# -*- coding: utf-8 -*-
"""
This file is part of coffeedatabase.
coffeedatabase is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
coffeedatabase is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with coffeedatabase.. If not, see <http://www.gnu.org/licenses/>.
"""
# system
import readline
import datetime
import configparser
# coffeedatabase
from lib import cuser
from lib import cpayment
from lib import citem
from lib import cdatabase
from lib import cprice
from lib import cbalance
# Completer Class
# For further reference please see
# https://stackoverflow.com/questions/7821661/how-to-code-autocompletion-in-python
class MyCompleter(object): # Custom completer
def __init__(self, options):
self.options = sorted(options)
def complete(self, text, state):
if state == 0: # on first trigger, build possible matches
if text: # cache matches (entries that start with entered text)
self.matches = [s for s in self.options
if text in s]
else: # no text entered, all matches possible
self.matches = self.options[:]
# return match indexed by state
try:
return self.matches[state]
except IndexError:
return None
class ckeyboard:
def __init__(self):
# First, load the config
config = configparser.ConfigParser()
config.sections()
config.read('config.ini')
if not ('FILENAME' in config) or not ('LIST' in config):
print("Broken config file \"config.ini\".")
raise
self.fileUser = config['FILENAME']['fileUser']
self.filePayment = config['FILENAME']['filePayment']
self.fileItem = config['FILENAME']['fileItem']
self.fileMarks = config['FILENAME']['fileMarks']
self.filePrice = config['FILENAME']['filePrice']
self.inactiveMonths = config['LIST']['inactiveMonths']
self.fileTemplateBalanceMonth = config['FILENAME']['fileTemplateBalanceMonth']
self.fileOutBalanceMonth = config['FILENAME']['fileOutBalanceMonth']
self.fileTemplateListMonth = config['FILENAME']['fileTemplateListMonth']
self.fileOutListMonth = config['FILENAME']['fileOutListMonth']
self.fileOutFolder = config['FILENAME']['fileOutFolder']
if (self.fileUser == "") or \
(self.filePayment == "") or \
(self.fileMarks == "") or \
(self.filePrice == "") or \
(self.fileItem == ""):
print("Broken config file \"config.ini\".")
raise
# create databases, if they do not exist.
database = cdatabase.cdatabase(self.fileUser, self.filePayment, self.fileItem, self.fileMarks, self.filePrice)
self.user = cuser.cuser(self.fileUser, self.inactiveMonths)
self.payment = cpayment.cpayment(self.filePayment, self.user)
self.item = citem.citem(self.fileItem, self.fileMarks, self.user)
self.price = cprice.cprice(self.filePrice, self.item)
self.balance = cbalance.cbalance(self.user, self.payment, self.price, self.item, self.inactiveMonths, self.fileTemplateBalanceMonth, self.fileOutBalanceMonth, self.fileTemplateListMonth, self.fileOutListMonth, self.fileOutFolder)
def inputStandard(self, valueDescription, valueStandard):
""" Displays an input field, nicely formatted. If valueDescription contains \"Name\" or \"name\", autocompletion for the name database will be activated.
valueDescription: List of description for input values.
valueStandard: List of standard values.
"""
if not len(valueDescription) == len(valueStandard):
print("Input vector", valueDescription, "has not the same length as standard value vector", valueStandard)
raise
counter = 0
for description in valueDescription:
if description.lower() == "status":
# display special user input field
print("New status:")
print("1 - active")
print("2 - auto")
print("3 - inactive")
textInput = input(str(description) + " [" + valueStandard[counter] + "]: ")
if textInput == "":
textInput = valueStandard[counter]
if textInput == "1" or textInput == "active":
valueStandard[counter] = "active"
elif textInput == "2" or textInput == "auto":
valueStandard[counter] = "auto"
elif textInput == "3" or textInput == "inactive":
valueStandard[counter] = "inactive"
else:
print("The input " + str(textInput) + " was not understood. Please use 1, 2, or 3, active, auto, or inactive.")
raise
else:
if not valueStandard[counter] == "":
textInput = input(str(description) + " [" + valueStandard[counter] + "]: ")
else:
textInput = input(str(description) + ": ")
if not textInput == "":
valueStandard[counter] = textInput
counter += 1
return valueStandard
def userAdd(self):
""" Adds a user to the user database
"""
userDescription = ["Name", "Mail"]
userStandard = ["", "[email protected]"]
inputUser = self.inputStandard(userDescription, userStandard)
inputUser.append("active")
self.user.userAdd(inputUser)
# Make a dummy payment
now = datetime.datetime.now()
year = now.strftime("%Y")
month = now.strftime("%m")
day = now.strftime("%d")
user = self.user.getRowByName(inputUser[1], 1)
payment = [user[0], year, month, day, 0]
self.payment.paymentAdd(payment)
# Make dummy marks
mark = [user[0], year, month, day, 0]
for _marks in self.item.marks:
_marks.marksAdd(mark)
return 0
def userChangeInfo(self):
""" Displays user information and allows to change them.
"""
user = self.getRowByTextname(self.user.getNamelist(), self.user)
# remove id
userId = user[0]
del user[0]
print("")
userDescription = ["Name", "Mail", "Status"]
inputUser = self.inputStandard(userDescription, user)
# add user id
inputUser.insert(0, userId)
# save in database
self.user.setUser(inputUser)
return 0
def paymentAdd(self):
""" Adds a payment to the payment database
"""
user = self.getRowByTextname(self.user.getNamelist(), self.user)
# create dates
now = datetime.datetime.now()
year = now.strftime("%Y")
month = now.strftime("%m")
day = now.strftime("%d")
payment1 = [user[0], int(year), int(month), int(day)]
print("")
userDescription = ["Payment"]
payment2 = [""]
inputUser = self.inputStandard(userDescription, payment2)
# fill payment
payment = payment1 + payment2
# save in database
self.payment.paymentAdd(payment)
# print new balance
self.payment.getDataBinMonth()
self.balance.getDataBinMonth()
self.balance.getBalance(user[0])
return 0
def itemAdd(self):
""" Adds a user to the user database
"""
itemDescription = ["Name", "Unit"]
itemStandard = ["Coffee", "per cup"]
inputItem = self.inputStandard(itemDescription, itemStandard)
inputItem.append("active")
self.item.itemAdd(inputItem)
return 0
def itemChangeInfo(self):
""" Displays item information and allows to change them.
"""
item = self.getRowByTextname(self.item.getColumn(1), self.item)
# remove id
itemId = item[0]
del item[0]
print("")
itemDescription = ["Name", "Unit", "Status"]
inputItem = self.inputStandard(itemDescription, item)
# add item id
inputItem.insert(0, itemId)
# save in database
self.item.setItem(inputItem)
return 0
def getRowByTextname(self, array, database):
""" Displays a name field and returns row.
array: Array used for auto completion in text input field.
database: Reference to database class, e.g. self.item, self.user, ...
"""
completer = MyCompleter(array)
readline.set_completer(completer.complete)
readline.parse_and_bind('tab: complete')
print("Search in item database:")
inputText = input("Name: ")
return database.getRowByName(inputText, 1)
def marksAdd(self):
""" Adds marks to the marks database
"""
# create dates
now = datetime.datetime.now()
year = now.strftime("%Y")
month = now.strftime("%m")
day = now.strftime("%d")
self.item.data
# get user
user = self.getRowByTextname(self.user.getNamelist(), self.user)
# get item list
markDescription = []
markDefault = []
for row in self.item.data:
if str(row[3]) == "active":
markDescription.append(row[1])
markDefault.append("0")
# query user input
print("")
inputMark = self.inputStandard(markDescription, markDefault)
# create array for cmark class
markArray = [[0 for x in range(0)] for x in range(0)]
counter = 0
for row in self.item.data:
if str(row[3]) == "active":
markArray.append([user[0], int(year), int(month), int(day), int(inputMark[counter])])
counter += 1
else:
markArray.append([user[0], int(year), int(month), int(day), 0])
# save in database
self.item.marksAdd(markArray)
return 0
def marksAddAll(self):
""" Adds marks to the marks database for all active users
"""
# This list holds all our active and auto active users
userActive = self.user.getIdByStatus("active")
# Check for auto active users in payment and marks
userAuto = self.user.getIdByStatus("auto")
userAutoM = self.payment.getIdDataBinMonthActive(self.inactiveMonths)
for marks in self.item.marks:
userAutoT = marks.getIdDataBinMonthActive(self.inactiveMonths)
userAutoM = userAutoM + userAutoT
userAutoM = list(set(userAutoM))
# which user is active in last n months and auto active?
userAuto = list(set(userAuto).intersection(userAutoM))
# merge both lists
userActive = userActive + userAuto
# remove double entries
userActive = list(set(userActive))
# remove inactive users
userInactive = self.user.getIdByStatus("inactive")
userInactive = list(set(userActive).intersection(userInactive))
userActive = [x for x in userActive if x not in userInactive]
# sort
userActive.sort()
# create dates
now = datetime.datetime.now()
year = int(now.strftime("%Y"))
month = int(now.strftime("%m"))
day = int(now.strftime("%d"))
# This is done usually in the following month, meaning we need to adapt the date to last month
month -= 1
day = 1
if month == 0:
month = 12
for userId in userActive:
user = self.user.getRowById(userId)
print("\n", user[1])
# get item list
markDescription = []
markDefault = []
for row in self.item.data:
if str(row[3]) == "active":
markDescription.append(row[1])
markDefault.append("0")
# query user input
print("")
inputMark = self.inputStandard(markDescription, markDefault)
# create array for cmark class
markArray = [[0 for x in range(0)] for x in range(0)]
counter = 0
for row in self.item.data:
if str(row[3]) == "active":
markArray.append([user[0], int(year), int(month), int(day), int(inputMark[counter])])
counter += 1
else:
markArray.append([user[0], int(year), int(month), int(day), 0])
# save in database
self.item.marksAdd(markArray)
return 0
def priceAdd(self):
""" Adds a price the price database
"""
priceDescription = []
priceStandard = []
itemId = []
priceOld = [[0 for x in range(0)] for x in range(0)]
# acquiere old prices, save as [itemId, price]
for row in self.price.dataBinMonth:
if len(row) >= 2:
for x in range(0, len(row)-1):
if not float(row[-1-x]) == 0:
priceOld.append([row[0], str(row[-1-x])])
break
# create input fields
for row in self.item.data:
priceDescription.append(str(row[1]) + " " + str(row[2]))
priceOldAdded = False
for row1 in priceOld:
if row[0] == row1[0]:
priceStandard.append(row1[1])
priceOldAdded = True
if not priceOldAdded:
priceStandard.append("0")
itemId.append(row[0])
inputPrice= self.inputStandard(priceDescription, priceStandard)
# create dates
now = datetime.datetime.now()
year = now.strftime("%Y")
month = now.strftime("%m")
day = now.strftime("%d")
counter = 0
for row in itemId:
self.price.priceAdd([row, year, month, day, inputPrice[counter]])
counter += 1
return 0
def priceFill(self):
""" Checks the marks database and matches marks with prices. If a price does not exist, it is requested and added to the price database.
"""
itemId=0
for row in self.item.data:
print ("Checking for item " + str(row[1]))
# Check for marks
self.item.marks[itemId].getDataBinMonth()
marks = self.item.marks[itemId].dataBinMonthHeader
# Check for prices
pricesH = self.price.dataBinMonthHeader
pricesF = self.price.dataBinMonth
prices = []
# Find Id in pricesF
for rowId in pricesF:
if rowId[0] == row[0]:
prices = rowId
del prices[0]
# If Id was not found, we create an empty array
if len(prices) == 0:
if len(pricesF) >= 1:
prices = [0 for x in range(len(pricesF[0])-1)]
# Find missing prices in Header
for mark in marks:
priceFound = False
for price in pricesH:
if mark == price:
priceFound = True
if not priceFound:
pricesH.append(mark)
prices.append(0)
# Find empty prices
priceMissing = [[0 for x in range(0)] for x in range(0)]
counter = 0
for price in prices:
if price == 0:
priceMissing.append(pricesH[counter])
counter += 1
# Request user input for missing prices
princeLatest = "0"
for price in priceMissing:
priceDescription = ["Enter price for " + str(row[1]) + " for year " + str(price[0]) + " and month " + str(price[1])]
priceStandard = [princeLatest]
inputPrice= self.inputStandard(priceDescription, priceStandard)
princeLatest = inputPrice[0]
# save prices
self.price.priceAdd([row[0], price[0], price[1], 1, str(inputPrice[0])])
itemId += 1
return 0
def balanceExportPDF(self):
""" Compute the balance
"""
# create dates
now = datetime.datetime.now()
year = int(now.strftime("%Y"))
month = int(now.strftime("%m"))
dateDescription = ["Year", "Month"]
dateStandard = [str(year), str(month)]
inputDate = self.inputStandard(dateDescription, dateStandard)
# create balance class
self.balance.exportMonthPDF(inputDate[0], inputDate[1], 1)
def listExportPDF(self):
""" Compute the name list
"""
# create dates
now = datetime.datetime.now()
year = int(now.strftime("%Y"))
month = int(now.strftime("%m"))
dateDescription = ["Year", "Month"]
dateStandard = [str(year), str(month)]
inputDate = self.inputStandard(dateDescription, dateStandard)
# create balance class
self.balance.exportMonthListPDF(inputDate[0], inputDate[1], 1)
def balanceCheck(self):
""" Prints a users balance
"""
user = self.getRowByTextname(self.user.getNamelist(), self.user)
# print balance
self.balance.getBalance(user[0])
return 0
| simonreich/coffeedatabase | lib/ckeyboard.py | Python | gpl-3.0 | 17,891 | 0.00218 |
# Copyright (c) 2005-2014, Enthought, Inc.
# some parts copyright 2002 by Space Telescope Science Institute
# All rights reserved.
#
# This software is provided without warranty under the terms of the BSD
# license included in enthought/LICENSE.txt and may be redistributed only
# under the conditions described in the aforementioned license. The license
# is also available online at http://www.enthought.com/licenses/BSD.txt
# Thanks for using Enthought open source!
""" PDF implementation of the core2d drawing library
:Author: Eric Jones, Enthought, Inc., [email protected]
:Copyright: Space Telescope Science Institute
:License: BSD Style
The PDF implementation relies heavily on the ReportLab project.
"""
from __future__ import absolute_import, print_function
# standard library imports
from itertools import izip
import warnings
import copy
from numpy import array, pi
# ReportLab PDF imports
import reportlab.pdfbase.pdfmetrics
import reportlab.pdfbase._fontdata
from reportlab.pdfgen import canvas
# local, relative Kiva imports
from .arc_conversion import arc_to_tangent_points
from .basecore2d import GraphicsContextBase
from .line_state import is_dashed
from .constants import FILL, STROKE, EOF_FILL
import kiva.constants as constants
import kiva.affine as affine
cap_style = {}
cap_style[constants.CAP_ROUND] = 1
cap_style[constants.CAP_SQUARE] = 2
cap_style[constants.CAP_BUTT] = 0
join_style = {}
join_style[constants.JOIN_ROUND] = 1
join_style[constants.JOIN_BEVEL] = 2
join_style[constants.JOIN_MITER] = 0
# stroke, fill, mode
path_mode = {}
path_mode[constants.FILL_STROKE] = (1, 1, canvas.FILL_NON_ZERO)
path_mode[constants.FILL] = (0, 1, canvas.FILL_NON_ZERO)
path_mode[constants.EOF_FILL] = (0, 1, canvas.FILL_EVEN_ODD)
path_mode[constants.STROKE] = (1, 0, canvas.FILL_NON_ZERO)
path_mode[constants.EOF_FILL_STROKE] = (1, 1, canvas.FILL_EVEN_ODD)
# fixme: I believe this can be implemented but for now, it is not.
class CompiledPath(object):
pass
class GraphicsContext(GraphicsContextBase):
"""
Simple wrapper around a PDF graphics context.
"""
def __init__(self, pdf_canvas, *args, **kwargs):
from .image import GraphicsContext as GraphicsContextImage
self.gc = pdf_canvas
self.current_pdf_path = None
self.current_point = (0, 0)
self.text_xy = None, None
# get an agg backend to assist in measuring text
self._agg_gc = GraphicsContextImage((1, 1))
super(GraphicsContext, self).__init__(self, *args, **kwargs)
# ----------------------------------------------------------------
# Coordinate Transform Matrix Manipulation
# ----------------------------------------------------------------
def scale_ctm(self, sx, sy):
"""
scale_ctm(sx: float, sy: float) -> None
Sets the coordinate system scale to the given values, (sx, sy).
"""
self.gc.scale(sx, sy)
def translate_ctm(self, tx, ty):
"""
translate_ctm(tx: float, ty: float) -> None
Translates the coordinate syetem by the given value by (tx, ty)
"""
self.gc.translate(tx, ty)
def rotate_ctm(self, angle):
"""
rotate_ctm(angle: float) -> None
Rotates the coordinate space by the given angle (in radians).
"""
self.gc.rotate(angle * 180 / pi)
def concat_ctm(self, transform):
"""
concat_ctm(transform: affine_matrix)
Concatenates the transform to current coordinate transform matrix.
transform is an affine transformation matrix (see kiva.affine_matrix).
"""
self.gc.transform(transform)
def get_ctm(self):
""" Returns the current coordinate transform matrix.
XXX: This should really return a 3x3 matrix (or maybe an affine
object?) like the other API's. Needs thought.
"""
return affine.affine_from_values(*copy.copy(self.gc._currentMatrix))
def set_ctm(self, transform):
""" Set the coordinate transform matrix
"""
# We have to do this by inverting the current state to zero it out,
# then transform by desired transform, as Reportlab Canvas doesn't
# provide a method to directly set the ctm.
current = self.get_ctm()
self.concat_ctm(affine.invert(current))
self.concat_ctm(transform)
# ----------------------------------------------------------------
# Save/Restore graphics state.
# ----------------------------------------------------------------
def save_state(self):
""" Saves the current graphic's context state.
Always pair this with a `restore_state()`
"""
self.gc.saveState()
def restore_state(self):
""" Restores the previous graphics state.
"""
self.gc.restoreState()
# ----------------------------------------------------------------
# Manipulate graphics state attributes.
# ----------------------------------------------------------------
def set_should_antialias(self, value):
""" Sets/Unsets anti-aliasing for bitmap graphics context.
"""
msg = "antialias is not part of the PDF canvas. Should it be?"
raise NotImplementedError(msg)
def set_line_width(self, width):
""" Sets the line width for drawing
Parameters
----------
width : float
The new width for lines in user space units.
"""
self.gc.setLineWidth(width)
def set_line_join(self, style):
""" Sets style for joining lines in a drawing.
style : join_style
The line joining style. The available
styles are JOIN_ROUND, JOIN_BEVEL, JOIN_MITER.
"""
try:
sjoin = join_style[style]
except KeyError:
msg = "Invalid line join style. See documentation for valid styles"
raise ValueError(msg)
self.gc.setLineJoin(sjoin)
def set_miter_limit(self, limit):
""" Specifies limits on line lengths for mitering line joins.
If line_join is set to miter joins, the limit specifies which
line joins should actually be mitered. If lines aren't mitered,
they are joined with a bevel. The line width is divided by
the length of the miter. If the result is greater than the
limit, the bevel style is used.
Parameters
----------
limit : float
limit for mitering joins.
"""
self.gc.setMiterLimit(limit)
def set_line_cap(self, style):
""" Specifies the style of endings to put on line ends.
Parameters
----------
style : cap_style
the line cap style to use. Available styles
are CAP_ROUND, CAP_BUTT, CAP_SQUARE
"""
try:
scap = cap_style[style]
except KeyError:
msg = "Invalid line cap style. See documentation for valid styles"
raise ValueError(msg)
self.gc.setLineCap(scap)
def set_line_dash(self, lengths, phase=0):
"""
Parameters
----------
lengths : float array
An array of floating point values
specifing the lengths of on/off painting
pattern for lines.
phase : float
Specifies how many units into dash pattern
to start. phase defaults to 0.
"""
if is_dashed((phase, lengths)):
lengths = list(lengths) if lengths is not None else []
self.gc.setDash(lengths, phase)
def set_flatness(self, flatness):
"""
It is device dependent and therefore not recommended by
the PDF documentation.
"""
raise NotImplementedError("Flatness not implemented yet on PDF")
# ----------------------------------------------------------------
# Sending drawing data to a device
# ----------------------------------------------------------------
def flush(self):
""" Sends all drawing data to the destination device.
Currently, this is a NOP. It used to call ReportLab's save()
method, and maybe it still should, but flush() is likely to
be called a lot, so this will really slow things down. Also,
I think save() affects the paging of a document I think.
We'll have to look into this more.
"""
pass
def synchronize(self):
""" Prepares drawing data to be updated on a destination device.
Currently, doesn't do anything.
Should this call ReportLab's canvas object's showPage() method.
"""
pass
# ----------------------------------------------------------------
# Page Definitions
# ----------------------------------------------------------------
def begin_page(self):
""" Creates a new page within the graphics context.
Currently, this just calls ReportLab's canvas object's
showPage() method. Not sure about this...
"""
self.gc.showPage()
def end_page(self):
""" Ends drawing in the current page of the graphics context.
Currently, this just calls ReportLab's canvas object's
showPage() method. Not sure about this...
"""
self.gc.showPage()
# ----------------------------------------------------------------
# Building paths (contours that are drawn)
#
# + Currently, nothing is drawn as the path is built. Instead, the
# instructions are stored and later drawn. Should this be changed?
# We will likely draw to a buffer instead of directly to the canvas
# anyway.
#
# Hmmm. No. We have to keep the path around for storing as a
# clipping region and things like that.
#
# + I think we should keep the current_path_point hanging around.
#
# ----------------------------------------------------------------
def begin_path(self):
""" Clears the current drawing path and begins a new one.
"""
self.current_pdf_path = self.gc.beginPath()
self.current_point = (0, 0)
def move_to(self, x, y):
""" Starts a new drawing subpath at place the current point at (x, y).
"""
if self.current_pdf_path is None:
self.begin_path()
self.current_pdf_path.moveTo(x, y)
self.current_point = (x, y)
def line_to(self, x, y):
""" Adds a line from the current point to the given point (x, y).
The current point is moved to (x, y).
"""
if self.current_pdf_path is None:
self.begin_path()
self.current_pdf_path.lineTo(x, y)
self.current_point = (x, y)
def lines(self, points):
""" Adds a series of lines as a new subpath.
Currently implemented by calling line_to a zillion times.
Points is an Nx2 array of x, y pairs.
current_point is moved to the last point in points
"""
if self.current_pdf_path is None:
self.begin_path()
self.current_pdf_path.moveTo(points[0][0], points[0][1])
for x, y in points[1:]:
self.current_pdf_path.lineTo(x, y)
self.current_point = (x, y)
def line_set(self, starts, ends):
if self.current_pdf_path is None:
self.begin_path()
for start, end in izip(starts, ends):
self.current_pdf_path.moveTo(start[0], start[1])
self.current_pdf_path.lineTo(end[0], end[1])
self.current_point = (end[0], end[1])
def rect(self, *args):
""" Adds a rectangle as a new subpath. Can be called in two ways:
rect(x, y, w, h)
rect( (x, y, w, h) )
"""
if self.current_pdf_path is None:
self.begin_path()
if len(args) == 1:
args = args[0]
self.current_pdf_path.rect(*args)
self.current_point = (args[0], args[1])
def draw_rect(self, rect, mode=constants.FILL_STROKE):
self.rect(rect)
self.draw_path(mode)
self.current_point = (rect[0], rect[1])
def rects(self, rects):
""" Adds multiple rectangles as separate subpaths to the path.
Currently implemented by calling rect a zillion times.
"""
if self.current_pdf_path is None:
self.begin_path()
for x, y, sx, sy in rects:
self.current_pdf_path.rect(x, y, sx, sy)
self.current_point = (x, y)
def close_path(self):
""" Closes the path of the current subpath.
"""
self.current_pdf_path.close()
def curve_to(self, cp1x, cp1y, cp2x, cp2y, x, y):
"""
"""
if self.current_pdf_path is None:
self.begin_path()
self.current_pdf_path.curveTo(cp1x, cp1y, cp2x, cp2y, x, y)
self.current_point = (x, y)
def quad_curve_to(self, cpx, cpy, x, y):
"""
"""
msg = "quad curve to not implemented yet on PDF"
raise NotImplementedError(msg)
def arc(self, x, y, radius, start_angle, end_angle, clockwise=False):
"""
"""
if self.current_pdf_path is None:
self.begin_path()
self.current_pdf_path.arc(x - radius, y - radius,
x + radius, y + radius,
start_angle * 180.0 / pi,
(end_angle-start_angle) * 180.0 / pi)
self.current_point = (x, y)
def arc_to(self, x1, y1, x2, y2, radius):
"""
"""
if self.current_pdf_path is None:
self.begin_path()
# Get the endpoints on the curve where it touches the line segments
t1, t2 = arc_to_tangent_points(self.current_point,
(x1, y1), (x2, y2), radius)
# draw!
self.current_pdf_path.lineTo(*t1)
self.current_pdf_path.curveTo(x1, y1, x1, y1, *t2)
self.current_pdf_path.lineTo(x2, y2)
self.current_point = (x2, y2)
# ----------------------------------------------------------------
# Getting infomration on paths
# ----------------------------------------------------------------
def is_path_empty(self):
""" Tests to see whether the current drawing path is empty
"""
msg = "is_path_empty not implemented yet on PDF"
raise NotImplementedError(msg)
def get_path_current_point(self):
""" Returns the current point from the graphics context.
Note: This should be a tuple or array.
"""
return self.current_point
def get_path_bounding_box(self):
"""
Should return a tuple or array instead of a strange object.
"""
msg = "get_path_bounding_box not implemented yet on PDF"
raise NotImplementedError(msg)
# ----------------------------------------------------------------
# Clipping path manipulation
# ----------------------------------------------------------------
def clip(self):
"""
"""
self.gc._fillMode = canvas.FILL_NON_ZERO
self.gc.clipPath(self.current_pdf_path, stroke=0, fill=0)
def even_odd_clip(self):
"""
"""
self.gc._fillMode = canvas.FILL_EVEN_ODD
self.gc.clipPath(self.current_pdf_path, stroke=0, fill=1)
def clip_to_rect(self, x, y, width, height):
""" Clips context to the given rectangular region.
Region should be a 4-tuple or a sequence.
"""
clip_path = self.gc.beginPath()
clip_path.rect(x, y, width, height)
self.gc.clipPath(clip_path, stroke=0, fill=0)
def clip_to_rects(self):
"""
"""
msg = "clip_to_rects not implemented yet on PDF."
raise NotImplementedError(msg)
def clear_clip_path(self):
"""
"""
return
self.clip_to_rect(0, 0, 10000, 10000)
# ----------------------------------------------------------------
# Color space manipulation
#
# I'm not sure we'll mess with these at all. They seem to
# be for setting the color syetem. Hard coding to RGB or
# RGBA for now sounds like a reasonable solution.
# ----------------------------------------------------------------
def set_fill_color_space(self):
"""
"""
msg = "set_fill_color_space not implemented on PDF yet."
raise NotImplementedError(msg)
def set_stroke_color_space(self):
"""
"""
msg = "set_stroke_color_space not implemented on PDF yet."
raise NotImplementedError(msg)
def set_rendering_intent(self):
"""
"""
msg = "set_rendering_intent not implemented on PDF yet."
raise NotImplementedError(msg)
# ----------------------------------------------------------------
# Color manipulation
# ----------------------------------------------------------------
def set_fill_color(self, color):
"""
"""
r, g, b = color[:3]
try:
a = color[3]
except IndexError:
a = 1.0
self.gc.setFillColorRGB(r, g, b, a)
def set_stroke_color(self, color):
"""
"""
r, g, b = color[:3]
try:
a = color[3]
except IndexError:
a = 1.0
self.gc.setStrokeColorRGB(r, g, b, a)
def set_alpha(self, alpha):
""" Sets alpha globally. Note that this will not affect draw_image
because reportlab does not currently support drawing images with
alpha.
"""
self.gc.setFillAlpha(alpha)
self.gc.setStrokeAlpha(alpha)
super(GraphicsContext, self).set_alpha(alpha)
# ----------------------------------------------------------------
# Drawing Images
# ----------------------------------------------------------------
def draw_image(self, img, rect=None):
"""
draw_image(img_gc, rect=(x, y, w, h))
Draws another gc into this one. If 'rect' is not provided, then
the image gc is drawn into this one, rooted at (0, 0) and at full
pixel size. If 'rect' is provided, then the image is resized
into the (w, h) given and drawn into this GC at point (x, y).
img_gc is either a Numeric array (WxHx3 or WxHx4) or a GC from Kiva's
Agg backend (kiva.agg.GraphicsContextArray).
Requires the Python Imaging Library (PIL).
"""
# We turn img into a PIL object, since that is what ReportLab
# requires. To do this, we first determine if the input image
# GC needs to be converted to RGBA/RGB. If so, we see if we can
# do it nicely (using convert_pixel_format), and if not, we do
# it brute-force using Agg.
from reportlab.lib.utils import ImageReader
from PIL import Image as PilImage
from kiva import agg
if type(img) == type(array([])):
# Numeric array
converted_img = agg.GraphicsContextArray(img, pix_format='rgba32')
format = 'RGBA'
elif isinstance(img, agg.GraphicsContextArray):
if img.format().startswith('RGBA'):
format = 'RGBA'
elif img.format().startswith('RGB'):
format = 'RGB'
else:
converted_img = img.convert_pixel_format('rgba32', inplace=0)
format = 'RGBA'
else:
warnings.warn("Cannot render image of type %r into PDF context."
% type(img))
return
# converted_img now holds an Agg graphics context with the image
pil_img = PilImage.fromstring(format,
(converted_img.width(),
converted_img.height()),
converted_img.bmp_array.tostring())
if rect is None:
rect = (0, 0, img.width(), img.height())
# Draw the actual image.
# Wrap it in an ImageReader object, because that's what reportlab
# actually needs.
self.gc.drawImage(ImageReader(pil_img),
rect[0], rect[1], rect[2], rect[3])
# ----------------------------------------------------------------
# Drawing Text
# ----------------------------------------------------------------
def select_font(self, name, size, textEncoding):
""" PDF ignores the Encoding variable.
"""
self.gc.setFont(name, size)
def set_font(self, font):
""" Sets the font for the current graphics context.
"""
# TODO: Make this actually do the right thing
if font.face_name == "":
font.face_name = "Helvetica"
self.gc.setFont(font.face_name, font.size)
def get_font(self):
""" Get the current font """
raise NotImplementedError
def set_font_size(self, size):
"""
"""
font = self.gc._fontname
self.gc.setFont(font, size)
def set_character_spacing(self):
"""
"""
pass
def get_character_spacing(self):
""" Get the current font """
raise NotImplementedError
def set_text_drawing_mode(self):
"""
"""
pass
def set_text_position(self, x, y):
"""
"""
self.text_xy = x, y
def get_text_position(self):
"""
"""
return self.state.text_matrix[2, :2]
def set_text_matrix(self, ttm):
"""
"""
a, b, c, d, tx, ty = affine.affine_params(ttm)
self.gc._textMatrix = (a, b, c, d, tx, ty)
def get_text_matrix(self):
"""
"""
a, b, c, d, tx, ty = self.gc._textMatrix
return affine.affine_from_values(a, b, c, d, tx, ty)
def show_text(self, text, x=None, y=None):
""" Draws text on the device at current text position.
This is also used for showing text at a particular point
specified by x and y.
This ignores the text matrix for now.
"""
if x and y:
pass
else:
x, y = self.text_xy
self.gc.drawString(x, y, text)
def show_text_at_point(self, text, x, y):
self.show_text(text, x, y)
def show_glyphs(self):
"""
"""
msg = "show_glyphs not implemented on PDF yet."
raise NotImplementedError(msg)
def get_full_text_extent(self, textstring):
fontname = self.gc._fontname
fontsize = self.gc._fontsize
ascent, descent = reportlab.pdfbase._fontdata.ascent_descent[fontname]
# get the AGG extent (we just care about the descent)
aw, ah, ad, al = self._agg_gc.get_full_text_extent(textstring)
# ignore the descent returned by reportlab if AGG returned 0.0 descent
descent = 0.0 if ad == 0.0 else descent * fontsize / 1000.0
ascent = ascent * fontsize / 1000.0
height = ascent + abs(descent)
width = self.gc.stringWidth(textstring, fontname, fontsize)
# the final return value is defined as leading. do not know
# how to get that number so returning zero
return width, height, descent, 0
def get_text_extent(self, textstring):
w, h, d, l = self.get_full_text_extent(textstring)
return w, h
# ----------------------------------------------------------------
# Painting paths (drawing and filling contours)
# ----------------------------------------------------------------
def clear(self):
"""
"""
warnings.warn("clear() is ignored for the pdf backend")
def stroke_path(self):
"""
"""
self.draw_path(mode=STROKE)
def fill_path(self):
"""
"""
self.draw_path(mode=FILL)
def eof_fill_path(self):
"""
"""
self.draw_path(mode=EOF_FILL)
def stroke_rect(self, rect):
"""
"""
self.begin_path()
self.rect(rect[0], rect[1], rect[2], rect[3])
self.stroke_path()
def stroke_rect_with_width(self, rect, width):
"""
"""
msg = "stroke_rect_with_width not implemented on PDF yet."
raise NotImplementedError(msg)
def fill_rect(self, rect):
"""
"""
self.begin_path()
self.rect(rect[0], rect[1], rect[2], rect[3])
self.fill_path()
def fill_rects(self):
"""
"""
msg = "fill_rects not implemented on PDF yet."
raise NotImplementedError(msg)
def clear_rect(self, rect):
"""
"""
msg = "clear_rect not implemented on PDF yet."
raise NotImplementedError(msg)
def draw_path(self, mode=constants.FILL_STROKE):
""" Walks through all the drawing subpaths and draw each element.
Each subpath is drawn separately.
"""
if self.current_pdf_path is not None:
stroke, fill, mode = path_mode[mode]
self.gc._fillMode = mode
self.gc.drawPath(self.current_pdf_path, stroke=stroke, fill=fill)
# erase the current path.
self.current_pdf_path = None
def save(self):
self.gc.save()
def simple_test():
pdf = canvas.Canvas("bob.pdf")
gc = GraphicsContext(pdf)
gc.begin_path()
gc.move_to(50, 50)
gc.line_to(100, 100)
gc.draw_path()
gc.flush()
pdf.save()
if __name__ == "__main__":
import sys
if len(sys.argv) == 1:
sys.exit("Usage: %s output_file" % sys.argv[0])
| tommy-u/enable | kiva/pdf.py | Python | bsd-3-clause | 25,949 | 0.000077 |
"""
Copyright (c) 2004-Present Pivotal Software, Inc.
This program and the accompanying materials are made available under
the terms of the 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.
"""
import os
import shutil
import tinctest
import tinctest
from gppylib.commands.base import Command
from mpp.models import MPPTestCase
from mpp.gpdb.tests.storage.walrepl.lib.pg_util import GpUtility
from mpp.gpdb.tests.storage.walrepl.gpinitstandby import GpinitStandby
class LoadClass(MPPTestCase):
def __init__(self,methodName):
self.gp =GpinitStandby()
super(LoadClass,self).__init__(methodName)
def run_skip(self, type):
tinctest.logger.info("skipping checkpoint")
cmd_str = 'gpfaultinjector -p %s -m async -H ALL -r primary -f checkpoint -y %s -o 0' % (os.getenv('PGPORT'), type)
cmd = Command('skip_chkpoint', cmd_str)
cmd.run(validateAfter =False)
def skip_checkpoint(self):
''' Routine to inject fault that skips checkpointing '''
self.run_skip('reset')
self.run_skip('suspend')
def init_standby(self):
pg = GpUtility()
pg.install_standby()
def cleanup(self):
# Remove standby and reset the checkpoint fault
self.gp.run(option='-r')
self.run_skip('reset')
| Chibin/gpdb | src/test/tinc/tincrepo/mpp/gpdb/tests/storage/walrepl/load/__init__.py | Python | apache-2.0 | 1,772 | 0.005643 |
#!/bin/sh -
# Copyright 2011-2012 James McCauley
#
# 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.
# If you have PyPy 1.6+ in a directory called pypy alongside pox.py, we
# use it.
# Otherwise, we try to use a Python interpreter called python2.7, which
# is a good idea if you're using Python from MacPorts, for example.
# We fall back to just "python" and hope that works.
''''true
#export OPT="-u -O"
export OPT="-u"
export FLG=""
if [ "$(basename $0)" = "debug-pox.py" ]; then
export OPT=""
export FLG="--debug"
fi
if [ -x pypy/bin/pypy ]; then
exec pypy/bin/pypy $OPT "$0" $FLG "$@"
fi
if type python2.7 > /dev/null 2> /dev/null; then
exec python2.7 $OPT "$0" $FLG "$@"
fi
exec python $OPT "$0" $FLG "$@"
'''
from pox.boot import boot
if __name__ == '__main__':
boot()
| voidcc/POXPOF | pox.py | Python | apache-2.0 | 1,289 | 0 |
"""
===============================================
Create topographic ERF maps in delayed SSP mode
===============================================
This script shows how to apply SSP projectors delayed, that is,
at the evoked stage. This is particularly useful to support decisions
related to the trade-off between denoising and preserving signal.
In this example we demonstrate how to use topographic maps for delayed
SSP application.
"""
# Authors: Denis Engemann <[email protected]>
# Christian Brodbeck <[email protected]>
# Alexandre Gramfort <[email protected]>
#
# License: BSD (3-clause)
import numpy as np
import mne
from mne import io
from mne.datasets import sample
print(__doc__)
data_path = sample.data_path()
###############################################################################
# Set parameters
raw_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw.fif'
event_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw-eve.fif'
ecg_fname = data_path + '/MEG/sample/sample_audvis_ecg_proj.fif'
event_id, tmin, tmax = 1, -0.2, 0.5
# Setup for reading the raw data
raw = io.Raw(raw_fname)
events = mne.read_events(event_fname)
# delete EEG projections (we know it's the last one)
raw.del_proj(-1)
# add ECG projs for magnetometers
[raw.add_proj(p) for p in mne.read_proj(ecg_fname) if 'axial' in p['desc']]
# pick magnetometer channels
picks = mne.pick_types(raw.info, meg='mag', stim=False, eog=True,
include=[], exclude='bads')
# We will make of the proj `delayed` option to
# interactively select projections at the evoked stage.
# more information can be found in the example/plot_evoked_delayed_ssp.py
epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks,
baseline=(None, 0), reject=dict(mag=4e-12), proj='delayed')
evoked = epochs.average() # average epochs and get an Evoked dataset.
###############################################################################
# Interactively select / deselect the SSP projection vectors
# set time instants in seconds (from 50 to 150ms in a step of 10ms)
times = np.arange(0.05, 0.15, 0.01)
evoked.plot_topomap(times, proj='interactive')
# Hint: the same works for evoked.plot and viz.plot_topo
| trachelr/mne-python | examples/visualization/plot_evoked_topomap_delayed_ssp.py | Python | bsd-3-clause | 2,301 | 0 |
from datetime import datetime
from django.core.exceptions import ValidationError
from django.db import models
def validate_answer_to_universe(value):
if value != 42:
raise ValidationError('This is not the answer to life, universe and everything!', code='not42')
class ModelToValidate(models.Model):
name = models.CharField(max_length=100)
created = models.DateTimeField(default=datetime.now)
number = models.IntegerField(db_column='number_val')
parent = models.ForeignKey('self', blank=True, null=True, limit_choices_to={'number': 10})
email = models.EmailField(blank=True)
url = models.URLField(blank=True)
f_with_custom_validator = models.IntegerField(blank=True, null=True, validators=[validate_answer_to_universe])
def clean(self):
super(ModelToValidate, self).clean()
if self.number == 11:
raise ValidationError('Invalid number supplied!')
class UniqueFieldsModel(models.Model):
unique_charfield = models.CharField(max_length=100, unique=True)
unique_integerfield = models.IntegerField(unique=True)
non_unique_field = models.IntegerField()
class CustomPKModel(models.Model):
my_pk_field = models.CharField(max_length=100, primary_key=True)
class UniqueTogetherModel(models.Model):
cfield = models.CharField(max_length=100)
ifield = models.IntegerField()
efield = models.EmailField()
class Meta:
unique_together = (('ifield', 'cfield',), ['ifield', 'efield'])
class UniqueForDateModel(models.Model):
start_date = models.DateField()
end_date = models.DateTimeField()
count = models.IntegerField(unique_for_date="start_date", unique_for_year="end_date")
order = models.IntegerField(unique_for_month="end_date")
name = models.CharField(max_length=100)
class CustomMessagesModel(models.Model):
other = models.IntegerField(blank=True, null=True)
number = models.IntegerField(db_column='number_val',
error_messages={'null': 'NULL', 'not42': 'AAARGH', 'not_equal': '%s != me'},
validators=[validate_answer_to_universe]
)
class Author(models.Model):
name = models.CharField(max_length=100)
class Article(models.Model):
title = models.CharField(max_length=100)
author = models.ForeignKey(Author)
pub_date = models.DateTimeField(blank=True)
def clean(self):
if self.pub_date is None:
self.pub_date = datetime.now()
class Post(models.Model):
title = models.CharField(max_length=50, unique_for_date='posted', blank=True)
slug = models.CharField(max_length=50, unique_for_year='posted', blank=True)
subtitle = models.CharField(max_length=50, unique_for_month='posted', blank=True)
posted = models.DateField()
def __unicode__(self):
return self.name
class FlexibleDatePost(models.Model):
title = models.CharField(max_length=50, unique_for_date='posted', blank=True)
slug = models.CharField(max_length=50, unique_for_year='posted', blank=True)
subtitle = models.CharField(max_length=50, unique_for_month='posted', blank=True)
posted = models.DateField(blank=True, null=True)
class UniqueErrorsModel(models.Model):
name = models.CharField(max_length=100, unique=True, error_messages={'unique': u'Custom unique name message.'})
no = models.IntegerField(unique=True, error_messages={'unique': u'Custom unique number message.'})
class GenericIPAddressTestModel(models.Model):
generic_ip = models.GenericIPAddressField(blank=True, null=True, unique=True)
v4_ip = models.GenericIPAddressField(blank=True, null=True, protocol="ipv4")
v6_ip = models.GenericIPAddressField(blank=True, null=True, protocol="ipv6")
class GenericIPAddrUnpackUniqueTest(models.Model):
generic_v4unpack_ip = models.GenericIPAddressField(blank=True, unique=True, unpack_ipv4=True)
# A model can't have multiple AutoFields
# Refs #12467.
assertion_error = None
try:
class MultipleAutoFields(models.Model):
auto1 = models.AutoField(primary_key=True)
auto2 = models.AutoField(primary_key=True)
except AssertionError as assertion_error:
pass # Fail silently
assert str(assertion_error) == u"A model can't have more than one AutoField."
| adrianholovaty/django | tests/modeltests/validation/models.py | Python | bsd-3-clause | 4,204 | 0.00785 |
#!/usr/bin/env python
'''
____ _ _ _ ____ _______ ____
/ ___)| | | | | |/ _ \ / _ _ \| _ \
\___ \| | | | | | (_) | | | | | | |_) )
___) | |_| |_| | ___ | | | | | | __/
(____/ \_______/|_| |_|_| |_| |_|_|
Sliding Window Alignment Masker for PAML - 31-03-14
SWAMP analyses multiple sequence alignments in a phylogenetic context,
looking for regions of higher than expected non-synonymous substitutions
along a branch, over a short sequence window. If a user defined
threshold is exceeded then the window of sequence is masked to prevent
its inclusion in downstream evolutionary analyses. This masking
approach removes sequence data that violates the assumptions of the
phylogenetic models implemented in the software package PAML that could
otherwise give a false signal of positive selection.
Copyright (C) 2015 Peter Harrison
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
'''
#==============================================================================
import sys
import os
import argparse
#==============================================================================
#Main==========================================================================
#==============================================================================
def main():
'''Main runs only when the file itself is executed.
If a part of the script is imported, main will not be executed.'''
parser = argparse.ArgumentParser(description="SWAMP - Sliding Window \
Alignment Masker for PAML - Version \
31-03-14", epilog="Copyright (C) 2014 \
Peter Harrison", add_help=False)
# Required parameters
parameters = parser.add_argument_group('Required parameters')
parameters.add_argument("-i", "--infolder", type=str,
help="An input folder containing .phy and rst \
files. This folder can contain multiple \
subfolders each with .phy and rst files.")
parameters.add_argument("-b", "--branchnames", type=str,
help="A file listing which branches to analyse \
and which sequences to mask, see documentation \
for file format in README.md.")
parameters.add_argument("-t", "--threshold", type=int,
help="A threshold integer of the number of \
non-synonymous changes at and above which the \
window will be masked.")
parameters.add_argument("-w", "--windowsize", type=int,
help="The window size (in codons) for the sliding \
window scan.")
# Optional arguments
options = parser.add_argument_group('Optional arguments')
options.add_argument("-h", "--help", action="help",
help="Show help and exit.")
options.add_argument("-m", "--minseqlength", type=int, default=33,
help="The required minimum number of informative \
codons in each sequence of the alignment \
post-masking, a warning will be provided if sequences\
are less than this length.")
options.add_argument("-s", "--interscan", action="store_true",
help="Activates interscan masking as desribed in the \
documentation, README.md.")
options.add_argument("-p", "--print-alignment", type=str,
help="Prints out a summary of the given alignment \
file. No other option can be used at the same time.")
# Check if the user supplied any arguments. If not, print help.
if len(sys.argv) == 1:
parser.print_help()
sys.exit(1)
# Shorten the access to command line arguments.
args = parser.parse_args()
if args.print_alignment:
print_alignment_summary(args.print_alignment)
sys.exit(0)
elif args.infolder is None:
print "Parameter -i [--infolder] is required!"
sys.exit(1)
elif args.branchnames is None:
print "Parameter -b [--branchnames] is required!"
sys.exit(1)
elif args.threshold is None:
print "Parameter -t [--threshold] is required!"
sys.exit(1)
elif args.windowsize is None:
print "Parameter -w [--windowsize] is required!"
sys.exit(1)
# Print user provided folder and SWAMP user options
print "Scanning folder:\t", args.infolder
params = (args.threshold, args.windowsize, args.minseqlength)
print "With selected parameters:"
print "\tThreshold:\t%s\n\tWindowsize:\t%s\n\tMinimum length:\t%s" % params
if args.interscan:
print "\tInterscan enabled"
# Get all files recursively.
file_list = list_folder_filtered(args.infolder, ".phy")
# Ignore any already-masked files.
file_list = [x for x in file_list if not x.endswith("_masked.phy")]
print "Found %s phylip files to scan with SWAMP." % len(file_list)
# Obtain sequences to be masked and branches to analyse from file
branchcodes = read_branchcodes(args.branchnames)
# Sliding window scan all found phylip alignments
sliding_window_scan(file_list, args.threshold, args.windowsize,
args.interscan, branchcodes,
args.minseqlength)
#==============================================================================
#Functions=====================================================================
#==============================================================================
def print_alignment_summary(infile):
'''Prints out a summary of the given alignment file'''
seq_dict = read_phylip(infile)
aln_length = len(seq_dict.values()[0])
print "%15s Alignment length: %d codons" % ('', aln_length)
total_masked_sites = 0
for species in seq_dict:
seq = seq_dict[species]
codons = get_codons(seq)
n_nongap_sites = 0
n_masked_sites = 0
for codon in codons:
if codon != '---':
n_nongap_sites += 1
if codon == 'NNN':
n_masked_sites += 1
total_masked_sites += 1
pct_masked = (float(n_masked_sites) / float(n_nongap_sites)) * 100
print ("%15s %.50s... %5d codons %4d masked (%.0f%%)" % (species, seq,
n_nongap_sites, n_masked_sites, pct_masked))
print "%15s Total masked codons: %d" % ('', total_masked_sites)
def list_folder_filtered(infolder, extension):
'''Recursivly returns files with given extension from the specified folder
and subfolders'''
try:
file_list = []
# Walk directory tree
for path, subdirs, files in os.walk(infolder):
for name in files:
if name.endswith(extension): # Check file ends with extension
phyfile = os.path.join(path, name) # Get full path
file_list.append(phyfile) # Add path to file list
# If no phylip files are found print error
if not file_list:
print "!----ERROR----!"
print "%s doesn't exist or does not contain .phy files!" % infolder
sys.exit(1)
return file_list
except KeyboardInterrupt:
sys.exit(1)
def read_branchcodes(infile):
'''Parses branch information file for sequences to mask and branches to use
for non-synonymous information, see documentation for file format.'''
try:
branchcodes = {}
with open(infile) as readfile:
for line in readfile:
parts = line.split()
# Check line has branch and sequence names
if len(parts) == 2:
seqparts = parts[1].split(",") # Obtain sequences to mask
branchcodes[parts[0]] = tuple(seqparts) # Store branches
# Raise error for lines that don't have two parts
else:
raise ValueError(("The following line in %s is not "
"formatted correctly. Check the "
"documentation:\n%s" % (infile, line)))
return branchcodes
except IOError:
print "File %s does not exist!" % infile
raise
except KeyboardInterrupt:
sys.exit(1)
def sliding_window_scan(file_list, threshold, windowsize,
interscan, branchcodes, minseqlength=None):
'''Sliding window scan and mask a list of files'''
# Counter for total masked and short seqs
masked_file_count, files_with_short_seqs_count = 0, 0
for infile in file_list:
result = sliding_window_scan_file(infile, threshold, windowsize,
interscan, branchcodes, minseqlength)
if result['masked_codon_count'] > 0:
masked_file_count += 1
if result['short_seq_count'] > 0:
files_with_short_seqs_count += 1
if __name__ == "__main__":
sinfo = (result['short_seq_count'], minseqlength)
print " !! %s sequence(s) contained fewer than %s" % sinfo
print " informative codons after masking!"
if __name__ == "__main__":
filesinfo = (masked_file_count, len(file_list))
print "SWAMP has masked %s out of %s PAML phylip files" % filesinfo
if minseqlength:
pin = (files_with_short_seqs_count, minseqlength)
print "%s files have sequences less than %s codons in length" % pin
def sliding_window_scan_file(infile, threshold, windowsize, interscan,
branchcodes, minseqlength=None):
'''Sliding window scan and mask a single file. Returns a 'result'
dict with info resulting from the scan & masking process.'''
result = {
'masked_codon_count': 0,
'masked_column_count': 0,
'short_seq_count': 0,
'masked_dict': None,
'seq_dict': None
}
seqdict = read_phylip(infile) # Create sequences dictionary
branch_error_check(branchcodes, seqdict) # Check validity of branchcodes
# Extract branch information from rst file
branches = read_rst(infile)
# Scan codons for those that need masking
codons_tomask = (scan(branches, seqdict, threshold, windowsize,
branchcodes))
# Check if any codons were needing to be masked
if len(codons_tomask) > 0:
# If interscan option was selected
if interscan:
codons_tomask = run_interscan(
codons_tomask, seqdict, branchcodes)
# Mask the codons to get a new seq_dict
masked_dict = mask_codons(seqdict, codons_tomask)
# Count number of codons with >0 species masked out.
result['masked_column_count'] = len(codons_tomask.keys())
result['masked_codon_count'] = count_masked_codons(masked_dict)
# Store the # of sequences with less than the desired minimum number of
# codons
if minseqlength is not None:
short_seq_count = count_short_seqs(masked_dict, minseqlength)
result['short_seq_count'] = short_seq_count
if __name__ == "__main__":
n_species = len(seqdict.keys())
n_columns = len(seqdict.values()[0]) / 3
spinfo = (infile, n_species, n_columns)
print " > %s (%d species, %d columns)" % spinfo
minfo = (result['masked_codon_count'], result['masked_column_count'])
print " masked %d codons from %d columns" % minfo
# Print out masked alignment.
print_masked_phyfile(infile, masked_dict)
result['masked_dict'] = masked_dict
result['seq_dict'] = seqdict
return result
def count_masked_codons(seq_dict):
'''Count number of masked codons'''
masked_codon_count = 0
for species in seq_dict:
seq = seq_dict[species]
codons = get_codons(seq)
for codon in codons:
if codon == 'NNN':
masked_codon_count += 1
return masked_codon_count
def read_phylip(infile):
'''Read in phylip sequences'''
try:
with open(infile) as readfile:
sequences = {}
# Get header
header = next(readfile).split()
# Check the supplied PHYLIP file is valid
if len(header) != 2:
raise ValueError("Cannot detect header in %s" % infile)
else:
expected_number = int(header[0])
seq_len = int(header[1])
# Parse the phylip by tracking a 'reading_seq' state
# variable, which flips to False when we expect to see
# another sequence ID.
cur_name = None
reading_seq = False
for line in readfile:
line = line.rstrip()
if not reading_seq:
# Get here if we're expecting a sequence ID. Take
# the current line as the ID and create an entry
# in the sequences dict with an empty string.
cur_name = line
sequences[cur_name] = ""
reading_seq = True
else:
# Get here if we're expecting sequence data.
sequences[cur_name] += line.upper()
cur_seq_len = len(sequences[cur_name])
if cur_seq_len == seq_len:
# Once the sequence has reached the
# header-defined length, we know to expect a
# sequence ID on the next line.
reading_seq = False
# Check if sequences are correct
if len(sequences) != expected_number:
err = (expected_number, len(sequences), infile)
raise ValueError(
"Expected %s sequences and have loaded %s in %s" % err)
# Check sequence length and frame
for seq in sequences:
if len(sequences[seq]) > seq_len:
raise ValueError(
"Sequence lengths are not all equal for: %s" % infile)
if len(sequences[seq]) == 0:
raise ValueError("Sequence must be longer than 0!")
if len(sequences[seq]) % 3 != 0:
raise ValueError("%s sequence not divisible by 3" % seq)
return sequences
except IOError:
print "File %s does not exist!" % infile
raise
except KeyboardInterrupt:
sys.exit(1)
def branch_error_check(branchcodes, seqdict):
'''Check for errors in branchcodes file and loaded branches'''
# If there are no valid branchcodes
if not branchcodes:
raise ValueError("No branchnames found in --branchnames file")
# Check for errors in supplied branchcodes
for branch in branchcodes:
if ".." not in branch:
raise ValueError("Check branchnames file. Branch %s is invalid" %
branch)
# Given list of species from branch code...
species_list = branchcodes[branch]
for species in species_list:
# Raise an error if any species isn't in the alignment dict.
if species not in seqdict:
raise ValueError("Species %s not in alignment file!" % species)
def read_rst(infile):
'''Parse rst file for non-synonymous substitutions'''
# Get path for rst file, should be in same folder as phylip file
rstinfile = "/".join(infile.split("/")[:-1])+"/rst"
try:
with open(rstinfile) as readfile:
branches = {}
readin = False # Save or not save line toggle
no_branch_found = True # No branch file check
for line in readfile:
line = line.rstrip()
# Find branch line
if line.startswith("Branch"):
parts = line.split()
branch = parts[2]
branches[branch] = []
readin = True
no_branch_found = False
# End of branch section
elif line.startswith("List"):
readin = False
elif readin is True:
parts = line.split()
if len(parts) > 1: # If line not empty
if parts[2] != parts[6]: # If it is non-synonymous
codon = int(parts[0]) # Get non-synonymous codon
branches[branch].append(codon)
if no_branch_found:
print "Check that PAML ran correctly!"
raise ValueError(
"File %s is missing branch information!" % rstinfile)
return branches
except IOError:
print "File %s does not exist!" % rstinfile
raise
except KeyboardInterrupt:
sys.exit(1)
def scan(branches, seqdict, threshold, windowsize, branchcodes):
'''Conducts sliding window scan on user supplied sequences and branches.'''
# Dictionary to store codons that need masking
codons_tomask = {}
# For each of the branches to be analysed
for branch in branchcodes:
if branch not in branches:
print "!----ERROR----!"
print "Check branchnames file as branch not valid: ", branch
sys.exit(1)
codons = branches[branch]
windowstart = 0
windowend = windowsize - 1
# For each window
while windowend <= len(seqdict.values()[0]) / 3:
count = 0
window = range(windowstart, windowend) # Get codons in window
for codon in codons:
if codon in window: # Count substitions within window
count += 1
# If threshold equaled or exceeded
if count >= threshold:
for codon in window:
if codon in codons_tomask: # Mark window for masking
for seq in branchcodes[branch]:
if seq not in codons_tomask[codon]:
codons_tomask[codon].append(seq)
else:
codons_tomask[codon] = list(branchcodes[branch])
windowstart += 1
windowend += 1
return codons_tomask
def run_interscan(codons_tomask, seqdict, branchcodes):
'''Extend masking around masked sections according to length'''
seqs_tomask = []
# Get list of sequences that need masking
for branch in branchcodes.values():
for seq in branch:
seqs_tomask.append(seq)
seqs_tomask = list(set(seqs_tomask))
seqlength = len(seqdict.values()[0])/3
# Scan each sequence seperately, but only those in branchcodes file
for seq in seqs_tomask:
startat = 0 # Start of sequence
scan_complete = False # Boolean for completion
# Only use codons specific to the sequence in question
bs_codons_tomask = {}
for codon in codons_tomask:
if seq in codons_tomask[codon]:
bs_codons_tomask[codon] = seq
#Run until no more sections to mask
while not scan_complete:
bs_codons_tomask, scan_complete, startat = (ngapscan(
bs_codons_tomask, seqlength, scan_complete, startat))
# Scan in reverse for end section until no more changes are found
rev_scan_complete = False
while not rev_scan_complete: # Scan in reverse for end section
bs_codons_tomask, changemade = (ngapscan_reverse(
bs_codons_tomask, seqlength))
# If change made scan in forward direction again
if changemade:
startat = 0 # Start from begining again
scan_complete = False
while not scan_complete:
bs_codons_tomask, scan_complete, startat = (ngapscan(
bs_codons_tomask, seqlength, scan_complete, startat))
# If no more sections can be masked
else:
rev_scan_complete = True
# Add new branch specific intermasking to main codons_tomask dictionary
for codon in bs_codons_tomask:
if codon in codons_tomask:
if seq not in codons_tomask[codon]:
codons_tomask[codon].append(seq)
else:
codons_tomask[codon] = [seq]
return codons_tomask
def ngapscan(codons_tomask, seqlength, scan_complete, startat):
'''Conduct intermask scan and masking'''
# Set starting window position
current = startat
start, masked1, inter, masked2 = 0, 0, 0, 0 # Set codon counters to 0
to_mask_start, to_mask_inter = [], [] # Lists to hold codons
# Scan for length of unmasked region at start of sequence if present
while current <= seqlength:
if current in codons_tomask: # Found first masked section
break
else:
start += 1
to_mask_start.append(current)
current += 1
# Scan length of masked region
while current <= seqlength:
if current not in codons_tomask:
break
else:
masked1 += 1
current += 1
# Scan for length of intermasked (unmasked) region
while current <= seqlength:
if current in codons_tomask:
newstart = current
break
else:
inter += 1
to_mask_inter.append(current)
current += 1
# Scan for length of second masked region
while current <= seqlength:
if current not in codons_tomask:
break
else:
masked2 += 1
current += 1
# If unmasked region at start of sequence less than twice length of
# masked region then mask it.
if start > 0 and start < (masked1*2):
for codon in to_mask_start:
codons_tomask[codon] = None
startat = 0
# If second masked region exists
elif masked2 > 0:
# If intermasked region less length than masked regions either
# side of it then mask it
if inter < (masked1+masked2):
for codon in to_mask_inter:
codons_tomask[codon] = None
startat = 0 # Scan from start again
else: # Look for more intermasked regions in the same sequence
startat = newstart
scan_complete = True
# No more intermasked regions to scan
else:
scan_complete = True
return codons_tomask, scan_complete, startat
def ngapscan_reverse(codons_tomask, seqlength):
'''Conduct intermask scan and masking in reverse'''
# Start at end of sequence
current = seqlength
end, masked1 = 0, 0 # Set codon counters to 0
to_mask_end = []
# Scan for length of unmasked region at end of sequence if present
while current >= 0:
if current in codons_tomask: # Found first masked section
break
else:
end += 1
to_mask_end.append(current)
current -= 1
# Get length of masked region
while current <= seqlength:
if current not in codons_tomask:
break
else:
masked1 += 1
current -= 1
# If unmasked region at end of sequence less than twice length of masked
#region next to it then mask it.
if end > 0 and end < (masked1*2):
for codon in to_mask_end:
codons_tomask[codon] = None
changemade = True
else:
changemade = False
return codons_tomask, changemade
def print_masked_phyfile(phyinfile, masked_dict):
'''Masks codons and prints the Phylip output file.'''
# Create the output file and write Phylip data.
phyoutfile = phyinfile.replace(".phy", "_masked.phy")
print_phyfile(phyoutfile, masked_dict)
if __name__ == "__main__":
print " wrote file %s" % phyoutfile
def mask_codons(seqdict, codons_tomask):
'''Masks a seq dict given the codons_tomask datastructure, which
is keyed by codon index with each value being a tuple of the seq
IDs needing masking.'''
masked_dict = {}
for seq in sorted(seqdict.keys()):
codons = get_codons(seqdict[seq]) # Split sequence into codons
i = 1
newsequence = ""
# For each codon in sequence
for codon in codons:
# If codon and sequence is to be masked
if i in codons_tomask and seq in codons_tomask[i]:
newsequence += "NNN" # Replace codon with N's
else: # If codon is not to be masked
newsequence += codon # Include original codon unmasked
i += 1
# Store sequences for length check
masked_dict[seq] = newsequence
return masked_dict
def print_phyfile(phyoutfile, seqdict):
'''Prints a sequence dict in phylip format.'''
out = create_outfile(phyoutfile) # Create output masked phylip file
# Print phylip header, needs number of sequences and sequence length
print >>out, " "+str(len(seqdict))+" "+str(len(seqdict.values()[0]))
for seq_id in sorted(seqdict.keys()):
print >>out, str(seq_id) # Print sequence header
seq_str = seqdict[seq_id]
lines = format_as_phylip(seq_str)
# Print each line of masked sequence
for line in lines:
print >>out, line
def count_short_seqs(masked_dict, minseqlength):
'''Count the number of sequences with fewer than minseqlength
codons post-masking.'''
short_seq_count = 0
# For each sequence
for seq in sorted(masked_dict.keys()):
masked_codons = {}
codons = get_codons(masked_dict[seq]) # Get codons
i = 0
while i < len(codons):
if "N" in codons[i]: # If codon has N charachter
masked_codons[i] = 1
i += 1
# Obtain length of informative sites
unmasked_length = len(codons)-len(masked_codons)
if unmasked_length < minseqlength:
short_seq_count += 1
return short_seq_count
def create_outfile(outfile):
'''Create outfile'''
try:
out = open(outfile, 'w')
return out
except IOError:
print "File %s cannot be created!" % outfile
raise
except KeyboardInterrupt:
sys.exit(1)
def get_codons(sequence):
'''Split DNA sequence into codons'''
codon_list = []
# Divide sequence into triplets
for i in range(0, len(sequence), 3):
codon_list.append(sequence[i: i + 3]) # Add codons to list
return codon_list
def format_as_phylip(line):
'''Split sequence into 60 character lines for printing in phylip format'''
phylip_lines = []
for i in range(0, len(line), 60):
phylip_lines.append(line[i: i + 60]) # Add 60 character chunks to list
return phylip_lines
if __name__ == "__main__":
main()
| peterwharrison/SWAMP | SWAMP.py | Python | gpl-3.0 | 27,840 | 0.000647 |
from game_state import BOX, COLS, ROWS, SCREEN
import levels
from random import randint
import pygame
from time import sleep
class Level(object):
def __init__(self):
self.size = 1
self.color = 255,120,0
self.x = 0
self.y = 0
self.layout = []
self.wall = []
def create_level(self, level):
self.wall = []
if level == 1:
self.layout = levels.one
elif level == 2:
self.layout = levels.two
elif level == 3:
self.layout = levels.three
elif level == 4:
self.layout = levels.four
elif level == 5:
self.layout = levels.five
elif level == 6:
self.layout = levels.six
for i in xrange(len(self.layout)):
for j in xrange(len(self.layout[0])):
if self.layout[i][j] == 1:
self.wall.append((j, i))
def draw(self):
for self.x, self.y in self.wall:
pygame.draw.rect(SCREEN, self.color, (self.x*BOX, self.y*BOX, self.size*BOX, self.size*BOX))
class Snake(object):
def __init__(self):
# reset values
self.init_size = 10
self.initx = COLS/2
self.inity = ROWS/2
# grow values
self.grow_to = 15
self.size = 1
# movement values
self.x = self.initx
self.y = self.inity
self.speed = 1
self.vx = 0
self.vy = -self.speed
self.turn('up', 'down')
# snake body values
self.body = []
self.color = 0,0,255
self.length = 1
def draw(self):
for x, y in self.body:
pygame.draw.rect(SCREEN, self.color, (x*BOX, y*BOX, self.size*BOX, self.size*BOX))
def eat(self, amount, state, wall):
self.grow(amount)
state.foodleft = state.foodleft - 1
state.score_reset()
state.increase_food_count(self, wall)
def grow(self, amount):
self.grow_to = self.grow_to + amount
def move(self):
self.x = self.x + self.vx
self.y = self.y + self.vy
x, y = self.x, self.y
self.body.insert(0, (x, y))
length = len(self.body)
if length > self.grow_to:
self.body.pop()
def turn(self, turn, oturn):
# don't go back on self; would be insta-death
if turn == oturn:
pass
elif turn == 'up':
self.vx = 0
self.vy = -self.speed
elif turn == 'down':
self.vx = 0
self.vy = self.speed
elif turn == 'left':
self.vx = -self.speed
self.vy = 0
elif turn == 'right':
self.vx = self.speed
self.vy = 0
class Food(object):
def __init__(self):
self.color = 255,0,0
self.size = 1
self.grow_value = 10
self.speed_value = 1
self.eaten_counter = 0
self.x, self.y = (randint(1, COLS-2)), (randint(1, ROWS-2))
def check(self, x, y, wall):
if (x, y) in wall:
self.x, self.y = (randint(1, COLS-2)), (randint(1, ROWS-2))
self.check(self.x, self.y)
def draw(self):
pygame.draw.rect(SCREEN, self.color, (self.x*BOX, self.y*BOX, self.size*BOX, self.size*BOX))
def get_eaten(self, wall):
self.x, self.y = (randint(1, COLS-2)), (randint(1, ROWS-2))
self.check(self.x, self.y, wall)
return self.grow_value
| BradleyMoore/Snake | game_objects.py | Python | mit | 3,550 | 0.006761 |
# pylint: disable = C0301
from bs4 import BeautifulSoup
from urllib2 import urlopen
import pandas as pd
pos_idx_map = {
'qb': 2,
'rb': 3,
'wr': 4,
'te': 5,
}
def make_url(pos, wk):
ii = pos_idx_map[pos]
fstr = "http://fantasydata.com/nfl-stats/nfl-fantasy-football-stats.aspx?fs=1&stype=0&sn=1&w=%s&s=&t=0&p=%s&st=FantasyPointsPPR&d=1&ls=&live=false" \
% (wk, ii)
return fstr
def html2df(soup):
table = soup.find('table')
headers = [header.text.lower() for header in table.find_all('th')]
rows = []
for row in table.find_all('tr'):
rows.append([val.text.encode('utf8') for val in row.find_all('td')])
rows = [rr for rr in rows if len(rr) > 0]
df = pd.DataFrame.from_records(rows)
df.columns = headers
return df
def position_html_local(posn):
dflist = []
for ii in range(1, 17):
fname = '%s%s.html' % (posn, ii)
with open(fname) as f:
df = html2df(BeautifulSoup(f))
df['wk'] = ii
df.columns = header_clean(df.columns, posn)
dflist.append(df)
return pd.concat(dflist)
def position_html(posn):
dflist = []
for ii in range(1, 17):
fname = make_url(posn, ii)
df = html2df(BeautifulSoup(urlopen(fname)))
df['wk'] = ii
df.columns = header_clean(df.columns, posn)
dflist.append(df)
return pd.concat(dflist)
pos_header_suffixes = {
'qb': ['_pass', '_rush'],
'rb': ['_rush', '_recv'],
'wr': ['_recv'],
'te': ['_recv'],
}
exclude_cols = ['rk', 'player', 'team', 'pos', 'fantasy points',
'wk', 'fum', 'lost', 'qb rating']
def header_clean(header, posn):
res = []
if posn in pos_header_suffixes:
suffixes = pos_header_suffixes[posn]
seen_dict = {hh: 0 for hh in header}
for hh in header:
if not hh in exclude_cols:
hres = hh + suffixes[seen_dict[hh]]
seen_dict[hh] += 1
res.append(hres)
else:
res.append(hh)
else:
res = header
return res
if __name__ == '__main__':
data_all = {}
for pp in ['qb', 'wr', 'rb', 'te']:
data_all[pp] = position_html_local(pp)
data_all[pp].to_pickle('%s.pkl' % pp)
| yikelu/nfl_fantasy_data | htmls2csvs.py | Python | gpl-2.0 | 2,265 | 0.004415 |
# -*- coding: utf-8 -*-
"""
Special purpose canvas including all required plotting function etc.
@newfield purpose: Purpose
@newfield sideeffect: Side effect, Side effects
@purpose: Plotting all
@author: Christian Kohl�ffel
@since: 22.04.2011
@license: GPL
"""
from copy import copy
from PyQt4 import QtCore, QtGui
from Core.Point import Point
from Core.Shape import ShapeClass
from Gui.WpZero import WpZero
from Gui.Arrow import Arrow
from Gui.StMove import StMove
from Gui.RouteText import RouteText
#import math
import Core.Globals as g
import Core.constants as c
import logging
logger=logging.getLogger("DxfImport.myCanvasClass")
class MyGraphicsView(QtGui.QGraphicsView):
"""
This is the used Canvas to print the graphical interface of dxf2gcode.
All GUI things should be performed in the View and plotting functions in
the scene
@sideeffect: None
"""
def __init__(self, parent = None):
"""
Initialisation of the View Object. This is called by the gui created
with the QTDesigner.
@param parent: Main is passed as a pointer for reference.
"""
super(MyGraphicsView, self).__init__(parent)
self.currentItem=None
self.setTransformationAnchor(QtGui.QGraphicsView.AnchorUnderMouse)
self.setResizeAnchor(QtGui.QGraphicsView.AnchorViewCenter)
#self.setDragMode(QtGui.QGraphicsView.RubberBandDrag )
self.setDragMode(QtGui.QGraphicsView.NoDrag)
self.parent=parent
self.mppos=None
self.selmode=0
self.rubberBand = QtGui.QRubberBand(QtGui.QRubberBand.Rectangle, self)
def tr(self,string_to_translate):
"""
Translate a string using the QCoreApplication translation framework
@param: string_to_translate: a unicode string
@return: the translated unicode string if it was possible to translate
"""
return unicode(QtGui.QApplication.translate("MyGraphicsView",
string_to_translate,
None,
QtGui.QApplication.UnicodeUTF8))
def contextMenuEvent(self, event):
"""
Create the contextmenu.
@purpose: Links the new Class of ContextMenu to Graphicsview.
"""
menu=MyDropDownMenu(self,self.scene(),event.pos())
def keyPressEvent(self,event):
"""
Rewritten KeyPressEvent to get other behavior while Shift is pressed.
@purpose: Changes to ScrollHandDrag while Control pressed
@param event: Event Parameters passed to function
"""
if (event.key()==QtCore.Qt.Key_Shift):
self.setDragMode(QtGui.QGraphicsView.ScrollHandDrag)
elif (event.key()==QtCore.Qt.Key_Control):
self.selmode=1
else:
pass
super(MyGraphicsView, self).keyPressEvent(event)
def keyReleaseEvent (self,event):
"""
Rewritten KeyReleaseEvent to get other behavior while Shift is pressed.
@purpose: Changes to RubberBandDrag while Control released
@param event: Event Parameters passed to function
"""
if (event.key()==QtCore.Qt.Key_Shift):
self.setDragMode(QtGui.QGraphicsView.NoDrag)
#self.setDragMode(QtGui.QGraphicsView.RubberBandDrag )
elif (event.key()==QtCore.Qt.Key_Control):
self.selmode=0
else:
pass
super(MyGraphicsView, self).keyPressEvent(event)
def wheelEvent(self,event):
"""
With Mouse Wheel the object is scaled
@purpose: Scale by mouse wheel
@param event: Event Parameters passed to function
"""
scale=(1000+event.delta())/1000.0
self.scale(scale,scale)
def mousePressEvent(self, event):
"""
Right Mouse click shall have no function, Therefore pass only left
click event
@purpose: Change inherited mousePressEvent
@param event: Event Parameters passed to function
"""
if(self.dragMode())==1:
super(MyGraphicsView, self).mousePressEvent(event)
elif event.button() == QtCore.Qt.LeftButton:
self.mppos=event.pos()
else:
pass
def mouseReleaseEvent(self, event):
"""
Right Mouse click shall have no function, Therefore pass only left
click event
@purpose: Change inherited mousePressEvent
@param event: Event Parameters passed to function
"""
delta=2
if(self.dragMode())==1:
#if (event.key()==QtCore.Qt.Key_Shift):
#self.setDragMode(QtGui.QGraphicsView.NoDrag)
super(MyGraphicsView, self).mouseReleaseEvent(event)
#Selection only enabled for left Button
elif event.button() == QtCore.Qt.LeftButton:
#If the mouse button is pressed without movement of rubberband
if self.rubberBand.isHidden():
rect=QtCore.QRect(event.pos().x()-delta,event.pos().y()-delta,
2*delta,2*delta)
#logger.debug(rect)
self.currentItems=self.items(rect)
# it=self.itemAt(event.pos())
# if it==None:
# self.currentItems=[]
# else:
# self.currentItems=[it]
#self.currentItems=[self.itemAt(event.pos())]
#logger.debug("No Rubberband")
#If movement is bigger and rubberband is enabled
else:
rect=self.rubberBand.geometry()
#All items in the selection mode=QtCore.Qt.ContainsItemShape
self.currentItems=self.items(rect)
self.rubberBand.hide()
#logger.debug("Rubberband Selection")
#All items in the selection
#self.currentItems=self.items(rect)
#print self.currentItems
scene=self.scene()
#logger.debug(rect)
if self.selmode==0:
for item in scene.selectedItems():
# item.starrow.setSelected(False)
# item.stmove.setSelected(False)
# item.enarrow.setSelected(False)
item.setSelected(False)
for item in self.currentItems:
if item.isSelected():
item.setSelected(False)
else:
#print (item.flags())
item.setSelected(True)
else:
pass
self.mppos=None
#super(MyGraphicsView, self).mouseReleaseEvent(event)
def mouseMoveEvent(self, event):
"""
MouseMoveEvent of the Graphiscview. May also be used for the Statusbar.
@purpose: Get the MouseMoveEvent and use it for the Rubberband Selection
@param event: Event Parameters passed to function
"""
if not(self.mppos is None):
Point = event.pos() - self.mppos
if (Point.manhattanLength() > 3):
#print 'the mouse has moved more than 3 pixels since the oldPosition'
#print "Mouse Pointer is currently hovering at: ", event.pos()
self.rubberBand.show()
self.rubberBand.setGeometry(QtCore.QRect(self.mppos, event.pos()).normalized())
scpoint=self.mapToScene(event.pos())
self.setStatusTip('X: %3.1f; Y: %3.1f' %(scpoint.x(),-scpoint.y()))
self.setToolTip('X: %3.1f; Y: %3.1f' %(scpoint.x(),-scpoint.y()))
super(MyGraphicsView, self).mouseMoveEvent(event)
def autoscale(self):
"""
Automatically zooms to the full extend of the current GraphicsScene
"""
scene=self.scene()
scext=scene.itemsBoundingRect()
self.fitInView(scext,QtCore.Qt.KeepAspectRatio)
logger.debug(self.tr("Autoscaling to extend: %s") % (scext))
def setShow_path_direction(self,flag):
"""
This function is called by the Main Window from the Menubar.
@param flag: This flag is true if all Path Direction shall be shown
"""
scene=self.scene()
for shape in scene.shapes:
shape.starrow.setallwaysshow(flag)
shape.enarrow.setallwaysshow(flag)
shape.stmove.setallwaysshow(flag)
def setShow_wp_zero(self,flag):
"""
This function is called by the Main Window from the Menubar.
@param flag: This flag is true if all Path Direction shall be shown
"""
scene=self.scene()
if flag is True:
scene.wpzero.show()
else:
scene.wpzero.hide()
def setShow_disabled_paths(self,flag):
"""
This function is called by the Main Window from the Menubar.
@param flag: This flag is true if hidden paths shall be shown
"""
scene=self.scene()
scene.setShow_disabled_paths(flag)
def clearScene(self):
"""
Deletes the existing GraphicsScene.
"""
scene=self.scene()
del(scene)
class MyDropDownMenu(QtGui.QMenu):
def __init__(self,MyGraphicsView,MyGraphicsScene,position):
QtGui.QMenu.__init__(self)
self.position=MyGraphicsView.mapToGlobal(position)
GVPos=MyGraphicsView.mapToScene(position)
self.PlotPos=Point(x=GVPos.x(),y=-GVPos.y())
self.MyGraphicsScene=MyGraphicsScene
self.MyGraphicsView=MyGraphicsView
if len(self.MyGraphicsScene.selectedItems())==0:
return
invertAction = self.addAction(self.tr("Invert Selection"))
disableAction = self.addAction(self.tr("Disable Selection"))
enableAction = self.addAction(self.tr("Enable Selection"))
self.addSeparator()
swdirectionAction = self.addAction(self.tr("Switch Direction"))
SetNxtStPAction = self.addAction(self.tr("Set Nearest StartPoint"))
self.addSeparator()
submenu1= QtGui.QMenu(self.tr('Cutter Compensation'),self)
self.noCompAction = submenu1.addAction(self.tr("G40 No Compensation"))
self.noCompAction.setCheckable(True)
self.leCompAction = submenu1.addAction(self.tr("G41 Left Compensation"))
self.leCompAction.setCheckable(True)
self.reCompAction = submenu1.addAction(self.tr("G42 Right Compensation"))
self.reCompAction.setCheckable(True)
logger.debug(self.tr("The selected shapes have the following direction: %i") % (self.calcMenuDir()))
self.checkMenuDir(self.calcMenuDir())
self.addMenu(submenu1)
invertAction.triggered.connect(self.invertSelection)
disableAction.triggered.connect(self.disableSelection)
enableAction.triggered.connect(self.enableSelection)
swdirectionAction.triggered.connect(self.switchDirection)
SetNxtStPAction.triggered.connect(self.setNearestStP)
self.noCompAction.triggered.connect(self.setNoComp)
self.leCompAction.triggered.connect(self.setLeftComp)
self.reCompAction.triggered.connect(self.setRightComp)
self.exec_(self.position)
def tr(self,string_to_translate):
"""
Translate a string using the QCoreApplication translation framework
@param: string_to_translate: a unicode string
@return: the translated unicode string if it was possible to translate
"""
return unicode(QtGui.QApplication.translate("MyDropDownMenu",
string_to_translate,
None,
QtGui.QApplication.UnicodeUTF8))
def calcMenuDir(self):
"""
This method returns the direction of the selected items. If there are
different cutter directions in the selection 0 is returned, else
1 for Left and 2 for right.
"""
items=self.MyGraphicsScene.selectedItems()
if len(items)==0:
return 0
dir=items[0].cut_cor
for item in items:
if not(dir==item.cut_cor):
return 0
return dir-40
def checkMenuDir(self,dir):
"""
This method checks the buttons in the Contextmenu for the direction of
the selected items.
@param dir: The direction of the items -1= different, 0=None, 1=left, 2 =right
"""
self.noCompAction.setChecked(False)
self.leCompAction.setChecked(False)
self.reCompAction.setChecked(False)
if dir==0:
self.noCompAction.setChecked(True)
elif dir==1:
self.leCompAction.setChecked(True)
elif dir==2:
self.reCompAction.setChecked(True)
def invertSelection(self):
"""
This function is called by the Contextmenu of the Graphicsview.
@purpose: Inverts the selection of all shapes.
"""
#scene=self.scene()
for shape in self.MyGraphicsScene.shapes:
if shape.isSelected():
shape.setSelected(False)
else:
shape.setSelected(True)
def disableSelection(self):
"""
Disable all shapes which are currently selected. Based on the view
options they are not shown or shown in a different color and pointed
"""
#scene=self.scene()
for shape in self.MyGraphicsScene.shapes:
if shape.isSelected():
shape.setDisable(True)
self.MyGraphicsScene.update()
def enableSelection(self):
"""
Enable all shapes which are currently selected. Based on the view
options they are not shown or shown in a different color and pointed
"""
#scene=self.scene()
for shape in self.MyGraphicsScene.shapes:
if shape.isSelected():
shape.setDisable(False)
self.MyGraphicsScene.update()
def switchDirection(self):
"""
Switch the Direction of all items. For example from CW direction to CCW
"""
for shape in self.MyGraphicsScene.shapes:
if shape.isSelected():
shape.reverse()
shape.reverseGUI()
logger.debug(self.tr('Switched Direction at Shape Nr: %i')\
%(shape.nr))
shape.updateCutCor()
shape.updateCCplot()
def setNearestStP(self):
"""
Search the nearest StartPoint to the clicked position of all selected
shapes.
"""
shapes=self.MyGraphicsScene.selectedItems()
for shape in shapes:
shape.FindNearestStPoint(self.PlotPos)
#self.MyGraphicsScene.plot_shape(shape)
shape.update_plot()
def setNoComp(self):
"""
Sets the compensation 40, which is none for the selected shapes.
"""
shapes=self.MyGraphicsScene.selectedItems()
for shape in shapes:
shape.cut_cor=40
logger.debug(self.tr('Changed Cutter Correction to None Shape Nr: %i')\
%(shape.nr))
shape.updateCutCor()
shape.updateCCplot()
def setLeftComp(self):
"""
Sets the compensation 41, which is Left for the selected shapes.
"""
shapes=self.MyGraphicsScene.selectedItems()
for shape in shapes:
shape.cut_cor=41
logger.debug(self.tr('Changed Cutter Correction to left Shape Nr: %i')\
%(shape.nr))
shape.updateCutCor()
shape.updateCCplot()
def setRightComp(self):
"""
Sets the compensation 42, which is Right for the selected shapes.
"""
shapes=self.MyGraphicsScene.selectedItems()
for shape in shapes:
shape.cut_cor=42
logger.debug(self.tr('Changed Cutter Correction to right Shape Nr: %i')\
%(shape.nr))
shape.updateCutCor()
shape.updateCCplot()
class MyGraphicsScene(QtGui.QGraphicsScene):
"""
This is the Canvas used to print the graphical interface of dxf2gcode.
The Scene is rendered into the previously defined mygraphicsView class.
All performed plotting functions should be defined here.
@sideeffect: None
"""
def __init__(self):
QtGui.QGraphicsScene.__init__(self)
self.shapes=[]
self.wpzero=[]
# self.LayerContents=[]
self.routearrows=[]
self.routetext=[]
self.showDisabled=False
# self.EntitiesRoot=EntitieContentClass(Nr=-1, Name='Base',parent=None,children=[],
# p0=Point(0,0),pb=Point(0,0),
# sca=1,rot=0)
# self.BaseEntities=EntitieContentClass()
def tr(self,string_to_translate):
"""
Translate a string using the QCoreApplication translation framework
@param: string_to_translate: a unicode string
@return: the translated unicode string if it was possible to translate
"""
return unicode(QtGui.QApplication.translate("MyGraphicsScene",
string_to_translate,
None,
QtGui.QApplication.UnicodeUTF8))
def plotAll(self,shapes,EntitiesRoot):
"""
Instance is called by the Main Window after the defined file is loaded.
It generates all ploting functionality. The parameters are generally
used to scale or offset the base geometry (by Menu in GUI).
@param values: The loaded dxf values fro mthe dxf_import.py file
@param p0: The Starting Point to plot (Default x=0 and y=0)
@param bp: The Base Point to insert the geometry and base for rotation
(Default is also x=0 and y=0)
@param sca: The scale of the basis function (default =1)
@param rot: The rotation of the geometries around base (default =0)
"""
self.shapes=shapes
self.EntitiesRoot=EntitiesRoot
del(self.wpzero)
self.plot_shapes()
self.plot_wp_zero()
self.update()
def plot_wp_zero(self):
"""
This function is called while the drawing of all items is done. It plots
the WPZero to the Point x=0 and y=0. This item will be enabled or
disabled to be shown or not.
"""
self.wpzero=WpZero(QtCore.QPointF(0,0))
self.addItem(self.wpzero)
def plot_shapes(self):
"""
This function performs all plotting for the shapes. This may also
get an instance of the shape later on.
FIXME
"""
for shape in self.shapes:
self.addItem(shape)
self.plot_shape(shape)
logger.debug(self.tr("Update GrapicsScene"))
def plot_shape(self,shape):
"""
Create all plotting related parts of one shape.
@param shape: The shape which shall be plotted.
"""
shape.make_papath()
shape.starrow=self.createstarrow(shape)
shape.enarrow=self.createenarrow(shape)
shape.stmove=self.createstmove(shape)
shape.starrow.setParentItem(shape)
shape.enarrow.setParentItem(shape)
shape.stmove.setParentItem(shape)
def createstarrow(self,shape):
"""
This function creates the Arrows at the end point of a shape when the
shape is selected.
@param shape: The shape for which the Arrow shall be created.
"""
length=20
start, start_ang = shape.get_st_en_points(0)
arrow=Arrow(startp=start,
length=length,
angle=start_ang,
color=QtGui.QColor(50, 200, 255),
pencolor=QtGui.QColor(50, 100, 255))
arrow.hide()
return arrow
def createenarrow(self,shape):
"""
This function creates the Arrows at the start point of a shape when the
shape is selected.
@param shape: The shape for which the Arrow shall be created.
"""
length=20
end, end_ang = shape.get_st_en_points(1)
arrow=Arrow(startp=end,
length=length,angle=end_ang,
color=QtGui.QColor(0, 245, 100),
pencolor=QtGui.QColor(0, 180, 50),
dir=1)
arrow.hide()
return arrow
def createstmove(self,shape):
"""
This function creates the Additional Start and End Moves in the plot
window when the shape is selected
@param shape: The shape for which the Move shall be created.
"""
start, start_ang = shape.get_st_en_points(0)
stmove=StMove(start,
start_ang,
QtGui.QColor(50, 100, 255),
shape,self.EntitiesRoot)
stmove.hide()
return stmove
def resetexproutes(self):
"""
This function resets all of the export route
"""
self.delete_opt_path()
def addexproute(self,exp_order,layer_nr):
"""
This function initialises the Arrows of the export route order and
its numbers.
@param shapes_st_en_points: The start and end points of the shapes.
@param route: The order of the shapes to be plotted.
"""
x_st=g.config.vars.Plane_Coordinates['axis1_start_end']
y_st=g.config.vars.Plane_Coordinates['axis2_start_end']
start=Point(x=x_st,y=y_st)
ende=Point(x=x_st,y=y_st)
#shapes_st_en_points.append([start,ende])
#Ausdrucken der optimierten Route
#Print the optimised route
for shape_nr in range(len(exp_order)+1):
if shape_nr==0:
st=start
[en,dummy]=self.shapes[exp_order[shape_nr]].get_st_en_points(0)
col=QtCore.Qt.darkRed
elif shape_nr==(len(exp_order)):
[st,dummy]=self.shapes[exp_order[shape_nr-1]].get_st_en_points(1)
en=ende
col=QtCore.Qt.darkRed
else:
[st,dummy]=self.shapes[exp_order[shape_nr-1]].get_st_en_points(1)
[en,dummy]=self.shapes[exp_order[shape_nr]].get_st_en_points(0)
col=QtCore.Qt.darkGray
# st=shapes_st_en_points[route[st_nr]][1]
# en=shapes_st_en_points[route[en_nr]][0]
self.routearrows.append(Arrow(startp=st,
endp=en,
color=col,
pencolor=col))
self.routetext.append(RouteText(text=("%s,%s" %(layer_nr,shape_nr)),
startp=st))
#self.routetext[-1].ItemIgnoresTransformations
self.addItem(self.routetext[-1])
self.addItem(self.routearrows[-1])
def updateexproute(self,exp_order):
"""
This function updates the Arrows of the export route order and
its numbers.
@param shapes_st_en_points: The start and end points of the shapes.
@param route: The order of the shapes to be plotted.
"""
x_st=g.config.vars.Plane_Coordinates['axis1_start_end']
y_st=g.config.vars.Plane_Coordinates['axis2_start_end']
start=Point(x=x_st,y=y_st)
ende=Point(x=x_st,y=y_st)
for shape_nr in range(len(exp_order)+1):
if shape_nr==0:
st=start
[en,dummy]=self.shapes[exp_order[shape_nr]].get_st_en_points(0)
elif shape_nr==(len(exp_order)):
[st,dummy]=self.shapes[exp_order[shape_nr-1]].get_st_en_points(1)
en=ende
else:
[st,dummy]=self.shapes[exp_order[shape_nr-1]].get_st_en_points(1)
[en,dummy]=self.shapes[exp_order[shape_nr]].get_st_en_points(0)
self.routearrows[shape_nr].updatepos(st,en)
self.routetext[shape_nr].updatepos(st)
def delete_opt_path(self):
"""
This function deletes all the plotted export routes.
"""
while self.routearrows:
item = self.routearrows.pop()
item.hide()
#self.removeItem(item)
del item
while self.routetext:
item = self.routetext.pop()
item.hide()
#self.removeItem(item)
del item
def setShow_disabled_paths(self,flag):
"""
This function is called by the Main Menu and is passed from Main to
MyGraphicsView to the Scene. It performs the showing or hiding
of enabled/disabled shapes.
@param flag: This flag is true if hidden paths shall be shown
"""
self.showDisabled=flag
for shape in self.shapes:
if flag and shape.isDisabled():
shape.show()
elif not(flag) and shape.isDisabled():
shape.hide()
| workflo/dxf2gcode | source/Gui/myCanvasClass.py | Python | gpl-3.0 | 26,794 | 0.014109 |
from __future__ import with_statement
import time
from concurrence import unittest, Tasklet, Channel, TimeoutError
from concurrence.timer import Timeout
class TimerTest(unittest.TestCase):
def testPushPop(self):
self.assertEquals(-1, Timeout.current())
Timeout.push(30)
self.assertAlmostEqual(30, Timeout.current(), places = 1)
Timeout.pop()
self.assertEquals(-1, Timeout.current())
Timeout.push(30)
self.assertAlmostEqual(30, Timeout.current(), places = 1)
Tasklet.sleep(1.0)
self.assertAlmostEqual(29, Timeout.current(), places = 1)
#push a temporary short timeout
Timeout.push(5)
self.assertAlmostEqual(5, Timeout.current(), places = 1)
Timeout.pop()
self.assertAlmostEqual(29, Timeout.current(), places = 1)
#try to push a new longer timeout than the parent timeout
#this should fail, e.g. it will keep the parent timeout
Timeout.push(60)
self.assertAlmostEqual(29, Timeout.current(), places = 1)
Timeout.pop()
self.assertAlmostEqual(29, Timeout.current(), places = 1)
Timeout.pop()
self.assertEquals(-1, Timeout.current())
def testPushPop2(self):
self.assertEquals(-1, Timeout.current())
Timeout.push(-1)
self.assertEquals(-1, Timeout.current())
Timeout.pop()
self.assertEquals(-1, Timeout.current())
Timeout.push(10)
self.assertAlmostEqual(10, Timeout.current(), places = 1)
Timeout.push(5)
self.assertAlmostEqual(5, Timeout.current(), places = 1)
Timeout.pop()
self.assertAlmostEqual(10, Timeout.current(), places = 1)
Timeout.pop()
self.assertEquals(-1, Timeout.current())
def testTimer(self):
ch = Channel()
def sender(times):
for i in range(times):
Tasklet.sleep(1.0)
ch.send(True)
with Timeout.push(10):
Tasklet.new(sender)(4)
for i in range(4):
ch.receive(Timeout.current())
start = time.time()
try:
with Timeout.push(2.5):
Tasklet.new(sender)(4)
for i in range(4):
ch.receive(Timeout.current())
self.fail('expected timeout')
except TimeoutError, e:
end = time.time()
self.assertAlmostEqual(2.5, end - start, places = 1)
if __name__ == '__main__':
unittest.main(timeout = 10)
| concurrence/concurrence | test/testtimer.py | Python | bsd-3-clause | 2,659 | 0.015795 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
'''
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License version 3 as published by
the Free Software Foundation.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/gpl-3.0.txt>.
'''
import sys
sys.path.append('../shared')
import functions as f
import ape, operator
def main():
d_output = ape.format_results('results.json')
crlf = '\r\n'
output = []
s = '======================================='
for item in sorted(d_output.iteritems(), key = operator.itemgetter(0)):
d_item = item[1]
f.append(output, s + crlf + 'Propuestas tarea - ' + item[0] + (' (' + d_item['task_id'] + ')') + crlf + s)
f.append(output, d_item['breadcrumbs'])
f.append(output, d_item['pages'] + crlf + '------------------')
answers = d_item['answers']
for answer in answers:
answ = answer
if 'desconocido' in answer:
answer = answer.split('_')
answer = answer[0] + ' (' + answer[1] + ')'
else:
answer = '(' + str(answer) + ')'
f.append(output, 'Propuestas analista ' + answer + crlf + '---------------------------------------')
f.append(output, 'Hora de inicio: ' + f.formatTime(answers[answ]['answer_end_date']) + crlf + 'Hora de fin: ' + f.formatTime(answers[answ]['answer_start_date']))
for item in answers[answ]['answer'].split('\n'):
if item.replace(' ', '') != '':
f.append(output, item + crlf + '----------')
f.write_file('propuestas.txt', str(crlf * 2).join(output))
if __name__ == '__main__':
main()
| proyectos-analizo-info/pyanalizo | src/app-ape/deprecated/get-propuestas-electorales-v5.py | Python | gpl-3.0 | 2,267 | 0.014116 |
from entities.base import Base
import game.constants
class Star(Base):
"""The Star objects represents a star (or a blackhole!)"""
symbol = 'O'
decoration = game.constants.STYLE_BOLD
color = game.constants.COLOR_WK
isCollider = True
def setClass(self, cl):
"""
Sets the star class, or spectral type.
Uses the Harvard spectral clssification only for simplicity,
but it could be extended to include also Yerkes.
See: http://en.wikipedia.org/wiki/Stellar_classification
TODO Drastically reduct chance of generating a blackhole!
"""
self.classification = cl # TODO: do some validation?
self.color = game.constants.STAR_COLORS[cl]
| dmalatesta/spaceterm | entities/star.py | Python | gpl-3.0 | 729 | 0 |
import sys
def solve(l):
numbers = l.split(',')
row_hash = {}
for num in numbers:
count = row_hash.setdefault(num, 0)
row_hash[num] = count + 1
if row_hash[num] > len(numbers) / 2:
return num
return None
with open(sys.argv[1], 'r') as f:
for line in f.readlines():
print solve(line.strip())
| systemsoverload/codeeval | easy/132_major_element/solution.py | Python | mit | 359 | 0.008357 |
# coding: utf-8
from django.test import SimpleTestCase
from corehq.apps.app_manager.commcare_settings import get_commcare_settings_lookup, get_custom_commcare_settings
from corehq.apps.app_manager.models import Application
from corehq.apps.app_manager.tests.util import TestXmlMixin
import xml.etree.ElementTree as ET
from corehq.apps.builds.models import BuildSpec
from corehq import toggles
from toggle.shortcuts import update_toggle_cache, clear_toggle_cache
class ProfileTest(SimpleTestCase, TestXmlMixin):
file_path = ('data',)
def setUp(self):
self.app = Application(build_spec=BuildSpec(
version='2.7.0'
),
name=u"TÉST ÁPP",
domain="potter",
langs=['en']
)
update_toggle_cache(toggles.CUSTOM_PROPERTIES.slug, 'potter', True, toggles.NAMESPACE_DOMAIN)
def tearDown(self):
clear_toggle_cache(toggles.CUSTOM_PROPERTIES.slug, 'potter', toggles.NAMESPACE_DOMAIN)
def _test_profile(self, app):
profile = app.create_profile()
assert isinstance(profile, bytes), type(profile)
assert u"TÉST ÁPP" in profile.decode('utf-8')
profile_xml = ET.fromstring(profile)
types = {
'features': self._test_feature,
'properties': self._test_property,
}
for p_type, test_method in types.items():
for key, value in app.profile.get(p_type, {}).items():
setting = get_commcare_settings_lookup()[p_type][key]
test_method(profile_xml, key, value, setting)
def _get_node(self, profile, key, xpath_template):
xpath = xpath_template.format(key)
node = profile.find(xpath)
self.assertIsNotNone(node, 'Node not found: {}.'.format(xpath))
return node
def _test_feature(self, profile, key, value, setting):
node = self._get_node(profile, key, './features/{}')
self.assertEqual(node.get('active'), value, 'Feature "{}"'.format(key))
def _test_property(self, profile, key, value, setting):
node = self._get_node(profile, key, "./property[@key='{}']")
self.assertEqual(node.get('value'), value, 'Property "{}"'.format(key))
force = setting.get('force', False)
force_actual = node.get('force')
if not force:
self.assertIn(
force_actual,
[None, 'false'],
'"force" incorrect for property "{}"'.format(key)
)
else:
self.assertEqual(
force_actual,
'true',
'"force" incorrect for property "{}"'.format(key)
)
def _test_custom_property(self, profile, key, value):
node = self._get_node(profile, key, "./property[@key='{}']")
self.assertEqual(node.get('value'), value, 'Property "{}"'.format(key))
force_actual = node.get('force')
self.assertEqual(
force_actual,
'true',
'"force" should always be true for custom properties"{}"'.format(key)
)
def test_profile_properties(self):
for setting in get_custom_commcare_settings():
if setting['id'] == 'users':
continue
for value in setting.get('values', []):
self.app.profile = {
setting['type']: {
setting['id']: value
}
}
self._test_profile(self.app)
# custom properties do not rely on SETTINGS so need to be tested separately
self.app.profile = {
'custom_properties': {
'random': 'value'
}
}
profile = self.app.create_profile()
self._test_profile(self.app)
self._test_custom_property(ET.fromstring(profile), 'random', 'value')
def test_version(self):
profile_xml = ET.fromstring(self.app.create_profile())
root = profile_xml.find('.')
self.assertEqual(root.get('requiredMajor'), '2')
self.assertEqual(root.get('requiredMinor'), '7')
| qedsoftware/commcare-hq | corehq/apps/app_manager/tests/test_profile.py | Python | bsd-3-clause | 4,112 | 0.001217 |
from Screen import Screen
from Screens.MessageBox import MessageBox
from Components.MenuList import MenuList
from Components.ActionMap import ActionMap
from Components.Sources.StreamService import StreamServiceList
from Components.Sources.StaticText import StaticText
from Components.Label import Label
from enigma import eStreamServer
from ServiceReference import ServiceReference
import socket
try:
from Plugins.Extensions.OpenWebif.controllers.stream import streamList
except:
streamList = []
class StreamingClientsInfo(Screen):
def __init__(self, session):
Screen.__init__(self, session)
self.streamServer = eStreamServer.getInstance()
self.clients = []
self["menu"] = MenuList(self.clients)
self["key_red"] = StaticText(_("Close"))
self["key_green"] = StaticText("")
self["key_yellow"] = StaticText("")
self["info"] = Label()
self.updateClients()
self["actions"] = ActionMap(["ColorActions", "SetupActions"],
{
"cancel": self.close,
"ok": self.stopCurrentStream,
"red": self.close,
"green": self.stopAllStreams,
"yellow": self.stopCurrentStream
})
def updateClients(self):
self["key_green"].setText("")
self["key_yellow"].setText("")
self.setTitle(_("Streaming clients info"))
self.clients = []
if self.streamServer:
for x in self.streamServer.getConnectedClients():
service_name = ServiceReference(x[1]).getServiceName() or "(unknown service)"
ip = x[0]
if int(x[2]) == 0:
strtype = "S"
else:
strtype = "T"
try:
raw = socket.gethostbyaddr(ip)
ip = raw[0]
except:
pass
info = ("%s %-8s %s") % (strtype, ip, service_name)
self.clients.append((info, (x[0], x[1])))
if StreamServiceList and streamList:
for x in StreamServiceList:
ip = "ip n/a"
service_name = "(unknown service)"
for stream in streamList:
if hasattr(stream, 'getService') and stream.getService() and stream.getService().__deref__() == x:
service_name = ServiceReference(stream.ref.toString()).getServiceName()
ip = stream.clientIP or ip
info = ("T %s %s %s") % (ip, service_name, _("(VU+ type)"))
self.clients.append((info,(-1, x)))
self["menu"].setList(self.clients)
if self.clients:
self["info"].setText("")
self["key_green"].setText(_("Stop all streams"))
self["key_yellow"].setText(_("Stop current stream"))
else:
self["info"].setText(_("No stream clients"))
def stopCurrentStream(self):
self.updateClients()
if self.clients:
client = self["menu"].l.getCurrentSelection()
if client:
self.session.openWithCallback(self.stopCurrentStreamCallback, MessageBox, client[0] +" \n\n" + _("Stop current stream") + "?", MessageBox.TYPE_YESNO)
def stopCurrentStreamCallback(self, answer):
if answer:
client = self["menu"].l.getCurrentSelection()
if client:
if client[1][0] != -1:
if self.streamServer:
for x in self.streamServer.getConnectedClients():
if client[1][0] == x[0] and client[1][1] == x[1]:
if not self.streamServer.stopStreamClient(client[1][0], client[1][1]):
self.session.open(MessageBox, client[0] +" \n\n" + _("Error stop stream!"), MessageBox.TYPE_WARNING)
elif StreamServiceList and streamList:
self.session.open(MessageBox, client[0] +" \n\n" + _("Not yet implemented!"), MessageBox.TYPE_WARNING)
# TODO
#for x in streamList[:]:
# if hasattr(x, 'getService') and x.getService() and x.getService().__deref__() == client[1][1]:
# x.execEnd()
# if x in streamList:
# streamList.remove(x)
self.updateClients()
def stopAllStreams(self):
self.updateClients()
if self.clients:
self.session.openWithCallback(self.stopAllStreamsCallback, MessageBox, _("Stop all streams") + "?", MessageBox.TYPE_YESNO)
def stopAllStreamsCallback(self, answer):
if answer:
if self.streamServer:
for x in self.streamServer.getConnectedClients():
self.streamServer.stopStream()
# TODO
#if StreamServiceList and streamList:
# for x in streamList[:]:
# if hasattr(x, 'execEnd'):
# x.execEnd()
# if x in streamList:
# streamList.remove(x)
self.updateClients()
if not self.clients:
self.close()
| fairbird/OpenPLI-TSimage | lib/python/Screens/StreamingClientsInfo.py | Python | gpl-2.0 | 4,194 | 0.030281 |
"""
This module provides a RangeSet data structure. A range set is, as the
name implies, a set of ranges. Intuitively, you could think about a
range set as a subset of the real number line, with arbitrary gaps.
Some examples of range sets on the real number line:
1. -infinity to +infinity
2. -1 to 1
3. 1 to 4, 10 to 20
4. -infinity to 0, 10 to 20
5. (the empty set)
The code lives on github at: https://github.com/axiak/py-rangeset.
Overview
-------------
.. toctree::
:maxdepth: 2
The rangeset implementation offers immutable objects that represent the range
sets as described above. The operations are largely similar to the
`set object <http://docs.python.org/library/stdtypes.html#set>`_ with the
obvious exception that mutating methods such as ``.add`` and ``.remove``
are not available. The main object is the ``RangeSet`` object.
"""
import blist
import operator
import functools
import collections
__version__ = (0, 0, 11)
__all__ = ('INFINITY', 'NEGATIVE_INFINITY',
'RangeSet')
class _Indeterminate(object):
def timetuple(self):
return ()
def __eq__(self, other):
return other is self
class _Infinity(_Indeterminate):
def __lt__(self, other):
return False
def __gt__(self, other):
return True
def __str__(self):
return 'inf'
__repr__ = __str__
class _NegativeInfinity(_Indeterminate):
def __lt__(self, other):
return True
def __gt__(self, other):
return False
def __str__(self):
return '-inf'
__repr__ = __str__
INFINITY = _Infinity()
NEGATIVE_INFINITY = _NegativeInfinity()
class RangeSet(object):
__slots__ = ['ends']
def __init__(self, start, end):
if isinstance(end, _RawEnd):
ends = start
else:
if isinstance(start, _Indeterminate) and isinstance(end, _Indeterminate) and \
start == end:
raise LogicError("A range cannot consist of a single end the line.")
if start > end:
start, end = end, start
ends = blist.sortedlist([(start, _START), (end, _END)])
object.__setattr__(self, "ends", ends)
def __getinitargs__(self):
return (self.ends, _RAW_ENDS)
def __merged_ends(self, *others):
sorted_ends = blist.sortedlist(self.ends)
for other in others:
for end in RangeSet.__coerce(other).ends:
sorted_ends.add(end)
return sorted_ends
def __merged_ends_inplace(self, *others):
sorted_ends = self.ends
for other in others:
for end in RangeSet.__coerce(other).ends:
sorted_ends.add(end)
return sorted_ends
@classmethod
def __coerce(cls, value):
if isinstance(value, RangeSet):
return value
elif isinstance(value, tuple) and len(value) == 2:
return cls(value[0], value[1])
else:
return cls.mutual_union(*[(x, x) for x in value])
@classmethod
def __iterate_state(cls, ends):
state = 0
for _, end in ends:
if end == _START:
state += 1
else:
state -= 1
yield _, end, state
def __or__(self, *other):
sorted_ends = self.__merged_ends(*other)
new_ends = []
for _, end, state in RangeSet.__iterate_state(sorted_ends):
if state > 1 and end == _START:
continue
elif state > 0 and end == _END:
continue
new_ends.append((_, end))
return RangeSet(blist.sortedlist(new_ends), _RAW_ENDS)
def __ior__(self, *other):
sorted_ends = self.__merged_ends(self, *other)
new_ends = []
for _, end, state in RangeSet.__iterate_state(sorted_ends):
if state > 1 and end == _START:
continue
elif state > 0 and end == _END:
continue
new_ends.append((_, end))
return RangeSet(new_ends, _RAW_ENDS)
union = __or__
def __setattr__(self, name, value):
raise AttributeError("This class does not support setting values.")
def __iand__(self, *other, **kwargs):
min_overlap = kwargs.pop('minimum', 2)
if kwargs:
raise ValueError("kwargs is not empty: {0}".format(kwargs))
sorted_ends = self.__merged_ends_inplace(*other)
new_ends = []
for _, end, state in RangeSet.__iterate_state(sorted_ends):
if state == min_overlap and end == _START:
new_ends.append((_, end))
elif state == (min_overlap - 1) and end == _END:
new_ends.append((_, end))
return RangeSet(blist.sortedlist(new_ends), _RAW_ENDS)
def __and__(self, *other, **kwargs):
min_overlap = kwargs.pop('minimum', 2)
if kwargs:
raise ValueError("kwargs is not empty: {0}".format(kwargs))
sorted_ends = self.__merged_ends(*other)
new_ends = []
for _, end, state in RangeSet.__iterate_state(sorted_ends):
if state == min_overlap and end == _START:
new_ends.append((_, end))
elif state == (min_overlap - 1) and end == _END:
new_ends.append((_, end))
return RangeSet(blist.sortedlist(new_ends), _RAW_ENDS)
intersect = __and__
def __ror__(self, other):
return self.__or__(other)
def __rand__(self, other):
return self.__and__(other)
def __rxor__(self, other):
return self.__xor__(other)
def __xor__(self, *other):
sorted_ends = self.__merged_ends(*other)
new_ends = []
old_val = None
for _, end, state in RangeSet.__iterate_state(sorted_ends):
if state == 2 and end == _START:
new_ends.append((_, _NEGATE[end]))
elif state == 1 and end == _END:
new_ends.append((_, _NEGATE[end]))
elif state == 1 and end == _START:
new_ends.append((_, end))
elif state == 0 and end == _END:
new_ends.append((_, end))
return RangeSet(blist.sortedlist(new_ends), _RAW_ENDS)
symmetric_difference = __xor__
def __contains__(self, test):
last_val, last_end = None, None
if not self.ends:
return False
if isinstance(test, _Indeterminate):
return False
for _, end, state in RangeSet.__iterate_state(self.ends):
if _ == test:
return True
elif last_val is not None and _ > test:
return last_end == _START
elif _ > test:
return False
last_val, last_end = _, end
return self.ends[-1][0] == test
def issuperset(self, test):
if isinstance(test, RangeSet):
rangeset = test
else:
rangeset = RangeSet.__coerce(test)
difference = rangeset - ~self
return difference == rangeset
__ge__ = issuperset
def __gt__(self, other):
return self != other and self >= other
def issubset(self, other):
return RangeSet.__coerce(other).issuperset(self)
__le__ = issubset
def __lt__(self, other):
return self != other and self <= other
def isdisjoint(self, other):
return not bool(self & other)
def __nonzero__(self):
return bool(self.ends)
__bool__ = __nonzero__
def __invert__(self):
if not self.ends:
new_ends = ((NEGATIVE_INFINITY, _START),
(INFINITY, _END))
return RangeSet(new_ends, _RAW_ENDS)
new_ends = blist.sortedlist(self.ends)
head, tail = [], []
if new_ends[0][0] == NEGATIVE_INFINITY:
new_ends.pop(0)
else:
head = [(NEGATIVE_INFINITY, _START)]
if new_ends[-1][0] == INFINITY:
new_ends.pop(-1)
else:
tail = [(INFINITY, _END)]
new_ends = blist.sortedlist((value[0], _NEGATE[value[1]])
for value in new_ends)
new_ends.update(head)
new_ends.update(tail)
return RangeSet(new_ends, _RAW_ENDS)
invert = __invert__
def __sub__(self, other):
return self & ~RangeSet.__coerce(other)
def difference(self, other):
return self.__sub__(other)
def __rsub__(self, other):
return RangeSet.__coerce(other) - self
def measure(self):
if not self.ends:
return 0
if isinstance(self.ends[0][0], _Indeterminate) or isinstance(self.ends[-1][0], _Indeterminate):
raise ValueError("Cannot compute range with unlimited bounds.")
result = None
# reduce would be really nice here... :(
for i in range(0, len(self.ends), 2):
val = self.ends[i + 1][0] - self.ends[i][0]
if result is None:
result = val
else:
result += val
return result
def range(self):
if not self.ends:
return 0
if isinstance(self.ends[0][0], _Indeterminate) or isinstance(self.ends[-1][0], _Indeterminate):
raise ValueError("Cannot compute range with unlimited bounds.")
return self.ends[-1][0] - self.ends[0][0]
def __str__(self):
pieces = ["{0} -- {1}".format(self.ends[i][0], self.ends[i + 1][0])
for i in range(0, len(self.ends), 2)]
return "<RangeSet {0}>".format(", ".join(pieces))
__repr__ = __str__
def __eq__(self, other):
if self is other:
return True
elif not isinstance(other, RangeSet):
try:
other = RangeSet.__coerce(other)
except TypeError:
return False
return self.ends == other.ends
def __ne__(self, other):
return not self.__eq__(other)
def __hash__(self):
return hash(self.ends)
@classmethod
def mutual_overlaps(cls, *ranges, **kwargs):
minimum = kwargs.pop('minimum', 2)
if kwargs:
raise ValueError("kwargs is not empty: {0}".format(kwargs))
return cls.__coerce(ranges[0]).intersect(*ranges[1:], minimum=minimum)
@classmethod
def mutual_union(cls, *ranges):
return cls.__coerce(ranges[0]).union(*ranges[1:])
@classmethod
def empty(cls):
return cls(blist.sortedlist(), _RAW_ENDS)
@property
def min(self):
return self.ends[0][0]
@property
def max(self):
return self.ends[-1][0]
def __iter__(self):
for i in range(0, len(self.ends), 2):
try:
yield (self.ends[i][0], self.ends[i + 1][0])
except:
raise TypeError("Got invalid ends: {0}".format(self.ends[i:i + 2]))
_START = -1
_END = 1
_NEGATE = {_START: _END, _END: _START}
class _RawEnd(object):
pass
_RAW_ENDS = _RawEnd()
class LogicError(ValueError):
pass
| axiak/py-rangeset | rangeset/__init__.py | Python | mit | 11,032 | 0.002085 |
# -*- coding: utf-8 -*-
"""
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License,
or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, see <http://www.gnu.org/licenses/>.
"""
import re
from module.plugins.Account import Account
from module.utils import parseFileSize
class StahnuTo(Account):
__name__ = "StahnuTo"
__version__ = "0.02"
__type__ = "account"
__description__ = """StahnuTo account plugin"""
__author_name__ = "zoidberg"
__author_mail__ = "[email protected]"
def loadAccountInfo(self, user, req):
html = req.load("http://www.stahnu.to/")
m = re.search(r'>VIP: (\d+.*)<', html)
trafficleft = parseFileSize(m.group(1)) * 1024 if m else 0
return {"premium": trafficleft > (512 * 1024), "trafficleft": trafficleft, "validuntil": -1}
def login(self, user, data, req):
html = req.load("http://www.stahnu.to/login.php", post={
"username": user,
"password": data['password'],
"submit": "Login"})
if not '<a href="logout.php">' in html:
self.wrongPassword()
| estaban/pyload | module/plugins/accounts/StahnuTo.py | Python | gpl-3.0 | 1,610 | 0.001863 |
import json
from django.db import transaction
from django.core.exceptions import ValidationError
from django.utils.translation import ugettext as _
from treemap.audit import Role, FieldPermission
from treemap.udf import (UserDefinedFieldDefinition)
def udf_exists(params, instance):
"""
A little helper function to enable searching for a udf using
the same syntax as udf_create.
Unfortunately, udf_create is designed to read a dict of data
that is quite different than the syntax you'd use for querying
the UserDefinedFieldDefinition model directly.
To make a more consistent API for the common case of first
checking if a UDF exists using a data dict, and if not,
creating it using the same API, this function exists.
"""
data = _parse_params(params)
udfs = UserDefinedFieldDefinition.objects.filter(
instance=instance,
model_type=data['model_type'],
name=data['name'])
return udfs.exists()
@transaction.atomic
def udf_create(params, instance):
data = _parse_params(params)
name, model_type, datatype = (data['name'], data['model_type'],
data['datatype'])
udfs = UserDefinedFieldDefinition.objects.filter(
instance=instance,
model_type=model_type,
name=name)
if udfs.exists():
raise ValidationError(
{'udf.name':
[_("A user defined field with name "
"'%(udf_name)s' already exists") % {'udf_name': name}]})
if model_type not in {cls.__name__ for cls
in instance.editable_udf_models()}:
raise ValidationError(
{'udf.model': [_('Invalid model')]})
udf = UserDefinedFieldDefinition(
name=name,
model_type=model_type,
iscollection=False,
instance=instance,
datatype=datatype)
udf.save()
field_name = udf.canonical_name
# Add a restrictive permission for this UDF to all roles in the
# instance
for role in Role.objects.filter(instance=instance):
FieldPermission.objects.get_or_create(
model_name=model_type,
field_name=field_name,
permission_level=FieldPermission.NONE,
role=role,
instance=role.instance)
return udf
def _parse_params(params):
name = params.get('udf.name', None)
model_type = params.get('udf.model', None)
udf_type = params.get('udf.type', None)
datatype = {'type': udf_type}
if udf_type in ('choice', 'multichoice'):
datatype['choices'] = params.get('udf.choices', None)
datatype = json.dumps(datatype)
return {'name': name, 'model_type': model_type,
'datatype': datatype}
| clever-crow-consulting/otm-core | opentreemap/treemap/lib/udf.py | Python | agpl-3.0 | 2,743 | 0 |
from lino.apps.ledger.ledger_tables import LedgerSchema
from lino.reports import Report
from lino.adamo.rowattrs import Field, Pointer, Detail
class SchemaOverview(Report):
def __init__(self,schema):
self.schema=schema
Report.__init__(self)
def getIterator(self):
return self.schema.getTableList()
def setupReport(self):
self.addVurtColumn(
label="TableName",
meth=lambda row: row.item.getTableName(),
width=15)
self.addVurtColumn(
label="Fields",
meth=lambda row:\
", ".join([fld.name for fld in row.item.getFields()
if isinstance(fld,Field) \
and not isinstance(fld,Pointer)]),
width=20)
self.addVurtColumn(
label="Pointers",
meth=lambda row:\
", ".join([fld.name for fld in row.item.getFields()
if isinstance(fld,Pointer)]),
width=15)
self.addVurtColumn(
label="Details",
meth=lambda row:\
", ".join([fld.name for fld in row.item.getFields()
if isinstance(fld,Detail)]),
width=25)
sch=LedgerSchema()
rpt=SchemaOverview(sch)
rpt.show()
| MaxTyutyunnikov/lino | obsolete/docs/examples/sprl2.py | Python | gpl-3.0 | 1,300 | 0.011538 |
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you 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.
'''
Created on May 9, 2011
'''
from gppylib.mainUtils import addStandardLoggingAndHelpOptions, ProgramArgumentValidationException
import os
from datetime import datetime
from optparse import OptionGroup
from gppylib import gplog
from gppylib import userinput
from gppylib.commands.gp import get_masterdatadir
from gppylib.gpparseopts import OptParser, OptChecker
from gppylib.mainUtils import UserAbortedException
from gppylib.operations import Operation
from gppylib.operations.verify import AbortVerification, CleanVerification, CleanDoneVerifications, FinalizeVerification, FinalizeAllVerifications, ResumeVerification, SuspendVerification, VerificationType, VerifyFilerep, VerificationState
logger = gplog.get_default_logger()
MAX_BATCH_SIZE=128
class GpVerifyProgram(Operation):
def __init__(self, options, args):
count = sum([1 for opt in ['full', 'verify_file', 'verify_dir', 'clean', 'results', 'abort', 'suspend', 'resume']
if options.__dict__[opt] is not None])
if count == 0:
raise ProgramArgumentValidationException("""Must specify one verify request type (--full, --file, or --directorytree)
or action (--clean, --results, --abort, --suspend, or --resume)""")
elif count > 1:
raise ProgramArgumentValidationException("""Only specify one verify request type (--full, --file, or --directorytree)
or action (--clean, --results, --abort, --suspend, or --resume)""")
self.full = options.full
self.verify_file = options.verify_file
self.verify_dir = options.verify_dir
self.results = options.results
self.clean = options.clean
self.abort = options.abort
self.suspend = options.suspend
self.resume = options.resume
count = sum([1 for opt in ['full', 'verify_file', 'verify_dir']
if options.__dict__[opt] is not None])
if options.ignore_file is not None and count != 1:
raise ProgramArgumentValidationException("--fileignore must be used with --full, --file, or --directorytree")
if options.ignore_dir is not None and count != 1:
raise ProgramArgumentValidationException("--dirignore must be used with --full, --file, or --directorytree")
if options.results_level is not None and count != 1:
raise ProgramArgumentValidationException("--resultslevel must be used with --full, --file, or --directorytree")
self.ignore_file = options.ignore_file
self.ignore_dir = options.ignore_dir
self.results_level = options.results_level
if options.parallel < 1 or options.parallel > MAX_BATCH_SIZE:
raise ProgramArgumentValidationException('Parallelism value must be between 1 and %d' % MAX_BATCH_SIZE)
self.batch_default = options.parallel
self.content = None
if options.content is not None:
if self.clean or self.results or self.abort or self.suspend or self.resume:
raise ProgramArgumentValidationException("--content can only be used when spooling new verifications, with --full, --file, or --directorytree.")
self.content = int(options.content)
if options.token is None:
if self.abort or self.suspend or self.resume:
raise ProgramArgumentValidationException("If --abort, --suspend, or --resume is provided, --token must be given.")
self.token = options.token
def execute(self):
"""
Based on options, sends different verification messages to the backend.
"""
if self.results:
self._do_results(self.token, self.batch_default)
elif self.clean:
self._do_clean(self.token, self.batch_default)
elif self.abort:
AbortVerification(token = self.token,
batch_default = self.batch_default).run()
elif self.resume:
ResumeVerification(token = self.token,
batch_default = self.batch_default).run()
elif self.suspend:
SuspendVerification(token = self.token,
batch_default = self.batch_default).run()
else:
if self.token is None:
self.token = datetime.now().strftime("%Y%m%d%H%M%S")
VerifyFilerep(content = self.content,
full = self.full,
verify_file = self.verify_file,
verify_dir = self.verify_dir,
token = self.token,
ignore_dir = self.ignore_dir,
ignore_file = self.ignore_file,
results_level = self.results_level,
batch_default = self.batch_default).run()
def _do_results(self, token, batch_default):
if self.token is not None:
entry = FinalizeVerification(token = token,
batch_default = batch_default).run()
entries = [entry]
else:
entries = FinalizeAllVerifications(batch_default).run()
master_datadir = get_masterdatadir()
for entry in entries:
logger.info('---------------------------')
logger.info('Token: %s' % entry['vertoken'])
logger.info('Type: %s' % VerificationType.lookup[entry['vertype']])
logger.info('Content: %s' % (entry['vercontent'] if entry['vercontent'] > 0 else "ALL"))
logger.info('Started: %s' % entry['verstarttime'])
logger.info('State: %s' % VerificationState.lookup[entry['verstate']])
if entry['verdone']:
path = os.path.join(master_datadir, 'pg_verify', entry['vertoken'])
logger.info('Details: %s' % path)
def _do_clean(self, token, batch_default):
if self.token is not None:
CleanVerification(token = self.token,
batch_default = self.batch_default).run()
else:
if not userinput.ask_yesno(None, "\nAre you sure you want to remove all completed verification artifacts across the cluster?", 'N'):
raise UserAbortedException()
CleanDoneVerifications(batch_default = self.batch_default).run()
def cleanup(self): pass
@staticmethod
def createParser():
"""
Creates the command line options parser object for gpverify.
"""
description = ("Initiates primary/mirror verification.")
help = []
parser = OptParser(option_class=OptChecker,
description=' '.join(description.split()),
version='%prog version $Revision: #1 $')
parser.setHelp(help)
addStandardLoggingAndHelpOptions(parser, True)
addTo = OptionGroup(parser, "Request Type")
parser.add_option_group(addTo)
addTo.add_option('--full', dest='full', action='store_true',
help='Perform a full verification pass. Use --token option to ' \
'give the verification pass an identifier.')
addTo.add_option('--file', dest='verify_file', metavar='<file>',
help='Based on file type, perform either a physical or logical verification of <file>. ' \
'Use --token option to give the verification request an identifier.')
addTo.add_option('--directorytree', dest='verify_dir',
metavar='<verify_dir>',
help='Perform a full verification pass on the specified directory. ' \
'Use --token option to assign the verification pass an identifier.' )
addTo = OptionGroup(parser, "Request Options")
parser.add_option_group(addTo)
addTo.add_option('--token', dest='token', metavar='<token>',
help='A token to use for the request. ' \
'This identifier will be used in the logs and can be used to identify ' \
'a verification pass to the --abort, --suspend, --resume and --results ' \
'options.')
addTo.add_option('-c', '--content', dest='content',
metavar='<content_id>',
help='Send verification request only to the primary segment with the given <content_id>.')
addTo.add_option('--abort', dest='abort', action='store_true',
help='Abort a verification request that is in progress. ' \
'Can use --token option to abort a specific verification request.')
addTo.add_option('--suspend', dest='suspend', action='store_true',
help='Suspend a verification request that is in progress.' \
'Can use --token option to suspend a specific verification request.')
addTo.add_option('--resume', dest='resume', action='store_true',
help='Resume a suspended verification request. Can use the ' \
'--token option to resume a specific verification request.')
addTo.add_option('--fileignore', dest='ignore_file', metavar='<ignore_file>',
help='Ignore any filenames matching <ignore_file>. Multiple ' \
'files can be specified using a comma separated list.')
addTo.add_option('--dirignore', dest='ignore_dir', metavar='<ignore_dir>',
help='Ignore any directories matching <ignore_dir>. Multiple ' \
'directories can be specified using a comma separated list.')
addTo = OptionGroup(parser, "Reporting Options")
parser.add_option_group(addTo)
addTo.add_option('--results', dest='results', action='store_true',
help='Display verification results. Can use' \
'the --token option to view results of a specific verification request.')
addTo.add_option('--resultslevel', dest='results_level', action='store',
metavar='<detail_level>', type=int,
help='Level of detail to show for results. Valid levels are from 1 to 10.')
addTo.add_option('--clean', dest='clean', action='store_true',
help='Clean up verification artifacts and the gp_verification_history table.')
addTo = OptionGroup(parser, "Misc. Options")
parser.add_option_group(addTo)
addTo.add_option('-B', '--parallel', action='store', default=64,
type=int, help='Number of worker threads used to send verification requests.')
parser.set_defaults()
return parser
| lavjain/incubator-hawq | tools/bin/gppylib/programs/verify.py | Python | apache-2.0 | 11,749 | 0.010043 |
from django.conf import settings
from django.contrib import admin
if 'django.contrib.auth' in settings.INSTALLED_APPS:
from tastypie.models import ApiKey
class ApiKeyInline(admin.StackedInline):
model = ApiKey
extra = 0
ABSTRACT_APIKEY = getattr(settings, 'TASTYPIE_ABSTRACT_APIKEY', False)
if ABSTRACT_APIKEY and not isinstance(ABSTRACT_APIKEY, bool):
raise TypeError("'TASTYPIE_ABSTRACT_APIKEY' must be either 'True' "
"or 'False'.")
if not ABSTRACT_APIKEY:
admin.site.register(ApiKey)
| rtucker-mozilla/WhistlePig | vendor-local/lib/python/tastypie/admin.py | Python | bsd-3-clause | 582 | 0.001718 |
import sys
import csv
import pickle
import numpy as np
from sklearn import svm
from sklearn.metrics import f1_score
from sklearn.metrics import confusion_matrix
from sklearn.preprocessing import StandardScaler
training_data = []
training_classes = []
test_data = []
test_classes = []
path = '../../data/'
filename = path + 'processed_data'
out_filename = path + 'results/'
# parse number of classes
if '-t' in sys.argv or '--two' in sys.argv:
two_classes = True
else:
two_classes = False
# parse axis independence
if '-a' in sys.argv or '--axis-independent' in sys.argv:
axis_indep = True
else:
axis_indep = False
c_parameter = 1
# parse value of C
if '-c' in sys.argv:
ind = sys.argv.index('-c')
c_parameter = float(sys.argv[ind+1])
# parse value of gamma
gamma_parameter = 1
if '-g' in sys.argv:
ind = sys.argv.index('-g')
gamma_parameter = float(sys.argv[ind+1])
# parse kernel type
kernel_type = 'linear'
if '-k' in sys.argv:
ind = sys.argv.index('-k')
kernel_type = sys.argv[ind+1]
# check if we are performing a sweep run
sweep_run = False
if '-s' in sys.argv:
sweep_run = True
if two_classes:
print 'Rodando classificador para 2 classes'
else:
print 'Rodando classificador para 3 classes'
if axis_indep:
print 'Rodando com independencia de eixo'
else:
print 'Rodando sem independencia de eixo'
print 'Tipo de kernel: ' + str(kernel_type)
if sweep_run:
print 'Rodando com varredura de parametros'
else:
print 'Parametros de classificacao: C=' + str(c_parameter) + ' gamma=' + str(gamma_parameter)
out_filename += kernel_type
if not sweep_run:
out_filename += '_c_' + str(c_parameter)
out_filename += '_g_' + str(gamma_parameter)
if two_classes:
filename += '_2'
out_filename += '_2'
if axis_indep:
filename += '_axis_indep'
out_filename += '_axis_indep'
filename += '.csv'
out_filename += '.csv'
with open(filename, 'r') as p_data:
csv_reader = csv.reader(p_data)
to_training_data = True
first_row = True
for row in csv_reader:
if not first_row:
r = np.array(row, dtype=float)
if to_training_data:
training_classes.append(int(r[0]))
if axis_indep:
training_data.append([r[1], r[2], r[3], r[4], r[5], r[6]])
else:
training_data.append([r[1], r[2], r[3], r[4], r[5], r[6], r[7],
r[8], r[9], r[10], r[11], r[12], r[13], r[14]])
to_training_data = False
else:
test_classes.append(int(r[0]))
if axis_indep:
test_data.append([r[1], r[2], r[3], r[4], r[5], r[6]])
else:
test_data.append([r[1], r[2], r[3], r[4], r[5], r[6], r[7],
r[8], r[9], r[10], r[11], r[12], r[13], r[14]])
to_training_data = True
first_row = False
scaler = StandardScaler()
training_normalized = scaler.fit_transform(training_data)
test_normalized = scaler.transform(test_data)
if sweep_run:
sweep_values = [0.00001, 0.0001, 0.001, 0.01, 0.1, 1, 10, 100, 1000]
f1_matrix = np.empty((len(sweep_values), len(sweep_values)))
for i, gamma in enumerate(sweep_values):
for j, c in enumerate(sweep_values):
classifier = svm.SVC(gamma=gamma, C=c, kernel=kernel_type, degree=2, cache_size=4000)
classifier.fit(training_normalized, training_classes)
predicted = classifier.predict(test_normalized)
f1_matrix[i][j] = str(f1_score(test_classes, predicted, average='macro'))
print 'F1 Score: ' + str(f1_matrix[i][j])
print 'Finished processing gamma = ' + str(gamma)
with open(out_filename, 'w') as out_file:
out_file.write('gamma\\C')
for sweep in sweep_values:
out_file.write(',' + str(sweep))
out_file.write('\n')
for i, row in enumerate(f1_matrix):
out_file.write(str(sweep_values[i]))
for cell in row:
out_file.write(',' + str(cell))
out_file.write('\n')
else:
classifier = svm.SVC(gamma=gamma_parameter, C=c_parameter, kernel=kernel_type, degree=2)
classifier.fit(training_normalized, training_classes)
predicted = classifier.predict(test_normalized)
np.set_printoptions(precision=2, suppress=True)
conf_matrix = np.transpose(confusion_matrix(test_classes, predicted))
f1 = str(f1_score(test_classes, predicted, average='macro'))
print 'F1 Score: ' + str(f1)
with open(out_filename, 'w') as out_file:
out_file.write(str(conf_matrix) + '\n')
out_file.write(f1)
# save model to file
pickle.dump(classifier, open('../../data/model.sav', 'wb'))
pickle.dump(scaler, open('../../data/scaler.sav', 'wb'))
| PMantovani/road-irregularity-detector | classification_algorithm/src/svm_training.py | Python | apache-2.0 | 4,872 | 0.001437 |
# -*- coding: utf-8 -*-
from openerp import models, api, _
class account_journal(models.Model):
_inherit = "account.journal"
@api.multi
def get_journal_dashboard_datas(self):
domain_checks_to_print = [
('journal_id', '=', self.id),
('payment_method_id.code', '=', 'check_printing'),
('state','=','posted')
]
return dict(
super(account_journal, self).get_journal_dashboard_datas(),
num_checks_to_print=len(self.env['account.payment'].search(domain_checks_to_print))
)
@api.multi
def action_checks_to_print(self):
return {
'name': _('Checks to Print'),
'type': 'ir.actions.act_window',
'view_mode': 'list,form,graph',
'res_model': 'account.payment',
'context': dict(
self.env.context,
search_default_checks_to_send=1,
journal_id=self.id,
default_journal_id=self.id,
default_payment_type='outbound',
default_payment_method_id=self.env.ref('account_check_printing.account_payment_method_check').id,
),
}
| vileopratama/vitech | src/addons/account_check_printing/account_journal_dashboard.py | Python | mit | 1,200 | 0.004167 |
import json
import os
import re
import sys
import django
from django.conf import settings
from django.contrib.auth.models import AnonymousUser
from django.contrib.sitemaps.views import x_robots_tag
from django.core.exceptions import PermissionDenied, ViewDoesNotExist
from django.core.paginator import EmptyPage, PageNotAnInteger
from django.db.transaction import non_atomic_requests
from django.http import Http404, HttpResponse, HttpResponseNotFound, JsonResponse
from django.template.response import TemplateResponse
from django.utils.cache import patch_cache_control
from django.views.decorators.cache import never_cache
from django_statsd.clients import statsd
from rest_framework.exceptions import NotFound
from rest_framework.response import Response
from rest_framework.views import APIView
from olympia import amo
from olympia.amo.utils import HttpResponseXSendFile, use_fake_fxa
from olympia.api.exceptions import base_500_data
from olympia.api.serializers import SiteStatusSerializer
from olympia.users.models import UserProfile
from . import monitors
from .sitemap import get_sitemap_path, get_sitemaps, render_index_xml
@never_cache
@non_atomic_requests
def heartbeat(request):
# For each check, a boolean pass/fail status to show in the template
status_summary = {}
checks = [
'memcache',
'libraries',
'elastic',
'path',
'rabbitmq',
'signer',
'database',
]
for check in checks:
with statsd.timer('monitor.%s' % check):
status, _ = getattr(monitors, check)()
# state is a string. If it is empty, that means everything is fine.
status_summary[check] = {'state': not status, 'status': status}
# If anything broke, send HTTP 500.
status_code = 200 if all(a['state'] for a in status_summary.values()) else 500
return JsonResponse(status_summary, status=status_code)
@never_cache
@non_atomic_requests
def client_info(request):
if getattr(settings, 'ENV', None) != 'dev':
raise PermissionDenied
keys = (
'HTTP_USER_AGENT',
'HTTP_X_COUNTRY_CODE',
'HTTP_X_FORWARDED_FOR',
'REMOTE_ADDR',
)
data = {key: request.META.get(key) for key in keys}
return JsonResponse(data)
@non_atomic_requests
def robots(request):
"""Generate a robots.txt"""
_service = request.META['SERVER_NAME'] == settings.SERVICES_DOMAIN
if _service or not settings.ENGAGE_ROBOTS:
response = HttpResponse('User-agent: *\nDisallow: /', content_type='text/plain')
else:
ctx = {
'apps': amo.APP_USAGE,
'mozilla_user_id': settings.TASK_USER_ID,
'mozilla_user_username': 'mozilla',
}
response = TemplateResponse(
request, 'amo/robots.html', context=ctx, content_type='text/plain'
)
return response
@non_atomic_requests
def contribute(request):
path = os.path.join(settings.ROOT, 'contribute.json')
return HttpResponse(open(path, 'rb'), content_type='application/json')
@non_atomic_requests
def handler403(request, exception=None, **kwargs):
return TemplateResponse(request, 'amo/403.html', status=403)
@non_atomic_requests
def handler404(request, exception=None, **kwargs):
if getattr(request, 'is_api', False):
# It's a v3+ api request (/api/vX/ or /api/auth/)
return JsonResponse({'detail': str(NotFound.default_detail)}, status=404)
elif re.match(r'^/api/\d\.\d/', getattr(request, 'path_info', '')):
# It's a legacy API request in the form of /api/X.Y/. We use path_info,
# which is set in LocaleAndAppURLMiddleware, because there might be a
# locale and app prefix we don't care about in the URL.
response = HttpResponseNotFound()
patch_cache_control(response, max_age=60 * 60 * 48)
return response
return TemplateResponse(request, 'amo/404.html', status=404)
@non_atomic_requests
def handler500(request, **kwargs):
# To avoid database queries, the handler500() cannot evaluate the user - so
# we need to avoid making log calls (our custom adapter would fetch the
# user from the current thread) and set request.user to anonymous to avoid
# its usage in context processors.
request.user = AnonymousUser()
if getattr(request, 'is_api', False):
# API exceptions happening in DRF code would be handled with by our
# custom_exception_handler function in olympia.api.exceptions, but in
# the rare case where the exception is caused by a middleware or django
# itself, it might not, so we need to handle it here.
return HttpResponse(
json.dumps(base_500_data()), content_type='application/json', status=500
)
return TemplateResponse(request, 'amo/500.html', status=500)
@non_atomic_requests
def csrf_failure(request, reason=''):
from django.middleware.csrf import REASON_NO_REFERER, REASON_NO_CSRF_COOKIE
ctx = {
'reason': reason,
'no_referer': reason == REASON_NO_REFERER,
'no_cookie': reason == REASON_NO_CSRF_COOKIE,
}
return TemplateResponse(request, 'amo/403.html', context=ctx, status=403)
@non_atomic_requests
def version(request):
path = os.path.join(settings.ROOT, 'version.json')
with open(path) as f:
contents = json.loads(f.read())
py_info = sys.version_info
contents['python'] = '{major}.{minor}'.format(
major=py_info.major, minor=py_info.minor
)
contents['django'] = '{major}.{minor}'.format(
major=django.VERSION[0], minor=django.VERSION[1]
)
path = os.path.join(settings.ROOT, 'package.json')
with open(path) as f:
data = json.loads(f.read())
contents['addons-linter'] = data['dependencies']['addons-linter']
res = HttpResponse(json.dumps(contents), content_type='application/json')
res.headers['Access-Control-Allow-Origin'] = '*'
return res
def _frontend_view(*args, **kwargs):
"""View has migrated to addons-frontend but we still have the url so we
can reverse() to it in addons-server code.
If you ever hit this url somethunk gun wrong!"""
raise ViewDoesNotExist()
@non_atomic_requests
def frontend_view(*args, **kwargs):
"""Wrap _frontend_view so we can mock it in tests."""
return _frontend_view(*args, **kwargs)
# Special attribute that our <ModelBase>.get_absolute_url() looks for to
# determine whether it's a frontend view (that requires a different host prefix
# on admin instances) or not.
frontend_view.is_frontend_view = True
def fake_fxa_authorization(request):
"""Fake authentication page to bypass FxA in local development envs."""
if not use_fake_fxa():
raise Http404()
interesting_accounts = UserProfile.objects.exclude(groups=None).exclude(
deleted=True
)[:25]
return TemplateResponse(
request,
'amo/fake_fxa_authorization.html',
context={'interesting_accounts': interesting_accounts},
)
class SiteStatusView(APIView):
authentication_classes = []
permission_classes = []
@classmethod
def as_view(cls, **initkwargs):
return non_atomic_requests(super().as_view(**initkwargs))
def get(self, request, format=None):
return Response(SiteStatusSerializer(object()).data)
class InvalidSection(Exception):
pass
@non_atomic_requests
@x_robots_tag
def sitemap(request):
section = request.GET.get('section') # no section means the index page
app = request.GET.get('app_name')
page = request.GET.get('p', 1)
if 'debug' in request.GET and settings.SITEMAP_DEBUG_AVAILABLE:
try:
sitemaps = get_sitemaps()
if not section:
if page != 1:
raise EmptyPage
content = render_index_xml(sitemaps)
else:
sitemap_object = sitemaps.get((section, amo.APPS.get(app)))
if not sitemap_object:
raise InvalidSection
content = sitemap_object.render(app, page)
except EmptyPage:
raise Http404('Page %s empty' % page)
except PageNotAnInteger:
raise Http404('No page "%s"' % page)
except InvalidSection:
raise Http404('No sitemap available for section: %r' % section)
response = HttpResponse(content, content_type='application/xml')
else:
path = get_sitemap_path(section, app, page)
response = HttpResponseXSendFile(request, path, content_type='application/xml')
patch_cache_control(response, max_age=60 * 60)
return response
| wagnerand/addons-server | src/olympia/amo/views.py | Python | bsd-3-clause | 8,643 | 0.000694 |
#!/usr/bin/python
# -*- coding: utf-8 -*-
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible. If not, see <http://www.gnu.org/licenses/>.
# Based on Jimmy Tang's implementation
DOCUMENTATION = '''
---
module: keystone_user
version_added: "1.2"
deprecated: Deprecated in 2.0. Use os_user instead
short_description: Manage OpenStack Identity (keystone) users, tenants and roles
description:
- Manage users,tenants, roles from OpenStack.
options:
login_user:
description:
- login username to authenticate to keystone
required: false
default: admin
login_password:
description:
- Password of login user
required: false
default: 'yes'
login_tenant_name:
description:
- The tenant login_user belongs to
required: false
default: None
version_added: "1.3"
token:
description:
- The token to be uses in case the password is not specified
required: false
default: None
endpoint:
description:
- The keystone url for authentication
required: false
default: 'http://127.0.0.1:35357/v2.0/'
user:
description:
- The name of the user that has to added/removed from OpenStack
required: false
default: None
password:
description:
- The password to be assigned to the user
required: false
default: None
tenant:
description:
- The tenant name that has be added/removed
required: false
default: None
tenant_description:
description:
- A description for the tenant
required: false
default: None
email:
description:
- An email address for the user
required: false
default: None
role:
description:
- The name of the role to be assigned or created
required: false
default: None
state:
description:
- Indicate desired state of the resource
choices: ['present', 'absent']
default: present
requirements:
- "python >= 2.6"
- python-keystoneclient
author: "Ansible Core Team (deprecated)"
'''
EXAMPLES = '''
# Create a tenant
- keystone_user: tenant=demo tenant_description="Default Tenant"
# Create a user
- keystone_user: user=john tenant=demo password=secrete
# Apply the admin role to the john user in the demo tenant
- keystone_user: role=admin user=john tenant=demo
'''
try:
from keystoneclient.v2_0 import client
except ImportError:
keystoneclient_found = False
else:
keystoneclient_found = True
def authenticate(endpoint, token, login_user, login_password, login_tenant_name):
"""Return a keystone client object"""
if token:
return client.Client(endpoint=endpoint, token=token)
else:
return client.Client(auth_url=endpoint, username=login_user,
password=login_password, tenant_name=login_tenant_name)
def tenant_exists(keystone, tenant):
""" Return True if tenant already exists"""
return tenant in [x.name for x in keystone.tenants.list()]
def user_exists(keystone, user):
"""" Return True if user already exists"""
return user in [x.name for x in keystone.users.list()]
def get_tenant(keystone, name):
""" Retrieve a tenant by name"""
tenants = [x for x in keystone.tenants.list() if x.name == name]
count = len(tenants)
if count == 0:
raise KeyError("No keystone tenants with name %s" % name)
elif count > 1:
raise ValueError("%d tenants with name %s" % (count, name))
else:
return tenants[0]
def get_user(keystone, name):
""" Retrieve a user by name"""
users = [x for x in keystone.users.list() if x.name == name]
count = len(users)
if count == 0:
raise KeyError("No keystone users with name %s" % name)
elif count > 1:
raise ValueError("%d users with name %s" % (count, name))
else:
return users[0]
def get_role(keystone, name):
""" Retrieve a role by name"""
roles = [x for x in keystone.roles.list() if x.name == name]
count = len(roles)
if count == 0:
raise KeyError("No keystone roles with name %s" % name)
elif count > 1:
raise ValueError("%d roles with name %s" % (count, name))
else:
return roles[0]
def get_tenant_id(keystone, name):
return get_tenant(keystone, name).id
def get_user_id(keystone, name):
return get_user(keystone, name).id
def ensure_tenant_exists(keystone, tenant_name, tenant_description,
check_mode):
""" Ensure that a tenant exists.
Return (True, id) if a new tenant was created, (False, None) if it
already existed.
"""
# Check if tenant already exists
try:
tenant = get_tenant(keystone, tenant_name)
except KeyError:
# Tenant doesn't exist yet
pass
else:
if tenant.description == tenant_description:
return (False, tenant.id)
else:
# We need to update the tenant description
if check_mode:
return (True, tenant.id)
else:
tenant.update(description=tenant_description)
return (True, tenant.id)
# We now know we will have to create a new tenant
if check_mode:
return (True, None)
ks_tenant = keystone.tenants.create(tenant_name=tenant_name,
description=tenant_description,
enabled=True)
return (True, ks_tenant.id)
def ensure_tenant_absent(keystone, tenant, check_mode):
""" Ensure that a tenant does not exist
Return True if the tenant was removed, False if it didn't exist
in the first place
"""
if not tenant_exists(keystone, tenant):
return False
# We now know we will have to delete the tenant
if check_mode:
return True
def ensure_user_exists(keystone, user_name, password, email, tenant_name,
check_mode):
""" Check if user exists
Return (True, id) if a new user was created, (False, id) user already
exists
"""
# Check if tenant already exists
try:
user = get_user(keystone, user_name)
except KeyError:
# Tenant doesn't exist yet
pass
else:
# User does exist, we're done
return (False, user.id)
# We now know we will have to create a new user
if check_mode:
return (True, None)
tenant = get_tenant(keystone, tenant_name)
user = keystone.users.create(name=user_name, password=password,
email=email, tenant_id=tenant.id)
return (True, user.id)
def ensure_role_exists(keystone, role_name):
# Get the role if it exists
try:
role = get_role(keystone, role_name)
# Role does exist, we're done
return (False, role.id)
except KeyError:
# Role doesn't exist yet
pass
role = keystone.roles.create(role_name)
return (True, role.id)
def ensure_user_role_exists(keystone, user_name, tenant_name, role_name,
check_mode):
""" Check if role exists
Return (True, id) if a new role was created or if the role was newly
assigned to the user for the tenant. (False, id) if the role already
exists and was already assigned to the user ofr the tenant.
"""
# Check if the user has the role in the tenant
user = get_user(keystone, user_name)
tenant = get_tenant(keystone, tenant_name)
roles = [x for x in keystone.roles.roles_for_user(user, tenant)
if x.name == role_name]
count = len(roles)
if count == 1:
# If the role is in there, we are done
role = roles[0]
return (False, role.id)
elif count > 1:
# Too many roles with the same name, throw an error
raise ValueError("%d roles with name %s" % (count, role_name))
# At this point, we know we will need to make changes
if check_mode:
return (True, None)
# Get the role if it exists
try:
role = get_role(keystone, role_name)
except KeyError:
# Role doesn't exist yet
role = keystone.roles.create(role_name)
# Associate the role with the user in the admin
keystone.roles.add_user_role(user, role, tenant)
return (True, role.id)
def ensure_user_absent(keystone, user, check_mode):
raise NotImplementedError("Not yet implemented")
def ensure_user_role_absent(keystone, uesr, tenant, role, check_mode):
raise NotImplementedError("Not yet implemented")
def ensure_role_absent(keystone, role_name):
raise NotImplementedError("Not yet implemented")
def main():
argument_spec = openstack_argument_spec()
argument_spec.update(dict(
tenant_description=dict(required=False),
email=dict(required=False),
user=dict(required=False),
tenant=dict(required=False),
password=dict(required=False),
role=dict(required=False),
state=dict(default='present', choices=['present', 'absent']),
endpoint=dict(required=False,
default="http://127.0.0.1:35357/v2.0"),
token=dict(required=False),
login_user=dict(required=False),
login_password=dict(required=False),
login_tenant_name=dict(required=False)
))
# keystone operations themselves take an endpoint, not a keystone auth_url
del(argument_spec['auth_url'])
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True,
mutually_exclusive=[['token', 'login_user'],
['token', 'login_password'],
['token', 'login_tenant_name']]
)
if not keystoneclient_found:
module.fail_json(msg="the python-keystoneclient module is required")
user = module.params['user']
password = module.params['password']
tenant = module.params['tenant']
tenant_description = module.params['tenant_description']
email = module.params['email']
role = module.params['role']
state = module.params['state']
endpoint = module.params['endpoint']
token = module.params['token']
login_user = module.params['login_user']
login_password = module.params['login_password']
login_tenant_name = module.params['login_tenant_name']
keystone = authenticate(endpoint, token, login_user, login_password, login_tenant_name)
check_mode = module.check_mode
try:
d = dispatch(keystone, user, password, tenant, tenant_description,
email, role, state, endpoint, token, login_user,
login_password, check_mode)
except Exception as e:
if check_mode:
# If we have a failure in check mode
module.exit_json(changed=True,
msg="exception: %s" % e)
else:
module.fail_json(msg="exception: %s" % e)
else:
module.exit_json(**d)
def dispatch(keystone, user=None, password=None, tenant=None,
tenant_description=None, email=None, role=None,
state="present", endpoint=None, token=None, login_user=None,
login_password=None, check_mode=False):
""" Dispatch to the appropriate method.
Returns a dict that will be passed to exit_json
tenant user role state
------ ---- ---- --------
X present ensure_tenant_exists
X absent ensure_tenant_absent
X X present ensure_user_exists
X X absent ensure_user_absent
X X X present ensure_user_role_exists
X X X absent ensure_user_role_absent
X present ensure_role_exists
X absent ensure_role_absent
"""
changed = False
id = None
if not tenant and not user and role and state == "present":
changed, id = ensure_role_exists(keystone, role)
elif not tenant and not user and role and state == "absent":
changed = ensure_role_absent(keystone, role)
elif tenant and not user and not role and state == "present":
changed, id = ensure_tenant_exists(keystone, tenant,
tenant_description, check_mode)
elif tenant and not user and not role and state == "absent":
changed = ensure_tenant_absent(keystone, tenant, check_mode)
elif tenant and user and not role and state == "present":
changed, id = ensure_user_exists(keystone, user, password,
email, tenant, check_mode)
elif tenant and user and not role and state == "absent":
changed = ensure_user_absent(keystone, user, check_mode)
elif tenant and user and role and state == "present":
changed, id = ensure_user_role_exists(keystone, user, tenant, role,
check_mode)
elif tenant and user and role and state == "absent":
changed = ensure_user_role_absent(keystone, user, tenant, role, check_mode)
else:
# Should never reach here
raise ValueError("Code should never reach here")
return dict(changed=changed, id=id)
# import module snippets
from ansible.module_utils.basic import *
from ansible.module_utils.openstack import *
if __name__ == '__main__':
main()
| cchurch/ansible-modules-core | cloud/openstack/_keystone_user.py | Python | gpl-3.0 | 14,116 | 0.001063 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.