repo_name
stringlengths 5
92
| path
stringlengths 4
232
| copies
stringclasses 19
values | size
stringlengths 4
7
| content
stringlengths 721
1.04M
| license
stringclasses 15
values | hash
int64 -9,223,277,421,539,062,000
9,223,102,107B
| line_mean
float64 6.51
99.9
| line_max
int64 15
997
| alpha_frac
float64 0.25
0.97
| autogenerated
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|
scionrep/scioncc | src/ion/service/test/test_governance.py | 1 | 83576 | #!/usr/bin/env python
__author__ = 'Stephen P. Henrie'
import unittest, os, gevent, platform, simplejson
from mock import Mock, patch
from pyon.util.int_test import IonIntegrationTestCase
from pyon.util.containers import get_ion_ts
from nose.plugins.attrib import attr
from pyon.util.context import LocalContextMixin
from pyon.datastore.datastore import DatastoreManager
from pyon.ion.event import EventRepository
from pyon.core.exception import BadRequest, Conflict, Inconsistent, NotFound, Unauthorized
from pyon.public import PRED, RT, IonObject, CFG, log, OT, LCS, LCE, AS
from pyon.ion.resregistry import ResourceRegistryServiceWrapper
from pyon.core.governance.negotiation import Negotiation
from ion.process.bootstrap.load_system_policy import LoadSystemPolicy
from pyon.core.governance import MODERATOR_ROLE, MEMBER_ROLE, SUPERUSER_ROLE, OPERATOR_ROLE, get_system_actor, get_system_actor_header
from pyon.core.governance import get_actor_header
from pyon.net.endpoint import RPCClient, BidirClientChannel
from interface.services.core.iresource_registry_service import ResourceRegistryServiceProcessClient
from interface.services.core.iorg_management_service import OrgManagementServiceProcessClient
from interface.services.core.iidentity_management_service import IdentityManagementServiceProcessClient
from interface.services.core.iexchange_management_service import ExchangeManagementServiceProcessClient
from interface.services.core.ipolicy_management_service import PolicyManagementServiceProcessClient
from interface.services.core.isystem_management_service import SystemManagementServiceProcessClient
from interface.objects import AgentCommand, ProposalOriginatorEnum, ProposalStatusEnum, NegotiationStatusEnum, ComputedValueAvailability
ORG2 = 'Org 2'
DENY_EXCHANGE_TEXT = '''
<Rule RuleId="%s" Effect="Deny">
<Description>
%s
</Description>
<Target>
<Resources>
<Resource>
<ResourceMatch MatchId="urn:oasis:names:tc:xacml:1.0:function:string-equal">
<AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">exchange_management</AttributeValue>
<ResourceAttributeDesignator AttributeId="urn:oasis:names:tc:xacml:1.0:resource:resource-id" DataType="http://www.w3.org/2001/XMLSchema#string"/>
</ResourceMatch>
</Resource>
</Resources>
</Target>
</Rule>
'''
TEST_POLICY_TEXT = '''
<Rule RuleId="%s" Effect="Permit">
<Description>
%s
</Description>
<Target>
<Subjects>
<Subject>
<SubjectMatch MatchId="urn:oasis:names:tc:xacml:1.0:function:string-equal">
<AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">anonymous</AttributeValue>
<SubjectAttributeDesignator AttributeId="urn:oasis:names:tc:xacml:1.0:subject:subject-id" DataType="http://www.w3.org/2001/XMLSchema#string"/>
</SubjectMatch>
</Subject>
</Subjects>
<Actions>
<Action>
<ActionMatch MatchId="urn:oasis:names:tc:xacml:1.0:function:string-equal">
<AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">create_exchange_space</AttributeValue>
<ActionAttributeDesignator AttributeId="urn:oasis:names:tc:xacml:1.0:action:action-id" DataType="http://www.w3.org/2001/XMLSchema#string"/>
</ActionMatch>
</Action>
</Actions>
</Target>
</Rule>
'''
TEST_BOUNDARY_POLICY_TEXT = '''
<Rule RuleId="%s" Effect="Deny">
<Description>
%s
</Description>
<Target>
<Subjects>
<Subject>
<SubjectMatch MatchId="urn:oasis:names:tc:xacml:1.0:function:string-equal">
<AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">anonymous</AttributeValue>
<SubjectAttributeDesignator AttributeId="urn:oasis:names:tc:xacml:1.0:subject:subject-id" DataType="http://www.w3.org/2001/XMLSchema#string"/>
</SubjectMatch>
</Subject>
</Subjects>
</Target>
</Rule>
'''
###########
DENY_PARAM_50_RULE = '''
<Rule RuleId="%s:" Effect="Permit">
<Description>
%s
</Description>
<Target>
<Resources>
<Resource>
<ResourceMatch MatchId="urn:oasis:names:tc:xacml:1.0:function:string-regexp-match">
<AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">.*$</AttributeValue>
<ResourceAttributeDesignator AttributeId="urn:oasis:names:tc:xacml:1.0:resource:resource-id" DataType="http://www.w3.org/2001/XMLSchema#string"/>
</ResourceMatch>
</Resource>
<Resource>
<ResourceMatch MatchId="urn:oasis:names:tc:xacml:1.0:function:string-equal">
<AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">agent</AttributeValue>
<ResourceAttributeDesignator AttributeId="urn:oasis:names:tc:xacml:1.0:resource:receiver-type" DataType="http://www.w3.org/2001/XMLSchema#string"/>
</ResourceMatch>
</Resource>
</Resources>
<Actions>
<Action>
<ActionMatch MatchId="urn:oasis:names:tc:xacml:1.0:function:string-equal">
<AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">set_resource</AttributeValue>
<ActionAttributeDesignator AttributeId="urn:oasis:names:tc:xacml:1.0:action:action-id" DataType="http://www.w3.org/2001/XMLSchema#string"/>
</ActionMatch>
</Action>
</Actions>
</Target>
<Condition>
<Apply FunctionId="urn:oasis:names:tc:xacml:1.0:function:evaluate-code">
<AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string"><![CDATA[def policy_func(process, message, headers):
params = message['params']
if params['INTERVAL'] <= 50:
return True, ''
return False, 'The value for SBE37Parameter.INTERVAL cannot be greater than 50'
]]>
</AttributeValue>
<ActionAttributeDesignator AttributeId="urn:oasis:names:tc:xacml:1.0:action:param-dict" DataType="http://www.w3.org/2001/XMLSchema#dict"/>
</Apply>
</Condition>
</Rule>
'''
DENY_PARAM_30_RULE = '''
<Rule RuleId="%s:" Effect="Permit">
<Description>
%s
</Description>
<Target>
<Resources>
<Resource>
<ResourceMatch MatchId="urn:oasis:names:tc:xacml:1.0:function:string-regexp-match">
<AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">.*$</AttributeValue>
<ResourceAttributeDesignator AttributeId="urn:oasis:names:tc:xacml:1.0:resource:resource-id" DataType="http://www.w3.org/2001/XMLSchema#string"/>
</ResourceMatch>
</Resource>
<Resource>
<ResourceMatch MatchId="urn:oasis:names:tc:xacml:1.0:function:string-equal">
<AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">agent</AttributeValue>
<ResourceAttributeDesignator AttributeId="urn:oasis:names:tc:xacml:1.0:resource:receiver-type" DataType="http://www.w3.org/2001/XMLSchema#string"/>
</ResourceMatch>
</Resource>
</Resources>
<Actions>
<Action>
<ActionMatch MatchId="urn:oasis:names:tc:xacml:1.0:function:string-equal">
<AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">set_resource</AttributeValue>
<ActionAttributeDesignator AttributeId="urn:oasis:names:tc:xacml:1.0:action:action-id" DataType="http://www.w3.org/2001/XMLSchema#string"/>
</ActionMatch>
</Action>
</Actions>
</Target>
<Condition>
<Apply FunctionId="urn:oasis:names:tc:xacml:1.0:function:evaluate-code">
<AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string"><![CDATA[def policy_func(process, message, headers):
params = message['params']
if params['INTERVAL'] <= 30:
return True, ''
return False, 'The value for SBE37Parameter.INTERVAL cannot be greater than 30'
]]>
</AttributeValue>
<ActionAttributeDesignator AttributeId="urn:oasis:names:tc:xacml:1.0:action:param-dict" DataType="http://www.w3.org/2001/XMLSchema#dict"/>
</Apply>
</Condition>
</Rule>
'''
DENY_PARAM_10_RULE = '''
<Rule RuleId="%s:" Effect="Permit">
<Description>
%s
</Description>
<Target>
<Resources>
<Resource>
<ResourceMatch MatchId="urn:oasis:names:tc:xacml:1.0:function:string-regexp-match">
<AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">.*$</AttributeValue>
<ResourceAttributeDesignator AttributeId="urn:oasis:names:tc:xacml:1.0:resource:resource-id" DataType="http://www.w3.org/2001/XMLSchema#string"/>
</ResourceMatch>
</Resource>
<Resource>
<ResourceMatch MatchId="urn:oasis:names:tc:xacml:1.0:function:string-equal">
<AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">agent</AttributeValue>
<ResourceAttributeDesignator AttributeId="urn:oasis:names:tc:xacml:1.0:resource:receiver-type" DataType="http://www.w3.org/2001/XMLSchema#string"/>
</ResourceMatch>
</Resource>
</Resources>
<Actions>
<Action>
<ActionMatch MatchId="urn:oasis:names:tc:xacml:1.0:function:string-equal">
<AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">set_resource</AttributeValue>
<ActionAttributeDesignator AttributeId="urn:oasis:names:tc:xacml:1.0:action:action-id" DataType="http://www.w3.org/2001/XMLSchema#string"/>
</ActionMatch>
</Action>
</Actions>
</Target>
<Condition>
<Apply FunctionId="urn:oasis:names:tc:xacml:1.0:function:evaluate-code">
<AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string"><![CDATA[def policy_func(process, message, headers):
params = message['params']
if params['INTERVAL'] <= 10:
return True, ''
return False, 'The value for SBE37Parameter.INTERVAL cannot be greater than 10'
]]>
</AttributeValue>
<ActionAttributeDesignator AttributeId="urn:oasis:names:tc:xacml:1.0:action:param-dict" DataType="http://www.w3.org/2001/XMLSchema#dict"/>
</Apply>
</Condition>
</Rule>
'''
@attr('INT', group='coi')
class TestGovernanceHeaders(IonIntegrationTestCase):
def setUp(self):
# Start container and services
self._start_container()
self.container.start_rel_from_url('res/deploy/basic.yml')
#Instantiate a process to represent the test
process = GovernanceTestProcess()
self.rr_client = ResourceRegistryServiceProcessClient(process=process)
#Get info on the ION System Actor
self.system_actor = get_system_actor()
log.info('system actor:' + self.system_actor._id)
self.system_actor_header = get_system_actor_header()
self.resource_id_header_value = ''
def test_governance_message_headers(self):
'''
This test is used to make sure the ION endpoint code is properly setting the
'''
#Get function pointer to send function
old_send = BidirClientChannel._send
# make new send to patch on that duplicates send
def patched_send(*args, **kwargs):
#Only duplicate the message send from the initial client call
msg_headers = kwargs['headers']
if (self.resource_id_header_value == '') and 'resource-id' in msg_headers:
self.resource_id_header_value = msg_headers['resource-id']
return old_send(*args, **kwargs)
# patch it into place with auto-cleanup to try to interogate the message headers
patcher = patch('pyon.net.endpoint.BidirClientChannel._send', patched_send)
patcher.start()
self.addCleanup(patcher.stop)
# Instantiate an object
obj = IonObject("ActorIdentity", name="name")
# Can't call update with object that hasn't been persisted
with self.assertRaises(BadRequest) as cm:
self.rr_client.update(obj)
# self.assertTrue(cm.exception.message.startswith("Object does not have required '_id' or '_rev' attribute"))
self.resource_id_header_value = ''
# Persist object and read it back
obj_id, obj_rev = self.rr_client.create(obj)
log.debug('The id of the created object is %s', obj_id)
self.assertEqual(self.resource_id_header_value, '' )
self.resource_id_header_value = ''
read_obj = self.rr_client.read(obj_id)
self.assertEqual(self.resource_id_header_value, obj_id )
# Cannot create object with _id and _rev fields pre-set
self.resource_id_header_value = ''
with self.assertRaises(BadRequest) as cm:
self.rr_client.create(read_obj)
#self.assertTrue(cm.exception.message.startswith("Doc must not have '_id'"))
self.assertEqual(self.resource_id_header_value, '' )
# Update object
read_obj.name = "John Doe"
self.resource_id_header_value = ''
self.rr_client.update(read_obj)
self.assertEqual(self.resource_id_header_value, obj_id )
# Update should fail with revision mismatch
self.resource_id_header_value = ''
with self.assertRaises(Conflict) as cm:
self.rr_client.update(read_obj)
#self.assertTrue(cm.exception.message.startswith("Object not based on most current version"))
self.assertEqual(self.resource_id_header_value, obj_id )
# Re-read and update object
self.resource_id_header_value = ''
read_obj = self.rr_client.read(obj_id)
self.assertEqual(self.resource_id_header_value, obj_id )
self.resource_id_header_value = ''
self.rr_client.update(read_obj)
self.assertEqual(self.resource_id_header_value, obj_id )
#Create second object
obj = IonObject("ActorIdentity", name="Babs Smith")
self.resource_id_header_value = ''
# Persist object and read it back
obj2_id, obj2_rev = self.rr_client.create(obj)
log.debug('The id of the created object is %s', obj_id)
self.assertEqual(self.resource_id_header_value, '' )
#Test for multi-read
self.resource_id_header_value = ''
objs = self.rr_client.read_mult([obj_id, obj2_id])
self.assertAlmostEquals(self.resource_id_header_value, [obj_id, obj2_id])
self.assertEqual(len(objs),2)
# Delete object
self.resource_id_header_value = ''
self.rr_client.delete(obj_id)
self.assertEqual(self.resource_id_header_value, obj_id )
# Delete object
self.resource_id_header_value = ''
self.rr_client.delete(obj2_id)
self.assertEqual(self.resource_id_header_value, obj2_id )
class GovernanceTestProcess(LocalContextMixin):
name = 'gov_test'
id='gov_client'
process_type = 'simple'
@attr('INT', group='coi')
class TestGovernanceInt(IonIntegrationTestCase):
def setUp(self):
from unittest import SkipTest
raise SkipTest("Need to rework governance tests")
# Start container
self._start_container()
#Load a deploy file
self.container.start_rel_from_url('res/deploy/basic.yml')
#Instantiate a process to represent the test
process=GovernanceTestProcess()
#Load system policies after container has started all of the services
policy_loaded = CFG.get_safe('system.load_policy', False)
if not policy_loaded:
log.debug('Loading policy')
LoadSystemPolicy.op_load_system_policies(process)
gevent.sleep(self.SLEEP_TIME*2) # Wait for events to be fired and policy updated
self.rr_msg_client = ResourceRegistryServiceProcessClient(process=process)
self.rr_client = ResourceRegistryServiceWrapper(self.container.resource_registry, process)
self.id_client = IdentityManagementServiceProcessClient(process=process)
self.pol_client = PolicyManagementServiceProcessClient(process=process)
self.org_client = OrgManagementServiceProcessClient(process=process)
self.ems_client = ExchangeManagementServiceProcessClient(process=process)
self.sys_management = SystemManagementServiceProcessClient(process=process)
#Get info on the ION System Actor
self.system_actor = get_system_actor()
log.info('system actor:' + self.system_actor._id)
self.system_actor_header = get_system_actor_header()
self.anonymous_actor_headers = {'ion-actor-id':'anonymous'}
self.ion_org = self.org_client.find_org()
# Setup access to event repository
dsm = DatastoreManager()
ds = dsm.get_datastore("events")
self.event_repo = EventRepository(dsm)
def tearDown(self):
policy_list, _ = self.rr_client.find_resources(restype=RT.Policy)
# Must remove the policies in the reverse order they were added
for policy in sorted(policy_list, key=lambda p: p.ts_created, reverse=True):
self.pol_client.delete_policy(policy._id, headers=self.system_actor_header)
gevent.sleep(self.SLEEP_TIME) # Wait for events to be fired and policy updated
def test_basic_policy_operations(self):
#Make sure that the system policies have been loaded
policy_list,_ = self.rr_client.find_resources(restype=RT.Policy, id_only=True)
self.assertNotEqual(len(policy_list),0,"The system policies have not been loaded into the Resource Registry")
log.debug('Begin testing with policies')
#First check existing policies to see if they are in place to keep an anonymous user from creating things
with self.assertRaises(Unauthorized) as cm:
test_org_id = self.org_client.create_org(org=IonObject(RT.Org, name='test_org', description='A test Org'))
self.assertIn( 'org_management(create_org) has been denied',cm.exception.message)
with self.assertRaises(NotFound) as cm:
test_org = self.org_client.find_org(name='test_org')
#Add a new policy to deny all operations to the exchange_management by default .
test_policy_id = self.pol_client.create_service_access_policy('exchange_management', 'Exchange_Management_Deny_Policy',
'Deny all operations in Exchange Management Service by default',
DENY_EXCHANGE_TEXT, headers=self.system_actor_header)
gevent.sleep(self.SLEEP_TIME) # Wait for events to be fired and policy updated
#Attempt to access an operation in service which does not have specific policies set
es_obj = IonObject(RT.ExchangeSpace, description= 'ION test XS', name='ioncore2' )
with self.assertRaises(Unauthorized) as cm:
self.ems_client.create_exchange_space(es_obj, headers=self.anonymous_actor_headers)
self.assertIn( 'exchange_management(create_exchange_space) has been denied',cm.exception.message)
#Add a new policy to allow the the above service call.
test_policy_id = self.pol_client.create_service_access_policy('exchange_management', 'Exchange_Management_Test_Policy',
'Allow specific operations in the Exchange Management Service for anonymous user',
TEST_POLICY_TEXT, headers=self.system_actor_header)
gevent.sleep(self.SLEEP_TIME) # Wait for events to be fired and policy updated
#The previous attempt at this operations should now be allowed.
es_obj = IonObject(RT.ExchangeSpace, description= 'ION test XS', name='ioncore2' )
with self.assertRaises(BadRequest) as cm:
self.ems_client.create_exchange_space(es_obj, headers=self.anonymous_actor_headers)
self.assertIn( 'Arguments not set',cm.exception.message)
#disable the test policy to try again
self.pol_client.disable_policy(test_policy_id, headers=self.system_actor_header)
gevent.sleep(self.SLEEP_TIME) # Wait for events to be published and policy updated
#The same request that previously was allowed should now be denied
es_obj = IonObject(RT.ExchangeSpace, description= 'ION test XS', name='ioncore2' )
with self.assertRaises(Unauthorized) as cm:
self.ems_client.create_exchange_space(es_obj, headers=self.anonymous_actor_headers)
self.assertIn( 'exchange_management(create_exchange_space) has been denied',cm.exception.message)
#now enable the test policy to try again
self.pol_client.enable_policy(test_policy_id, headers=self.system_actor_header)
gevent.sleep(self.SLEEP_TIME) # Wait for events to be published and policy updated
#The previous attempt at this operations should now be allowed.
es_obj = IonObject(RT.ExchangeSpace, description= 'ION test XS', name='ioncore2' )
with self.assertRaises(BadRequest) as cm:
self.ems_client.create_exchange_space(es_obj, headers=self.anonymous_actor_headers)
self.assertIn( 'Arguments not set',cm.exception.message)
#Now test service operation specific policies - specifically that there can be more than one on the same operation.
pol1_id = self.pol_client.add_process_operation_precondition_policy(process_name='policy_management', op='disable_policy', policy_content='func1_pass', headers=self.system_actor_header )
gevent.sleep(self.SLEEP_TIME) # Wait for events to be published and policy updated
#try to disable the test policy again
self.pol_client.disable_policy(test_policy_id, headers=self.system_actor_header)
gevent.sleep(self.SLEEP_TIME) # Wait for events to be published and policy updated
#The same request that previously was allowed should now be denied
es_obj = IonObject(RT.ExchangeSpace, description= 'ION test XS', name='ioncore2' )
with self.assertRaises(Unauthorized) as cm:
self.ems_client.create_exchange_space(es_obj, headers=self.anonymous_actor_headers)
self.assertIn( 'exchange_management(create_exchange_space) has been denied',cm.exception.message)
#now enable the test policy to try again
self.pol_client.enable_policy(test_policy_id, headers=self.system_actor_header)
gevent.sleep(self.SLEEP_TIME) # Wait for events to be published and policy updated
#The previous attempt at this operations should now be allowed.
es_obj = IonObject(RT.ExchangeSpace, description= 'ION test XS', name='ioncore2' )
with self.assertRaises(BadRequest) as cm:
self.ems_client.create_exchange_space(es_obj, headers=self.anonymous_actor_headers)
self.assertIn( 'Arguments not set',cm.exception.message)
pol2_id = self.pol_client.add_process_operation_precondition_policy(process_name='policy_management', op='disable_policy', policy_content='func2_deny', headers=self.system_actor_header )
gevent.sleep(self.SLEEP_TIME) # Wait for events to be published and policy updated
#try to disable the test policy again
with self.assertRaises(Unauthorized) as cm:
self.pol_client.disable_policy(test_policy_id, headers=self.system_actor_header)
self.assertIn( 'Denied for no reason',cm.exception.message)
self.pol_client.delete_policy(pol2_id, headers=self.system_actor_header)
gevent.sleep(self.SLEEP_TIME) # Wait for events to be published and policy updated
#try to disable the test policy again
self.pol_client.disable_policy(test_policy_id, headers=self.system_actor_header)
gevent.sleep(self.SLEEP_TIME) # Wait for events to be published and policy updated
#The same request that previously was allowed should now be denied
es_obj = IonObject(RT.ExchangeSpace, description= 'ION test XS', name='ioncore2' )
with self.assertRaises(Unauthorized) as cm:
self.ems_client.create_exchange_space(es_obj, headers=self.anonymous_actor_headers)
self.assertIn( 'exchange_management(create_exchange_space) has been denied',cm.exception.message)
#try to enable the test policy again
self.pol_client.enable_policy(test_policy_id, headers=self.system_actor_header)
gevent.sleep(self.SLEEP_TIME) # Wait for events to be published and policy updated
#The previous attempt at this operations should now be allowed.
es_obj = IonObject(RT.ExchangeSpace, description= 'ION test XS', name='ioncore2' )
with self.assertRaises(BadRequest) as cm:
self.ems_client.create_exchange_space(es_obj, headers=self.anonymous_actor_headers)
self.assertIn( 'Arguments not set',cm.exception.message)
pre_func1 =\
"""def precondition_func(process, msg, headers):
if headers['op'] == 'disable_policy':
return False, 'Denied for no reason again'
else:
return True, ''
"""
#Create a dynamic precondition function to deny calls to disable policy
pre_func1_id = self.pol_client.add_process_operation_precondition_policy(process_name='policy_management', op='disable_policy', policy_content=pre_func1, headers=self.system_actor_header )
gevent.sleep(self.SLEEP_TIME) # Wait for events to be published and policy updated
#try to disable the test policy again
with self.assertRaises(Unauthorized) as cm:
self.pol_client.disable_policy(test_policy_id, headers=self.system_actor_header)
self.assertIn( 'Denied for no reason again',cm.exception.message)
#Now delete the most recent precondition policy
self.pol_client.delete_policy(pre_func1_id, headers=self.system_actor_header)
gevent.sleep(self.SLEEP_TIME) # Wait for events to be published and policy updated
#The previous attempt at this operations should now be allowed.
es_obj = IonObject(RT.ExchangeSpace, description= 'ION test XS', name='ioncore2' )
with self.assertRaises(BadRequest) as cm:
self.ems_client.create_exchange_space(es_obj, headers=self.anonymous_actor_headers)
self.assertIn( 'Arguments not set',cm.exception.message)
#Now test that a precondition function can be enabled and disabled
pre_func2 =\
"""def precondition_func(process, msg, headers):
if headers['op'] == 'create_exchange_space':
return False, 'Denied for from a operation precondition function'
else:
return True, ''
"""
#Create a dynamic precondition function to deny calls to disable policy
pre_func2_id = self.pol_client.add_process_operation_precondition_policy(process_name='exchange_management', op='create_exchange_space', policy_content=pre_func2, headers=self.system_actor_header )
gevent.sleep(self.SLEEP_TIME) # Wait for events to be published and policy updated
#The same request that previously was allowed should now be denied
es_obj = IonObject(RT.ExchangeSpace, description= 'ION test XS', name='ioncore2' )
with self.assertRaises(Unauthorized) as cm:
self.ems_client.create_exchange_space(es_obj, headers=self.anonymous_actor_headers)
self.assertIn( 'Denied for from a operation precondition function',cm.exception.message)
#try to enable the precondition policy
self.pol_client.disable_policy(pre_func2_id, headers=self.system_actor_header)
gevent.sleep(self.SLEEP_TIME) # Wait for events to be published and policy updated
#The previous attempt at this operations should now be allowed.
es_obj = IonObject(RT.ExchangeSpace, description= 'ION test XS', name='ioncore2' )
with self.assertRaises(BadRequest) as cm:
self.ems_client.create_exchange_space(es_obj, headers=self.anonymous_actor_headers)
self.assertIn( 'Arguments not set',cm.exception.message)
#try to enable the precondition policy
self.pol_client.enable_policy(pre_func2_id, headers=self.system_actor_header)
gevent.sleep(self.SLEEP_TIME) # Wait for events to be published and policy updated
#The same request that previously was allowed should now be denied
es_obj = IonObject(RT.ExchangeSpace, description= 'ION test XS', name='ioncore2' )
with self.assertRaises(Unauthorized) as cm:
self.ems_client.create_exchange_space(es_obj, headers=self.anonymous_actor_headers)
self.assertIn( 'Denied for from a operation precondition function',cm.exception.message)
#Delete the precondition policy
self.pol_client.delete_policy(pre_func2_id, headers=self.system_actor_header)
gevent.sleep(self.SLEEP_TIME) # Wait for events to be published and policy updated
#The previous attempt at this operations should now be allowed.
es_obj = IonObject(RT.ExchangeSpace, description= 'ION test XS', name='ioncore2' )
with self.assertRaises(BadRequest) as cm:
self.ems_client.create_exchange_space(es_obj, headers=self.anonymous_actor_headers)
self.assertIn( 'Arguments not set',cm.exception.message)
self.pol_client.delete_policy(test_policy_id, headers=self.system_actor_header)
gevent.sleep(self.SLEEP_TIME) # Wait for events to be published and policy updated
#The same request that previously was allowed should now be denied
es_obj = IonObject(RT.ExchangeSpace, description= 'ION test XS', name='ioncore2' )
with self.assertRaises(Unauthorized) as cm:
self.ems_client.create_exchange_space(es_obj, headers=self.anonymous_actor_headers)
self.assertIn( 'exchange_management(create_exchange_space) has been denied',cm.exception.message)
###########
### Now test access to service create* operations based on roles...
#Anonymous users should not be allowed
with self.assertRaises(Unauthorized) as cm:
id = self.ssclient.create_interval_timer(start_time="now", event_origin="Interval_Timer_233", headers=self.anonymous_actor_headers)
self.assertIn( 'scheduler(create_interval_timer) has been denied',cm.exception.message)
#now try creating a new user with a valid actor
actor_id, valid_until, registered = self.id_client.signon(USER1_CERTIFICATE, True, headers=self.apache_actor_header)
log.info( "actor id=" + actor_id)
actor_header = get_actor_header(actor_id)
#User without OPERATOR or MANAGER role should not be allowed
with self.assertRaises(Unauthorized) as cm:
id = self.ssclient.create_interval_timer(start_time="now", event_origin="Interval_Timer_233", headers=actor_header)
self.assertIn( 'scheduler(create_interval_timer) has been denied',cm.exception.message)
#Remove the OPERATOR_ROLE from the user.
self.org_client.grant_role(self.ion_org._id, actor_id, MODERATOR_ROLE, headers=self.system_actor_header)
#Refresh headers with new role
actor_header = get_actor_header(actor_id)
#User with proper role should now be allowed to access this service operation.
id = self.ssclient.create_interval_timer(start_time="now", end_time="-1", event_origin="Interval_Timer_233", headers=actor_header)
@patch.dict(CFG, {'container':{'org_boundary':True}})
def test_policy_cache_reset(self):
before_policy_set = self.container.governance_controller.get_active_policies()
#First clear all of the policies to test that failures will be caught due to missing policies
self.container.governance_controller._clear_container_policy_caches()
empty_policy_set = self.container.governance_controller.get_active_policies()
self.assertEqual(len(empty_policy_set['service_access'].keys()), 0)
self.assertEqual(len(empty_policy_set['resource_access'].keys()), 0)
#With policies gone, an anonymous user should be able to create an object
test_org_id = self.org_client.create_org(org=IonObject(RT.Org, name='test_org1', description='A test Org'))
test_org = self.org_client.find_org(name='test_org1')
self.assertEqual(test_org._id, test_org_id)
#Trigger the event to reset the policy caches
self.sys_management.reset_policy_cache()
gevent.sleep(20) # Wait for events to be published and policy reloaded for all running processes
after_policy_set = self.container.governance_controller.get_active_policies()
#With policies refreshed, an anonymous user should NOT be able to create an object
with self.assertRaises(Unauthorized) as cm:
test_org_id = self.org_client.create_org(org=IonObject(RT.Org, name='test_org2', description='A test Org'))
self.assertIn( 'org_management(create_org) has been denied',cm.exception.message)
with self.assertRaises(NotFound) as cm:
test_org = self.org_client.find_org(name='test_org2')
self.assertEqual(len(before_policy_set.keys()), len(after_policy_set.keys()))
self.assertEqual(len(before_policy_set['service_access'].keys()), len(after_policy_set['service_access'].keys()))
self.assertEqual(len(before_policy_set['resource_access'].keys()), len(after_policy_set['resource_access'].keys()))
self.assertEqual(len(before_policy_set['service_operation'].keys()), len(after_policy_set['service_operation'].keys()))
#If the number of keys for service operations were equal, then check each set of operation precondition functions
for key in before_policy_set['service_operation']:
self.assertEqual(len(before_policy_set['service_operation'][key]), len(after_policy_set['service_operation'][key]))
@patch.dict(CFG, {'container':{'org_boundary':True}})
def test_org_boundary(self):
with self.assertRaises(NotFound) as nf:
org2 = self.org_client.find_org(ORG2)
self.assertIn('The Org with name Org 2 does not exist',nf.exception.message)
#Create a second Org
org2 = IonObject(RT.Org, name=ORG2, description='A second Org')
org2_id = self.org_client.create_org(org2, headers=self.system_actor_header)
org2 = self.org_client.find_org(ORG2)
self.assertEqual(org2_id, org2._id)
#First try to get a list of Users by hitting the RR anonymously - should be allowed.
actors,_ = self.rr_msg_client.find_resources(restype=RT.ActorIdentity)
self.assertEqual(len(actors),2) #Should include the ION System Actor, Web auth actor.
log.debug('Begin testing with policies')
#Create a new actor - should be denied for anonymous access
with self.assertRaises(Unauthorized) as cm:
actor_id, valid_until, registered = self.id_client.signon(USER1_CERTIFICATE, True, headers=self.anonymous_actor_headers)
self.assertIn( 'identity_management(signon) has been denied',cm.exception.message)
#now try creating a new actors with a valid actor
actor_id, valid_until, registered = self.id_client.signon(USER1_CERTIFICATE, True, headers=self.apache_actor_header)
log.info( "actor id=" + actor_id)
actor_header = get_actor_header(actor_id)
#First try to get a list of Users by hitting the RR anonymously - should be allowed.
actors,_ = self.rr_msg_client.find_resources(restype=RT.ActorIdentity)
self.assertEqual(len(actors),3) #Should include the ION System Actor and web auth actor as well.
#Now enroll the actor as a member of the Second Org
self.org_client.enroll_member(org2_id,actor_id, headers=self.system_actor_header)
actor_header = get_actor_header(actor_id)
#Add a new Org boundary policy which deny's all anonymous access
test_policy_id = self.pol_client.create_resource_access_policy( org2_id, 'Org_Test_Policy',
'Deny all access for anonymous actor',
TEST_BOUNDARY_POLICY_TEXT, headers=self.system_actor_header)
gevent.sleep(self.SLEEP_TIME) # Wait for events to be fired and policy updated
#Hack to force container into an Org Boundary for second Org
self.container.governance_controller._container_org_name = org2.org_governance_name
self.container.governance_controller._is_container_org_boundary = True
#First try to get a list of Users by hitting the RR anonymously - should be denied.
with self.assertRaises(Unauthorized) as cm:
actors,_ = self.rr_msg_client.find_resources(restype=RT.ActorIdentity, headers=self.anonymous_actor_headers)
self.assertIn( 'resource_registry(find_resources) has been denied',cm.exception.message)
#Now try to hit the RR with a real user and should now be allowed
actors,_ = self.rr_msg_client.find_resources(restype=RT.ActorIdentity, headers=actor_header)
self.assertEqual(len(actors),3) #Should include the ION System Actor and web auth actor as well.
#TODO - figure out how to right a XACML rule to be a member of the specific Org as well
#Hack to force container back to default values
self.container.governance_controller._container_org_name = 'ION'
self.container.governance_controller._is_container_org_boundary = False
self.container.governance_controller._container_org_id = None
self.pol_client.delete_policy(test_policy_id, headers=self.system_actor_header)
gevent.sleep(self.SLEEP_TIME) # Wait for events to be published and policy updated
def test_org_enroll_negotiation(self):
#Make sure that the system policies have been loaded
policy_list,_ = self.rr_client.find_resources(restype=RT.Policy)
self.assertNotEqual(len(policy_list),0,"The system policies have not been loaded into the Resource Registry")
with self.assertRaises(BadRequest) as cm:
myorg = self.org_client.read_org()
self.assertTrue(cm.exception.message == 'The org_id parameter is missing')
log.debug('Begin testing with policies')
#Create a new user - should be denied for anonymous access
with self.assertRaises(Unauthorized) as cm:
actor_id, valid_until, registered = self.id_client.signon(USER1_CERTIFICATE, True, headers=self.anonymous_actor_headers)
self.assertIn( 'identity_management(signon) has been denied',cm.exception.message)
#Now create user with proper credentials
actor_id, valid_until, registered = self.id_client.signon(USER1_CERTIFICATE, True, headers=self.apache_actor_header)
log.info( "actor id=" + actor_id)
#Build the message headers used with this user
actor_header = get_actor_header(actor_id)
#Get the associated user id
user_info = IonObject(RT.UserInfo, name='Test User')
actor_user_id = self.id_client.create_user_info(actor_id=actor_id, user_info=user_info, headers=actor_header)
#Attempt to enroll a user anonymously - should not be allowed
with self.assertRaises(Unauthorized) as cm:
self.org_client.enroll_member(self.ion_org._id,actor_id, headers=self.anonymous_actor_headers)
self.assertIn( 'org_management(enroll_member) has been denied',cm.exception.message)
#Attempt to let a user enroll themselves - should not be allowed
with self.assertRaises(Unauthorized) as cm:
self.org_client.enroll_member(self.ion_org._id,actor_id, headers=actor_header)
self.assertIn( 'org_management(enroll_member) has been denied',cm.exception.message)
#Attept to enroll the user in the ION Root org as a manager - should not be allowed since
#registration with the system implies membership in the ROOT Org.
with self.assertRaises(BadRequest) as cm:
self.org_client.enroll_member(self.ion_org._id,actor_id, headers=self.system_actor_header)
self.assertTrue(cm.exception.message == 'A request to enroll in the root ION Org is not allowed')
#Verify that anonymous user cannot find a list of enrolled users in an Org
with self.assertRaises(Unauthorized) as cm:
actors = self.org_client.list_enrolled_actors(self.ion_org._id, headers=self.anonymous_actor_headers)
self.assertIn('org_management(list_enrolled_actors) has been denied',cm.exception.message)
#Verify that a user without the proper Org Manager cannot find a list of enrolled users in an Org
with self.assertRaises(Unauthorized) as cm:
actors = self.org_client.list_enrolled_actors(self.ion_org._id, headers=actor_header)
self.assertIn( 'org_management(list_enrolled_actors) has been denied',cm.exception.message)
actors = self.org_client.list_enrolled_actors(self.ion_org._id, headers=self.system_actor_header)
self.assertEqual(len(actors),3) # WIll include the ION system actor
#Create a second Org
with self.assertRaises(NotFound) as nf:
org2 = self.org_client.find_org(ORG2)
self.assertIn('The Org with name Org 2 does not exist',nf.exception.message)
org2 = IonObject(RT.Org, name=ORG2, description='A second Org')
org2_id = self.org_client.create_org(org2, headers=self.system_actor_header)
org2 = self.org_client.find_org(ORG2)
self.assertEqual(org2_id, org2._id)
negotiations = self.org_client.find_org_negotiations(org2_id, headers=self.system_actor_header)
self.assertEqual(len(negotiations),0)
#Build the Service Agreement Proposal for enrollment request
sap = IonObject(OT.EnrollmentProposal,consumer=actor_id, provider=org2_id )
sap_response = self.org_client.negotiate(sap, headers=actor_header )
negotiations = self.org_client.find_org_negotiations(org2_id, headers=self.system_actor_header)
self.assertEqual(len(negotiations),1)
negotiations = self.org_client.find_user_negotiations(actor_id, org2_id, headers=actor_header)
self.assertEqual(len(negotiations),1)
#Build the Service Agreement Proposal for enrollment request
sap2 = IonObject(OT.EnrollmentProposal,consumer=actor_id, provider=org2_id )
#User tried proposing an enrollment again - this should fail
with self.assertRaises(BadRequest) as cm:
self.org_client.negotiate(sap2, headers=actor_header )
self.assertIn('A precondition for this request has not been satisfied: not is_enroll_negotiation_open',cm.exception.message)
#Manager trys to reject the proposal but incorrectly
negotiations = self.org_client.find_org_negotiations(org2_id, proposal_type=OT.EnrollmentProposal,
negotiation_status=NegotiationStatusEnum.OPEN, headers=self.system_actor_header)
sap_response = Negotiation.create_counter_proposal(negotiations[0], ProposalStatusEnum.REJECTED, ProposalOriginatorEnum.PROVIDER)
sap_response.sequence_num -= 1
#Should fail because the proposal sequence was not incremented
with self.assertRaises(Inconsistent) as cm:
self.org_client.negotiate(sap_response, headers=actor_header )
self.assertIn('The Service Agreement Proposal does not have the correct sequence_num value (0) for this negotiation (1)',cm.exception.message)
#Manager now trys to reject the proposal but with the correct proposal sequence
sap_response.sequence_num += 1
sap_response2 = self.org_client.negotiate(sap_response, headers=self.system_actor_header )
negotiations = self.org_client.find_org_negotiations(org2_id, headers=self.system_actor_header)
self.assertEqual(len(negotiations),1)
self.assertEqual(negotiations[0].negotiation_status, NegotiationStatusEnum.REJECTED)
gevent.sleep(self.SLEEP_TIME) # Wait for events to be published
#Check that there are the correct number of events
events_r = self.event_repo.find_events(origin=sap_response2.negotiation_id, event_type=OT.EnrollmentNegotiationStatusEvent)
self.assertEquals(len(events_r), 2)
self.assertEqual(events_r[-1][2].description, ProposalStatusEnum._str_map[ProposalStatusEnum.REJECTED])
#Create a new enrollment proposal
#Build the Service Agreement Proposal to enroll
sap = IonObject(OT.EnrollmentProposal,consumer=actor_id, provider=org2_id, description='Enrollment request for test user' )
sap_response = self.org_client.negotiate(sap, headers=actor_header )
negotiations = self.org_client.find_org_negotiations(org2_id, headers=self.system_actor_header)
self.assertEqual(len(negotiations),2)
negotiations = self.org_client.find_user_negotiations(actor_id, org2_id, headers=actor_header)
self.assertEqual(len(negotiations),2)
actors = self.org_client.list_enrolled_actors(org2_id, headers=self.system_actor_header)
self.assertEqual(len(actors),0)
#Check the get extended marine facility to check on the open and closed negotiations when called by normal user
ext_mf = self.obs_client.get_marine_facility_extension(org_id=org2_id,user_id=actor_user_id, headers=actor_header)
self.assertEqual(len(ext_mf.closed_requests), 0)
self.assertEqual(len(ext_mf.open_requests), 0)
#Check the get extended marine facility to check on the open and closed negotiations when called by privledged user
ext_mf = self.obs_client.get_marine_facility_extension(org_id=org2_id,user_id=self.system_actor._id, headers=self.system_actor_header)
self.assertEqual(len(ext_mf.closed_requests), 1)
self.assertEqual(len(ext_mf.open_requests), 1)
#Manager approves proposal
negotiations = self.org_client.find_org_negotiations(org2_id, proposal_type=OT.EnrollmentProposal,
negotiation_status=NegotiationStatusEnum.OPEN, headers=self.system_actor_header)
#Make sure the Negotiation object has the proper description set from the initial SAP
self.assertEqual(negotiations[0].description, sap.description)
sap_response = Negotiation.create_counter_proposal(negotiations[0], ProposalStatusEnum.ACCEPTED, ProposalOriginatorEnum.PROVIDER)
sap_response2 = self.org_client.negotiate(sap_response, headers=self.system_actor_header )
actors = self.org_client.list_enrolled_actors(org2_id, headers=self.system_actor_header)
self.assertEqual(len(actors),1)
#User tried requesting enrollment again - this should fail
with self.assertRaises(BadRequest) as cm:
sap = IonObject(OT.EnrollmentProposal,consumer=actor_id, provider=org2_id )
neg_id = self.org_client.negotiate(sap, headers=actor_header )
self.assertIn('A precondition for this request has not been satisfied: not is_enrolled',cm.exception.message)
#Check the get extended marine facility to check on the open and closed negotiations when called by normal user
ext_mf = self.obs_client.get_marine_facility_extension(org_id=org2_id,user_id=actor_user_id, headers=actor_header)
self.assertEqual(len(ext_mf.closed_requests), 0)
self.assertEqual(len(ext_mf.open_requests), 0)
#Check the get extended marine facility to check on the open and closed negotiations when called by privledged user
ext_mf = self.obs_client.get_marine_facility_extension(org_id=org2_id,user_id=self.system_actor._id, headers=self.system_actor_header)
self.assertEqual(len(ext_mf.closed_requests), 2)
self.assertEqual(len(ext_mf.open_requests), 0)
gevent.sleep(self.SLEEP_TIME) # Wait for events to be published
#Check that there are the correct number of events
events_r = self.event_repo.find_events(origin=sap_response2.negotiation_id, event_type=OT.EnrollmentNegotiationStatusEvent)
self.assertEquals(len(events_r), 4)
self.assertEqual(events_r[-1][2].description, ProposalStatusEnum._str_map[ProposalStatusEnum.GRANTED])
events_c = self.event_repo.find_events(origin=org2_id, event_type=OT.OrgMembershipGrantedEvent)
self.assertEquals(len(events_c), 1)
events_i = self.event_repo.find_events(origin=org2_id, event_type=OT.OrgNegotiationInitiatedEvent)
self.assertEquals(len(events_i), 2)
ret = self.org_client.is_enrolled(org_id=org2_id, actor_id=actor_id, headers=self.system_actor_header)
self.assertEquals(ret, True)
self.org_client.cancel_member_enrollment(org_id=org2_id, actor_id=actor_id, headers=self.system_actor_header)
ret = self.org_client.is_enrolled(org_id=org2_id, actor_id=actor_id, headers=self.system_actor_header)
self.assertEquals(ret, False)
def test_org_role_negotiation(self):
#Make sure that the system policies have been loaded
policy_list,_ = self.rr_client.find_resources(restype=RT.Policy)
self.assertNotEqual(len(policy_list),0,"The system policies have not been loaded into the Resource Registry")
with self.assertRaises(BadRequest) as cm:
myorg = self.org_client.read_org()
self.assertTrue(cm.exception.message == 'The org_id parameter is missing')
log.debug('Begin testing with policies')
#Create a new user - should be denied for anonymous access
with self.assertRaises(Unauthorized) as cm:
actor_id, valid_until, registered = self.id_client.signon(USER1_CERTIFICATE, True, headers=self.anonymous_actor_headers)
self.assertIn( 'identity_management(signon) has been denied',cm.exception.message)
#Now create user with proper credentials
actor_id, valid_until, registered = self.id_client.signon(USER1_CERTIFICATE, True, headers=self.apache_actor_header)
log.info( "actor id=" + actor_id)
#Build the message headers used with this user
actor_header = get_actor_header(actor_id)
actors = self.org_client.list_enrolled_actors(self.ion_org._id, headers=self.system_actor_header)
self.assertEqual(len(actors),3) # WIll include the ION system actor and the non user actor from setup
## test_org_roles and policies
roles = self.org_client.list_org_roles(self.ion_org._id)
self.assertEqual(len(roles),3)
self.assertItemsEqual([r.governance_name for r in roles], [MODERATOR_ROLE, MEMBER_ROLE, SUPERUSER_ROLE])
roles = self.org_client.list_enrolled_actors(self.ion_org._id, self.system_actor._id, headers=self.system_actor_header)
self.assertEqual(len(roles),3)
self.assertItemsEqual([r.governance_name for r in roles], [MEMBER_ROLE, MODERATOR_ROLE, SUPERUSER_ROLE])
roles = self.org_client.list_enrolled_actors(self.ion_org._id, actor_id, headers=self.system_actor_header)
self.assertEqual(len(roles),1)
self.assertItemsEqual([r.governance_name for r in roles], [MEMBER_ROLE])
#Create a second Org
with self.assertRaises(NotFound) as nf:
org2 = self.org_client.find_org(ORG2)
self.assertIn('The Org with name Org 2 does not exist',nf.exception.message)
org2 = IonObject(RT.Org, name=ORG2, description='A second Org')
org2_id = self.org_client.create_org(org2, headers=self.system_actor_header)
org2 = self.org_client.find_org(ORG2)
self.assertEqual(org2_id, org2._id)
roles = self.org_client.list_org_roles(org2_id)
self.assertEqual(len(roles),2)
self.assertItemsEqual([r.governance_name for r in roles], [MODERATOR_ROLE, MEMBER_ROLE])
#Create the Instrument Operator Role
operator_role = IonObject(RT.UserRole, governance_name=OPERATOR_ROLE,name='Instrument Operator', description='Instrument Operator')
#First try to add the user role anonymously
with self.assertRaises(Unauthorized) as cm:
self.org_client.add_org_role(org2_id, operator_role, headers=self.anonymous_actor_headers)
self.assertIn('org_management(add_org_role) has been denied',cm.exception.message)
self.org_client.add_org_role(org2_id, operator_role, headers=self.system_actor_header)
roles = self.org_client.list_org_roles(org2_id)
self.assertEqual(len(roles),3)
self.assertItemsEqual([r.governance_name for r in roles], [MODERATOR_ROLE, MEMBER_ROLE, OPERATOR_ROLE])
#Add the same role to the first Org as well
self.org_client.add_org_role(self.ion_org._id, operator_role, headers=self.system_actor_header)
# test proposals roles.
#First try to find user requests anonymously
with self.assertRaises(Unauthorized) as cm:
requests = self.org_client.find_org_negotiations(org2_id, headers=self.anonymous_actor_headers)
self.assertIn('org_management(find_org_negotiations) has been denied',cm.exception.message)
#Next try to find user requests as as a basic member
with self.assertRaises(Unauthorized) as cm:
requests = self.org_client.find_org_negotiations(org2_id, headers=actor_header)
self.assertIn('org_management(find_org_negotiations) has been denied',cm.exception.message)
#Should not be denied for user with Org Manager role or ION System manager role
requests = self.org_client.find_org_negotiations(org2_id, headers=self.system_actor_header)
self.assertEqual(len(requests),0)
#Build the Service Agreement Proposal for assigning a role to a user
sap = IonObject(OT.RequestRoleProposal,consumer=actor_id, provider=org2_id, role_name=OPERATOR_ROLE )
# First try to request a role anonymously
with self.assertRaises(Unauthorized) as cm:
sap_response = self.org_client.negotiate(sap, headers=self.anonymous_actor_headers)
self.assertIn('org_management(negotiate) has been denied',cm.exception.message)
# Next try to propose to assign a role without being a member
with self.assertRaises(BadRequest) as cm:
sap_response = self.org_client.negotiate(sap, headers=actor_header )
self.assertIn('A precondition for this request has not been satisfied: is_enrolled',cm.exception.message)
negotiations = self.org_client.find_org_negotiations(org2_id, headers=self.system_actor_header)
self.assertEqual(len(negotiations),0)
#Build the Service Agreement Proposal to enroll
sap = IonObject(OT.EnrollmentProposal,consumer=actor_id, provider=org2_id )
sap_response = self.org_client.negotiate(sap, headers=actor_header )
negotiations = self.org_client.find_org_negotiations(org2_id, headers=self.system_actor_header)
self.assertEqual(len(negotiations),1)
negotiations = self.org_client.find_user_negotiations(actor_id, org2_id, headers=actor_header)
self.assertEqual(len(negotiations),1)
actors = self.org_client.list_enrolled_actors(org2_id, headers=self.system_actor_header)
self.assertEqual(len(actors),0)
#Manager approves proposal
negotiations = self.org_client.find_org_negotiations(org2_id, proposal_type=OT.EnrollmentProposal,
negotiation_status=NegotiationStatusEnum.OPEN, headers=self.system_actor_header)
sap_response = Negotiation.create_counter_proposal(negotiations[0], ProposalStatusEnum.ACCEPTED, ProposalOriginatorEnum.PROVIDER)
sap_response2 = self.org_client.negotiate(sap_response, headers=self.system_actor_header )
actors = self.org_client.list_enrolled_actors(org2_id, headers=self.system_actor_header)
self.assertEqual(len(actors),1)
#Create a proposal to add a role to a user
sap = IonObject(OT.RequestRoleProposal,consumer=actor_id, provider=org2_id, role_name=OPERATOR_ROLE )
sap_response = self.org_client.negotiate(sap, headers=actor_header )
ret = self.org_client.has_role(org2_id, actor_id,OPERATOR_ROLE, headers=actor_header )
self.assertEqual(ret, False)
#Run through a series of differet finds to ensure the various parameter filters are working.
negotiations = self.org_client.find_org_negotiations(org2_id, headers=self.system_actor_header)
self.assertEqual(len(negotiations),2)
negotiations = self.org_client.find_org_negotiations(org2_id,negotiation_status=NegotiationStatusEnum.OPEN, headers=self.system_actor_header)
self.assertEqual(len(negotiations),1)
negotiations = self.org_client.find_user_negotiations(actor_id, org2_id, headers=actor_header)
self.assertEqual(len(negotiations),2)
negotiations = self.org_client.find_user_negotiations(actor_id, org2_id, proposal_type=OT.RequestRoleProposal, headers=actor_header)
self.assertEqual(len(negotiations),1)
negotiations = self.org_client.find_user_negotiations(actor_id, org2_id, negotiation_status=NegotiationStatusEnum.OPEN, headers=actor_header)
self.assertEqual(len(negotiations),1)
#Manager rejects the initial role proposal
negotiations = self.org_client.find_org_negotiations(org2_id, proposal_type=OT.RequestRoleProposal,
negotiation_status=NegotiationStatusEnum.OPEN, headers=self.system_actor_header)
sap_response = Negotiation.create_counter_proposal(negotiations[0], ProposalStatusEnum.REJECTED, ProposalOriginatorEnum.PROVIDER)
sap_response2 = self.org_client.negotiate(sap_response, headers=self.system_actor_header )
negotiations = self.org_client.find_org_negotiations(org2_id, headers=self.system_actor_header)
self.assertEqual(len(negotiations),2)
negotiations = self.org_client.find_org_negotiations(org2_id,negotiation_status=NegotiationStatusEnum.REJECTED, headers=self.system_actor_header)
self.assertEqual(len(negotiations),1)
self.assertEqual(negotiations[0].negotiation_status, NegotiationStatusEnum.REJECTED)
#Make sure the user still does not have the requested role
ret = self.org_client.has_role(org2_id, actor_id,OPERATOR_ROLE, headers=actor_header )
self.assertEqual(ret, False)
gevent.sleep(self.SLEEP_TIME) # Wait for events to be published
#Check that there are the correct number of events
events_r = self.event_repo.find_events(origin=sap_response2.negotiation_id, event_type=OT.RequestRoleNegotiationStatusEvent)
self.assertEquals(len(events_r), 2)
self.assertEqual(events_r[-1][2].description, ProposalStatusEnum._str_map[ProposalStatusEnum.REJECTED])
#Create a second proposal to add a role to a user
sap = IonObject(OT.RequestRoleProposal,consumer=actor_id, provider=org2_id, role_name=OPERATOR_ROLE )
sap_response = self.org_client.negotiate(sap, headers=actor_header )
negotiations = self.org_client.find_org_negotiations(org2_id, headers=self.system_actor_header)
self.assertEqual(len(negotiations),3)
closed_negotiations = self.org_client.find_org_closed_negotiations(org2_id, headers=self.system_actor_header)
self.assertEqual(len(closed_negotiations),2)
#Create an instrument resource
ia_list,_ = self.rr_client.find_resources(restype=RT.InstrumentAgent)
self.assertEqual(len(ia_list),0)
ia_obj = IonObject(RT.InstrumentAgent, name='Instrument Agent1', description='The first Instrument Agent')
#Intruments should not be able to be created by anoymous users
with self.assertRaises(Unauthorized) as cm:
self.ims_client.create_instrument_agent(ia_obj, headers=self.anonymous_actor_headers)
self.assertIn('instrument_management(create_instrument_agent) has been denied',cm.exception.message)
#Intruments should not be able to be created by users that are not Instrument Operators
with self.assertRaises(Unauthorized) as cm:
self.ims_client.create_instrument_agent(ia_obj, headers=actor_header)
self.assertIn('instrument_management(create_instrument_agent) has been denied',cm.exception.message)
#Manager approves proposal for role request
negotiations = self.org_client.find_org_negotiations(org2_id, proposal_type=OT.RequestRoleProposal,
negotiation_status=NegotiationStatusEnum.OPEN, headers=self.system_actor_header)
sap_response = Negotiation.create_counter_proposal(negotiations[0], ProposalStatusEnum.ACCEPTED, ProposalOriginatorEnum.PROVIDER)
sap_response2 = self.org_client.negotiate(sap_response, headers=self.system_actor_header )
#mke sure there are no more open negotiations
negotiations = self.org_client.find_user_negotiations(actor_id, org2_id, negotiation_status=NegotiationStatusEnum.OPEN, headers=actor_header)
self.assertEqual(len(negotiations),0)
#Verify the user has been assigned the requested role in the second Org
ret = self.org_client.has_role(org2_id, actor_id,OPERATOR_ROLE, headers=actor_header )
self.assertEqual(ret, True)
#Verify the user has only been assigned the requested role in the second Org and not in the first Org
ret = self.org_client.has_role(self.ion_org._id, actor_id,OPERATOR_ROLE, headers=actor_header )
self.assertEqual(ret, False)
#Refresh headers with new role
actor_header = get_actor_header(actor_id)
#now try to request the same role for the same user - should be denied
with self.assertRaises(BadRequest) as cm:
sap = IonObject(OT.RequestRoleProposal,consumer=actor_id, provider=org2_id, role_name=OPERATOR_ROLE )
sap_response = self.org_client.negotiate(sap, headers=actor_header )
self.assertIn('A precondition for this request has not been satisfied: not has_role',cm.exception.message)
#Now the user with the proper role should be able to create an instrument.
self.ims_client.create_instrument_agent(ia_obj, headers=actor_header)
gevent.sleep(self.SLEEP_TIME) # Wait for events to be published
#Check that there are the correct number of events
events_r = self.event_repo.find_events(origin=sap_response2.negotiation_id, event_type=OT.RequestRoleNegotiationStatusEvent)
self.assertEquals(len(events_r), 4)
self.assertEqual(events_r[-1][2].description, ProposalStatusEnum._str_map[ProposalStatusEnum.GRANTED])
self.assertEqual(events_r[-1][2].role_name, sap_response2.role_name)
events_c = self.event_repo.find_events(origin=org2_id, event_type=OT.UserRoleGrantedEvent)
self.assertEquals(len(events_c), 2)
events_i = self.event_repo.find_events(origin=org2_id, event_type=OT.OrgNegotiationInitiatedEvent)
self.assertEquals(len(events_i), 3)
def test_org_acquire_resource_negotiation(self):
#Make sure that the system policies have been loaded
policy_list,_ = self.rr_client.find_resources(restype=RT.Policy)
self.assertNotEqual(len(policy_list),0,"The system policies have not been loaded into the Resource Registry")
with self.assertRaises(BadRequest) as cm:
myorg = self.org_client.read_org()
self.assertTrue(cm.exception.message == 'The org_id parameter is missing')
log.debug('Begin testing with policies')
#Create a new user - should be denied for anonymous access
with self.assertRaises(Unauthorized) as cm:
actor_id, valid_until, registered = self.id_client.signon(USER1_CERTIFICATE, True, headers=self.anonymous_actor_headers)
self.assertIn( 'identity_management(signon) has been denied',cm.exception.message)
#Now create user with proper credentials
actor_id, valid_until, registered = self.id_client.signon(USER1_CERTIFICATE, True, headers=self.apache_actor_header)
log.info( "actor id=" + actor_id)
#Create a second Org
org2 = IonObject(RT.Org, name=ORG2, description='A second Org')
org2_id = self.org_client.create_org(org2, headers=self.system_actor_header)
org2 = self.org_client.find_org(ORG2)
self.assertEqual(org2_id, org2._id)
roles = self.org_client.list_org_roles(org2_id)
self.assertEqual(len(roles),2)
self.assertItemsEqual([r.governance_name for r in roles], [MODERATOR_ROLE, MEMBER_ROLE])
#Create the Instrument Operator Role
operator_role = IonObject(RT.UserRole, governance_name=OPERATOR_ROLE,name='Instrument Operator', description='Instrument Operator')
#And add it to all Orgs
self.org_client.add_org_role(self.ion_org._id, operator_role, headers=self.system_actor_header)
self.org_client.add_org_role(org2_id, operator_role, headers=self.system_actor_header)
#Add the OPERATOR_ROLE to the User for the ION Org
self.org_client.grant_role(self.ion_org._id, actor_id, OPERATOR_ROLE, headers=self.system_actor_header)
#Enroll the user in the second Org - do without Negotiation for test
self.org_client.enroll_member(org2_id, actor_id,headers=self.system_actor_header )
#Build the message headers used with this user
actor_header = get_actor_header(actor_id)
#Test the invitation process
#Create a invitation proposal to add a role to a user
sap = IonObject(OT.RequestRoleProposal,consumer=actor_id, provider=org2_id, role_name=OPERATOR_ROLE,
originator=ProposalOriginatorEnum.PROVIDER )
sap_response = self.org_client.negotiate(sap, headers=self.system_actor_header )
ret = self.org_client.has_role(org2_id, actor_id,OPERATOR_ROLE, headers=actor_header )
self.assertEqual(ret, False)
#User creates proposal to approve
negotiations = self.org_client.find_user_negotiations(actor_id, org2_id, proposal_type=OT.RequestRoleProposal,
negotiation_status=NegotiationStatusEnum.OPEN, headers=actor_header)
sap_response = Negotiation.create_counter_proposal(negotiations[0], ProposalStatusEnum.ACCEPTED)
sap_response2 = self.org_client.negotiate(sap_response, headers=actor_header )
#Verify the user has been assigned the requested role in the second Org
ret = self.org_client.has_role(org2_id, actor_id,OPERATOR_ROLE, headers=actor_header )
self.assertEqual(ret, True)
#Build the message headers used with this user
actor_header = get_actor_header(actor_id)
gevent.sleep(self.SLEEP_TIME) # Wait for events to be published
#Check that there are the correct number of events
events_r = self.event_repo.find_events(origin=sap_response2.negotiation_id, event_type=OT.RequestRoleNegotiationStatusEvent)
self.assertEquals(len(events_r), 4)
self.assertEqual(events_r[-1][2].description, ProposalStatusEnum._str_map[ProposalStatusEnum.GRANTED])
#Create the instrument agent with the user that has the proper role
ia_obj = IonObject(RT.InstrumentAgent, name='Instrument Agent1', description='The Instrument Agent')
self.ims_client.create_instrument_agent(ia_obj, headers=actor_header)
#Ensure the instrument agent has been created
ia_list,_ = self.rr_client.find_resources(restype=RT.InstrumentAgent)
self.assertEqual(len(ia_list),1)
self.assertEquals(ia_list[0].lcstate, LCS.DRAFT)
self.assertEquals(ia_list[0].availability, AS.PRIVATE)
#Advance the Life cycle to planned. Must be OPERATOR so anonymous user should fail
with self.assertRaises(Unauthorized) as cm:
self.ims_client.execute_instrument_agent_lifecycle(ia_list[0]._id, LCE.PLAN, headers=self.anonymous_actor_headers)
self.assertIn( 'instrument_management(execute_instrument_agent_lifecycle) has been denied',cm.exception.message)
#Advance the Life cycle to planned. Must be OPERATOR
self.ims_client.execute_instrument_agent_lifecycle(ia_list[0]._id, LCE.PLAN, headers=actor_header)
ia = self.rr_client.read(ia_list[0]._id)
self.assertEquals(ia.lcstate, LCS.PLANNED)
#First make a acquire resource request with an non-enrolled user.
with self.assertRaises(BadRequest) as cm:
sap = IonObject(OT.AcquireResourceProposal,consumer=self.system_actor._id, provider=org2_id, resource_id=ia_list[0]._id )
sap_response = self.org_client.negotiate(sap, headers=self.system_actor_header )
self.assertIn('A precondition for this request has not been satisfied: is_enrolled',cm.exception.message)
#Make a proposal to acquire a resource with an enrolled user that has the right role but the resource is not shared the Org
with self.assertRaises(BadRequest) as cm:
sap = IonObject(OT.AcquireResourceProposal,consumer=actor_id, provider=org2_id, resource_id=ia_list[0]._id)
sap_response = self.org_client.negotiate(sap, headers=actor_header )
self.assertIn('A precondition for this request has not been satisfied: is_resource_shared',cm.exception.message)
#So share the resource
self.org_client.share_resource(org_id=org2_id, resource_id=ia_list[0]._id, headers=self.system_actor_header )
#Verify the resource is shared
res_list,_ = self.rr_client.find_objects(org2,PRED.hasResource)
self.assertEqual(len(res_list), 1)
self.assertEqual(res_list[0]._id, ia_list[0]._id)
#First try to acquire the resource exclusively but it should fail since the user cannot do this without first
#having had acquired the resource
with self.assertRaises(BadRequest) as cm:
sap = IonObject(OT.AcquireResourceExclusiveProposal,consumer=actor_id, provider=org2_id, resource_id=ia_list[0]._id)
sap_response = self.org_client.negotiate(sap, headers=actor_header )
self.assertIn('A precondition for this request has not been satisfied: is_resource_acquired',cm.exception.message)
#Make a proposal to acquire a resource with an enrolled user that has the right role and is now shared
sap = IonObject(OT.AcquireResourceProposal,consumer=actor_id, provider=org2_id, resource_id=ia_list[0]._id)
sap_response = self.org_client.negotiate(sap, headers=actor_header )
negotiations = self.org_client.find_org_negotiations(org2_id, headers=self.system_actor_header)
self.assertEqual(len(negotiations),2)
negotiations = self.org_client.find_user_negotiations(actor_id, org2_id, headers=actor_header)
self.assertEqual(len(negotiations),2)
negotiations = self.org_client.find_user_negotiations(actor_id, org2_id, proposal_type=OT.AcquireResourceProposal, headers=actor_header)
self.assertEqual(len(negotiations),1)
negotiations = self.org_client.find_user_negotiations(actor_id, org2_id, negotiation_status=NegotiationStatusEnum.OPEN, headers=actor_header)
self.assertEqual(len(negotiations),1)
self.assertEqual(negotiations[0]._id, sap_response.negotiation_id)
#Manager Creates a counter proposal
negotiations = self.org_client.find_org_negotiations(org2_id, proposal_type=OT.AcquireResourceProposal,
negotiation_status=NegotiationStatusEnum.OPEN, headers=self.system_actor_header)
#Counter proposals for demonstration only
#Calculate one week from now in milliseconds
cur_time = int(get_ion_ts())
week_expiration = cur_time + ( 7 * 24 * 60 * 60 * 1000 )
sap_response = Negotiation.create_counter_proposal(negotiations[0], originator=ProposalOriginatorEnum.PROVIDER)
sap_response.expiration = str(week_expiration)
sap_response2 = self.org_client.negotiate(sap_response, headers=self.system_actor_header )
#User Creates a counter proposal
negotiations = self.org_client.find_user_negotiations(actor_id, org2_id, proposal_type=OT.AcquireResourceProposal,
negotiation_status=NegotiationStatusEnum.OPEN, headers=actor_header)
cur_time = int(get_ion_ts())
month_expiration = cur_time + ( 30 * 24 * 60 * 60 * 1000 )
sap_response = Negotiation.create_counter_proposal(negotiations[0])
sap_response.expiration = str(month_expiration)
sap_response2 = self.org_client.negotiate(sap_response, headers=self.system_actor_header )
gevent.sleep(self.SLEEP_TIME+1) # Wait for events to be published
#Check that there are the correct number of events
events_r = self.event_repo.find_events(origin=sap_response2.negotiation_id, event_type=OT.AcquireResourceNegotiationStatusEvent)
self.assertEquals(len(events_r), 3)
self.assertEqual(events_r[-1][2].description, ProposalStatusEnum._str_map[ProposalStatusEnum.COUNTER])
self.assertEqual(events_r[-1][2].resource_id, ia_list[0]._id)
#Manager approves Instrument resource proposal
negotiations = self.org_client.find_org_negotiations(org2_id, proposal_type=OT.AcquireResourceProposal,
negotiation_status=NegotiationStatusEnum.OPEN, headers=self.system_actor_header)
sap_response = Negotiation.create_counter_proposal(negotiations[0], ProposalStatusEnum.ACCEPTED, ProposalOriginatorEnum.PROVIDER)
sap_response2 = self.org_client.negotiate(sap_response, headers=self.system_actor_header )
negotiations = self.org_client.find_user_negotiations(actor_id, org2_id, negotiation_status=NegotiationStatusEnum.OPEN, headers=actor_header)
self.assertEqual(len(negotiations),0) #Should be no more open negotiations for a user because auto-accept is enabled
#The following are no longer needed with auto-accept enabled for acquiring a resource
'''
self.assertEqual(len(negotiations),1)
#User accepts proposal in return
negotiations = self.org_client.find_user_negotiations(actor_id, org2_id, proposal_type=OT.AcquireResourceProposal,
negotiation_status=NegotiationStatusEnum.OPEN, headers=actor_header)
sap_response = Negotiation.create_counter_proposal(negotiations[0], ProposalStatusEnum.ACCEPTED)
sap_response2 = self.org_client.negotiate(sap_response, headers=actor_header )
'''
negotiations = self.org_client.find_user_negotiations(actor_id, org2_id, negotiation_status=NegotiationStatusEnum.OPEN, headers=actor_header)
self.assertEqual(len(negotiations),0)
#Check commitment to be active
commitments, _ = self.rr_client.find_objects(ia_list[0]._id,PRED.hasCommitment, RT.Commitment)
self.assertEqual(len(commitments),1)
resource_commitment, _ = self.rr_client.find_objects(actor_id,PRED.hasCommitment, RT.Commitment)
self.assertEqual(len(resource_commitment),1)
self.assertNotEqual(resource_commitment[0].lcstate, LCS.DELETED)
subjects, _ = self.rr_client.find_subjects(None,PRED.hasCommitment, commitments[0]._id)
self.assertEqual(len(subjects),3)
contracts, _ = self.rr_client.find_subjects(RT.Negotiation,PRED.hasContract, commitments[0]._id)
self.assertEqual(len(contracts),1)
cur_time = int(get_ion_ts())
invalid_expiration = cur_time + ( 13 * 60 * 60 * 1000 ) # 12 hours from now
#Now try to acquire the resource exclusively for longer than 12 hours
sap = IonObject(OT.AcquireResourceExclusiveProposal,consumer=actor_id, provider=org2_id, resource_id=ia_list[0]._id,
expiration=str(invalid_expiration))
sap_response = self.org_client.negotiate(sap, headers=actor_header )
#make sure the negotiation was rejected for being too long.
negotiation = self.rr_client.read(sap_response.negotiation_id)
self.assertEqual(negotiation.negotiation_status, NegotiationStatusEnum.REJECTED)
#Now try to acquire the resource exclusively for 20 minutes
cur_time = int(get_ion_ts())
valid_expiration = cur_time + ( 20 * 60 * 1000 ) # 12 hours from now
sap = IonObject(OT.AcquireResourceExclusiveProposal,consumer=actor_id, provider=org2_id, resource_id=ia_list[0]._id,
expiration=str(valid_expiration))
sap_response = self.org_client.negotiate(sap, headers=actor_header )
#Check commitment to be active
commitments, _ = self.rr_client.find_objects(ia_list[0]._id,PRED.hasCommitment, RT.Commitment)
self.assertEqual(len(commitments),2)
exclusive_contract, _ = self.rr_client.find_objects(sap_response.negotiation_id,PRED.hasContract, RT.Commitment)
self.assertEqual(len(contracts),1)
#Now try to acquire the resource exclusively again - should fail
with self.assertRaises(BadRequest) as cm:
sap = IonObject(OT.AcquireResourceExclusiveProposal,consumer=actor_id, provider=org2_id, resource_id=ia_list[0]._id)
sap_response = self.org_client.negotiate(sap, headers=actor_header )
self.assertIn('A precondition for this request has not been satisfied: not is_resource_acquired_exclusively',cm.exception.message)
#Release the exclusive commitment to the resource
self.org_client.release_commitment(exclusive_contract[0]._id, headers=actor_header)
#Check exclusive commitment to be inactive
commitments, _ = self.rr_client.find_resources(restype=RT.Commitment, lcstate=LCS.DELETED)
self.assertEqual(len(commitments),1)
self.assertEqual(commitments[0].commitment.exclusive, True)
#Shared commitment is still actove
commitments, _ = self.rr_client.find_objects(ia_list[0],PRED.hasCommitment, RT.Commitment)
self.assertEqual(len(commitments),1)
self.assertNotEqual(commitments[0].lcstate, LCS.DELETED)
#Now release the shared commitment
self.org_client.release_commitment(resource_commitment[0]._id, headers=actor_header)
#Check for both commitments to be inactive
commitments, _ = self.rr_client.find_resources(restype=RT.Commitment, lcstate=LCS.DELETED)
self.assertEqual(len(commitments),2)
commitments, _ = self.rr_client.find_objects(ia_list[0],PRED.hasCommitment, RT.Commitment)
self.assertEqual(len(commitments),0)
#Now check some negative cases...
#Attempt to acquire the same resource from the ION Org which is not sharing it - should fail
with self.assertRaises(BadRequest) as cm:
sap = IonObject(OT.AcquireResourceProposal,consumer=actor_id, provider=self.ion_org._id, resource_id=ia_list[0]._id)
sap_response = self.org_client.negotiate(sap, headers=actor_header )
self.assertIn('A precondition for this request has not been satisfied: is_resource_shared',cm.exception.message)
#Remove the OPERATOR_ROLE from the user.
self.org_client.revoke_role(org2_id, actor_id, OPERATOR_ROLE, headers=self.system_actor_header)
#Refresh headers with new role
actor_header = get_actor_header(actor_id)
#Make a proposal to acquire a resource with an enrolled user that does not have the right role
with self.assertRaises(BadRequest) as cm:
sap = IonObject(OT.AcquireResourceProposal,consumer=actor_id, provider=org2_id, resource_id=ia_list[0]._id )
sap_response = self.org_client.negotiate(sap, headers=actor_header )
self.assertIn('A precondition for this request has not been satisfied: has_role',cm.exception.message)
gevent.sleep(self.SLEEP_TIME+1) # Wait for events to be published
#Check that there are the correct number of events
events_r = self.event_repo.find_events(origin=sap_response2.negotiation_id, event_type=OT.AcquireResourceNegotiationStatusEvent)
self.assertEquals(len(events_r), 6)
self.assertEqual(events_r[-1][2].description, ProposalStatusEnum._str_map[ProposalStatusEnum.GRANTED])
self.assertEqual(events_r[-1][2].resource_id, ia_list[0]._id)
events_c = self.event_repo.find_events(origin=org2_id, event_type=OT.ResourceCommitmentCreatedEvent)
self.assertEquals(len(events_c), 2)
events_i = self.event_repo.find_events(origin=org2_id, event_type=OT.OrgNegotiationInitiatedEvent)
self.assertEquals(len(events_i), 4)
ret = self.org_client.is_resource_shared(org_id=org2_id, resource_id=ia_list[0]._id, headers=self.system_actor_header )
self.assertEquals(ret, True)
#So unshare the resource
self.org_client.unshare_resource(org_id=org2_id, resource_id=ia_list[0]._id, headers=self.system_actor_header )
ret = self.org_client.is_resource_shared(org_id=org2_id, resource_id=ia_list[0]._id, headers=self.system_actor_header )
self.assertEquals(ret, False)
| bsd-2-clause | 6,302,384,183,825,388,000 | 51.039851 | 205 | 0.675876 | false |
stephenlienharrell/roster-dns-management | test/dnsrmacl_test.py | 1 | 8124 | #!/usr/bin/python
# Copyright (c) 2009, Purdue University
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
#
# Redistributions in binary form must reproduce the above copyright notice, this
# list of conditions and the following disclaimer in the documentation and/or
# other materials provided with the distribution.
#
# Neither the name of the Purdue University nor the names of its contributors
# may be used to endorse or promote products derived from this software without
# specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""Regression test for dnsrmacl
Make sure you are running this against a database that can be destroyed.
DO NOT EVER RUN THIS TEST AGAINST A PRODUCTION DATABASE.
"""
__copyright__ = 'Copyright (C) 2009, Purdue University'
__license__ = 'BSD'
__version__ = '#TRUNK#'
import os
import sys
import socket
import threading
import time
import getpass
import unittest
import roster_core
import roster_server
from roster_user_tools import roster_client_lib
USER_CONFIG = 'test_data/roster_user_tools.conf'
CONFIG_FILE = 'test_data/roster.conf' # Example in test_data
SCHEMA_FILE = '../roster-core/data/database_schema.sql'
DATA_FILE = 'test_data/test_data.sql'
HOST = u'localhost'
USERNAME = u'sharrell'
PASSWORD = u'test'
KEYFILE=('test_data/dnsmgmt.key.pem')
CERTFILE=('test_data/dnsmgmt.cert.pem')
CREDFILE='%s/.dnscred' % os.getcwd()
EXEC='../roster-user-tools/scripts/dnsrmacl'
class options(object):
password = u'test'
username = u'sharrell'
server = None
ldap = u'ldaps://ldap.cs.university.edu:636'
credfile = CREDFILE
view_name = None
ip_address = None
target = u'machine1'
ttl = 64
class DaemonThread(threading.Thread):
def __init__(self, config_instance, port):
threading.Thread.__init__(self)
self.config_instance = config_instance
self.port = port
self.daemon_instance = None
def run(self):
self.daemon_instance = roster_server.Server(self.config_instance, KEYFILE,
CERTFILE)
self.daemon_instance.Serve(port=self.port)
class Testdnsrmacl(unittest.TestCase):
def setUp(self):
def PickUnusedPort():
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((HOST, 0))
addr, port = s.getsockname()
s.close()
return port
self.config_instance = roster_core.Config(file_name=CONFIG_FILE)
db_instance = self.config_instance.GetDb()
db_instance.CreateRosterDatabase()
data = open(DATA_FILE, 'r').read()
db_instance.StartTransaction()
db_instance.cursor.execute(data)
db_instance.EndTransaction()
db_instance.close()
self.port = PickUnusedPort()
self.server_name = 'https://%s:%s' % (HOST, self.port)
self.daemon_thread = DaemonThread(self.config_instance, self.port)
self.daemon_thread.daemon = True
self.daemon_thread.start()
self.core_instance = roster_core.Core(USERNAME, self.config_instance)
self.password = 'test'
time.sleep(1)
roster_client_lib.GetCredentials(USERNAME, u'test', credfile=CREDFILE,
server_name=self.server_name)
def tearDown(self):
if( os.path.exists(CREDFILE) ):
os.remove(CREDFILE)
def testRemoveAcl(self):
self.core_instance.MakeACL(u'acl1', u'192.168.1.0/24')
self.assertEqual(self.core_instance.ListACLs(),
{u'acl1': [{'cidr_block': u'192.168.1.0/24'}],
u'any': [{'cidr_block': None}]})
command = os.popen('python %s --force -a acl1 -u %s -p %s --config-file %s '
'-s %s -c %s' % (
EXEC, USERNAME, self.password, USER_CONFIG, self.server_name, CREDFILE))
self.assertEqual(command.read(),
'REMOVED ACL: acl: acl1\n')
command.close()
self.assertEqual(self.core_instance.ListACLs(),
{u'any': [{'cidr_block': None}]})
def testRemoveCIDRFromAcl(self):
self.core_instance.MakeACL(u'acl1', u'192.168.1.0/24')
self.core_instance.MakeACL(u'acl1', u'192.168.2.0/24')
self.assertEqual(self.core_instance.ListACLs(),
{u'acl1': [{'cidr_block': u'192.168.1.0/24'},
{'cidr_block': u'192.168.2.0/24'}],
u'any': [{'cidr_block': None}]})
command = os.popen('python %s -a acl1 --cidr-block 192.168.2.0/24 '
'-u %s -p %s --config-file %s -s %s -c %s' % (
EXEC, USERNAME, self.password, USER_CONFIG, self.server_name, CREDFILE))
self.assertEqual(command.read(),
'REMOVED ACL: acl: acl1 cidr_block: 192.168.2.0/24\n')
self.assertEqual(self.core_instance.ListACLs(),
{u'acl1': [{'cidr_block': u'192.168.1.0/24'}],
u'any': [{'cidr_block': None}]})
command = os.popen('python %s -a acl1 --cidr-block 192.168.1.0/24 '
'-u %s -p %s --config-file %s -s %s -c %s' % (
EXEC, USERNAME, self.password, USER_CONFIG, self.server_name, CREDFILE))
self.assertEqual(command.read(),
'REMOVED ACL: acl: acl1 cidr_block: 192.168.1.0/24\n')
self.assertEqual(self.core_instance.ListACLs(),
{u'any': [{'cidr_block': None}]})
self.core_instance.MakeACL(u'acl1', u'192.168.1.0/24')
self.core_instance.MakeACL(u'acl1', u'192.168.2.0/24')
command = os.popen('python %s -a acl1 --cidr-block 192.168.2.0/24 '
'-u %s -p %s --config-file %s -s %s -c %s' % (
EXEC, USERNAME, self.password, USER_CONFIG, self.server_name, CREDFILE))
self.assertEqual(command.read(),
'REMOVED ACL: acl: acl1 cidr_block: 192.168.2.0/24\n')
command = os.popen('python %s -a acl1 --cidr-block 192.168.1.0/24 '
'-u %s -p %s --config-file %s -s %s -c %s' % (
EXEC, USERNAME, self.password, USER_CONFIG, self.server_name, CREDFILE))
self.assertEqual(command.read(),
'REMOVED ACL: acl: acl1 cidr_block: 192.168.1.0/24\n')
self.assertEqual(self.core_instance.ListACLs(),
{u'any': [{'cidr_block': None}]})
def testErrors(self):
command = os.popen('python %s -a acl1 --cidr-block 192.168.2.0/24 '
'-u %s -p %s --config-file %s -s %s -c %s' % (
EXEC, USERNAME, self.password, USER_CONFIG, self.server_name, CREDFILE))
self.assertEqual(command.read(),
'CLIENT ERROR: No acl found with acl: acl1 cidr_block: 192.168.2.0/24'
'\n')
command = os.popen('python %s -u %s -p %s --config-file %s '
'--force -s %s -c %s' % (
EXEC, USERNAME, self.password, USER_CONFIG,
self.server_name, CREDFILE))
self.assertEqual(command.read(),
"CLIENT ERROR: The -a/--acl flag is required.\n")
command.close()
command = os.popen('python %s --acl acl1 -u %s -p %s --config-file %s '
'-s %s -c %s' % (
EXEC, USERNAME, self.password, USER_CONFIG,
self.server_name, CREDFILE))
self.assertEqual(command.read(),
"CLIENT ERROR: Must use --force to delete entire ACL.\n")
command.close()
if( __name__ == '__main__' ):
unittest.main()
| bsd-3-clause | -5,292,346,615,663,352,000 | 39.217822 | 80 | 0.64094 | false |
Camiloasc1/AstronomyUNAL | CelestialMechanics/orbits/test/test_ellipse.py | 1 | 4276 | import unittest
from astropy import constants as astroconst
from astropy import units as u
from astropy.time import Time
from CelestialMechanics.kepler import constants
from CelestialMechanics.orbits import ellipse
from CelestialMechanics.orbits.ellipse import delta_t_t0_aeangle
class MyTestCase(unittest.TestCase):
def test_ellipse(self):
r = ellipse.r(1.5236164, 0.0932802, 32.)
self.assertAlmostEqual(1.3996391, r, places=7)
a, e = ellipse.ae(0.275, 1.168)
self.assertAlmostEqual(0.722, a, places=3)
self.assertAlmostEqual(0.618, e, places=2)
sun = astroconst.M_sun
mercury = astroconst.M_sun / constants.Mercury
energy = ellipse.E((0.38709 * u.au).to(u.m), sun, mercury)
self.assertAlmostEqual(-3.817E32, energy.value, delta=1E32)
# 4.14
a = 17.8 * u.au
e = 0.967
q, Q = ellipse.qQ(a, e)
self.assertAlmostEqual(0.031478, ellipse.v_sun(q, a, 0).value, places=5)
self.assertAlmostEqual(0.000528, ellipse.v_sun(Q, a, 0).value, places=5)
self.assertAlmostEqual(54.50, ellipse.v_sun(q, a, 0).to(u.km / u.s).value, places=2)
self.assertAlmostEqual(0.91, ellipse.v_sun(Q, a, 0).to(u.km / u.s).value, places=2)
vq, vQ = ellipse.vqQ_sun(a, e, 0)
self.assertAlmostEqual(0.031478, vq.value, places=2)
self.assertAlmostEqual(0.000528, vQ.value, places=2)
self.assertAlmostEqual(54.50, vq.to(u.km / u.s).value, places=2)
self.assertAlmostEqual(0.91, vQ.to(u.km / u.s).value, places=2)
# 4.15
a = astroconst.R_earth + 560 * u.km
self.assertAlmostEqual(7569.5, ellipse.v(a, a, astroconst.M_earth, 0).value, delta=20)
def test_chapter_5(self):
from CelestialMechanics.mu import mu_sun
# 5.5
t0 = Time('2014-01-03T00:00:00Z', format='isot', scale='utc').jd * u.d + 0.633 * u.d
t1 = Time('2014-04-03T00:00:00Z', format='isot', scale='utc').jd * u.d + 0.9 * u.d
t2 = Time('2014-10-05T00:00:00Z', format='isot', scale='utc').jd * u.d + 0.5 * u.d
a = 1 * u.au
e = 0.01669
r = 1 * u.au
mu = mu_sun(1 / constants.Earth_Moon)
angles = ellipse.angles(a, e, r)
self.assertAlmostEqual(90.9563109612867, angles[0].value)
self.assertAlmostEqual(269.0436890387133, angles[1].value)
delta_t_t0 = delta_t_t0_aeangle(a, e, angles[0], mu) % (1 * u.yr).to(u.d) # module 1 year
self.assertAlmostEqual((t1 - t0).value, delta_t_t0.value, delta=0.1)
delta_t_t0 = delta_t_t0_aeangle(a, e, angles[1], mu) % (1 * u.yr).to(u.d) # module 1 year
self.assertAlmostEqual((t2 - t0).value, delta_t_t0.value, delta=0.1)
# 5.6
a = 17.834144 * u.au
e = 0.967143
angle = 60 * u.deg
mu = mu_sun(0)
delta_t_t0 = delta_t_t0_aeangle(a, e, angle, mu)
self.assertAlmostEqual(23.7573, delta_t_t0.value, places=2)
# 5.7
t0 = Time('2003-10-23T05:57:10Z', format='isot', scale='utc').jd * u.d
t1 = Time('2007-06-20T00:00:00Z', format='isot', scale='utc').jd * u.d
a = 2.56743 * u.au
e = 0.75355
r = 2.325364 * u.au
mu = mu_sun(0)
angles = ellipse.angles(a, e, r)
self.assertAlmostEqual(360 - 226.064389, angles[0].value, places=5)
self.assertAlmostEqual(226.064389, angles[1].value, places=5)
angle = angles[1] # r. < 0
# inlined ellipse.delta_t_t0_aeangle()
E = ellipse.E_angle(e, angle)
M = ellipse.angle_M_eE(e, E)
from CelestialMechanics.kepler.kepler3 import T_sun
T = T_sun(a, 0) # 1 year (of the minor planet)
delta_t_t0 = ellipse.delta_t_t0_Mn(M, ellipse.n(a, mu)) % T # module 1 year (of the minor planet)
self.assertAlmostEqual(277.187625, E.to(u.deg).value % 360, places=6)
self.assertAlmostEqual(320.023578, M.to(u.deg).value % 360, places=6)
self.assertAlmostEqual(((t1 - t0) % T).value, delta_t_t0.value, places=4)
t0_calculated = t1 - delta_t_t0
# print(Time(t0_calculated, format='jd', scale='utc').isot)
self.assertAlmostEqual(t0.value, t0_calculated.value, places=4)
if __name__ == '__main__':
unittest.main()
| mit | -1,451,791,043,087,483,000 | 40.115385 | 106 | 0.600094 | false |
erangre/Dioptas | dioptas/model/util/PeakShapes.py | 1 | 1278 | # -*- coding: utf-8 -*-
# Dioptas - GUI program for fast processing of 2D X-ray diffraction data
# Principal author: Clemens Prescher ([email protected])
# Copyright (C) 2014-2019 GSECARS, University of Chicago, USA
# Copyright (C) 2015-2018 Institute for Geology and Mineralogy, University of Cologne, Germany
# Copyright (C) 2019 DESY, Hamburg, Germany
#
# 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 numpy as np
s2pi = np.sqrt(2 * np.pi)
def gaussian(x, amplitude=1.0, center=0.0, sigma=1.0):
"""1 dimensional gaussian:
gaussian(x, amplitude, center, sigma)
"""
return (amplitude / (s2pi * sigma)) * np.exp(-(1.0 * x - center) ** 2 / (2 * sigma ** 2))
| gpl-3.0 | -9,125,827,370,369,577,000 | 43.068966 | 94 | 0.723005 | false |
scaramallion/pynetdicom3 | setup.py | 1 | 1741 | from setuptools import setup, find_packages
import os
import sys
# Version
BASE_DIR = os.path.dirname(os.path.realpath(__file__))
VERSION_FILE = os.path.join(BASE_DIR, 'pynetdicom', '_version.py')
with open(VERSION_FILE) as fp:
exec(fp.read())
with open("README.rst", "r") as fp:
long_description = fp.read()
setup(
name = "pynetdicom",
packages = find_packages(),
include_package_data = True,
version = __version__,
zip_safe = False,
description = "A Python implementation of the DICOM networking protocol",
long_description = long_description,
long_description_content_type="text/x-rst",
author = "",
author_email = "[email protected]",
url = "https://github.com/pydicom/pynetdicom",
license = "MIT",
keywords = (
"dicom python medicalimaging radiotherapy oncology pydicom imaging"
),
project_urls={
'Documentation' : 'https://pydicom.github.io/pynetdicom/'
},
classifiers = [
"License :: OSI Approved :: MIT License",
"Intended Audience :: Developers",
"Intended Audience :: Healthcare Industry",
"Intended Audience :: Science/Research",
#"Development Status :: 4 - Beta",
"Development Status :: 5 - Production/Stable",
"Natural Language :: English",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Operating System :: OS Independent",
"Topic :: Scientific/Engineering :: Medical Science Apps.",
"Topic :: Software Development :: Libraries",
],
install_requires = ["pydicom>=2.0.0"],
)
| mit | 3,179,822,450,583,220,700 | 33.82 | 77 | 0.628374 | false |
qtproject/qt3d | tools/utils/exporters/blender/qt3d_armature_export.py | 2 | 5606 | #############################################################################
##
## Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB).
## Contact: https://www.qt.io/licensing/
##
## This file is part of the Qt3D module of the Qt Toolkit.
##
## $QT_BEGIN_LICENSE:LGPL$
## Commercial License Usage
## Licensees holding valid commercial Qt licenses may use this file in
## accordance with the commercial license agreement provided with the
## Software or, alternatively, in accordance with the terms contained in
## a written agreement between you and The Qt Company. For licensing terms
## and conditions see https://www.qt.io/terms-conditions. For further
## information use the contact form at https://www.qt.io/contact-us.
##
## GNU Lesser General Public License Usage
## Alternatively, this file may be used under the terms of the GNU Lesser
## General Public License version 3 as published by the Free Software
## Foundation and appearing in the file LICENSE.LGPL3 included in the
## packaging of this file. Please review the following information to
## ensure the GNU Lesser General Public License version 3 requirements
## will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
##
## GNU General Public License Usage
## Alternatively, this file may be used under the terms of the GNU
## General Public License version 2.0 or (at your option) the GNU General
## Public license version 3 or any later version approved by the KDE Free
## Qt Foundation. The licenses are as published by the Free Software
## Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
## included in the packaging of this file. Please review the following
## information to ensure the GNU General Public License requirements will
## be met: https://www.gnu.org/licenses/gpl-2.0.html and
## https://www.gnu.org/licenses/gpl-3.0.html.
##
## $QT_END_LICENSE$
##
#############################################################################
# Required Blender information.
bl_info = {
"name": "Qt3D Armature Exporter",
"author": "Sean Harmer <[email protected]>, Robert Brock <[email protected]>",
"version": (0, 2),
"blender": (2, 80, 0),
"location": "File > Export > Qt3D Armature Exporter (.json)",
"description": "Export Armature to json to use with Qt3D",
"warning": "",
"wiki_url": "",
"tracker_url": "",
"category": "Import-Export"
}
import bpy
import os
import struct
import mathutils
import math
import json
from array import array
from bpy import context
from bpy_extras.io_utils import ExportHelper
from bpy.props import (
BoolProperty,
FloatProperty,
StringProperty,
EnumProperty,
)
from collections import defaultdict
def jsonBuilder():
bonesList = []
name = ""
boneParent = ""
ob = bpy.context.object.data
if not hasattr(ob, 'bones'):
return bonesList
for bone in ob.bones:
#check parent exists
if bone.parent:
boneParent = bone.parent.name
else:
boneParent = ""
#add the bones
bonesList.append({"bone": bone.name,
"parent": boneParent,
"matrix": jsonMatrix(bone)
})
return bonesList
def jsonMatrix(bone):
matrix = []
for i in range(0, 4):
matrix.append(str("%.4f, %.4f, %.4f, %.4f" % (bone.matrix_local[i][0],
bone.matrix_local[i][1],
bone.matrix_local[i][2],
bone.matrix_local[i][3])))
return matrix
class Qt3DMeshDataConverter:
def boneInfoToJson(self):
# Pass 1 - collect data we need to produce the output in pass 2
print(">>> About to enter Objects")
jsonData = json.dumps({ "bones": jsonBuilder()}, indent=2, sort_keys=True, separators=(',', ': '))
return jsonData
class Qt3DArmatureExporter(bpy.types.Operator, ExportHelper):
"""Qt3D Exporter"""
bl_idname = "export_scene.qt3d_armature_exporter";
bl_label = "Qt3DArmatureExporter";
bl_options = {'PRESET'};
filename_ext = ""
use_filter_folder = True
def __init__(self):
pass
def execute(self, context):
print("In Execute" + bpy.context.scene.name)
self.userpath = self.properties.filepath
# unselect all
bpy.ops.object.select_all(action='DESELECT')
converter = Qt3DMeshDataConverter()
fileContent = converter.boneInfoToJson()
with open(self.userpath + ".json", '+w') as f:
f.write(fileContent)
return {'FINISHED'}
def createBlenderMenu(self, context):
self.layout.operator(Qt3DArmatureExporter.bl_idname, text="Qt3D Armature Export(.json)")
# Register against Blender
def register():
bpy.utils.register_class(Qt3DArmatureExporter)
if bpy.app.version < (2, 80, 0):
bpy.types.INFO_MT_file_export.append(createBlenderMenu)
else:
bpy.types.TOPBAR_MT_file_export.append(createBlenderMenu)
def unregister():
bpy.utils.unregister_class(Qt3DArmatureExporter)
if bpy.app.version < (2, 80, 0):
bpy.types.INFO_MT_file_export.remove(createBlenderMenu)
else:
bpy.types.TOPBAR_MT_file_export.remove(createBlenderMenu)
# Handle running the script from Blender's text editor.
if (__name__ == "__main__"):
register();
bpy.ops.export_scene.qt3d_Armature_exporter();
| lgpl-3.0 | 1,695,850,950,272,810,000 | 32.568862 | 106 | 0.620407 | false |
aroig/metadata-readers | libs/docmeta/utils.py | 1 | 2250 | #!/usr/bin/env python2
# -*- coding: utf-8 -*-
#
# docmeta - A python module to extract metadata from document files
# Copyright 2012 Abdó Roig-Maranges <[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 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
import sys
import subprocess
class CommandError(Exception):
"""Conversion error"""
def __init__(self, desc, cmdlist, retlist, stderrlist):
Exception.__init__(self, desc)
self.desc = desc
self.cmdlist = cmdlist
self.retlist = retlist
self.stderrlist = stderrlist
print("Command Error !!!")
print(" cmd: %s" % ' | '.join([' '.join(c) for c in self.cmdlist]))
print(" ret: %s" % str(self.retlist))
print(" stderr: %s" % str(self.stderrlist))
def executepipe(cmdlst, outfile=None, checkreturn=True):
N = len(cmdlst)
p = []
for n in range(0,N):
cmd = cmdlst[n]
if n == 0: sin = None
else: sin = plast.stdout
if n < N-1:
sout = subprocess.PIPE
else:
if outfile != None: sout = open(outfile, 'w')
else: sout = subprocess.PIPE
serr = subprocess.PIPE
plast = subprocess.Popen(cmd, stdout=sout, stderr=serr, stdin=sin)
p.append(plast)
ret,err = plast.communicate()
if checkreturn and plast.returncode != 0:
raise CommandError("Command produced errors", cmdlst, plast.returncode, err)
if outfile == None:
if sys.version_info[0] >= 3: return ret.decode('utf-8')
else: return ret
else:
sout.close()
return None
| gpl-3.0 | 8,381,212,299,770,244,000 | 32.073529 | 84 | 0.618497 | false |
jhamman/xray | xarray/backends/netCDF4_.py | 1 | 13873 | from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import functools
import operator
import numpy as np
from .. import Variable
from ..conventions import pop_to
from ..core import indexing
from ..core.utils import (FrozenOrderedDict, NdimSizeLenMixin,
DunderArrayMixin, close_on_error,
is_remote_uri)
from ..core.pycompat import iteritems, basestring, OrderedDict, PY3
from .common import (WritableCFDataStore, robust_getitem,
DataStorePickleMixin, find_root)
from .netcdf3 import (encode_nc3_attr_value, encode_nc3_variable,
maybe_convert_to_char_array)
# This lookup table maps from dtype.byteorder to a readable endian
# string used by netCDF4.
_endian_lookup = {'=': 'native',
'>': 'big',
'<': 'little',
'|': 'native'}
class BaseNetCDF4Array(NdimSizeLenMixin, DunderArrayMixin):
def __init__(self, variable_name, datastore):
self.datastore = datastore
self.variable_name = variable_name
array = self.get_array()
self.shape = array.shape
dtype = array.dtype
if dtype is str:
# use object dtype because that's the only way in numpy to
# represent variable length strings; it also prevents automatic
# string concatenation via conventions.decode_cf_variable
dtype = np.dtype('O')
self.dtype = dtype
def get_array(self):
self.datastore.assert_open()
return self.datastore.ds.variables[self.variable_name]
class NetCDF4ArrayWrapper(BaseNetCDF4Array):
def __getitem__(self, key):
if self.datastore.is_remote: # pragma: no cover
getitem = functools.partial(robust_getitem, catch=RuntimeError)
else:
getitem = operator.getitem
with self.datastore.ensure_open(autoclose=True):
try:
data = getitem(self.get_array(), key)
except IndexError:
# Catch IndexError in netCDF4 and return a more informative
# error message. This is most often called when an unsorted
# indexer is used before the data is loaded from disk.
msg = ('The indexing operation you are attempting to perform '
'is not valid on netCDF4.Variable object. Try loading '
'your data into memory first by calling .load().')
if not PY3:
import traceback
msg += '\n\nOriginal traceback:\n' + traceback.format_exc()
raise IndexError(msg)
if self.ndim == 0:
# work around for netCDF4-python's broken handling of 0-d
# arrays (slicing them always returns a 1-dimensional array):
# https://github.com/Unidata/netcdf4-python/pull/220
data = np.asscalar(data)
return data
def _nc4_values_and_dtype(var):
if var.dtype.kind == 'U':
# this entire clause should not be necessary with netCDF4>=1.0.9
if len(var) > 0:
var = var.astype('O')
dtype = str
elif var.dtype.kind == 'S':
# use character arrays instead of unicode, because unicode support in
# netCDF4 is still rather buggy
data, dims = maybe_convert_to_char_array(var.data, var.dims)
var = Variable(dims, data, var.attrs, var.encoding)
dtype = var.dtype
elif var.dtype.kind in ['i', 'u', 'f', 'c']:
dtype = var.dtype
else:
raise ValueError('cannot infer dtype for netCDF4 variable')
return var, dtype
def _nc4_group(ds, group, mode):
if group in set([None, '', '/']):
# use the root group
return ds
else:
# make sure it's a string
if not isinstance(group, basestring):
raise ValueError('group must be a string or None')
# support path-like syntax
path = group.strip('/').split('/')
for key in path:
try:
ds = ds.groups[key]
except KeyError as e:
if mode != 'r':
ds = ds.createGroup(key)
else:
# wrap error to provide slightly more helpful message
raise IOError('group not found: %s' % key, e)
return ds
def _ensure_fill_value_valid(data, attributes):
# work around for netCDF4/scipy issue where _FillValue has the wrong type:
# https://github.com/Unidata/netcdf4-python/issues/271
if data.dtype.kind == 'S' and '_FillValue' in attributes:
attributes['_FillValue'] = np.string_(attributes['_FillValue'])
def _force_native_endianness(var):
# possible values for byteorder are:
# = native
# < little-endian
# > big-endian
# | not applicable
# Below we check if the data type is not native or NA
if var.dtype.byteorder not in ['=', '|']:
# if endianness is specified explicitly, convert to the native type
data = var.data.astype(var.dtype.newbyteorder('='))
var = Variable(var.dims, data, var.attrs, var.encoding)
# if endian exists, remove it from the encoding.
var.encoding.pop('endian', None)
# check to see if encoding has a value for endian its 'native'
if not var.encoding.get('endian', 'native') is 'native':
raise NotImplementedError("Attempt to write non-native endian type, "
"this is not supported by the netCDF4 "
"python library.")
return var
def _extract_nc4_variable_encoding(variable, raise_on_invalid=False,
lsd_okay=True, backend='netCDF4'):
encoding = variable.encoding.copy()
safe_to_drop = set(['source', 'original_shape'])
valid_encodings = set(['zlib', 'complevel', 'fletcher32', 'contiguous',
'chunksizes'])
if lsd_okay:
valid_encodings.add('least_significant_digit')
if (encoding.get('chunksizes') is not None and
(encoding.get('original_shape', variable.shape) !=
variable.shape) and not raise_on_invalid):
del encoding['chunksizes']
for k in safe_to_drop:
if k in encoding:
del encoding[k]
if raise_on_invalid:
invalid = [k for k in encoding if k not in valid_encodings]
if invalid:
raise ValueError('unexpected encoding parameters for %r backend: '
' %r' % (backend, invalid))
else:
for k in list(encoding):
if k not in valid_encodings:
del encoding[k]
return encoding
def _open_netcdf4_group(filename, mode, group=None, **kwargs):
import netCDF4 as nc4
ds = nc4.Dataset(filename, mode=mode, **kwargs)
with close_on_error(ds):
ds = _nc4_group(ds, group, mode)
_disable_mask_and_scale(ds)
return ds
def _disable_mask_and_scale(ds):
for var in ds.variables.values():
# we handle masking and scaling ourselves
var.set_auto_maskandscale(False)
class NetCDF4DataStore(WritableCFDataStore, DataStorePickleMixin):
"""Store for reading and writing data via the Python-NetCDF4 library.
This store supports NetCDF3, NetCDF4 and OpenDAP datasets.
"""
def __init__(self, netcdf4_dataset, mode='r', writer=None, opener=None,
autoclose=False):
if autoclose and opener is None:
raise ValueError('autoclose requires an opener')
_disable_mask_and_scale(netcdf4_dataset)
self.ds = netcdf4_dataset
self._autoclose = autoclose
self._isopen = True
self.format = self.ds.data_model
self._filename = self.ds.filepath()
self.is_remote = is_remote_uri(self._filename)
self._mode = mode = 'a' if mode == 'w' else mode
if opener:
self._opener = functools.partial(opener, mode=self._mode)
else:
self._opener = opener
super(NetCDF4DataStore, self).__init__(writer)
@classmethod
def open(cls, filename, mode='r', format='NETCDF4', group=None,
writer=None, clobber=True, diskless=False, persist=False,
autoclose=False):
if format is None:
format = 'NETCDF4'
opener = functools.partial(_open_netcdf4_group, filename, mode=mode,
group=group, clobber=clobber,
diskless=diskless, persist=persist,
format=format)
ds = opener()
return cls(ds, mode=mode, writer=writer, opener=opener,
autoclose=autoclose)
def open_store_variable(self, name, var):
with self.ensure_open(autoclose=False):
dimensions = var.dimensions
data = indexing.LazilyIndexedArray(NetCDF4ArrayWrapper(name, self))
attributes = OrderedDict((k, var.getncattr(k))
for k in var.ncattrs())
_ensure_fill_value_valid(data, attributes)
# netCDF4 specific encoding; save _FillValue for later
encoding = {}
filters = var.filters()
if filters is not None:
encoding.update(filters)
chunking = var.chunking()
if chunking is not None:
if chunking == 'contiguous':
encoding['contiguous'] = True
encoding['chunksizes'] = None
else:
encoding['contiguous'] = False
encoding['chunksizes'] = tuple(chunking)
# TODO: figure out how to round-trip "endian-ness" without raising
# warnings from netCDF4
# encoding['endian'] = var.endian()
pop_to(attributes, encoding, 'least_significant_digit')
# save source so __repr__ can detect if it's local or not
encoding['source'] = self._filename
encoding['original_shape'] = var.shape
return Variable(dimensions, data, attributes, encoding)
def get_variables(self):
with self.ensure_open(autoclose=False):
dsvars = FrozenOrderedDict((k, self.open_store_variable(k, v))
for k, v in
iteritems(self.ds.variables))
return dsvars
def get_attrs(self):
with self.ensure_open(autoclose=True):
attrs = FrozenOrderedDict((k, self.ds.getncattr(k))
for k in self.ds.ncattrs())
return attrs
def get_dimensions(self):
with self.ensure_open(autoclose=True):
dims = FrozenOrderedDict((k, len(v))
for k, v in iteritems(self.ds.dimensions))
return dims
def get_encoding(self):
with self.ensure_open(autoclose=True):
encoding = {}
encoding['unlimited_dims'] = {
k for k, v in self.ds.dimensions.items() if v.isunlimited()}
return encoding
def set_dimension(self, name, length):
with self.ensure_open(autoclose=False):
self.ds.createDimension(name, size=length)
def set_attribute(self, key, value):
with self.ensure_open(autoclose=False):
if self.format != 'NETCDF4':
value = encode_nc3_attr_value(value)
self.ds.setncattr(key, value)
def set_variables(self, *args, **kwargs):
with self.ensure_open(autoclose=False):
super(NetCDF4DataStore, self).set_variables(*args, **kwargs)
def prepare_variable(self, name, variable, check_encoding=False,
unlimited_dims=None):
attrs = variable.attrs.copy()
variable = _force_native_endianness(variable)
if self.format == 'NETCDF4':
variable, datatype = _nc4_values_and_dtype(variable)
else:
variable = encode_nc3_variable(variable)
datatype = variable.dtype
self.set_necessary_dimensions(variable, unlimited_dims=unlimited_dims)
fill_value = attrs.pop('_FillValue', None)
if fill_value in ['', '\x00']:
# these are equivalent to the default FillValue, but netCDF4
# doesn't like setting fill_value to an empty string
fill_value = None
encoding = _extract_nc4_variable_encoding(
variable, raise_on_invalid=check_encoding)
nc4_var = self.ds.createVariable(
varname=name,
datatype=datatype,
dimensions=variable.dims,
zlib=encoding.get('zlib', False),
complevel=encoding.get('complevel', 4),
shuffle=encoding.get('shuffle', True),
fletcher32=encoding.get('fletcher32', False),
contiguous=encoding.get('contiguous', False),
chunksizes=encoding.get('chunksizes'),
endian='native',
least_significant_digit=encoding.get('least_significant_digit'),
fill_value=fill_value)
nc4_var.set_auto_maskandscale(False)
for k, v in iteritems(attrs):
# set attributes one-by-one since netCDF4<1.0.10 can't handle
# OrderedDict as the input to setncatts
nc4_var.setncattr(k, v)
return nc4_var, variable.data
def sync(self):
with self.ensure_open(autoclose=True):
super(NetCDF4DataStore, self).sync()
self.ds.sync()
def close(self):
if self._isopen:
# netCDF4 only allows closing the root group
ds = find_root(self.ds)
if ds._isopen:
ds.close()
self._isopen = False
| apache-2.0 | -2,989,005,801,748,905,500 | 36.904372 | 79 | 0.579975 | false |
mvtuong/mysite | v1/blog/migrations/0002_auto_20150708_1454.py | 1 | 1092 | # -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
class Migration(migrations.Migration):
dependencies = [
('blog', '0001_initial'),
]
operations = [
migrations.AddField(
model_name='blog',
name='file',
field=models.FileField(upload_to=b'user_upload/files/', blank=True),
),
migrations.AddField(
model_name='blog',
name='image',
field=models.ImageField(upload_to=b'user_upload/images/', blank=True),
),
migrations.AddField(
model_name='tag',
name='description',
field=models.TextField(max_length=500, blank=True),
),
migrations.AddField(
model_name='topic',
name='description',
field=models.TextField(max_length=500, blank=True),
),
migrations.AlterField(
model_name='blog',
name='tag',
field=models.ManyToManyField(to='blog.Tag', blank=True),
),
]
| apache-2.0 | 8,163,413,012,375,880,000 | 27 | 82 | 0.540293 | false |
arnikz/EMF_data_mining | DEA/mzscore.py | 1 | 12015 | #!/usr/bin/env python
#
# This script takes a database (SQLite) obtained from the PIQMIe service and populates
# additional tables/views to facilitate differential protein expression analyses based
# on standardized SILAC ratios.
#
# Note:
# z_score_{raw|norm}_ratio - column with canonical Z-score transformed raw/normalized
# SILAC protein ratios
#
# mz_score_{raw|norm}_ratio - column with modified Z-score transformed SILAC protein ratios
# suitable for heavy-tailed data (Iglewicz and Hoaglin, 1993)
#
#
# Author: Arnold Kuzniar
#
# Version: 1.0
#
import os
import sys
import argparse as argp
import math
import numpy as np
import scipy.stats as st
import sqlite3 as sqlt
import collections as cls
ratio_types = { # lookup to link column values to column names
'RATIO H/L': 'raw_ratio_HL',
'RATIO H/M': 'raw_ratio_HM',
'RATIO M/L': 'raw_ratio_ML',
'RATIO H/L NORMALIZED': 'norm_ratio_HL',
'RATIO H/M NORMALIZED': 'norm_ratio_HM',
'RATIO M/L NORMALIZED': 'norm_ratio_ML'
}
score_types = { # lookup to link user input to table column
'Zr' : 'z_score_raw_ratio',
'Zn' : 'z_score_norm_ratio',
'Mr' : 'm_score_raw_ratio',
'Mn' : 'm_score_norm_ratio'
}
# parse command-line args
parser = argp.ArgumentParser(
description = 'Differential analysis of SILAC protein ratios based on standardized scores.')
parser.add_argument(
'-n',
action = 'store_true',
dest = 'new_tabs',
help = 'populate new db tables with (modified) Z-scores')
parser.add_argument(
'-d',
dest = 'dts',
required = True,
choices = ['VH10', 'U2OS', 'IB10'],
help = 'select one of the data sets or cell lines')
parser.add_argument(
'-s',
required = True,
choices = score_types.keys(),
help = 'select one of the score types for filtering: Z*,M* - Z-score or modified Z-score; *r,*n - score based on raw or normalized SILAC protein ratios')
parser.add_argument(
'-c',
required = True,
dest = 'cutoff',
type = float,
help = 'absolute score cutoff (e.g. 1.65, 1.96 or 2.58)')
parser.add_argument(
'-o',
dest = 'outfile',
help = 'output file')
parser.add_argument(
'dbfile',
help = 'sqlite3 database file')
args = parser.parse_args()
# check user input
dbfile = args.dbfile
outfile = args.outfile
new_tabs = args.new_tabs
dts = args.dts
stype = args.s
cutoff = args.cutoff
score_type = None
if os.path.isfile(dbfile) is False:
parser.error("dbfile '%s' not found" % dbfile)
if stype and cutoff:
score_type = score_types[stype]
else:
parser.error('-s and -c args must be used together')
if outfile is None:
# set the default output filename
outfile = os.path.join(os.path.dirname(dbfile), '%s_mzscore_%s_%.2f.tab' % (dts, stype, cutoff))
if cutoff < 0:
parser.error('the absolute score cutoff must be a positive value')
# print info into STDOUT
print """
dbfile = %s
outfile = %s
dataset = %s
re-score = %s
score type = %s
score cutoff = %.2f
""" % (dbfile, outfile, dts, new_tabs, stype, cutoff)
# sqlite3 user-defined functions (UDFs)
def log(value, base):
try:
return math.log(value) / math.log(base)
except:
return None
def sqrt(value):
try:
return math.sqrt(value)
except:
return None
def pvalue(score): # convert Z- or M-score to two-tailed probability (P-value)
try:
return 2 * st.norm.cdf(-abs(score))
except:
return None
class Stdev: # sample standard deviation (aggregate function)
def __init__(self):
self.vec = []
def step(self, value):
self.vec.append(value)
def finalize(self):
return np.array(self.vec).std(ddof=1)
class Median: # median (aggregate function)
def __init__(self):
self.arr = []
def step(self, value):
self.arr.append(value)
def finalize(self):
return np.median(np.array(self.arr))
class Mad: # median absolute deviation (aggregate function)
def __init__(self):
self.arr = []
def step(self, value):
self.arr.append(value)
def finalize(self):
median = np.median(np.array(self.arr))
return np.median(np.abs(self.arr - median))
# SQL statements to populate tables/views
sql_create_tables = """
DROP VIEW IF EXISTS V_PGROUP_RATIO;
CREATE VIEW V_PGROUP_RATIO AS
-- simplifies the selection of SILAC ratios/types
SELECT
A.grp_id,
exp_name,
CAST(CASE %s
END AS TEXT) AS ratio_type,
CAST(quant_value AS NUMERIC) AS ratio_value
FROM
PGROUP_QUANT A, V_PGROUP B
WHERE
A.grp_id = B.grp_id
AND quant_type IN ('%s')
AND quant_value;
DROP TABLE IF EXISTS PGROUP_LOG2RATIO_STAT;
CREATE TABLE PGROUP_LOG2RATIO_STAT AS
-- stores descriptive statistics on SILAC protein ratios for each experiment
SELECT
exp_name,
ratio_type,
CAST(COUNT(ratio_value) AS INT) AS n,
CAST(MIN(LOG(ratio_value, 2)) AS NUMERIC) AS min,
CAST(MAX(LOG(ratio_value, 2)) AS NUMERIC) AS max,
CAST(AVG(LOG(ratio_value, 2)) AS NUMERIC) AS mean,
CAST(MEDIAN(LOG(ratio_value, 2)) AS NUMERIC) AS median,
CAST(STDEV(LOG(ratio_value, 2)) AS NUMERIC) AS sd,
CAST(MAD(LOG(ratio_value, 2)) AS NUMERIC) AS mad
FROM
V_PGROUP_RATIO
GROUP BY
exp_name, ratio_type;
CREATE INDEX idx_PGROUP_LOG2RATIO_STAT_exp_name_ratio_type ON PGROUP_LOG2RATIO_STAT(exp_name, ratio_type);
DROP VIEW IF EXISTS V_PGROUP_LOG2RATIO_STAT;
CREATE VIEW V_PGROUP_LOG2RATIO_STAT AS
-- shows rounded values of the statistics
SELECT
exp_name,
ratio_type,
n,
ROUND(min, 4) AS min,
ROUND(max, 4) AS max,
ROUND(mean, 4) AS mean,
ROUND(median, 4) AS median,
ROUND(sd, 4) AS sd,
ROUND(mad, 4) AS mad
FROM
PGROUP_LOG2RATIO_STAT;
DROP TABLE IF EXISTS PGROUP_MZSCORE;
CREATE TABLE PGROUP_MZSCORE AS
-- stores (modified) Z-score transformed SILAC protein raw/norm ratios
SELECT
grp_id,
A.exp_name AS exp_name,
CAST(A.ratio_type AS TEXT) AS ratio_type,
CAST((LOG(ratio_value, 2) - mean) / sd AS NUMERIC) AS z_score,
CAST(0.6745 * (LOG(ratio_value, 2) - median) / mad AS NUMERIC) AS m_score
FROM
V_PGROUP_RATIO A, PGROUP_LOG2RATIO_STAT B
WHERE
A.exp_name = B.exp_name
AND A.ratio_type = B.ratio_type;
CREATE INDEX idx_PGROUP_MZSCORE_grp_id ON PGROUP_MZSCORE(grp_id);
CREATE INDEX idx_PGROUP_MZSCORE_exp_name_ratio_type ON PGROUP_MZSCORE(exp_name, ratio_type);
""" % (' '.join([ "\n\tWHEN quant_type='%s' THEN '%s'" % (k, v) for (k, v) in ratio_types.iteritems() ]),
"','".join(ratio_types.keys()))
# dynamically construct SQL query to select diff. reg. protein groups
sql_sel_pgrps = """
SELECT
A.grp_id grp_id,
IFNULL(GROUP_CONCAT(DISTINCT gene), '-') genes,
{dts}_L0_M0_H1_{score_type}_HL '{stype}_H1L0', -- Z or M-score ON/OFF (treat1)
{dts}_L1_M1_H0_{score_type}_LH '{stype}_L1H0', -- Z or M-score ON/OFF (treat2)
{dts}_L0_M0_H1_{score_type}_HM '{stype}_H1M0', -- Z or M-score ON/OFF (treat3)
{dts}_L1_M1_H0_{score_type}_MH '{stype}_M1H0', -- Z or M-score ON/OFF (treat4)
{dts}_L0_M0_H1_{score_type}_LM '{stype}_L0M0', -- Z or M-score OFF/OFF (ctrl1)
{dts}_L1_M1_H0_{score_type}_LM '{stype}_L1M1', -- Z or M-score ON/ON (ctrl2)
PVALUE({dts}_L0_M0_H1_{score_type}_HL) 'pval_H1L0', -- P-value ON/OFF (treat1)
PVALUE({dts}_L1_M1_H0_{score_type}_LH) 'pval_L1H0', -- P-value ON/OFF (treat2)
PVALUE({dts}_L0_M0_H1_{score_type}_HM) 'pval_H1M0', -- P-value ON/OFF (treat3)
PVALUE({dts}_L1_M1_H0_{score_type}_MH) 'pval_M1H0', -- P-value ON/OFF (treat4)
PVALUE({dts}_L0_M0_H1_{score_type}_LM) 'pval_L0M0', -- P-value OFF/OFF (ctrl1)
PVALUE({dts}_L1_M1_H0_{score_type}_LM) 'pval_L1M1' -- P-value ON/ON (ctrl2)
FROM
V_PGROUP_MZSCORE A, PROT2GRP B, V_PROTEIN C
WHERE
A.grp_id = B.grp_id
AND B.prot_acc = C.acc
AND (({dts}_L0_M0_H1_{score_type}_HL > {cutoff}
AND {dts}_L0_M0_H1_{score_type}_HM > {cutoff}
AND {dts}_L1_M1_H0_{score_type}_LH > {cutoff}
AND {dts}_L1_M1_H0_{score_type}_MH > {cutoff})
OR ({dts}_L0_M0_H1_{score_type}_LH > {cutoff}
AND {dts}_L0_M0_H1_{score_type}_MH > {cutoff}
AND {dts}_L1_M1_H0_{score_type}_HL > {cutoff}
AND {dts}_L1_M1_H0_{score_type}_HM > {cutoff}))
AND {dts}_L0_M0_H1_{score_type}_ML <= {cutoff}
AND {dts}_L0_M0_H1_{score_type}_LM <= {cutoff}
AND {dts}_L1_M1_H0_{score_type}_ML <= {cutoff}
AND {dts}_L1_M1_H0_{score_type}_LM <= {cutoff}
GROUP BY A.grp_id;
""".format(dts=dts, score_type=score_type, stype=stype, cutoff=cutoff)
# connect to db
with sqlt.connect(args.dbfile) as conn:
conn.row_factory = sqlt.Row # enable column access by name: row['colnm']
conn.create_function('log', 2, log)
conn.create_function('sqrt', 1, sqrt)
conn.create_function('pvalue', 1, pvalue)
conn.create_aggregate('stdev', 1, Stdev)
conn.create_aggregate('median', 1, Median)
conn.create_aggregate('mad', 1, Mad)
cur = conn.cursor()
if new_tabs is True: # populate tables/views only with -n option
cur.executescript(sql_create_tables)
cur.execute('SELECT DISTINCT exp_name FROM EXPERIMENT')
exp_names = [ str(r[0]) for r in cur.fetchall() ]
cur.execute("SELECT DISTINCT ratio_type FROM PGROUP_LOG2RATIO_STAT")
ratio_types = [ str(r[0]) for r in cur.fetchall() ]
n = len(exp_names) * len(ratio_types)
i = 0
comma = ','
# create view for selecting diff. reg. proteins
sql_create_view = """
DROP VIEW IF EXISTS V_PGROUP_MZSCORE;
CREATE VIEW V_PGROUP_MZSCORE AS
SELECT
grp_id,
"""
for e in exp_names:
for r in ratio_types:
i += 1
rr = r[:-2] + r[-2:][::-1] # add inverse ratio (e.g., {raw|norm}_ratio_HL for *_ratio_LH)
if i == n: comma = ''
sql_create_view += "\tROUND(CAST(GROUP_CONCAT(CASE WHEN exp_name = '{exp}' AND ratio_type = '{ratio}' THEN z_score ELSE NULL END) AS NUMERIC), 4) AS '{exp}_z_score_{ratio}',\n".format(exp=e, ratio=r)
sql_create_view += "\tROUND(CAST(GROUP_CONCAT(CASE WHEN exp_name = '{exp}' AND ratio_type = '{ratio}' THEN -1 * z_score ELSE NULL END) AS NUMERIC), 4) AS '{exp}_z_score_{iratio}',\n".format(exp=e, ratio=r, iratio=rr)
sql_create_view += "\tROUND(CAST(GROUP_CONCAT(CASE WHEN exp_name = '{exp}' AND ratio_type = '{ratio}' THEN m_score ELSE NULL END) AS NUMERIC), 4) AS '{exp}_m_score_{ratio}',\n".format(exp=e, ratio=r)
sql_create_view += "\tROUND(CAST(GROUP_CONCAT(CASE WHEN exp_name = '{exp}' AND ratio_type = '{ratio}' THEN -1 * m_score ELSE NULL END) AS NUMERIC), 4) AS '{exp}_m_score_{iratio}'{comma}\n".format(exp=e, ratio=r, iratio=rr, comma=comma)
sql_create_view += "FROM PGROUP_MZSCORE GROUP BY grp_id"
cur.executescript(sql_create_view)
# write results onto tab-delim file
if dts is not None:
sep = '\t' # column separator
n_pgrps = 0 # count diff. reg. protein groups
with open(outfile, 'w+') as fout:
try:
for drow in [ cls.OrderedDict(xi) for xi in cur.execute(sql_sel_pgrps) ]:
# first output column names
if n_pgrps == 0:
header = sep.join(drow.keys()) + os.linesep
fout.write(header)
# output remaining rows with column values (grp_id, Z-/M-scores and P-values)
row = drow.values()
grp_id = str(drow['grp_id'])
genes = str(drow['genes'])
scores = [ str(round(float(x), 4)) for x in row[2:] ]
srow = grp_id + sep + genes + sep + sep.join(scores) + os.linesep
fout.write(srow)
n_pgrps += 1
except sqlt.OperationalError as e:
sys.stderr.write('Error: Selected data set not found: %s\n' % e)
sys.exit(1)
# remove empty outfile
if os.path.getsize(outfile) == 0:
print 'Nothing to write onto outfile.'
os.remove(outfile)
else:
print 'Ndiff =', n_pgrps
| gpl-3.0 | 7,526,957,426,108,315,000 | 33.426934 | 247 | 0.627549 | false |
mupi/escolamupi | timtec/settings.py | 1 | 18426 | # -*- coding: utf-8 -*-
# Django settings for timtec project.
from django.utils.translation import ugettext_lazy as _
import os
SETTINGS_DIR = os.path.dirname(os.path.realpath(__file__))
PROJECT_ROOT = os.path.dirname(SETTINGS_DIR)
DEBUG = True
TEMPLATE_DEBUG = DEBUG
SITE_ID = 1
SITE_HOME = '/'
SITE_NAME = 'Escola Mupi'
SITE_DOMAIN = 'escolamupi.com.br'
SITE_URL = 'http://escolamupi.com.br'
ADMINS = (
('mupi', '[email protected]'),
)
MANAGERS = (ADMINS[0],)
EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
EMAIL_HOST = 'localhost'
DEFAULT_FROM_EMAIL = '[email protected]'
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'.
'NAME': 'timtec.sqlite', # Or path to database file if using sqlite3.
# The following settings are not used with sqlite3:
'USER': '',
'PASSWORD': '',
'HOST': '', # Empty for localhost through domain sockets or '127.0.0.1' for localhost through TCP.
'PORT': '', # Set to empty string for default.
}
}
METRON_SETTINGS = {
"google": {
1: "set-your-google-analytics-key-here",
},
}
LOGIN_URL = '/accounts/login/'
LOGIN_REDIRECT_URL = '/my-courses'
AUTHENTICATION_BACKENDS = ("django.contrib.auth.backends.ModelBackend",
"allauth.account.auth_backends.AuthenticationBackend")
# Hosts/domain names that are valid for this site; required if DEBUG is False
# See https://docs.djangoproject.com/en/1.5/ref/settings/#allowed-hosts
ALLOWED_HOSTS = ['localhost']
# Local time zone for this installation. Choices can be found here:
# http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
# although not all choices may be available on all operating systems.
# In a Windows environment this must be set to your system time zone.
TIME_ZONE = 'America/Sao_Paulo'
# Language code for this installation. All choices can be found here:
# http://www.i18nguy.com/unicode/language-identifiers.html
LANGUAGE_CODE = 'mupi'
# If you set this to False, Django will make some optimizations so as not
# to load the internationalization machinery.
USE_I18N = True
# If you set this to False, Django will not format dates, numbers and
# calendars according to the current locale.
USE_L10N = True
LANGUAGES = (
('mupi', _('Mupi translation')),
)
LOCALE_PATHS = (
os.path.join(PROJECT_ROOT, 'locale'),
)
# If you set this to False, Django will not use timezone-aware datetimes.
USE_TZ = True
# Absolute filesystem path to the directory that will hold user-uploaded files.
# Example: "/var/www/example.com/media/"
MEDIA_ROOT = os.path.join(PROJECT_ROOT, 'media')
#MEDIA_ROOT = '~/tmp/escola/media'
# URL that handles the media served from MEDIA_ROOT. Make sure to use a
# trailing slash.
# Examples: "http://example.com/media/", "http://media.example.com/"
MEDIA_URL = '/media/'
# Absolute path to the directory static files should be collected to.
# Don't put anything in this directory yourself; store your static files
# in apps' "static/" subdirectories and in STATICFILES_DIRS.
# Example: "/var/www/example.com/static/"
#STATIC_ROOT = '~/tmp/escola/static'
STATIC_ROOT = os.path.join(PROJECT_ROOT, 'static2')
# URL prefix for static files.
# Example: "http://example.com/static/", "http://static.example.com/"
STATIC_URL = '/static/'
# Additional locations of static files
STATICFILES_DIRS = (
# Put strings here, like "/home/html/static" or "C:/www/django/static".
# Always use forward slashes, even on Windows.
# Don't forget to use absolute paths, not relative paths.
os.path.join(PROJECT_ROOT, "static"),
os.path.join(PROJECT_ROOT, 'bower_components'),
)
# List of finder classes that know how to find static files in
# various locations.
STATICFILES_FINDERS = (
'django.contrib.staticfiles.finders.FileSystemFinder',
'django.contrib.staticfiles.finders.AppDirectoriesFinder',
# 'pipeline.finders.FileSystemFinder',
# 'pipeline.finders.AppDirectoriesFinder',
'pipeline.finders.PipelineFinder',
'pipeline.finders.CachedFileFinder',
# 'django.contrib.staticfiles.finders.DefaultStorageFinder',
)
STATICFILES_STORAGE = 'pipeline.storage.PipelineCachedStorage'
PIPELINE_JS_COMPRESSOR = 'timtec.ngminyuglify.NgminYuglifyCompressor'
PIPELINE_COMPILERS = (
'pipeline.compilers.less.LessCompiler',
)
PIPELINE_CSS = {
'common': {
'source_filenames': (
'fonts/teuton/stylesheet.css',
'fonts/questrial/stylesheet.css',
'font-awesome/css/font-awesome.css',
'codemirror/lib/codemirror.css',
'codemirror/addon/hint/show-hint.css',
'codemirror/theme/monokai.css',
'css/codemirrorconf.css',
),
'output_filename': 'css/common.css',
'extra_context': {
'media': 'screen,projection,print',
},
},
'public': {
'source_filenames': (
'css/mupi.less',
),
'output_filename': 'css/public.css',
'extra_context': {
'media': 'screen,projection,print',
},
},
'admin': {
'source_filenames': (
'css/mupi-admin.less',
),
'output_filename': 'css/admin.css',
'extra_context': {
'media': 'screen,projection,print',
},
'variant': 'datauri',
},
}
PIPELINE_JS = {
'all': {
'source_filenames': (
'modernizr/modernizr.js',
'jquery/dist/jquery.js',
'jquery-ui/ui/jquery-ui.js',
'jquery-ui/ui/jquery.ui.sortable.js',
'bootstrap/dist/js/bootstrap.js',
'angular/angular.js',
'angular-animate/angular-animate.js',
'angular-cookies/angular-cookies.js',
'angular-resource/angular-resource.js',
'angular-route/angular-route.js',
'angular-sanitize/angular-sanitize.js',
'angular-bootstrap/ui-bootstrap-tpls.js',
'angular-gettext/dist/angular-gettext.js',
'js/consolelogfallback.js',
'js/django.js',
'js/contact_form.js',
'js/helpers.js',
'js/angular-youtube.js',
'js/truncate.js',
'js/layout.js',
'markdown/lib/markdown.js',
'mupi/js/plans-boxes.js',
'mupi/js/courses-tab.js',
),
'output_filename': 'js/all.js',
},
'markdown': {
'source_filenames': (
'js/vendor/pagedown/Markdown.Converter.js',
'js/vendor/pagedown/Markdown.Editor.js',
'js/vendor/pagedown/Markdown.Sanitizer.js',
'js/markdown/app.js',
'js/markdown/filters.js',
),
'output_filename': 'js/markdown.js',
},
'messages': {
'source_filenames': (
'js/messages/app.js',
'js/messages/controllers.js',
'js/messages/services.js',
'checklist-model/checklist-model.js',
'js/markdown/app.js',
'js/markdown/filters.js',
),
'output_filename': 'js/messages.js',
},
'codemirror': {
'source_filenames': (
'codemirror/lib/codemirror.js',
'codemirror/addon/fold/xml-fold.js',
'codemirror/addon/hint/show-hint.js',
'codemirror/addon/hint/xml-hint.js',
'codemirror/addon/hint/html-hint.js',
'codemirror/addon/hint/css-hint.js',
'codemirror/addon/hint/javascript-hint.js',
'codemirror/addon/edit/matchbrackets.js',
'codemirror/addon/edit/closebrackets.js',
'codemirror/addon/edit/matchtags.js',
'codemirror/mode/xml/xml.js',
'codemirror/mode/css/css.js',
'codemirror/mode/javascript/javascript.js',
'codemirror/mode/htmlmixed/htmlmixed.js',
'codemirror/mode/clike/clike.js',
'codemirror/mode/php/php.js',
# 'js/codemirrorconf.js',
'js/vendor/angular-ui-codemirror/ui-codemirror.js',
),
'output_filename': 'js/codemirrorcomp.js',
},
'markdown_editor': {
'source_filenames': (
'js/vendor/pagedown/Markdown.Converter.js',
'js/vendor/pagedown/Markdown.Editor.js',
'js/vendor/pagedown/Markdown.Sanitizer.js',
),
'output_filename': 'js/markdown_editor.js',
},
'lesson': {
'source_filenames': (
'js/activities/app.js',
'js/activities/controllers.js',
'js/activities/directives.js',
'js/activities/services.js',
'js/lesson/app.js',
'js/lesson/controllers.js',
'js/lesson/services.js',
'js/directives/markdowneditor.js',
'js/directives/codemirror.js',
'js/markdown/app.js',
'js/markdown/filters.js',
),
'output_filename': 'js/lesson.js',
},
'course_material': {
'source_filenames': (
'js/course_material/app.js',
'js/course_material/controllers.js',
'js/course_material/directives.js',
'js/course_material/filters.js',
'js/course_material/services.js',
'dropzone/downloads/dropzone.js',
),
'output_filename': 'js/course_material.js',
},
'forum': {
'source_filenames': (
'js/forum/app.js',
'js/forum/controllers.js',
'js/forum/directives.js',
'js/forum/filters.js',
'js/forum/services.js',
'js/truncate.js',
),
'output_filename': 'js/forum.js',
},
'notes': {
'source_filenames': (
'js/notes/app.js',
'js/notes/controllers.js',
'js/notes/services.js',
),
'output_filename': 'js/notes.js',
},
'admin_course_header': {
'source_filenames': (
'js/admin-header/app.js',
'js/admin-header/controllers.js',
'js/factories/timtec-models.js',
),
'output_filename': 'js/admin_course_header.js',
},
'reports': {
'source_filenames': (
'js/reports/app.js',
'js/reports/controllers.js',
'js/reports/services.js',
),
'output_filename': 'js/reports.js',
},
'core': {
'source_filenames': (
'js/core/app.js',
'js/core/controllers.js',
'js/core/services.js',
'angular-tweet-filter/index.js',
),
'output_filename': 'js/core.js',
},
}
MOMMY_CUSTOM_FIELDS_GEN = {
'jsonfield.JSONField': lambda: '{}',
}
REST_FRAMEWORK = {
# Use hyperlinked styles by default.
# Only used if the `serializer_class` attribute is not set on a view.
'DEFAULT_MODEL_SERIALIZER_CLASS':
'rest_framework.serializers.HyperlinkedModelSerializer',
# Use Django's standard `django.contrib.auth` permissions,
# or allow read-only access for unauthenticated users.
'DEFAULT_PERMISSION_CLASSES': [
'rest_framework.permissions.DjangoModelPermissions'
],
'DEFAULT_FILTER_BACKENDS': [
'rest_framework.filters.DjangoFilterBackend'
],
'DEFAULT_AUTHENTICATION_CLASSES': (
'rest_framework.authentication.SessionAuthentication',
)
}
APPEND_SLASH = True
# Make this unique, and don't share it with anybody.
SECRET_KEY = 'e%6a01vfbue28$xxssu!9r_)usqjh817((mr+7vv3ek&@#p0!$'
# List of callables that know how to import templates from various sources.
TEMPLATE_LOADERS = (
'django.template.loaders.filesystem.Loader',
'django.template.loaders.app_directories.Loader',
# 'django.template.loaders.eggs.Loader',
)
TEMPLATE_DIRS = (
# Put strings here, like "/home/html/django_templates" or "C:/www/django/templates".
# Always use forward slashes, even on Windows.
# Don't forget to use absolute paths, not relative paths.
os.path.join(PROJECT_ROOT, 'administration/templates/mupi'),
os.path.join(PROJECT_ROOT, 'core/templates/mupi'),
os.path.join(PROJECT_ROOT, 'accounts/templates/mupi'),
os.path.join(PROJECT_ROOT, 'forum/templates/mupi'),
os.path.join(PROJECT_ROOT, 'notes/templates/mupi'),
os.path.join(PROJECT_ROOT, 'payments/templates/mupi'),
#os.path.join(PROJECT_ROOT, 'administration/templates'),
#os.path.join(PROJECT_ROOT, 'core/templates'
)
from django.conf.global_settings import TEMPLATE_CONTEXT_PROCESSORS as TCP
TEMPLATE_CONTEXT_PROCESSORS = TCP + (
'django.core.context_processors.request',
'allauth.account.context_processors.account',
'allauth.socialaccount.context_processors.socialaccount',
'core.context_processors.contact_form',
'core.context_processors.site_settings',
'timtec.locale_context_processor.locale',
'django.core.context_processors.media',
'payments.context_processors.test_user_paid',
)
# Django Suit configuration example
SUIT_CONFIG = {
# header
'ADMIN_NAME': 'Timtec Admin',
'HEADER_DATE_FORMAT': 'l, j. F Y',
'HEADER_TIME_FORMAT': 'H:i',
# forms
# 'SHOW_REQUIRED_ASTERISK': True, # Default True
# 'CONFIRM_UNSAVED_CHANGES': True, # Default True
# menu
'SEARCH_URL': '/admin/accounts/timtecuser/',
# 'MENU_ICONS': {
# 'sites': 'icon-leaf',
# 'auth': 'icon-lock',
# },
# 'MENU_OPEN_FIRST_CHILD': True, # Default True
# 'MENU_EXCLUDE': ('auth.group',),
# 'MENU': (
# 'sites',
# {'app': 'auth', 'icon':'icon-lock', 'models': ('user', 'group')},
# {'label': 'Settings', 'icon':'icon-cog', 'models': ('accounts.TimtecUser', 'auth.group')},
# # {'label': 'Support', 'icon':'icon-question-sign', 'url': '/support/'},
# ),
# misc
# 'LIST_PER_PAGE': 15
}
AUTH_USER_MODEL = 'accounts.TimtecUser'
MIDDLEWARE_CLASSES = (
'django.contrib.sessions.middleware.SessionMiddleware',
# 'django.middleware.locale.LocaleMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
# Uncomment the next line for simple clickjacking protection:
# 'django.middleware.clickjacking.XFrameOptionsMiddleware',
)
ROOT_URLCONF = 'timtec.urls'
# Python dotted path to the WSGI application used by Django's runserver.
WSGI_APPLICATION = 'timtec.wsgi.application'
SOUTH_MIGRATION_MODULES = {
'easy_thumbnails': 'easy_thumbnails.south_migrations',
}
INSTALLED_APPS = (
'django_extensions',
'south',
'pipeline',
'suit',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.sites',
'django.contrib.messages',
'django.contrib.staticfiles',
'django.contrib.flatpages',
'django.contrib.admin',
'filer',
'mptt',
'easy_thumbnails',
# Uncomment the next line to enable admin documentation:
'django.contrib.admindocs',
'rest_framework',
'rosetta',
'autoslug',
# TIM Tec
'core',
'accounts',
'activities',
'administration',
'forum',
'course_material',
'notes',
'reports',
'payments',
# django-metron
'metron',
# allauth
'allauth',
'allauth.account',
'allauth.socialaccount',
'allauth.socialaccount.providers.facebook',
'django_markdown',
'paypal.standard.ipn',
# raven has to be the last one
'raven.contrib.django.raven_compat',
)
PAYPAL_TEST = True
PAYPAL_RECEIVER_EMAIL = "[email protected]"
PAYPAL_SUBSCRIPTION_SANDBOX_IMAGE = "https://www.paypalobjects.com/pt_BR/BR/i/btn/btn_subscribeCC_LG.gif"
PAYPAL_SUBSCRIPTION_IMAGE = "https://www.paypalobjects.com/pt_BR/BR/i/btn/btn_subscribeCC_LG.gif"
PAYPAL_IMAGE = "https://www.paypalobjects.com/pt_BR/BR/i/btn/btn_subscribeCC_LG.gif"
PAYPAL_SANDBOX_IMAGE = "http://escolamupi.com.br/static/img/logo.5d174d245c09.png"
#PAYPAL_DONATION_SANDBOX_IMAGE = "https://www.paypalobjects.com/pt_BR/BR/i/btn/btn_subscribeCC_LG.gif"
#PAYPAL_DONATION_IMAGE = "https://www.paypalobjects.com/pt_BR/BR/i/btn/btn_subscribeCC_LG.gif"
# PAYPAL_RECEIVER_EMAIL = "[email protected]"
SOCIALACCOUNT_PROVIDERS = {
'facebook': {
'SCOPE': ['email', 'publish_stream'],
'AUTH_PARAMS': {'auth_type': 'reauthenticate'},
'METHOD': 'oauth2',
}
}
if DEBUG:
MIDDLEWARE_CLASSES += (
'debug_toolbar.middleware.DebugToolbarMiddleware',
)
INSTALLED_APPS += (
'debug_toolbar',
)
INTERNAL_IPS = ('127.0.0.1', )
DEBUG_TOOLBAR_CONFIG = {
'INTERCEPT_REDIRECTS': False,
}
# django-registration flag
# ACCOUNT_ACTIVATION_DAYS = 7
ACCOUNT_EMAIL_CONFIRMATION_AUTHENTICATED_REDIRECT_URL = "/accounts/payment"
REGISTRATION_DEFAULT_GROUP_NAME = 'students'
ACCOUNT_ADAPTER = "accounts.adapter.TimtecAdapter"
ACCOUNT_UNIQUE_EMAIL = True
ACCOUNT_AUTHENTICATION_METHOD = "username_email"
ACCOUNT_EMAIL_CONFIRMATION_EXPIRE_DAYS = 7
ACCOUNT_EMAIL_REQUIRED = True
#ACCOUNT_EMAIL_VERIFICATION =
ACCOUNT_EMAIL_SUBJECT_PREFIX = "[Escola Mupi] "
ACCOUNT_SIGNUP_FORM_CLASS = 'accounts.forms.SignupForm'
SOCIALACCOUNT_EMAIL_VERIFICATION = False
TWITTER_CONSUMER_KEY = ''
TWITTER_CONSUMER_SECRET = ''
TWITTER_ACESS_TOKEN = ''
TWITTER_ACESS_TOKEN_SECRET = ''
TWITTER_USER = ''
# A sample logging configuration. The only tangible logging
# performed by this configuration is to send an email to
# the site admins on every HTTP 500 error when DEBUG=False.
# See http://docs.djangoproject.com/en/dev/topics/logging for
# more details on how to customize your logging configuration.
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'filters': {
'require_debug_false': {
'()': 'django.utils.log.RequireDebugFalse'
}
},
'handlers': {
'mail_admins': {
'level': 'ERROR',
'filters': ['require_debug_false'],
'class': 'django.utils.log.AdminEmailHandler'
}
},
'loggers': {
'django.request': {
'handlers': ['mail_admins'],
'level': 'ERROR',
'propagate': True,
},
}
}
try:
from .settings_local import *
except ImportError:
pass
| agpl-3.0 | -4,608,623,161,978,571,000 | 31.045217 | 127 | 0.622381 | false |
brando56894/Dungeon-Quest | player.py | 1 | 8551 | #!/usr/bin/python2
#
#~~Player Functions~~
from superRandom import superRandint, superChoice
from time import sleep
import actions
import monsters
class CreatePlayer(object):
def __init__(self, name):
self.health = 125
self.xp = 0 #TODO: use gained XP to gain levels
self.potions = 0
self.gold = 0
self.weapons = ["dagger"]
self.name = name
self.steps = 0
self.damage_dealt = 12 #not needed
self.current_weapon = "dagger"
self.dragon_attack = False
self.basilisk_attack = False
self.has_sword = False
self.has_pistol = False
self.has_rifle = False
self.run_away = 0
self.has_key = False
self.turns = 0
def __repr__(self):
return ("\nName: %s\nHealth: %d\nXP: %d\nPotions: "
"%d\nGold: %d\nWeapons: %s\nSteps: %d\nCurr"
"ent Weapon: %s\nDragon Attack: %s\nBasili"
"skAttack: %s\nHas Sword: %s\nHas Pistol: "
"%s\nHas Rifle: %s\nTimes Run Away: %d\nHa"
"s Key: %s\nTurns: %s" % (self.name,self.health,self.xp,
self.potions,self.gold,self.weapons,
self.steps,self.current_weapon,
self.dragon_attack,self.basilisk_attack,
self.has_sword,self.has_pistol,self.has_rifle,
self.run_away,self.has_key,self.turns)
)
def find_gold(self):
amount = superRandint(1,25)
self.gold += amount
print "\nYou found %d gold coins, which brings you to a total of %d coins!" % (amount, self.gold)
sleep(2)
return self
def find_gold_debug(self,amount):
self.gold += amount
print "\nYou found %d gold coins, which brings you to a total of %d coins!" % (amount, self.gold)
sleep(2)
return self
def find_potions(self):
self.potions += 1
print "\nYou found a health potion! You now have %d potions in your inventory." % self.potions
sleep(2)
return self
def find_weapon(self):
#TODO: add more weapons
weapons = ["sword","pistol","rifle"]
found = superChoice(weapons)
print "\nYou found a %s!" % found
if found == "sword":
self.has_sword = True
elif found == "pistol":
self.has_pistol = True
else:
self.has_rifle = True
return self
def buy_potions(self):
print "\nGold: %d" % self.gold
print "Each potion costs 20 gold pieces and restores 25 HP."
amount = raw_input("\nHow many would you like to purchase? ")
cost = int(amount) * 20
if self.gold >= int(cost):
self.gold = self.gold - int(cost)
self.potions += int(amount)
print "\n%d potions have been added to your inventory." % int(amount)
sleep(2)
return self
else:
print "\nSorry you don't have enough gold for %d potions!" % int(amount)
sleep(2)
actions.visit_shop(self)
def use_potion(self):
if self.potions > 0 and self.potions < 2:
self.potions -= 1
self.health += 25
print "\nYour health is now at %d" % self.health
elif self.potions > 1:
print "\nYou currently have %d potions" % self.potions
amount = int(raw_input("\nHow many? "))
raise_health = amount * 25
self.health += raise_health
self.potions -= amount
print "\nYour health is now at %d" % self.health
else:
print "\nSorry you don't have any more potions!"
sleep(2)
return self
def list_inventory(self):
actions.clearscreen()
print ("\nName: %s\n"
"Exp. Points: %d\n"
"Potions Held: %d\n"
"Gold: %d pieces\n"
"Current Weapon: %s" %(self.name, self.xp,
self.potions, self.gold, self.current_weapon)
)
if self.has_pistol is True and "pistol" not in self.weapons:
self.weapons.append("pistol")
elif self.has_rifle is True and "rifle" not in self.weapons:
self.weapons.append("rifle")
elif self.has_sword is True and "sword" not in self.weapons:
self.weapons.append("sword")
print "Weapons: %s" % ", ".join(str(weapon) for weapon in self.weapons)
sleep(4)
def low_health(self):
if self.health <= 60 and self.potions > 0:
print "\n*****DANGER*****\n"
choice = raw_input("\nYour health is currently at %d, a"
"nd you currently have %d potions in your inven"
"tory. \nWould you like to use one? " % (self.health,self.potions)
)
choice.lower()
if choice == 'y' or choice == 'yes':
self.use_potion()
return self
else:
print "\nOk tough guy."
sleep(2)
return self
def set_health(self, newHealth):
self.health = newHealth
print "\nHealth set to %d" % self.health
sleep(2)
return self
def take_damage(self, damage):
self.health -= damage
print "\nYour health is now at %d" % self.health
if self.health < 0:
print "\nYou were slain! Maybe you should carry more health potions with you next time!\n"
exit(0)
sleep(2)
return self
def deal_damage(self,Monster):
if self.current_weapon == "sword":
damage_dealt = superRandint(13,30)
elif self.current_weapon == "pistol":
damage_dealt = superRandint(31,60)
elif self.current_weapon == "rifle":
damage_dealt = superRandint(61,120)
else:
damage_dealt = superRandint(1,12)
Monster.take_damage(damage_dealt,self)
def gain_xp(self,monster_name):
if monster_name == "Dragon":
gained = superRandint(40,150)
elif monster_name == "Gremlin":
gained = superRandint(1,35)
elif monster_name == "Demon":
gained = superRandint(15,50)
elif monster_name == "Zombie":
gained = superRandint(16,75)
else:
gained = superRandint(1,30)
self.xp += gained
print "\nYou gained %d XP!" % gained
return self
def buy_weapon(self):
print "\nS)word: 25 Gold"
print "P)istol: 60 Gold"
print "R)ifle: 120 Gold"
choice = raw_input("\nWhich one would you like to purchase? ").lower()
if choice == 's'and self.gold >= 25:
self.gold -= 25
self.has_sword = True
print "\nA sword has been added to your inventory."
sleep(2)
elif choice == 'p' and self.gold >= 60:
self.gold -= 60
self.has_pistol = True
print "\nA pistol has been added to your inventory."
sleep(2)
elif choice == 'r' and self.gold >= 120:
self.gold -= 120
self.has_rifle = True
print "\nA rifle has been added to your inventory."
sleep(2)
else:
print "\nSorry you don't have enough gold for that purchase."
sleep(2)
actions.visit_shop(self)
return (self)
def set_current_weapon(self):
print "\nCurrent Weapon: " + self.current_weapon
#doesn't show correct weapons after a new weapon is found
#even if weapon is in inventory, method itself works perfectly.
print "Available Weapons: %s" % ", ".join(str(weapon) for weapon in self.weapons)
choice = raw_input("\nUse weapon: ").lower()
if choice == "sword" and self.has_sword is True:
self.current_weapon = "sword"
elif choice == "pistol" and self.has_pistol is True:
self.current_weapon = "pistol"
elif choice == "rifle" and self.has_rifle is True:
self.current_weapon = "rifle"
elif choice == "dagger":
self.current_weapon = "dagger"
else:
print "\nSorry you don't currently have that weapon in your inventory."
print "\nCurrent weapon has been changed to: %s" % self.current_weapon
sleep(2)
return self
| gpl-3.0 | 426,067,084,616,806,100 | 36.017316 | 105 | 0.535376 | false |
adelina-t/compute-hyperv | hyperv/nova/serialproxy.py | 1 | 3962 | # Copyright 2015 Cloudbase Solutions Srl
# 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 eventlet import patcher
import functools
import socket
from nova.i18n import _
from hyperv.nova import constants
from hyperv.nova import vmutils
threading = patcher.original('threading')
def handle_socket_errors(func):
@functools.wraps(func)
def wrapper(self, *args, **kwargs):
try:
return func(self, *args, **kwargs)
except socket.error:
self._client_connected.clear()
return wrapper
class SerialProxy(threading.Thread):
def __init__(self, instance_name, addr, port, input_queue,
output_queue, client_connected):
super(SerialProxy, self).__init__()
self.setDaemon(True)
self._instance_name = instance_name
self._addr = addr
self._port = port
self._conn = None
self._input_queue = input_queue
self._output_queue = output_queue
self._client_connected = client_connected
self._stopped = threading.Event()
def _setup_socket(self):
try:
self._sock = socket.socket(socket.AF_INET,
socket.SOCK_STREAM)
self._sock.setsockopt(socket.SOL_SOCKET,
socket.SO_REUSEADDR,
1)
self._sock.bind((self._addr, self._port))
self._sock.listen(1)
except socket.error as err:
self._sock.close()
msg = (_('Failed to initialize serial proxy on'
'%(addr)s:%(port)s, handling connections '
'to instance %(instance_name)s. Error: %(error)s') %
{'addr': self._addr, 'port': self._port,
'instance_name': self._instance_name,
'error': err})
raise vmutils.HyperVException(msg)
def stop(self):
self._stopped.set()
self._client_connected.clear()
if self._conn:
self._conn.shutdown(socket.SHUT_RDWR)
self._conn.close()
self._sock.close()
def run(self):
self._setup_socket()
while not self._stopped.isSet():
self._accept_conn()
@handle_socket_errors
def _accept_conn(self):
self._conn, client_addr = self._sock.accept()
self._client_connected.set()
workers = []
for job in [self._get_data, self._send_data]:
worker = threading.Thread(target=job)
worker.setDaemon(True)
worker.start()
workers.append(worker)
for worker in workers:
worker_running = (worker.is_alive() and
worker is not threading.current_thread())
if worker_running:
worker.join()
self._conn.close()
self._conn = None
@handle_socket_errors
def _get_data(self):
while self._client_connected.isSet():
data = self._conn.recv(constants.SERIAL_CONSOLE_BUFFER_SIZE)
if not data:
self._client_connected.clear()
return
self._input_queue.put(data)
@handle_socket_errors
def _send_data(self):
while self._client_connected.isSet():
data = self._output_queue.get_burst()
if data:
self._conn.sendall(data)
| apache-2.0 | -2,187,697,925,085,981,000 | 31.47541 | 78 | 0.572438 | false |
Auzzy/pyinq | pyinq/tests/test_results.py | 1 | 9565 | """
Copyright (c) 2012-2013, Austin Noto-Moniz ([email protected])
Permission to use, copy, modify, and/or distribute this software for any purpose
with or without fee is hereby granted, provided that the above copyright notice
and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
THIS SOFTWARE.
"""
from pyinq.results import *
##### TEST ASSERT RESULTS #####
LINENO = 12
CALL = "assert_true(True)"
FAIL = "FAIL"
TRACE = "TRACE"
EXPECTED = IOError
def test_Result_true():
check_Result(True)
def test_Result_false():
check_Result(False)
def test_AssertResult_true():
check_AssertResult(True)
def test_AssertResult_false():
check_AssertResult(False)
def test_AssertEqualsResult_true():
check_AssertEqualsResult(True,4,4)
def test_AssertEqualsResult_false():
check_AssertEqualsResult(False,4,5)
def test_AssertInResult_true():
check_AssertInResult(True,4,[1,2,4,8,16,32,64])
def test_AssertInResult_false():
check_AssertInResult(False,4,[1,1,2,3,5,8,13])
def test_AssertInstanceResult_true():
check_AssertInstanceResult(True,IOError,Exception)
def test_AssertInstanceResult_false():
check_AssertInstanceResult(False,IOError,WindowsError)
def test_AssertRaisesResult_true():
check_AssertRaisesResult(True,TRACE)
def test_AssertRaisesResult_false():
check_AssertRaisesResult(False,"")
def test_ExpectedErrorResult_true():
check_ExpectedErrorResult(True,LINENO)
def test_ExpectedErrorResult_false():
check_ExpectedErrorResult(False,None)
def test_FailResult():
result = FailResult(LINENO,FAIL)
assert result.lineno == LINENO
assert result.mess == FAIL
assert result.result == False
def test_AssertError():
result = AssertError(TRACE)
assert result.trace == TRACE
assert result.result is None
##### TEST RESULTS #####
NAME = "FOO"
def test_TestResult():
test_result = TestResult(NAME)
assert test_result.name == NAME
assert not test_result.before
assert not test_result.after
def test_TestResult_true():
test_result = TestResult(NAME)
test_result.extend(make_AssertResult_list(True,True,True))
assert test_result.get_status() == True
def test_TestResult_false():
test_result = TestResult(NAME)
test_result.extend(make_AssertResult_list(True,True,False))
assert test_result.get_status() == False
def test_TestClassResult():
cls_result = TestClassResult(NAME)
assert cls_result.name == NAME
assert not cls_result.before
assert not cls_result.after
def test_TestClassResult_true():
cls_result = TestClassResult(NAME)
cls_result.extend(make_TestResult_list(True,True,True))
assert cls_result.get_status() == True
def test_TestClassResult_false():
cls_result = TestClassResult(NAME)
cls_result.extend(make_TestResult_list(True,True,False))
assert cls_result.get_status() == False
def test_TestModuleResult():
mod_result = TestModuleResult(NAME)
assert mod_result.name == NAME
assert not mod_result.before
assert not mod_result.after
def test_TestModuleResult_true():
mod_result = TestModuleResult(NAME)
mod_result.extend(make_TestClassResult_list(True,True,True))
assert mod_result.get_status() == True
def test_TestModuleResult_false():
mod_result = TestModuleResult(NAME)
mod_result.extend(make_TestClassResult_list(True,True,False))
assert mod_result.get_status() == False
def test_TestSuiteResult():
suite_result = TestSuiteResult(NAME)
assert suite_result.name == NAME
assert not suite_result.before
assert not suite_result.after
def test_TestSuiteResult_true():
suite_result = TestSuiteResult(NAME)
suite_result.extend(make_TestModuleResult_list(True,True,True))
assert suite_result.get_status() == True
def test_TestSuiteResult_false():
suite_result = TestModuleResult(NAME)
suite_result.extend(make_TestModuleResult_list(True,True,False))
assert suite_result.get_status() == False
##### TEST ERRORS #####
def construct_call_str(name, args):
arg_str = ",".join([str(arg) for arg in args])
return "{name}({arg_str})".format(name=name,arg_str=arg_str)
def check_PyInqError(func_name, arg_dict, error_cls, result_cls, check_func):
call = construct_call_str(func_name,arg_dict.values())
error = error_cls(LINENO,call,**arg_dict)
result = error.result()
assert error.lineno == LINENO
assert error.call == call
for arg_name in arg_dict:
assert getattr(error,arg_name) == arg_dict[arg_name]
assert type(result) is result_cls
check_func(state=False,lineno=LINENO,call=call,result=result,**arg_dict)
def test_PyInqAssertError():
arg_dict = {}
check_PyInqError("assert_true",arg_dict,PyInqAssertError,AssertResult,check_AssertResult)
def test_PyInqAssertEqualsError():
arg_dict = {"actual":4, "expected":42}
check_PyInqError("assert_equal",arg_dict,PyInqAssertEqualsError,AssertEqualsResult,check_AssertEqualsResult)
def test_PyInqAssertInError():
arg_dict = {"item":4, "collection":[1,1,2,3,5,8,13,21]}
check_PyInqError("assert_in",arg_dict,PyInqAssertInError,AssertInResult,check_AssertInResult)
def test_PyInqAssertInstanceError():
arg_dict = {"obj":IOError, "cls":IndexError}
check_PyInqError("assert_is_instance",arg_dict,PyInqAssertInstanceError,AssertInstanceResult,check_AssertInstanceResult)
def test_PyInqAssertRaisesError():
arg_dict = {"expected":IOError, "trace":""}
check_PyInqError("assert_raises",arg_dict,PyInqAssertRaisesError,AssertRaisesResult,check_AssertRaisesResult)
def test_PyInqFailError():
arg_dict = {"mess":"This is a failure message."}
error = PyInqFailError(LINENO,**arg_dict)
result = error.result()
assert error.lineno == LINENO
assert error.mess == arg_dict["mess"]
assert type(result) is FailResult
assert result.lineno == LINENO
assert result.mess == arg_dict["mess"]
assert result.result == False
##### TEST HELPERS #####
def check_Result(state, result=None):
if not result:
result = Result(state)
assert result.result == state
def check_AssertResult(state, lineno=LINENO, call=CALL, result=None):
if not result:
result = AssertResult(lineno,call,state)
assert result.lineno == lineno
assert result.call == call
assert result.result == state
def check_AssertEqualsResult(state, actual, expected, lineno=LINENO, call=CALL, result=None):
if not result:
result = AssertEqualsResult(lineno,call,state,actual,expected)
assert result.lineno == lineno
assert result.call == call
assert result.result == state
assert result.actual == actual
assert result.expected == expected
def check_AssertInResult(state, item, collection, lineno=LINENO, call=CALL, result=None):
if not result:
result = AssertInResult(lineno,call,state,item,collection)
assert result.lineno == lineno
assert result.call == call
assert result.result == state
assert result.item == item
assert result.collection == collection
def check_AssertInstanceResult(state, obj, cls, lineno=LINENO, call=CALL, result=None):
if not result:
result = AssertInstanceResult(lineno,call,state,obj,cls)
assert result.lineno == lineno
assert result.call == call
assert result.result == state
assert result.obj_name == obj.__class__.__name__
assert result.class_name == cls.__name__
def check_AssertRaisesResult(state, trace, lineno=LINENO, call=CALL, expected=EXPECTED, result=None):
if not result:
result = AssertRaisesResult(lineno,call,state,trace,expected)
assert result.lineno == lineno
assert result.call == call
assert result.result == state
assert remove_whitespace(result.trace) == remove_whitespace(trace)
assert result.expected == expected.__name__
def check_ExpectedErrorResult(state, lineno, expected=EXPECTED, result=None):
if not result:
result = ExpectedErrorResult(state,expected,lineno)
assert result.expected == expected.__name__
assert result.lineno == lineno
assert result.call is None
assert result.result == state
def make_AssertResult_list(*state_list):
return [AssertResult(LINENO,CALL,state) for state in state_list]
def make_TestResult_list(*state_list):
result_list = []
for state in state_list:
result = TestResult(NAME)
result.extend(make_AssertResult_list(state))
result_list.append(result)
return result_list
def make_TestClassResult_list(*state_list):
result_list = []
for state in state_list:
result = TestClassResult(NAME)
result.extend(make_TestResult_list(state))
result_list.append(result)
return result_list
def make_TestModuleResult_list(*state_list):
result_list = []
for state in state_list:
result = TestModuleResult(NAME)
result.extend(make_TestClassResult_list(state))
result_list.append(result)
return result_list
##### UTIL #####
def remove_whitespace(string):
return ''.join([line.strip() for line in string.splitlines()])
| isc | 8,524,622,938,886,892,000 | 30.883333 | 124 | 0.716675 | false |
neogi/machine-learning | clustering_and_retrieval/gaussian_mixture_model/em-gmm.py | 1 | 11332 | # Imports
import sframe
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import multivariate_normal
import copy
from PIL import Image
from io import BytesIO
import matplotlib.mlab as mlab
import colorsys
def generate_MoG_data(num_data, means, covariances, weights):
data = []
for i in range(num_data):
# Use np.random.choice and weights to pick a cluster id greater than or equal to 0 and less than num_clusters.
k = np.random.choice(len(weights), 1, p=weights)[0]
# Use np.random.multivariate_normal to create data from this cluster
x = np.random.multivariate_normal(means[k], covariances[k])
data.append(x)
return data
def log_sum_exp(Z):
""" Compute log(\sum_i exp(Z_i)) for some array Z."""
return np.max(Z) + np.log(np.sum(np.exp(Z - np.max(Z))))
def loglikelihood(data, weights, means, covs):
""" Compute the loglikelihood of the data for a Gaussian mixture model with the given parameters. """
num_clusters = len(means)
num_dim = len(data[0])
ll = 0
for d in data:
Z = np.zeros(num_clusters)
for k in range(num_clusters):
# Compute (x-mu)^T * Sigma^{-1} * (x-mu)
delta = np.array(d) - means[k]
exponent_term = np.dot(delta.T, np.dot(np.linalg.inv(covs[k]), delta))
# Compute loglikelihood contribution for this data point and this cluster
Z[k] += np.log(weights[k])
Z[k] -= 1/2. * (num_dim * np.log(2*np.pi) + np.log(np.linalg.det(covs[k])) + exponent_term)
# Increment loglikelihood contribution of this data point across all clusters
ll += log_sum_exp(Z)
return ll
def EM(data, init_means, init_covariances, init_weights, maxiter=1000, thresh=1e-4):
# Make copies of initial parameters, which we will update during each iteration
means = copy.deepcopy(init_means)
covariances = copy.deepcopy(init_covariances)
weights = copy.deepcopy(init_weights)
# Infer dimensions of dataset and the number of clusters
num_data = len(data)
num_dim = len(data[0])
num_clusters = len(means)
# Initialize some useful variables
resp = np.zeros((num_data, num_clusters))
ll = loglikelihood(data, weights, means, covariances)
ll_trace = [ll]
for i in range(maxiter):
if i % 5 == 0:
print("Iteration %s" % i)
# E-step: compute responsibilities
# Update resp matrix so that resp[j, k] is the responsibility of cluster k for data point j.
# Hint: To compute likelihood of seeing data point j given cluster k, use multivariate_normal.pdf.
for j in range(num_data):
for k in range(num_clusters):
# YOUR CODE HERE
resp[j, k] = weights[k] * multivariate_normal.pdf(x=data[j],
mean=means[k],
cov=covariances[k])
row_sums = resp.sum(axis=1)[:, np.newaxis]
resp = resp / row_sums # normalize over all possible cluster assignments
# M-step
# Compute the total responsibility assigned to each cluster, which will be useful when
# implementing M-steps below. In the lectures this is called N^{soft}
counts = np.sum(resp, axis=0)
for k in range(num_clusters):
# Update the weight for cluster k using the M-step update rule for the cluster weight, \hat{\pi}_k.
# YOUR CODE HERE
Nsoft_k = counts[k]
weights[k] = float(Nsoft_k)/float(num_data)
# Update means for cluster k using the M-step update rule for the mean variables.
# This will assign the variable means[k] to be our estimate for \hat{\mu}_k.
weighted_sum = 0
for j in range(num_data):
# YOUR CODE HERE
weighted_sum += resp[j, k] * data[j]
# YOUR CODE HERE
means[k] = weighted_sum/Nsoft_k
# Update covariances for cluster k using the M-step update rule for covariance variables.
# This will assign the variable covariances[k] to be the estimate for \hat{Sigma}_k.
weighted_sum = np.zeros((num_dim, num_dim))
for j in range(num_data):
# YOUR CODE HERE (Hint: Use np.outer on the data[j] and this cluster's mean)
weighted_sum += resp[j, k] * np.outer(data[j] - means[k], data[j] - means[k])
# YOUR CODE HERE
covariances[k] = weighted_sum/Nsoft_k
# Compute the loglikelihood at this iteration
# YOUR CODE HERE
ll_latest = loglikelihood(data, weights, means, covariances)
ll_trace.append(ll_latest)
# Check for convergence in log-likelihood and store
if (ll_latest - ll) < thresh and ll_latest > -np.inf:
break
ll = ll_latest
if i % 5 != 0:
print("Iteration %s" % i)
out = {'weights': weights, 'means': means, 'covs': covariances, 'loglik': ll_trace, 'resp': resp}
return out
def plot_contours(data, means, covs, title):
plt.figure()
plt.plot([x[0] for x in data], [y[1] for y in data],'ko') # data
delta = 0.025
k = len(means)
x = np.arange(-2.0, 7.0, delta)
y = np.arange(-2.0, 7.0, delta)
X, Y = np.meshgrid(x, y)
col = ['green', 'red', 'indigo']
for i in range(k):
mean = means[i]
cov = covs[i]
sigmax = np.sqrt(cov[0][0])
sigmay = np.sqrt(cov[1][1])
sigmaxy = cov[0][1]/(sigmax*sigmay)
Z = mlab.bivariate_normal(X, Y, sigmax, sigmay, mean[0], mean[1], sigmaxy)
plt.contour(X, Y, Z, colors = col[i])
plt.title(title)
plt.rcParams.update({'font.size':16})
plt.tight_layout()
def plot_responsibilities_in_RB(img, resp, title):
N, K = resp.shape
HSV_tuples = [(x*1.0/K, 0.5, 0.9) for x in range(K)]
RGB_tuples = map(lambda x: colorsys.hsv_to_rgb(*x), HSV_tuples)
R = img['red']
B = img['blue']
resp_by_img_int = [[resp[n][k] for k in range(K)] for n in range(N)]
cols = [tuple(np.dot(resp_by_img_int[n], np.array(RGB_tuples))) for n in range(N)]
plt.figure()
for n in range(len(R)):
plt.plot(R[n], B[n], 'o', c=cols[n])
plt.title(title)
plt.xlabel('R value')
plt.ylabel('B value')
plt.rcParams.update({'font.size':16})
plt.tight_layout()
def get_top_images(assignments, cluster, k=5):
# YOUR CODE HERE
images_in_cluster = assignments[assignments['assignments']==cluster]
print images_in_cluster
top_images = images_in_cluster.topk('probs', k)
return top_images['image']
def save_images(images, prefix):
for i, image in enumerate(images):
Image.open(BytesIO(image._image_data)).save(prefix % i)
# Model parameters
init_means = [
[5, 0], # mean of cluster 1
[1, 1], # mean of cluster 2
[0, 5] # mean of cluster 3
]
init_covariances = [
[[.5, 0.], [0, .5]], # covariance of cluster 1
[[.92, .38], [.38, .91]], # covariance of cluster 2
[[.5, 0.], [0, .5]] # covariance of cluster 3
]
init_weights = [1/4., 1/2., 1/4.] # weights of each cluster
# Generate data
np.random.seed(4)
data = generate_MoG_data(100, init_means, init_covariances, init_weights)
# Plot clusters
plt.figure()
d = np.vstack(data)
plt.plot(d[:,0], d[:,1],'ko')
plt.rcParams.update({'font.size':16})
plt.tight_layout()
# Test EM algorithm
np.random.seed(4)
# Initialization of parameters
chosen = np.random.choice(len(data), 3, replace=False)
initial_means = [data[x] for x in chosen]
initial_covs = [np.cov(data, rowvar=0)] * 3
initial_weights = [1/3.] * 3
# Run EM
results = EM(data, initial_means, initial_covs, initial_weights)
# Parameters after initialization
plot_contours(data, initial_means, initial_covs, 'Initial clusters')
# Parameters after 12 iterations
results = EM(data, initial_means, initial_covs, initial_weights, maxiter=12)
plot_contours(data, results['means'], results['covs'], 'Clusters after 12 iterations')
# Parameters after running EM to convergence
results = EM(data, initial_means, initial_covs, initial_weights)
plot_contours(data, results['means'], results['covs'], 'Final clusters')
# Log-likelihood plot
loglikelihoods = results['loglik']
plt.plot(range(len(loglikelihoods)), loglikelihoods, linewidth=4)
plt.xlabel('Iteration')
plt.ylabel('Log-likelihood')
plt.rcParams.update({'font.size':16})
plt.tight_layout()
# Load image data
images = sframe.SFrame('../data/Week04/images.sf/')
images['rgb'] = images.pack_columns(['red', 'green', 'blue'])['X4']
# Run EM on image data
np.random.seed(1)
# Initalize parameters
init_means = [images['rgb'][x] for x in np.random.choice(len(images), 4, replace=False)]
cov = np.diag([images['red'].var(), images['green'].var(), images['blue'].var()])
init_covariances = [cov, cov, cov, cov]
init_weights = [1/4., 1/4., 1/4., 1/4.]
# Convert rgb data to numpy arrays
img_data = [np.array(i) for i in images['rgb']]
# Run our EM algorithm on the image data using the above initializations.
# This should converge in about 125 iterations
out = EM(img_data, init_means, init_covariances, init_weights)
# Log-likelihood plot
ll = out['loglik']
plt.plot(range(len(ll)),ll,linewidth=4)
plt.xlabel('Iteration')
plt.ylabel('Log-likelihood')
plt.rcParams.update({'font.size':16})
plt.tight_layout()
plt.figure()
plt.plot(range(10,len(ll)),ll[10:],linewidth=4)
plt.xlabel('Iteration')
plt.ylabel('Log-likelihood')
plt.rcParams.update({'font.size':16})
plt.tight_layout()
# Visualize evolution of responsibility
N, K = out['resp'].shape
random_resp = np.random.dirichlet(np.ones(K), N)
plot_responsibilities_in_RB(images, random_resp, 'Random responsibilities')
out = EM(img_data, init_means, init_covariances, init_weights, maxiter=1)
plot_responsibilities_in_RB(images, out['resp'], 'After 1 iteration')
out = EM(img_data, init_means, init_covariances, init_weights, maxiter=20)
plot_responsibilities_in_RB(images, out['resp'], 'After 20 iterations')
# Interpreting clusters
weights = out['weights']
means = out['means']
covariances = out['covs']
rgb = images['rgb']
N = len(images) # number of images
K = len(means) # number of clusters
assignments = [0]*N
probs = [0]*N
for i in range(N):
# Compute the score of data point i under each Gaussian component:
p = np.zeros(K)
for k in range(K):
p[k] = weights[k]*multivariate_normal.pdf(rgb[i], mean=means[k], cov=covariances[k])
# Compute assignments of each data point to a given cluster based on the above scores:
assignments[i] = np.argmax(p)
# For data point i, store the corresponding score under this cluster assignment:
probs[i] = np.max(p)
assignments = sframe.SFrame({'assignments':assignments, 'probs':probs, 'image': images['image']})
for idx in range(4):
get_top_images(assignments, idx)
for component_id in range(4):
print 'Component {0:d}'.format(component_id)
images = get_top_images(assignments, component_id)
save_images(images, 'component_{0:d}_%d.jpg'.format(component_id))
print '\n'
| gpl-3.0 | 2,065,051,852,382,707,500 | 33.867692 | 119 | 0.623544 | false |
xorpaul/check_mk | modules/automation.py | 1 | 45601 | #!/usr/bin/python
# -*- encoding: utf-8; py-indent-offset: 4 -*-
# +------------------------------------------------------------------+
# | ____ _ _ __ __ _ __ |
# | / ___| |__ ___ ___| | __ | \/ | |/ / |
# | | | | '_ \ / _ \/ __| |/ / | |\/| | ' / |
# | | |___| | | | __/ (__| < | | | | . \ |
# | \____|_| |_|\___|\___|_|\_\___|_| |_|_|\_\ |
# | |
# | Copyright Mathias Kettner 2014 [email protected] |
# +------------------------------------------------------------------+
#
# This file is part of Check_MK.
# The official homepage is at http://mathias-kettner.de/check_mk.
#
# check_mk 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 in version 2. check_mk is distributed
# in the hope that it will be useful, but WITHOUT ANY WARRANTY; with-
# out even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE. See the GNU General Public License for more de-
# ails. You should have received a copy of the GNU General Public
# License along with GNU Make; see the file COPYING. If not, write
# to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
# Boston, MA 02110-1301 USA.
class MKAutomationError(Exception):
def __init__(self, reason):
self.reason = reason
def __str__(self):
return self.reason
def do_automation(cmd, args):
try:
if cmd == "get-configuration":
read_config_files(with_conf_d=False)
result = automation_get_configuration()
elif cmd == "get-check-information":
result = automation_get_check_information()
elif cmd == "get-check-manpage":
result = automation_get_check_manpage(args)
elif cmd == "get-check-catalog":
result = automation_get_check_catalog(args)
elif cmd == "notification-get-bulks":
result = automation_get_bulks(args)
else:
read_config_files()
if cmd == "try-inventory":
result = automation_try_discovery(args)
elif cmd == "inventory":
result = automation_discovery(args)
elif cmd == "analyse-service":
result = automation_analyse_service(args)
elif cmd == "active-check":
result = automation_active_check(args)
elif cmd == "get-autochecks":
result = automation_get_autochecks(args)
elif cmd == "set-autochecks":
result = automation_set_autochecks(args)
elif cmd == "reload":
result = automation_restart("reload")
elif cmd == "restart":
result = automation_restart("restart")
elif cmd == "scan-parents":
result = automation_scan_parents(args)
elif cmd == "diag-host":
result = automation_diag_host(args)
elif cmd == "delete-host":
result = automation_delete_host(args)
elif cmd == "rename-host":
result = automation_rename_host(args)
elif cmd == "create-snapshot":
result = automation_create_snapshot(args)
elif cmd == "notification-replay":
result = automation_notification_replay(args)
elif cmd == "notification-analyse":
result = automation_notification_analyse(args)
elif cmd == "update-dns-cache":
result = automation_update_dns_cache()
elif cmd == "bake-agents":
result = automation_bake_agents()
else:
raise MKAutomationError("Automation command '%s' is not implemented." % cmd)
except MKAutomationError, e:
sys.stderr.write("%s\n" % e)
if opt_debug:
raise
output_profile()
sys.exit(1)
except Exception, e:
if opt_debug:
raise
else:
sys.stderr.write("%s\n" % e)
output_profile()
sys.exit(2)
if opt_debug:
import pprint
sys.stdout.write(pprint.pformat(result)+"\n")
else:
sys.stdout.write("%r\n" % (result,))
output_profile()
sys.exit(0)
# Does inventory for *one* host. Possible values for how:
# "new" - find only new services (like -I)
# "remove" - remove exceeding services
# "fixall" - find new, remove exceeding
# "refresh" - drop all services and reinventorize
def automation_discovery(args):
# Error sensivity
if args[0] == "@raiseerrors":
args = args[1:]
on_error = "raise"
os.dup2(os.open("/dev/null", os.O_WRONLY), 2)
else:
on_error = "ignore"
# perform full SNMP scan on SNMP devices?
if args[0] == "@scan":
do_snmp_scan = True
args = args[1:]
else:
do_snmp_scan = False
# use cache files if present?
if args[0] == "@cache":
args = args[1:]
use_caches = True
else:
use_caches = False
if len(args) < 2:
raise MKAutomationError("Need two arguments: new|remove|fixall|refresh HOSTNAME")
how = args[0]
hostnames = args[1:]
counts = {}
failed_hosts = {}
for hostname in hostnames:
counts.setdefault(hostname, [0, 0, 0, 0]) # added, removed, kept, total
try:
# in "refresh" mode we first need to remove all previously discovered
# checks of the host, so that get_host_services() does show us the
# new discovered check parameters.
if how == "refresh":
counts[hostname][1] += remove_autochecks_of(hostname) # this is cluster-aware!
# Compute current state of new and existing checks
services = get_host_services(hostname, use_caches=use_caches,
do_snmp_scan=do_snmp_scan, on_error=on_error)
# Create new list of checks
new_items = {}
for (check_type, item), (check_source, paramstring) in services.items():
if check_source in ("custom", "legacy", "active", "manual"):
continue # this is not an autocheck or ignored and currently not checked
# Note discovered checks that are shadowed by manual checks will vanish
# that way.
if check_source in ("new"):
if how in ("new", "fixall", "refresh"):
counts[hostname][0] += 1 # added
counts[hostname][3] += 1 # total
new_items[(check_type, item)] = paramstring
elif check_source in ("old", "ignored"):
# keep currently existing valid services in any case
new_items[(check_type, item)] = paramstring
counts[hostname][2] += 1 # kept
counts[hostname][3] += 1 # total
elif check_source in ("obsolete", "vanished"):
# keep item, if we are currently only looking for new services
# otherwise fix it: remove ignored and non-longer existing services
if how not in ("fixall", "remove"):
new_items[(check_type, item)] = paramstring
counts[hostname][2] += 1 # kept
counts[hostname][3] += 1 # total
else:
counts[hostname][1] += 1 # removed
# Silently keep clustered services
elif check_source.startswith("clustered_"):
new_items[(check_type, item)] = paramstring
else:
raise MKGeneralException("Unknown check source '%s'" % check_source)
set_autochecks_of(hostname, new_items)
except Exception, e:
if opt_debug:
raise
failed_hosts[hostname] = str(e)
return counts, failed_hosts
def automation_try_discovery(args):
use_caches = False
do_snmp_scan = False
if args[0] == '@noscan':
args = args[1:]
do_snmp_scan = False
use_caches = True
elif args[0] == '@scan':
args = args[1:]
do_snmp_scan = True
use_caches = False
if args[0] == '@raiseerrors':
on_error = "raise"
args = args[1:]
else:
on_error = "ignore"
# TODO: Remove this unlucky option opt_use_cachefile. At least do not
# handle this option so deep in the code. It should only be handled
# by top-level functions.
global opt_use_cachefile, check_max_cachefile_age
opt_use_cachefile = use_caches
if use_caches:
check_max_cachefile_age = inventory_max_cachefile_age
hostname = args[0]
table = get_check_preview(hostname, use_caches=use_caches,
do_snmp_scan=do_snmp_scan, on_error=on_error)
return table
# Set the new list of autochecks. This list is specified by a
# table of (checktype, item). No parameters are specified. Those
# are either (1) kept from existing autochecks or (2) computed
# from a new inventory. Note: we must never convert check parameters
# from python source code to actual values.
def automation_set_autochecks(args):
hostname = args[0]
new_items = eval(sys.stdin.read())
set_autochecks_of(hostname, new_items)
def set_autochecks_of(hostname, new_items):
# A Cluster does not have an autochecks file
# All of its services are located in the nodes instead
# So we cycle through all nodes remove all clustered service
# and add the ones we've got from stdin
if is_cluster(hostname):
for node in nodes_of(hostname):
new_autochecks = []
existing = parse_autochecks_file(node)
for check_type, item, paramstring in existing:
descr = service_description(check_type, item)
if hostname != host_of_clustered_service(node, descr):
new_autochecks.append((check_type, item, paramstring))
for (check_type, item), paramstring in new_items.items():
new_autochecks.append((check_type, item, paramstring))
# write new autochecks file for that host
automation_write_autochecks_file(node, new_autochecks)
else:
existing = parse_autochecks_file(hostname)
# write new autochecks file, but take paramstrings from existing ones
# for those checks which are kept
new_autochecks = []
for ct, item, paramstring in existing:
if (ct, item) in new_items:
new_autochecks.append((ct, item, paramstring))
del new_items[(ct, item)]
for (ct, item), paramstring in new_items.items():
new_autochecks.append((ct, item, paramstring))
# write new autochecks file for that host
automation_write_autochecks_file(hostname, new_autochecks)
def automation_write_autochecks_file(hostname, table):
if not os.path.exists(autochecksdir):
os.makedirs(autochecksdir)
path = "%s/%s.mk" % (autochecksdir, hostname)
f = file(path, "w")
f.write("[\n")
for check_type, item, paramstring in table:
f.write(" (%r, %r, %s),\n" % (check_type, item, paramstring))
f.write("]\n")
if inventory_check_autotrigger and inventory_check_interval:
schedule_inventory_check(hostname)
def automation_get_autochecks(args):
hostname = args[0]
result = []
for ct, item, paramstring in parse_autochecks_file(hostname):
result.append((ct, item, eval(paramstring), paramstring))
return result
def schedule_inventory_check(hostname):
try:
import socket
s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
s.connect(livestatus_unix_socket)
now = int(time.time())
if 'cmk-inventory' in use_new_descriptions_for:
command = "SCHEDULE_FORCED_SVC_CHECK;%s;Check_MK Discovery;%d" % (hostname, now)
else:
# FIXME: Remove this old name handling one day
command = "SCHEDULE_FORCED_SVC_CHECK;%s;Check_MK inventory;%d" % (hostname, now)
s.send("COMMAND [%d] %s\n" % (now, command))
except Exception, e:
if opt_debug:
raise
# Determine the type of the check, and how the parameters are being
# constructed
def automation_analyse_service(args):
global g_hostname
hostname = args[0]
servicedesc = args[1]
g_hostname = hostname # To be sure for all subfunctions
# We just consider types of checks that are managed via WATO.
# We have the following possible types of services:
# 1. manual checks (static_checks) (currently overriding inventorized checks)
# 2. inventorized check
# 3. classical checks
# 4. active checks
# Compute effective check table, in order to remove SNMP duplicates
check_table = get_check_table(hostname, remove_duplicates = True)
# 1. Manual checks
for nr, (checkgroup, entries) in enumerate(static_checks.items()):
for entry in entries:
entry, rule_options = get_rule_options(entry)
if rule_options.get("disabled"):
continue
# Parameters are optional
if len(entry[0]) == 2:
checktype, item = entry[0]
params = None
else:
checktype, item, params = entry[0]
if len(entry) == 3:
taglist, hostlist = entry[1:3]
else:
hostlist = entry[1]
taglist = []
if hosttags_match_taglist(tags_of_host(hostname), taglist) and \
in_extraconf_hostlist(hostlist, hostname):
descr = service_description(checktype, item)
if descr == servicedesc:
return {
"origin" : "static",
"checkgroup" : checkgroup,
"checktype" : checktype,
"item" : item,
"rule_nr" : nr,
"parameters" : params,
}
# 2. Load all autochecks of the host in question and try to find
# our service there
try:
path = "%s/%s.mk" % (autochecksdir, hostname)
for entry in eval(file(path).read()):
if len(entry) == 4: # old format
hn, ct, item, params = entry
else:
ct, item, params = entry # new format without host name
hn = hostname
if (ct, item) not in check_table:
continue # this is a removed duplicate or clustered service
descr = service_description(ct, item)
if hn == hostname and descr == servicedesc:
dlv = check_info[ct].get("default_levels_variable")
if dlv:
fs = factory_settings.get(dlv, None)
else:
fs = None
return {
"origin" : "auto",
"checktype" : ct,
"checkgroup" : check_info[ct].get("group"),
"item" : item,
"inv_parameters" : params,
"factory_settings" : fs,
"parameters" : compute_check_parameters(hostname, ct, item, params),
}
except:
if opt_debug:
raise
# 3. Classical checks
custchecks = host_extra_conf(hostname, custom_checks)
for nr, entry in enumerate(custchecks):
desc = entry["service_description"]
if desc == servicedesc:
result = {
"origin" : "classic",
"rule_nr" : nr,
}
if "command_line" in entry: # Only active checks have a command line
result["command_line"] = entry["command_line"]
return result
# 4. Active checks
for acttype, rules in active_checks.items():
entries = host_extra_conf(hostname, rules)
if entries:
act_info = active_check_info[acttype]
for params in entries:
description = act_info["service_description"](params)
if description == servicedesc:
return {
"origin" : "active",
"checktype" : acttype,
"parameters" : params,
}
return {} # not found
# TODO: Was ist mit Clustern???
# TODO: Klappt das mit automatischen verschatten von SNMP-Checks (bei dual Monitoring)
def automation_delete_host(args):
hostname = args[0]
for path in [
"%s/%s" % (precompiled_hostchecks_dir, hostname),
"%s/%s.py" % (precompiled_hostchecks_dir, hostname),
"%s/%s.mk" % (autochecksdir, hostname),
"%s/%s" % (logwatch_dir, hostname),
"%s/%s" % (counters_directory, hostname),
"%s/%s" % (tcp_cache_dir, hostname),
"%s/%s.*" % (tcp_cache_dir, hostname)]:
os.system("rm -rf '%s'" % path)
def automation_restart(job = "restart", use_rushd = True):
# make sure, Nagios does not inherit any open
# filedescriptors. This really happens, e.g. if
# check_mk is called by WATO via Apache. Nagios inherits
# the open file where Apache is listening for incoming
# HTTP connections. Really.
if monitoring_core == "nagios":
objects_file = nagios_objects_file
for fd in range(3, 256):
try:
os.close(fd)
except:
pass
else:
objects_file = var_dir + "/core/config"
if job == "restart":
job = "reload" # force reload for CMC
# os.closerange(3, 256) --> not available in older Python versions
class null_file:
def write(self, stuff):
pass
def flush(self):
pass
# Deactivate stdout by introducing fake file without filedescriptor
old_stdout = sys.stdout
sys.stdout = null_file()
try:
backup_path = None
if not lock_objects_file():
raise MKAutomationError("Cannot activate changes. "
"Another activation process is currently in progresss")
if os.path.exists(objects_file):
backup_path = objects_file + ".save"
os.rename(objects_file, backup_path)
else:
backup_path = None
try:
if monitoring_core == "nagios":
create_nagios_config(file(objects_file, "w"))
else:
do_create_cmc_config(opt_cmc_relfilename, use_rushd = use_rushd)
if "do_bake_agents" in globals() and bake_agents_on_restart:
do_bake_agents()
except Exception, e:
if backup_path:
os.rename(backup_path, objects_file)
if opt_debug:
raise
raise MKAutomationError("Error creating configuration: %s" % e)
if do_check_nagiosconfig():
if backup_path:
os.remove(backup_path)
if monitoring_core == "cmc":
do_pack_config()
else:
do_precompile_hostchecks()
do_core_action(job)
else:
if backup_path:
os.rename(backup_path, objects_file)
else:
os.remove(objects_file)
raise MKAutomationError("Configuration for monitoring core is invalid. Rolling back.")
except Exception, e:
if backup_path and os.path.exists(backup_path):
os.remove(backup_path)
if opt_debug:
raise
raise MKAutomationError(str(e))
sys.stdout = old_stdout
def automation_get_configuration():
# We read the list of variable names from stdin since
# that could be too much for the command line
variable_names = eval(sys.stdin.read())
result = {}
for varname in variable_names:
if varname in globals():
if not hasattr(globals()[varname], '__call__'):
result[varname] = globals()[varname]
return result
def automation_get_check_catalog(args):
def path_prefix_matches(p, op):
if op and not p:
return False
elif not op:
return True
else:
return p[0] == op[0] and path_prefix_matches(p[1:], op[1:])
read_manpage_catalog()
tree = {}
if len(args) > 0:
only_path = tuple(args)
else:
only_path = ()
for path, entries in g_manpage_catalog.items():
if not path_prefix_matches(path, only_path):
continue
subtree = tree
for component in path[:-1]:
subtree = subtree.setdefault(component, {})
subtree[path[-1]] = map(strip_manpage_entry, entries)
for p in only_path:
tree = tree[p]
return tree, manpage_catalog_titles
def strip_manpage_entry(entry):
return dict([ (k,v) for (k,v) in entry.items() if k in [
"name", "agents", "title"
]])
def automation_get_check_information():
manuals = all_manuals()
checks = {}
for check_type, check in check_info.items():
manfile = manuals.get(check_type)
if manfile:
title = file(manfile).readline().strip().split(":", 1)[1].strip()
else:
title = check_type
checks[check_type] = { "title" : title }
if check["group"]:
checks[check_type]["group"] = check["group"]
checks[check_type]["service_description"] = check.get("service_description","%s")
checks[check_type]["snmp"] = check_uses_snmp(check_type)
return checks
def automation_get_check_manpage(args):
if len(args) != 1:
raise MKAutomationError("Need exactly one argument.")
check_type = args[0]
manpage = load_manpage(args[0])
# Add a few informations from check_info. Note: active checks do not
# have an entry in check_info
if check_type in check_info:
manpage["type"] = "check_mk"
info = check_info[check_type]
for key in [ "snmp_info", "has_perfdata", "service_description" ]:
if key in info:
manpage[key] = info[key]
if "." in check_type:
section = check_type.split(".")[0]
if section in check_info and "snmp_info" in check_info[section]:
manpage["snmp_info"] = check_info[section]["snmp_info"]
if "group" in info:
manpage["group"] = info["group"]
# Assume active check
elif check_type.startswith("check_"):
manpage["type"] = "active"
return manpage
def automation_scan_parents(args):
settings = {
"timeout" : int(args[0]),
"probes" : int(args[1]),
"max_ttl" : int(args[2]),
"ping_probes" : int(args[3]),
}
hostnames = args[4:]
traceroute_prog = find_bin_in_path('traceroute')
if not traceroute_prog:
raise MKAutomationError("Cannot find binary <tt>traceroute</tt> in search path.")
try:
gateways = scan_parents_of(hostnames, silent=True, settings=settings)
return gateways
except Exception, e:
raise MKAutomationError(str(e))
def automation_diag_host(args):
import subprocess
hostname, test, ipaddress, snmp_community = args[:4]
agent_port, snmp_timeout, snmp_retries = map(int, args[4:7])
cmd = args[7]
if not ipaddress:
try:
ipaddress = lookup_ipaddress(hostname)
except:
raise MKGeneralException("Cannot resolve hostname %s into IP address" % hostname)
try:
if test == 'ping':
p = subprocess.Popen('ping -A -i 0.2 -c 2 -W 5 %s 2>&1' % ipaddress, shell = True, stdout = subprocess.PIPE)
response = p.stdout.read()
return (p.wait(), response)
elif test == 'agent':
if not cmd:
cmd = get_datasource_program(hostname, ipaddress)
if cmd:
return 0, get_agent_info_program(cmd)
else:
return 0, get_agent_info_tcp(hostname, ipaddress, agent_port or None)
elif test == 'traceroute':
traceroute_prog = find_bin_in_path('traceroute')
if not traceroute_prog:
return 1, "Cannot find binary <tt>traceroute</tt>."
else:
p = subprocess.Popen('traceroute -n %s 2>&1' % ipaddress, shell = True, stdout = subprocess.PIPE)
response = p.stdout.read()
return (p.wait(), response)
elif test.startswith('snmp'):
if snmp_community:
explicit_snmp_communities[hostname] = snmp_community
# override timing settings if provided
if snmp_timeout or snmp_retries:
timing = {}
if snmp_timeout:
timing['timeout'] = snmp_timeout
if snmp_retries:
timing['retries'] = snmp_retries
snmp_timing.insert(0, (timing, [], [hostname]))
# SNMP versions
global bulkwalk_hosts, snmpv2c_hosts
if test == 'snmpv2':
bulkwalk_hosts = [hostname]
elif test == 'snmpv2_nobulk':
bulkwalk_hosts = []
snmpv2c_hosts = [hostname]
elif test == 'snmpv1':
bulkwalk_hosts = []
snmpv2c_hosts = []
else:
return 1, "SNMP command not implemented"
data = get_snmp_table(hostname, ipaddress, None, ('.1.3.6.1.2.1.1', ['1.0', '4.0', '5.0', '6.0']))
if data:
return 0, 'sysDescr:\t%s\nsysContact:\t%s\nsysName:\t%s\nsysLocation:\t%s\n' % tuple(data[0])
else:
return 1, 'Got empty SNMP response'
else:
return 1, "Command not implemented"
except Exception, e:
if opt_debug:
raise
return 1, str(e)
# WATO calls this automation when a host has been renamed. We need to change
# several file and directory names.
# HIRN: Hier auch das neue Format berücksichtigen! Andererseits sollte
# eigentlich auch nix Schlimmes passieren, wenn der Hostname *nicht* in
# der Datei steht.
def automation_rename_host(args):
oldname = args[0]
newname = args[1]
actions = []
# Autochecks: simply read and write out the file again. We do
# not store a host name here anymore - but old versions did.
# by rewriting we get rid of the host name.
acpath = autochecksdir + "/" + oldname + ".mk"
if os.path.exists(acpath):
old_autochecks = parse_autochecks_file(oldname)
out = file(autochecksdir + "/" + newname + ".mk", "w")
out.write("[\n")
for ct, item, paramstring in old_autochecks:
out.write(" (%r, %r, %s),\n" % (ct, item, paramstring))
out.write("]\n")
out.close()
os.remove(acpath) # Remove old file
actions.append("autochecks")
# At this place WATO already has changed it's configuration. All further
# data might be changed by the still running core. So we need to stop
# it now.
core_was_running = core_is_running()
if core_was_running:
do_core_action("stop", quiet=True)
# Rename temporary files of the host
for d in [ "cache", "counters" ]:
if rename_host_file(tmp_dir + "/" + d + "/", oldname, newname):
actions.append(d)
if rename_host_dir(tmp_dir + "/piggyback/", oldname, newname):
actions.append("piggyback-load")
# Rename piggy files *created* by the host
piggybase = tmp_dir + "/piggyback/"
if os.path.exists(piggybase):
for piggydir in os.listdir(piggybase):
if rename_host_file(piggybase + piggydir, oldname, newname):
actions.append("piggyback-pig")
# Logwatch
if rename_host_dir(logwatch_dir, oldname, newname):
actions.append("logwatch")
# SNMP walks
if rename_host_file(snmpwalks_dir, oldname, newname):
actions.append("snmpwalk")
# OMD-Stuff. Note: The question really is whether this should be
# included in Check_MK. The point is - however - that all these
# actions need to take place while the core is stopped.
if omd_root:
actions += omd_rename_host(oldname, newname)
# Start monitoring again. In case of CMC we need to ignore
# any configuration created by the CMC Rushahead daemon
if core_was_running:
global ignore_ip_lookup_failures
ignore_ip_lookup_failures = True # force config generation to succeed. The core *must* start.
automation_restart("start", use_rushd = False)
if monitoring_core == "cmc":
try:
os.remove(var_dir + "/core/config.rush")
os.remove(var_dir + "/core/config.rush.id")
except:
pass
if failed_ip_lookups:
actions.append("ipfail")
return actions
def rename_host_dir(basedir, oldname, newname):
import shutil
if os.path.exists(basedir + "/" + oldname):
if os.path.exists(basedir + "/" + newname):
shutil.rmtree(basedir + "/" + newname)
os.rename(basedir + "/" + oldname, basedir + "/" + newname)
return 1
return 0
def rename_host_file(basedir, oldname, newname):
if os.path.exists(basedir + "/" + oldname):
if os.path.exists(basedir + "/" + newname):
os.remove(basedir + "/" + newname)
os.rename(basedir + "/" + oldname, basedir + "/" + newname)
return 1
return 0
# This functions could be moved out of Check_MK.
def omd_rename_host(oldname, newname):
oldregex = oldname.replace(".", "[.]")
newregex = newname.replace(".", "[.]")
actions = []
# Temporarily stop processing of performance data
npcd_running = os.path.exists(omd_root + "/tmp/pnp4nagios/run/npcd.pid")
if npcd_running:
os.system("omd stop npcd >/dev/null 2>&1 </dev/null")
rrdcache_running = os.path.exists(omd_root + "/tmp/run/rrdcached.sock")
if rrdcache_running:
os.system("omd stop rrdcached >/dev/null 2>&1 </dev/null")
# Fix pathnames in XML files
dirpath = omd_root + "/var/pnp4nagios/perfdata/" + oldname
os.system("sed -i 's@/perfdata/%s/@/perfdata/%s/@' %s/*.xml 2>/dev/null" % (oldname, newname, dirpath))
# RRD files
if rename_host_dir(rrd_path, oldname, newname):
actions.append("rrd")
# entries of rrdcached journal
dirpath = omd_root + "/var/rrdcached/"
if not os.system("sed -i 's@/perfdata/%s/@/perfdata/%s/@' "
"%s/var/rrdcached/rrd.journal.* 2>/dev/null" % ( oldregex, newregex, omd_root)):
actions.append("rrdcached")
# Spoolfiles of NPCD
if not os.system("sed -i 's/HOSTNAME::%s /HOSTNAME::%s /' "
"%s/var/pnp4nagios/perfdata.dump %s/var/pnp4nagios/spool/perfdata.* 2>/dev/null" % (
oldregex, newregex, omd_root, omd_root)):
actions.append("pnpspool")
if rrdcache_running:
os.system("omd start rrdcached >/dev/null 2>&1 </dev/null")
if npcd_running:
os.system("omd start npcd >/dev/null 2>&1 </dev/null")
# Logfiles and history files of CMC and Nagios. Problem
# here: the exact place of the hostname varies between the
# various log entry lines
sed_commands = r'''
s/(INITIAL|CURRENT) (HOST|SERVICE) STATE: %(old)s;/\1 \2 STATE: %(new)s;/
s/(HOST|SERVICE) (DOWNTIME |FLAPPING |)ALERT: %(old)s;/\1 \2ALERT: %(new)s;/
s/PASSIVE (HOST|SERVICE) CHECK: %(old)s;/PASSIVE \1 CHECK: %(new)s;/
s/(HOST|SERVICE) NOTIFICATION: ([^;]+);%(old)s;/\1 NOTIFICATION: \2;%(new)s;/
''' % { "old" : oldregex, "new" : newregex }
patterns = [
"var/check_mk/core/history",
"var/check_mk/core/archive/*",
"var/nagios/nagios.log",
"var/nagios/archive/*",
]
one_matched = False
for pattern in patterns:
command = "sed -ri --file=/dev/fd/0 %s/%s >/dev/null 2>&1" % (omd_root, pattern)
p = os.popen(command, "w")
p.write(sed_commands)
if not p.close():
one_matched = True
if one_matched:
actions.append("history")
# State retention (important for Downtimes, Acknowledgements, etc.)
if monitoring_core == "nagios":
if not os.system("sed -ri 's/^host_name=%s$/host_name=%s/' %s/var/nagios/retention.dat" % (
oldregex, newregex, omd_root)):
actions.append("retention")
else: # CMC
# Create a file "renamed_hosts" with the information about the
# renaming of the hosts. The core will honor this file when it
# reads the status file with the saved state.
file(var_dir + "/core/renamed_hosts", "w").write("%s\n%s\n" % (oldname, newname))
actions.append("retention")
# NagVis maps
if not os.system("sed -i 's/^[[:space:]]*host_name=%s[[:space:]]*$/host_name=%s/' "
"%s/etc/nagvis/maps/*.cfg 2>/dev/null" % (
oldregex, newregex, omd_root)):
actions.append("nagvis")
return actions
def automation_create_snapshot(args):
try:
import tarfile, time, cStringIO, shutil, subprocess, thread, traceback, threading
from hashlib import sha256
the_data = sys.stdin.read()
data = eval(the_data)
snapshot_name = data["snapshot_name"]
snapshot_dir = var_dir + "/wato/snapshots"
work_dir = snapshot_dir + "/workdir/%s" % snapshot_name
if not os.path.exists(work_dir):
os.makedirs(work_dir)
# Open / initialize files
filename_target = "%s/%s" % (snapshot_dir, snapshot_name)
filename_work = "%s/%s.work" % (work_dir, snapshot_name)
filename_status = "%s/%s.status" % (work_dir, snapshot_name)
filename_pid = "%s/%s.pid" % (work_dir, snapshot_name)
filename_subtar = ""
current_domain = ""
file(filename_target, "w").close()
file(filename_status, "w").close()
def wipe_directory(path):
for entry in os.listdir(path):
if entry not in [ '.', '..' ]:
p = path + "/" + entry
if os.path.isdir(p):
shutil.rmtree(p)
else:
os.remove(p)
lock_status_file = threading.Lock()
def update_status_file(domain = None, infotext = None):
lock_status_file.acquire()
if os.path.exists(filename_status):
if domain:
statusinfo[domain] = infotext
statusfile = file(filename_status, "w")
statusfile.write("comment:%s\n" % data.get("comment"," ").encode("utf-8"))
status_list = list(statusinfo.items())
status_list.sort()
for status in status_list:
statusfile.write("%s.tar.gz:%s\n" % status)
lock_status_file.release()
# Set initial status info
statusinfo = {}
for name in data.get("domains", {}).keys():
statusinfo[name] = "TODO:0"
update_status_file()
# Now fork into our own process to have an asynchronous backup creation
try:
pid = os.fork()
if pid > 0:
# Exit parent process
return
# Decouple from parent environment
os.chdir("/")
os.umask(0)
os.setsid()
# Close all fd except stdin,out,err
for fd in range(3, 256):
try:
os.close(fd)
except OSError:
pass
sys.stdout.flush()
sys.stderr.flush()
si = os.open("/dev/null", os.O_RDONLY)
so = os.open("/dev/null", os.O_WRONLY)
os.dup2(si, 0)
os.dup2(so, 1)
os.dup2(so, 2)
os.close(si)
os.close(so)
except OSError, e:
raise MKAutomationError(str(e))
# Save pid of working process.
file(filename_pid, "w").write("%d" % os.getpid())
def cleanup():
wipe_directory(work_dir)
os.rmdir(work_dir)
def check_should_abort():
if not os.path.exists(filename_target):
cleanup()
sys.exit(0)
def get_basic_tarinfo(name):
tarinfo = tarfile.TarInfo(name)
tarinfo.mtime = time.time()
tarinfo.uid = 0
tarinfo.gid = 0
tarinfo.mode = 0644
tarinfo.type = tarfile.REGTYPE
return tarinfo
def update_subtar_size(seconds):
while current_domain != None:
try:
if current_domain:
if os.path.exists(path_subtar):
update_status_file(current_domain, "Processing:%d" % os.stat(path_subtar).st_size)
except:
pass
time.sleep(seconds)
def snapshot_secret():
path = default_config_dir + '/snapshot.secret'
try:
return file(path).read()
except IOError:
# create a secret during first use
try:
s = os.urandom(256)
except NotImplementedError:
s = sha256(time.time())
file(path, 'w').write(s)
return s
#
# Initialize the snapshot tar file and populate with initial information
#
tar_in_progress = tarfile.open(filename_work, "w")
# Add comment to tar file
if data.get("comment"):
tarinfo = get_basic_tarinfo("comment")
tarinfo.size = len(data.get("comment").encode("utf-8"))
tar_in_progress.addfile(tarinfo, cStringIO.StringIO(data.get("comment").encode("utf-8")))
if data.get("created_by"):
tarinfo = get_basic_tarinfo("created_by")
tarinfo.size = len(data.get("created_by"))
tar_in_progress.addfile(tarinfo, cStringIO.StringIO(data.get("created_by")))
# Add snapshot type
snapshot_type = data.get("type")
tarinfo = get_basic_tarinfo("type")
tarinfo.size = len(snapshot_type)
tar_in_progress.addfile(tarinfo, cStringIO.StringIO(snapshot_type))
# Close tar in progress, all other files are included via command line tar
tar_in_progress.close()
#
# Process domains (sorted)
#
subtar_update_thread = thread.start_new_thread(update_subtar_size, (1,))
domains = map(lambda x: x, data.get("domains").items())
domains.sort()
subtar_info = {}
for name, info in domains:
current_domain = name # Set name for update size thread
prefix = info.get("prefix","")
exclude_options = ""
for entry in info.get("exclude", []):
exclude_options += "--exclude=%s " % entry
check_should_abort()
filename_subtar = "%s.tar.gz" % name
path_subtar = "%s/%s" % (work_dir, filename_subtar)
if info.get("backup_command"):
command = info.get("backup_command") % {
"prefix" : prefix,
"path_subtar" : path_subtar,
"work_dir" : work_dir
}
else:
paths = map(lambda x: x[1] == "" and "." or x[1], info.get("paths", []))
command = "tar czf %s --ignore-failed-read --force-local %s -C %s %s" % \
(path_subtar, exclude_options, prefix, " ".join(paths))
proc = subprocess.Popen(command, shell=True, stdin=None, close_fds=True,
stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=prefix)
stdout, stderr = proc.communicate()
exit_code = proc.wait()
# Allow exit codes 0 and 1 (files changed during backup)
if exit_code not in [0, 1]:
raise MKAutomationError("Error while creating backup of %s (Exit Code %d) - %s.\n%s" %
(current_domain, exit_code, stderr, command))
subtar_size = os.stat(path_subtar).st_size
subtar_hash = sha256(file(path_subtar).read()).hexdigest()
subtar_signed = sha256(subtar_hash + snapshot_secret()).hexdigest()
subtar_info[filename_subtar] = (subtar_hash, subtar_signed)
# Append tar.gz subtar to snapshot
command = "tar --append --file=%s %s ; rm %s" % \
(filename_work, filename_subtar, filename_subtar)
proc = subprocess.Popen(command, shell=True, cwd = work_dir)
proc.communicate()
exit_code = proc.wait()
if exit_code != 0:
raise MKAutomationError("Error on adding backup domain %s to tarfile" % current_domain)
current_domain = ""
update_status_file(name, "Finished:%d" % subtar_size)
# Now add the info file which contains hashes and signed hashes for
# each of the subtars
info = ''.join([ '%s %s %s\n' % (k, v[0], v[1]) for k, v in subtar_info.items() ]) + '\n'
tar_in_progress = tarfile.open(filename_work, "a")
tarinfo = get_basic_tarinfo("checksums")
tarinfo.size = len(info)
tar_in_progress.addfile(tarinfo, cStringIO.StringIO(info))
tar_in_progress.close()
current_domain = None
shutil.move(filename_work, filename_target)
cleanup()
except Exception, e:
cleanup()
raise MKAutomationError(str(e))
def automation_notification_replay(args):
nr = args[0]
return notification_replay_backlog(int(nr))
def automation_notification_analyse(args):
nr = args[0]
return notification_analyse_backlog(int(nr))
def automation_get_bulks(args):
only_ripe = args[0] == "1"
return find_bulks(only_ripe)
def automation_active_check(args):
hostname, plugin, item = args
actchecks = []
needed_commands = []
if plugin == "custom":
custchecks = host_extra_conf(hostname, custom_checks)
for entry in custchecks:
if entry["service_description"] == item:
command_line = replace_core_macros(hostname, entry.get("command_line", ""))
if command_line:
command_line = autodetect_plugin(command_line)
return execute_check_plugin(command_line)
else:
return -1, "Passive check - cannot be executed"
else:
rules = active_checks.get(plugin)
if rules:
entries = host_extra_conf(hostname, rules)
if entries:
act_info = active_check_info[plugin]
for params in entries:
description = act_info["service_description"](params).replace('$HOSTNAME$', hostname)
if description == item:
args = act_info["argument_function"](params)
command_line = replace_core_macros(hostname, act_info["command_line"].replace("$ARG1$", args))
return execute_check_plugin(command_line)
def load_resource_file(macros):
try:
for line in file(omd_root + "/etc/nagios/resource.cfg"):
line = line.strip()
if not line or line[0] == '#':
continue
varname, value = line.split('=', 1)
macros[varname] = value
except:
if opt_debug:
raise
# Simulate replacing some of the more important macros of hosts. We
# cannot use dynamic macros, of course. Note: this will not work
# without OMD, since we do not know the value of $USER1$ and $USER2$
# here. We could read the Nagios resource.cfg file, but we do not
# know for sure the place of that either.
def replace_core_macros(hostname, commandline):
macros = {
"$HOSTNAME$" : hostname,
"$HOSTADDRESS$" : lookup_ipaddress(hostname),
}
load_resource_file(macros)
for varname, value in macros.items():
commandline = commandline.replace(varname, value)
return commandline
def execute_check_plugin(commandline):
try:
p = os.popen(commandline + " 2>&1")
output = p.read().strip()
ret = p.close()
if not ret:
status = 0
else:
if ret & 0xff == 0:
status = ret / 256
else:
status = 3
if status < 0 or status > 3:
status = 3
output = output.split("|",1)[0] # Drop performance data
return status, output
except Exception, e:
if opt_debug:
raise
return 3, "UNKNOWN - Cannot execute command: %s" % e
def automation_update_dns_cache():
return do_update_dns_cache()
def automation_bake_agents():
if "do_bake_agents" in globals():
return do_bake_agents()
| gpl-2.0 | -6,314,698,494,620,364,000 | 35.774194 | 120 | 0.551162 | false |
nilmtk/nilmtk | nilmtk/dataset_converters/greend/convert_greend.py | 1 | 6684 | from os import listdir, getcwd
from os.path import join, isdir, isfile, dirname, abspath
import pandas as pd
import numpy as np
import datetime
import time
from nilmtk.datastore import Key
from nilmtk.measurement import LEVEL_NAMES
from nilm_metadata import convert_yaml_to_hdf5
import warnings
import numpy as np
from io import StringIO
from multiprocessing import Pool
from nilmtk.utils import get_module_directory
def _get_blocks(filename):
'''
Return a list of dataframes from a GREEND CSV file
GREEND files can be interpreted as multiple CSV blocks concatenated into
a single file per date. Since the columns of the individual blocks can
vary in a single file, they need to be read separately.
There are some issues we need to handle in the converter:
- the headers from the multiple blocks
- corrupted data (lines with null chars, broken lines)
- more fields than specified in header
'''
block_data = None
dfs = []
previous_header = None
print(filename)
# Use float64 for timestamps and float32 for the rest of the columns
dtypes = {}
dtypes['timestamp'] = np.float64
def _process_block():
if block_data is None:
return
block_data.seek(0)
try:
# ignore extra fields for some files
error_bad_lines = not (
('building5' in filename and 'dataset_2014-02-04.csv' in filename)
)
df = pd.read_csv(block_data, index_col='timestamp', dtype=dtypes, error_bad_lines=error_bad_lines)
except: #(pd.errors.ParserError, ValueError, TypeError):
print("ERROR", filename)
raise
df.index = pd.to_datetime(df.index, unit='s')
df = df.tz_localize("UTC").tz_convert("CET").sort_index()
dfs.append(df)
block_data.close()
special_check = (
('dataset_2014-01-28.csv' in filename and 'building5' in filename) or
('dataset_2014-09-02.csv' in filename and 'building6' in filename)
)
with open(filename, 'r') as f:
for line in f:
# At least one file have a bunch of nulls present, let's clean the data
line = line.strip('\0')
if 'time' in line:
# Found a new block
if not line.startswith('time'):
# Some lines are corrupted, e.g. 1415605814.541311,0.0,NULL,NUtimestamp,000D6F00029C2918...
line = line[line.find('time'):]
if previous_header == line.strip():
# Same exact header, we can treat it as the same block
# print('Skipping split')
continue
# Using a defaultdict for the dtypes didn't work with read_csv,
# so we fill a normal dict when we find the columns
cols = line.strip().split(',')[1:]
for col in cols:
dtypes[col] = np.float32
# print('Found new block')
_process_block()
block_data = StringIO()
previous_header = line.strip()
if special_check:
if ('0.072.172091508705606' in line or
'1409660828.0753369,NULL,NUL' == line):
continue
block_data.write(line)
# Process the remaining block
_process_block()
return (filename, dfs)
def _get_houses(greend_path):
house_list = listdir(greend_path)
return [h for h in house_list if isdir(join(greend_path,h))]
def convert_greend(greend_path, hdf_filename, use_mp=True):
"""
Parameters
----------
greend_path : str
The root path of the greend dataset.
hdf_filename : str
The destination HDF5 filename (including path and suffix).
use_mp : bool
Defaults to True. Use multiprocessing to load the files for
each building.
"""
store = pd.HDFStore(hdf_filename, 'w', complevel=5, complib='zlib')
houses = sorted(_get_houses(greend_path))
print('Houses found:', houses)
if use_mp:
pool = Pool()
h = 1 # nilmtk counts buildings from 1 not from 0 as we do, so everything is shifted by 1
for house in houses:
print('Loading', house)
abs_house = join(greend_path, house)
dates = [d for d in listdir(abs_house) if d.startswith('dataset')]
target_filenames = [join(abs_house, date) for date in dates]
if use_mp:
house_data = pool.map(_get_blocks, target_filenames)
# Ensure the blocks are sorted by date and make a plain list
house_data_dfs = []
for date, data in sorted(house_data, key=lambda x: x[0]):
house_data_dfs.extend(data)
else:
house_data_dfs = []
for fn in target_filenames:
house_data_dfs.extend(_get_blocks(fn)[1])
overall_df = pd.concat(house_data_dfs, sort=False).sort_index()
dups_in_index = overall_df.index.duplicated(keep='first')
if dups_in_index.any():
print("Found duplicated values in index, dropping them.")
overall_df = overall_df[~dups_in_index]
m = 1
for column in overall_df.columns:
print("meter {}: {}".format(m, column))
key = Key(building=h, meter=m)
print("Putting into store...")
df = overall_df[column].to_frame() #.dropna(axis=0)
# if drop_duplicates:
# print("Dropping duplicated values in data...")
# df = df.drop_duplicates()
df.columns = pd.MultiIndex.from_tuples([('power', 'active')])
df.columns.set_names(LEVEL_NAMES, inplace=True)
store.put(str(key), df, format = 'table')
m += 1
# print('Flushing store...')
# store.flush()
h += 1
store.close()
# retrieve the dataset metadata in the metadata subfolder
metadata_dir = join(get_module_directory(), 'dataset_converters', 'greend', 'metadata')
convert_yaml_to_hdf5(metadata_dir, hdf_filename)
#is only called when this file is the main file... only test purpose
if __name__ == '__main__':
t1 = time.time()
convert_greend('GREEND_0-2_300615',
'GREEND_0-2_300615.h5')
dt = time.time() - t1
print()
print()
print('Time passed: {}:{}'.format(int(dt/60), int(dt%60)))
| apache-2.0 | 5,599,120,602,864,636,000 | 34.553191 | 111 | 0.565679 | false |
CIGIHub/greyjay | greyjay/content_notes/apps.py | 1 | 1139 | from django.apps import AppConfig
class EndNotesAppConfig(AppConfig):
name = 'greyjay.content_notes'
label = 'content_notes'
verbose_name = "Wagtail end notes"
def ready(self):
from greyjay.articles.models import ArticlePage
from wagtail.wagtailadmin.edit_handlers import (
MultiFieldPanel,
FieldPanel,
InlinePanel,
ObjectList
)
notes_panel = [
MultiFieldPanel(
[
FieldPanel('endnotes_heading'),
FieldPanel('endnote_identifier_style'),
InlinePanel('endnote_links', label="End Notes"),
],
heading="End Notes Section"
),
MultiFieldPanel(
[
FieldPanel('citations_heading'),
InlinePanel('citation_links', label="Citations"),
],
heading="Citations Section"
),
]
ArticlePage.edit_handler.children.insert(
-1,
ObjectList(notes_panel, heading="Notes")
)
| mit | 8,242,842,528,254,381,000 | 28.205128 | 69 | 0.507463 | false |
rew4332/tensorflow | tensorflow/python/ops/array_ops.py | 1 | 94317 | # Copyright 2015 The TensorFlow Authors. 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.
# ==============================================================================
"""## Casting
TensorFlow provides several operations that you can use to cast tensor data
types in your graph.
@@string_to_number
@@to_double
@@to_float
@@to_bfloat16
@@to_int32
@@to_int64
@@cast
@@saturate_cast
## Shapes and Shaping
TensorFlow provides several operations that you can use to determine the shape
of a tensor and change the shape of a tensor.
@@shape
@@size
@@rank
@@reshape
@@squeeze
@@expand_dims
@@meshgrid
## Slicing and Joining
TensorFlow provides several operations to slice or extract parts of a tensor,
or join multiple tensors together.
@@slice
@@strided_slice
@@split
@@tile
@@pad
@@concat
@@pack
@@unpack
@@reverse_sequence
@@reverse
@@transpose
@@extract_image_patches
@@space_to_batch
@@batch_to_space
@@space_to_depth
@@depth_to_space
@@gather
@@gather_nd
@@dynamic_partition
@@dynamic_stitch
@@boolean_mask
@@one_hot
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import sys
import numpy as np
from tensorflow.python.framework import common_shapes
from tensorflow.python.framework import constant_op
from tensorflow.python.framework import dtypes
from tensorflow.python.framework import ops
from tensorflow.python.framework import tensor_shape
from tensorflow.python.framework import tensor_util
# 'Constant' gets imported in the module 'array_ops'.
from tensorflow.python.framework.constant_op import constant
from tensorflow.python.ops import gen_array_ops
from tensorflow.python.ops import gen_math_ops
from tensorflow.python.ops import logging_ops
# go/tf-wildcard-import
# pylint: disable=wildcard-import
from tensorflow.python.ops.gen_array_ops import *
# pylint: enable=wildcard-import
# Used for slicing to specify a new 1 size dimension
newaxis = None
# We override the 'slice' for the "slice" op, so we keep python's
# existing 'slice' for later use in this module.
_baseslice = slice
# Aliases for some automatically-generated names.
listdiff = gen_array_ops.list_diff
def shape(input, name=None):
"""Returns the shape of a tensor.
This operation returns a 1-D integer tensor representing the shape of `input`.
For example:
```python
# 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]
shape(t) ==> [2, 2, 3]
```
Args:
input: A `Tensor` or `SparseTensor`.
name: A name for the operation (optional).
Returns:
A `Tensor` of type `int32`.
"""
return shape_internal(input, name, optimize=True)
def shape_internal(input, name=None, optimize=True):
"""Returns the shape of a tensor.
Args:
input: A `Tensor` or `SparseTensor`.
name: A name for the operation (optional).
optimize: if true, encode the shape as a constant when possible.
Returns:
A `Tensor` of type `int32`.
"""
with ops.name_scope(name, "Shape", [input]) as name:
if isinstance(input, ops.SparseTensor):
return gen_math_ops.cast(input.shape, dtypes.int32)
else:
input_tensor = ops.convert_to_tensor(input)
input_shape = input_tensor.get_shape()
# Static shape inference can be incorrect when loops are involved: disable
# shape optimization in this case to avoid generating invalid constants.
optimize &= input_tensor.graph._get_control_flow_context() is None
if optimize and input_shape.is_fully_defined():
return constant(input_shape.as_list(), dtypes.int32, name=name)
return gen_array_ops.shape(input, name=name)
def size(input, name=None):
"""Returns the size of a tensor.
This operation returns an integer representing the number of elements in
`input`.
For example:
```python
# 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]]
size(t) ==> 12
```
Args:
input: A `Tensor` or `SparseTensor`.
name: A name for the operation (optional).
Returns:
A `Tensor` of type `int32`.
"""
return size_internal(input, name, optimize=True)
def size_internal(input, name=None, optimize=True):
"""Returns the size of a tensor.
Args:
input: A `Tensor` or `SparseTensor`.
name: A name for the operation (optional).
optimize: if true, encode the size as a constant when possible.
Returns:
A `Tensor` of type `int32`.
"""
with ops.name_scope(name, "Size", [input]) as name:
if isinstance(input, ops.SparseTensor):
return gen_math_ops._prod(gen_math_ops.cast(input.shape, dtypes.int32), 0,
name=name)
else:
input_tensor = ops.convert_to_tensor(input)
input_shape = input_tensor.get_shape()
# Static shape inference can be incorrect when loops are involved: disable
# shape optimization in this case to avoid generating invalid constants.
optimize &= input_tensor.graph._get_control_flow_context() is None
if optimize and input_shape.is_fully_defined():
return constant(input_shape.num_elements(), dtypes.int32, name=name)
return gen_array_ops.size(input, name=name)
def rank(input, name=None):
"""Returns the rank of a tensor.
This operation returns an integer representing the rank of `input`.
For example:
```python
# 't' is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]
# shape of tensor 't' is [2, 2, 3]
rank(t) ==> 3
```
**Note**: The rank of a tensor is not the same as the rank of a matrix. The
rank of a tensor is the number of indices required to uniquely select each
element of the tensor. Rank is also known as "order", "degree", or "ndims."
Args:
input: A `Tensor` or `SparseTensor`.
name: A name for the operation (optional).
Returns:
A `Tensor` of type `int32`.
"""
return rank_internal(input, name, optimize=True)
def rank_internal(input, name=None, optimize=True):
"""Returns the rank of a tensor.
Args:
input: A `Tensor` or `SparseTensor`.
name: A name for the operation (optional).
optimize: if true, encode the rank as a constant when possible.
Returns:
A `Tensor` of type `int32`.
"""
with ops.name_scope(name, "Rank", [input]) as name:
if isinstance(input, ops.SparseTensor):
return gen_array_ops.size(input.shape, name=name)
else:
input_tensor = ops.convert_to_tensor(input)
input_shape = input_tensor.get_shape()
# Static shape inference can be incorrect when loops are involved: disable
# shape optimization in this case to avoid generating invalid constants.
optimize &= input_tensor.graph._get_control_flow_context() is None
if optimize and input_shape.ndims is not None:
return constant(input_shape.ndims, dtypes.int32, name=name)
return gen_array_ops.rank(input, name=name)
# DEPRECATED use init_ops.zeros_initializer
# TODO(irving) Move it to init_ops.py
def zeros_initializer(shape, dtype=dtypes.float32):
"""An adaptor for zeros() to match the Initializer spec."""
return zeros(shape, dtype)
def _SliceHelper(tensor, slice_spec):
"""Overload for Tensor.__getitem__.
This operation extracts the specified region from the tensor.
The notation is similar to numpy with the restriction that
currently only support basic indexing. That means that
using a tensor as input is not currently allowed
Args:
tensor: An ops.Tensor object.
slice_spec: The arguments to Tensor.__getitem__.
Returns:
The appropriate slice of "tensor", based on "slice_spec".
Raises:
ValueError: If a slice range is negative size.
TypeError: If the slice indices aren't int, slice, or Ellipsis.
"""
if not isinstance(slice_spec, (list, tuple)):
slice_spec = [slice_spec]
begin, end, strides = [], [], []
index = 0
new_axis_mask, shrink_axis_mask = 0, 0
begin_mask, end_mask = 0, 0
ellipsis_mask = 0
for s in slice_spec:
if isinstance(s, _baseslice):
strides.append(s.step if s.step is not None else 1)
# python doesn't always use None when constructing ranges
# for example a[:] gives slice(None,sys.maxsize,None)
# whereas a[::1] gives slice(None,None,None)
if s.start is not None and s.start is not sys.maxsize:
begin.append(s.start)
else:
begin.append(0)
begin_mask |= (1 << index)
if s.stop is not None and s.stop != sys.maxsize:
end.append(s.stop)
else:
end.append(0)
end_mask |= (1 << index)
elif s is Ellipsis:
begin.append(0)
end.append(0)
strides.append(1)
ellipsis_mask |= (1 << index)
elif s is newaxis:
begin.append(0)
end.append(0)
strides.append(1)
new_axis_mask |= (1 << index)
else:
try:
s = int(s)
except TypeError:
raise TypeError("Bad slice index %s of type %s" % (s, type(s)))
begin.append(s)
end.append(s + 1)
strides.append(1)
shrink_axis_mask |= (1 << index)
index += 1
# pack possibly involves often involves no tensors, so we must use op_scope
# correct graph
with ops.name_scope(None, "strided_slice",
[tensor] + begin + end + strides) as name:
begin_pack, end_pack, strides_pack = pack(begin), pack(end), pack(strides)
return strided_slice(tensor,
begin_pack,
end_pack,
strides_pack,
begin_mask=begin_mask,
end_mask=end_mask,
shrink_axis_mask=shrink_axis_mask,
new_axis_mask=new_axis_mask,
ellipsis_mask=ellipsis_mask,
name=name)
# pylint: disable=undefined-variable,protected-access
def slice(input_, begin, size, name=None):
"""Extracts a slice from a tensor.
This operation extracts a slice of size `size` from a tensor `input` starting
at the location specified by `begin`. The slice `size` is represented as a
tensor shape, where `size[i]` is the number of elements of the 'i'th dimension
of `input` that you want to slice. The starting location (`begin`) for the
slice is represented as an offset in each dimension of `input`. In other
words, `begin[i]` is the offset into the 'i'th dimension of `input` that you
want to slice from.
`begin` is zero-based; `size` is one-based. If `size[i]` is -1,
all remaining elements in dimension i are included in the
slice. In other words, this is equivalent to setting:
`size[i] = input.dim_size(i) - begin[i]`
This operation requires that:
`0 <= begin[i] <= begin[i] + size[i] <= Di for i in [0, n]`
For example:
```
# 'input' is [[[1, 1, 1], [2, 2, 2]],
# [[3, 3, 3], [4, 4, 4]],
# [[5, 5, 5], [6, 6, 6]]]
tf.slice(input, [1, 0, 0], [1, 1, 3]) ==> [[[3, 3, 3]]]
tf.slice(input, [1, 0, 0], [1, 2, 3]) ==> [[[3, 3, 3],
[4, 4, 4]]]
tf.slice(input, [1, 0, 0], [2, 1, 3]) ==> [[[3, 3, 3]],
[[5, 5, 5]]]
```
Args:
input_: A `Tensor`.
begin: An `int32` or `int64` `Tensor`.
size: An `int32` or `int64` `Tensor`.
name: A name for the operation (optional).
Returns:
A `Tensor` the same type as `input`.
"""
return gen_array_ops._slice(input_, begin, size, name=name)
# pylint: disable=invalid-name
def strided_slice(input_,
begin,
end,
strides,
begin_mask=0,
end_mask=0,
ellipsis_mask=0,
new_axis_mask=0,
shrink_axis_mask=0,
name=None):
"""Extracts a strided slice from a tensor.
To a first order, this operation extracts a slice of size `end - begin`
from a tensor `input`
starting at the location specified by `begin`. The slice continues by adding
`stride` to the `begin` index until all dimensions are not less than `end`.
Note that components of stride can be negative, which causes a reverse
slice.
This operation can be thought of an encoding of a numpy style sliced
range. Given a python slice input[<spec0>, <spec1>, ..., <specn>]
this function will be called as follows.
`begin`, `end`, and `strides` will be all length n. n is in general
not the same dimensionality as `input`.
For the ith spec,
`begin_mask`, `end_mask`, `ellipsis_mask`, `new_axis_mask`,
and `shrink_axis_mask` will have the ith bit corrsponding to
the ith spec.
If the ith bit of `begin_mask` is non-zero, `begin[i]` is ignored and
the fullest possible range in that dimension is used instead.
`end_mask` works analogously, except with the end range.
`foo[5:,:,:3]` on a 7x8x9 tensor is equivalent to `foo[5:7,0:8,0:3]`.
`foo[::-1]` reverses a tensor with shape 8.
If the ith bit of `ellipsis_mask`, as many unspecified dimensions
as needed will be inserted between other dimensions. Only one
non-zero bit is allowed in `ellipsis_mask`.
For example `foo[3:5,...,4:5]` on a shape 10x3x3x10 tensor is
equivalent to `foo[3:5,:,:,4:5]` and
`foo[3:5,...]` is equivalent to `foo[3:5,:,:,:]`.
If the ith bit of `new_axis_mask` is one, then a `begin`,
`end`, and `stride` are ignored and a new length 1 dimension is
added at this point in the output tensor.
For example `foo[3:5,4]` on a 10x8 tensor produces a shape 2 tensor
whereas `foo[3:5,4:5]` produces a shape 2x1 tensor with shrink_mask
being 1<<1 == 2.
If the ith bit of `shrink_axis_mask` is one, then `begin`,
`end[i]`, and `stride[i]` are used to do a slice in the appropriate
dimension, but the output tensor will be reduced in dimensionality
by one. This is only valid if the ith entry of slice[i]==1.
NOTE: `begin` and `end` are zero-indexed`.
`strides` entries must be non-zero.
```
# 'input' is [[[1, 1, 1], [2, 2, 2]],
# [[3, 3, 3], [4, 4, 4]],
# [[5, 5, 5], [6, 6, 6]]]
tf.slice(input, [1, 0, 0], [2, 1, 3], [1, 1, 1]) ==> [[[3, 3, 3]]]
tf.slice(input, [1, 0, 0], [2, 2, 3], [1, 1, 1]) ==> [[[3, 3, 3],
[4, 4, 4]]]
tf.slice(input, [1, 1, 0], [2, -1, 3], [1, -1, 1]) ==>[[[4, 4, 4],
[3, 3, 3]]]
```
Args:
input_: A `Tensor`.
begin: An `int32` or `int64` `Tensor`.
end: An `int32` or `int64` `Tensor`.
strides: An `int32` or `int64` `Tensor`.
begin_mask: An `int32` mask.
end_mask: An `int32` mask.
ellipsis_mask: An `int32` mask.
new_axis_mask: An `int32` mask.
shrink_axis_mask: An `int32` mask.
name: A name for the operation (optional).
Returns:
A `Tensor` the same type as `input`.
"""
return gen_array_ops.strided_slice(input_,
begin,
end,
strides,
name=name,
begin_mask=begin_mask,
end_mask=end_mask,
ellipsis_mask=ellipsis_mask,
new_axis_mask=new_axis_mask,
shrink_axis_mask=shrink_axis_mask)
ops.Tensor._override_operator("__getitem__", _SliceHelper)
def pack(values, axis=0, name="pack"):
"""Packs a list of rank-`R` tensors into one rank-`(R+1)` tensor.
Packs the list of tensors in `values` into a tensor with rank one higher than
each tensor in `values`, by packing them along the `axis` dimension.
Given a list of length `N` of tensors of shape `(A, B, C)`;
if `axis == 0` then the `output` tensor will have the shape `(N, A, B, C)`.
if `axis == 1` then the `output` tensor will have the shape `(A, N, B, C)`.
Etc.
For example:
```prettyprint
# 'x' is [1, 4]
# 'y' is [2, 5]
# 'z' is [3, 6]
pack([x, y, z]) => [[1, 4], [2, 5], [3, 6]] # Pack along first dim.
pack([x, y, z], axis=1) => [[1, 2, 3], [4, 5, 6]]
```
This is the opposite of unpack. The numpy equivalent is
tf.pack([x, y, z]) = np.asarray([x, y, z])
Args:
values: A list of `Tensor` objects with the same shape and type.
axis: An `int`. The axis to pack along. Defaults to the first dimension.
Supports negative indexes.
name: A name for this operation (optional).
Returns:
output: A packed `Tensor` with the same type as `values`.
Raises:
ValueError: If `axis` is out of the range [-(R+1), R+1).
"""
if axis == 0:
try:
# If the input is a constant list, it can be converted to a constant op
return ops.convert_to_tensor(values, name=name)
except (TypeError, ValueError):
pass # Input list contains non-constant tensors
value_shape = ops.convert_to_tensor(values[0], name=name).get_shape()
if value_shape.ndims is not None:
expanded_num_dims = value_shape.ndims + 1
if axis < -expanded_num_dims or axis >= expanded_num_dims:
raise ValueError("axis = %d not in [%d, %d)" %
(axis, -expanded_num_dims, expanded_num_dims))
return gen_array_ops._pack(values, axis=axis, name=name)
# pylint: disable=invalid-name
def _autopacking_helper(list_or_tuple, dtype, name):
"""Converts the given list or tuple to a tensor by packing.
Args:
list_or_tuple: A (possibly nested) list or tuple containing a tensor.
dtype: The element type of the returned tensor.
name: A name for the returned tensor.
Returns:
A `tf.Tensor` with value equivalent to `list_or_tuple`.
"""
must_pack = False
converted_elems = []
with ops.name_scope(name) as scope:
for i, elem in enumerate(list_or_tuple):
if ops.is_dense_tensor_like(elem):
if dtype is not None and elem.dtype.base_dtype != dtype:
raise TypeError(
"Cannot convert a list containing a tensor of dtype "
"%s to %s (Tensor is: %r)" % (elem.dtype, dtype, elem))
converted_elems.append(elem)
must_pack = True
elif isinstance(elem, (list, tuple)):
converted_elem = _autopacking_helper(elem, dtype, str(i))
if ops.is_dense_tensor_like(converted_elem):
must_pack = True
converted_elems.append(converted_elem)
else:
converted_elems.append(elem)
if must_pack:
elems_as_tensors = []
for i, elem in enumerate(converted_elems):
if ops.is_dense_tensor_like(elem):
elems_as_tensors.append(elem)
else:
# NOTE(mrry): This is inefficient, but it enables us to
# handle the case where the list arguments are other
# convertible-to-tensor types, such as numpy arrays.
elems_as_tensors.append(
constant_op.constant(elem, dtype=dtype, name=str(i)))
return gen_array_ops._pack(elems_as_tensors, name=scope)
else:
return converted_elems
def _get_dtype_from_nested_lists(list_or_tuple):
"""Returns the dtype of any tensor-like object in `list_or_tuple`, if found.
Args:
list_or_tuple: A list or tuple representing an object that can be
converted to a `tf.Tensor`.
Returns:
The dtype of any tensor-like object in `list_or_tuple`, or `None` if no
such object exists.
"""
for elem in list_or_tuple:
if ops.is_dense_tensor_like(elem):
return elem.dtype.base_dtype
elif isinstance(elem, (list, tuple)):
maybe_dtype = _get_dtype_from_nested_lists(elem)
if maybe_dtype is not None:
return maybe_dtype
return None
def _autopacking_conversion_function(v, dtype=None, name=None, as_ref=False):
"""Tensor conversion function that automatically packs arguments."""
if as_ref:
return NotImplemented
inferred_dtype = _get_dtype_from_nested_lists(v)
if inferred_dtype is None:
# We did not find any tensor-like objects in the nested lists, so defer to
# other conversion functions.
return NotImplemented
if dtype is not None and dtype != inferred_dtype:
return NotImplemented
return _autopacking_helper(v, inferred_dtype, name or "packed")
# pylint: enable=invalid-name
# NOTE: Register this conversion function to run *before* one that
# assumes every element is a value.
ops.register_tensor_conversion_function(
(list, tuple), _autopacking_conversion_function, 99)
def unpack(value, num=None, axis=0, name="unpack"):
"""Unpacks the given dimension of a rank-`R` tensor into rank-`(R-1)` tensors.
Unpacks `num` tensors from `value` by chipping it along the `axis` dimension.
If `num` is not specified (the default), it is inferred from `value`'s shape.
If `value.shape[axis]` is not known, `ValueError` is raised.
For example, given a tensor of shape `(A, B, C, D)`;
If `axis == 0` then the i'th tensor in `output` is the slice
`value[i, :, :, :]` and each tensor in `output` will have shape `(B, C, D)`.
(Note that the dimension unpacked along is gone, unlike `split`).
If `axis == 1` then the i'th tensor in `output` is the slice
`value[:, i, :, :]` and each tensor in `output` will have shape `(A, C, D)`.
Etc.
This is the opposite of pack. The numpy equivalent is
tf.unpack(x, n) = list(x)
Args:
value: A rank `R > 0` `Tensor` to be unpacked.
num: An `int`. The length of the dimension `axis`. Automatically inferred
if `None` (the default).
axis: An `int`. The axis to unpack along. Defaults to the first
dimension. Supports negative indexes.
name: A name for the operation (optional).
Returns:
The list of `Tensor` objects unpacked from `value`.
Raises:
ValueError: If `num` is unspecified and cannot be inferred.
ValueError: If `axis` is out of the range [-R, R).
"""
if num is None:
value = ops.convert_to_tensor(value)
value_shape = value.get_shape()
if value_shape.ndims is not None:
if axis < -value_shape.ndims or axis >= value_shape.ndims:
raise ValueError("axis = %d not in [%d, %d)" %
(axis, -value_shape.ndims, value_shape.ndims))
num = value_shape[axis].value
if num is None:
raise ValueError("Cannot infer num from shape %s" % value_shape)
return gen_array_ops._unpack(value, num=num, axis=axis, name=name)
def concat(concat_dim, values, name="concat"):
"""Concatenates tensors along one dimension.
Concatenates the list of tensors `values` along dimension `concat_dim`. If
`values[i].shape = [D0, D1, ... Dconcat_dim(i), ...Dn]`, the concatenated
result has shape
[D0, D1, ... Rconcat_dim, ...Dn]
where
Rconcat_dim = sum(Dconcat_dim(i))
That is, the data from the input tensors is joined along the `concat_dim`
dimension.
The number of dimensions of the input tensors must match, and all dimensions
except `concat_dim` must be equal.
For example:
```python
t1 = [[1, 2, 3], [4, 5, 6]]
t2 = [[7, 8, 9], [10, 11, 12]]
tf.concat(0, [t1, t2]) ==> [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]
tf.concat(1, [t1, t2]) ==> [[1, 2, 3, 7, 8, 9], [4, 5, 6, 10, 11, 12]]
# tensor t3 with shape [2, 3]
# tensor t4 with shape [2, 3]
tf.shape(tf.concat(0, [t3, t4])) ==> [4, 3]
tf.shape(tf.concat(1, [t3, t4])) ==> [2, 6]
```
Note: If you are concatenating along a new axis consider using pack.
E.g.
```python
tf.concat(axis, [tf.expand_dims(t, axis) for t in tensors])
```
can be rewritten as
```python
tf.pack(tensors, axis=axis)
```
Args:
concat_dim: 0-D `int32` `Tensor`. Dimension along which to concatenate.
values: A list of `Tensor` objects or a single `Tensor`.
name: A name for the operation (optional).
Returns:
A `Tensor` resulting from concatenation of the input tensors.
"""
if not isinstance(values, (list, tuple)):
values = [values]
# TODO(mrry): Change to return values?
if len(values) == 1: # Degenerate case of one tensor.
# Make a throwaway call to convert_to_tensor to make sure
# that concat_dim is of the correct type, and make sure that
# the returned tensor is a scalar.
# TODO(keveman): Implement a standalone type and shape checker.
with ops.name_scope(name) as scope:
ops.convert_to_tensor(concat_dim,
name="concat_dim",
dtype=dtypes.int32).get_shape(
).assert_is_compatible_with(tensor_shape.scalar())
return identity(values[0], name=scope)
return gen_array_ops._concat(concat_dim=concat_dim,
values=values,
name=name)
@ops.RegisterShape("Pack")
def _PackShape(op):
input_shape = op.inputs[0].get_shape()
if input_shape.ndims is None:
return [tensor_shape.unknown_shape()]
for inp in op.inputs[1:]:
input_shape = input_shape.merge_with(inp.get_shape())
input_shape = input_shape.as_list()
input_shape.insert(op.get_attr("axis"), len(op.inputs))
return [tensor_shape.TensorShape(input_shape)]
@ops.RegisterShape("Unpack")
def _UnpackShape(op):
input_shape = op.inputs[0].get_shape()
if input_shape.ndims is None:
return [tensor_shape.unknown_shape()] * op.get_attr("num")
input_shape = input_shape.as_list()
del input_shape[op.get_attr("axis")]
return [tensor_shape.TensorShape(input_shape)] * op.get_attr("num")
@ops.RegisterShape("Concat")
def _ConcatShape(op):
concat_dim = tensor_util.constant_value(op.inputs[0])
if concat_dim is None:
# Return an unknown shape with the same rank as the inputs, or an
# unknown rank if no input's rank is known.
rank = None
for value in op.inputs[1:]:
if rank is not None:
value.get_shape().assert_has_rank(rank)
else:
rank = value.get_shape().ndims
if rank == 0:
raise ValueError("Can't concatenate scalars (use tf.pack instead)")
return [tensor_shape.unknown_shape(ndims=rank)]
else:
# Merge all the non-concat dims, and sum the concat dim to make an
# output shape.
concat_dim = int(concat_dim)
if concat_dim < 0:
raise ValueError("Expected concat_dim >= 0, but got %d" % concat_dim)
output_shape = op.inputs[1].get_shape()
for value in op.inputs[2:]:
value_shape = value.get_shape()
if value_shape.ndims is not None and concat_dim >= value_shape.ndims:
raise ValueError("Expected concat_dim in range [0, %d), but got %d" %
(value_shape.ndims, concat_dim))
before = output_shape[:concat_dim].merge_with(value_shape[:concat_dim])
at = output_shape[concat_dim] + value_shape[concat_dim]
after = output_shape[
concat_dim + 1:].merge_with(value_shape[concat_dim + 1:])
output_shape = before.concatenate(at).concatenate(after)
return [output_shape]
@ops.RegisterShape("ConcatOffset")
def _ConcatOffsetShape(op):
return [x.get_shape() for x in op.inputs[1:]]
def boolean_mask(tensor, mask, name="boolean_mask"):
"""Apply boolean mask to tensor. Numpy equivalent is `tensor[mask]`.
```python
# 1-D example
tensor = [0, 1, 2, 3]
mask = [True, False, True, False]
boolean_mask(tensor, mask) ==> [0, 2]
```
In general, `0 < dim(mask) = K <= dim(tensor)`, and `mask`'s shape must match
the first K dimensions of `tensor`'s shape. We then have:
`boolean_mask(tensor, mask)[i, j1,...,jd] = tensor[i1,...,iK,j1,...,jd]`
where `(i1,...,iK)` is the ith `True` entry of `mask` (row-major order).
Args:
tensor: N-D tensor.
mask: K-D boolean tensor, K <= N and K must be known statically.
name: A name for this operation (optional).
Returns:
Tensor populated by entries in `tensor` corresponding to `True` values in
`mask`.
Raises:
ValueError: If shapes do not conform.
Examples:
```python
# 2-D example
tensor = [[1, 2], [3, 4], [5, 6]]
mask = [True, False, True]
boolean_mask(tensor, mask) ==> [[1, 2], [5, 6]]
```
"""
def _apply_mask_1d(reshaped_tensor, mask):
"""Mask tensor along dimension 0 with a 1-D mask."""
indices = squeeze(where(mask), squeeze_dims=[1])
return gather(reshaped_tensor, indices)
with ops.name_scope(name, values=[tensor, mask]):
tensor = ops.convert_to_tensor(tensor, name="tensor")
mask = ops.convert_to_tensor(mask, name="mask")
shape_mask = mask.get_shape()
ndims_mask = shape_mask.ndims
shape_tensor = tensor.get_shape()
if ndims_mask == 0:
raise ValueError("mask cannot be scalar.")
if ndims_mask is None:
raise ValueError(
"mask dimensions must be specified, even if some dimensions are None"
". E.g. shape=[None] is ok, but shape=None is not.")
shape_tensor[:ndims_mask].assert_is_compatible_with(shape_mask)
tensor = reshape(tensor, concat(0, [[-1], shape(tensor)[ndims_mask:]]))
first_dim = shape_tensor[:ndims_mask].num_elements()
tensor.set_shape(
tensor_shape.as_shape([first_dim])
.concatenate(shape_tensor[ndims_mask:]))
mask = reshape(mask, [-1])
return _apply_mask_1d(tensor, mask)
def sparse_mask(a, mask_indices, name=None):
"""Masks elements of `IndexedSlices`.
Given an `IndexedSlices` instance `a`, returns another `IndexedSlices` that
contains a subset of the slices of `a`. Only the slices at indices not
specified in `mask_indices` are returned.
This is useful when you need to extract a subset of slices in an
`IndexedSlices` object.
For example:
```python
# `a` contains slices at indices [12, 26, 37, 45] from a large tensor
# with shape [1000, 10]
a.indices => [12, 26, 37, 45]
tf.shape(a.values) => [4, 10]
# `b` will be the subset of `a` slices at its second and third indices, so
# we want to mask its first and last indices (which are at absolute
# indices 12, 45)
b = tf.sparse_mask(a, [12, 45])
b.indices => [26, 37]
tf.shape(b.values) => [2, 10]
```
Args:
* `a`: An `IndexedSlices` instance.
* `mask_indices`: Indices of elements to mask.
* `name`: A name for the operation (optional).
Returns:
The masked `IndexedSlices` instance.
"""
with ops.name_scope(name, "sparse_mask", [a, mask_indices]) as name:
indices = a.indices
out_indices, to_gather = listdiff(indices, mask_indices)
out_values = gather(a.values, to_gather, name=name)
return ops.IndexedSlices(out_values, out_indices, a.dense_shape)
def split(split_dim, num_split, value, name="split"):
"""Splits a tensor into `num_split` tensors along one dimension.
Splits `value` along dimension `split_dim` into `num_split` smaller tensors.
Requires that `num_split` evenly divide `value.shape[split_dim]`.
For example:
```python
# 'value' is a tensor with shape [5, 30]
# Split 'value' into 3 tensors along dimension 1
split0, split1, split2 = tf.split(1, 3, value)
tf.shape(split0) ==> [5, 10]
```
Note: If you are splitting along an axis by the length of that axis, consider
using unpack, e.g.
```python
num_items = t.get_shape()[axis].value
[tf.squeeze(s, [axis]) for s in tf.split(axis, num_items, t)]
```
can be rewritten as
```python
tf.unpack(t, axis=axis)
```
Args:
split_dim: A 0-D `int32` `Tensor`. The dimension along which to split.
Must be in the range `[0, rank(value))`.
num_split: A Python integer. The number of ways to split.
value: The `Tensor` to split.
name: A name for the operation (optional).
Returns:
`num_split` `Tensor` objects resulting from splitting `value`.
"""
return gen_array_ops._split(split_dim=split_dim,
num_split=num_split,
value=value,
name=name)
@ops.RegisterShape("Reverse")
def _ReverseShape(op):
input_shape = op.inputs[0].get_shape()
dims_shape = op.inputs[1].get_shape().with_rank(1)
if dims_shape[0].value is not None:
input_shape = input_shape.with_rank(dims_shape[0])
if input_shape.ndims is not None and input_shape.ndims > 8:
raise ValueError(
"tf.reverse() does not work on tensors with more than 8 dimensions")
return [input_shape]
def transpose(a, perm=None, name="transpose"):
"""Transposes `a`. Permutes the dimensions according to `perm`.
The returned tensor's dimension i will correspond to the input dimension
`perm[i]`. If `perm` is not given, it is set to (n-1...0), where n is
the rank of the input tensor. Hence by default, this operation performs a
regular matrix transpose on 2-D input Tensors.
For example:
```python
# 'x' is [[1 2 3]
# [4 5 6]]
tf.transpose(x) ==> [[1 4]
[2 5]
[3 6]]
# Equivalently
tf.transpose(x, perm=[1, 0]) ==> [[1 4]
[2 5]
[3 6]]
# 'perm' is more useful for n-dimensional tensors, for n > 2
# 'x' is [[[1 2 3]
# [4 5 6]]
# [[7 8 9]
# [10 11 12]]]
# Take the transpose of the matrices in dimension-0
tf.transpose(x, perm=[0, 2, 1]) ==> [[[1 4]
[2 5]
[3 6]]
[[7 10]
[8 11]
[9 12]]]
```
Args:
a: A `Tensor`.
perm: A permutation of the dimensions of `a`.
name: A name for the operation (optional).
Returns:
A transposed `Tensor`.
"""
with ops.name_scope(name, "transpose", [a]) as name:
if perm is None:
rank = gen_array_ops.rank(a)
perm = (rank - 1) - gen_math_ops._range(0, rank, 1)
ret = gen_array_ops.transpose(a, perm, name=name)
# NOTE(mrry): Setting the shape explicitly because
# reverse is not handled by the shape function.
input_shape = ret.op.inputs[0].get_shape().dims
if input_shape is not None:
ret.set_shape(input_shape[::-1])
else:
ret = gen_array_ops.transpose(a, perm, name=name)
return ret
# pylint: disable=invalid-name
def batch_matrix_transpose(a, name="batch_matrix_transpose"):
"""Transposes last two dimensions of batch matrix `a`.
For example:
```python
# Matrix with no batch dimension.
# 'x' is [[1 2 3]
# [4 5 6]]
tf.batch_matrixtranspose(x) ==> [[1 4]
[2 5]
[3 6]]
# Matrix with two batch dimensions.
# x.shape is [1, 2, 3, 4]
# tf.batch_matrix_transpose(x) is shape [1, 2, 4, 3]
```
Args:
a: A `Tensor` with `rank >= 2`.
name: A name for the operation (optional).
Returns:
A transposed batch matrix `Tensor`.
Raises:
ValueError: If `a` is determined statically to have `rank < 2`.
"""
with ops.name_scope(name, values=[a]):
a = ops.convert_to_tensor(a, name="a")
# If we know the number of dimensions (statically), we can do two things:
# 1. Check that `a` is a (batch) matrix.
# 2. Use a python list for perm. This preserves static shape information
# and avoids extra computations.
a_shape = a.get_shape()
ndims = a_shape.ndims
if ndims is not None:
if ndims < 2:
raise ValueError(
"Argument 'a' should be a (batch) matrix, with rank >= 2. Found: "
"%s" % a_shape)
perm = list(range(ndims - 2)) + [ndims - 1] + [ndims - 2]
else:
a_rank = rank(a)
perm = concat(
0, (gen_math_ops._range(0, a_rank - 2, 1), [a_rank - 1, a_rank - 2]))
return transpose(a, perm=perm)
# pylint: enable=invalid-name
def zeros(shape, dtype=dtypes.float32, name=None):
"""Creates a tensor with all elements set to zero.
This operation returns a tensor of type `dtype` with shape `shape` and
all elements set to zero.
For example:
```python
tf.zeros([3, 4], int32) ==> [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
```
Args:
shape: Either a list of integers, or a 1-D `Tensor` of type `int32`.
dtype: The type of an element in the resulting `Tensor`.
name: A name for the operation (optional).
Returns:
A `Tensor` with all elements set to zero.
"""
with ops.name_scope(name, "zeros", [shape]) as name:
try:
shape = tensor_shape.as_shape(shape)
output = constant(0, shape=shape, dtype=dtype, name=name)
except (TypeError, ValueError):
shape = ops.convert_to_tensor(shape, dtype=dtypes.int32, name="shape")
output = fill(shape, constant(0, dtype=dtype), name=name)
assert output.dtype.base_dtype == dtypes.as_dtype(dtype).base_dtype
return output
def zeros_like(tensor, dtype=None, name=None, optimize=True):
"""Creates a tensor with all elements set to zero.
Given a single tensor (`tensor`), this operation returns a tensor of the
same type and shape as `tensor` with all elements set to zero. Optionally,
you can use `dtype` to specify a new type for the returned tensor.
For example:
```python
# 'tensor' is [[1, 2, 3], [4, 5, 6]]
tf.zeros_like(tensor) ==> [[0, 0, 0], [0, 0, 0]]
```
Args:
tensor: A `Tensor`.
dtype: A type for the returned `Tensor`. Must be `float32`, `float64`,
`int8`, `int16`, `int32`, `int64`, `uint8`, `complex64`, or `complex128`.
name: A name for the operation (optional).
optimize: if true, attempt to statically determine the shape of 'tensor'
and encode it as a constant.
Returns:
A `Tensor` with all elements set to zero.
"""
with ops.name_scope(name, "zeros_like", [tensor]) as name:
tensor = ops.convert_to_tensor(tensor, name="tensor")
if dtype is not None and tensor.dtype != dtype:
ret = zeros(shape_internal(tensor, optimize=optimize), dtype, name=name)
ret.set_shape(tensor.get_shape())
return ret
else:
return gen_array_ops._zeros_like(tensor, name=name)
def ones_like(tensor, dtype=None, name=None, optimize=True):
"""Creates a tensor with all elements set to 1.
Given a single tensor (`tensor`), this operation returns a tensor of the same
type and shape as `tensor` with all elements set to 1. Optionally, you can
specify a new type (`dtype`) for the returned tensor.
For example:
```python
# 'tensor' is [[1, 2, 3], [4, 5, 6]]
tf.ones_like(tensor) ==> [[1, 1, 1], [1, 1, 1]]
```
Args:
tensor: A `Tensor`.
dtype: A type for the returned `Tensor`. Must be `float32`, `float64`,
`int8`, `int16`, `int32`, `int64`, `uint8`, `complex64`, or `complex128`.
name: A name for the operation (optional).
optimize: if true, attempt to statically determine the shape of 'tensor'
and encode it as a constant.
Returns:
A `Tensor` with all elements set to 1.
"""
with ops.name_scope(name, "ones_like", [tensor]) as name:
tensor = ops.convert_to_tensor(tensor, name="tensor")
ones_shape = shape_internal(tensor, optimize=optimize)
if dtype is None:
dtype = tensor.dtype
ret = ones(ones_shape, dtype=dtype, name=name)
ret.set_shape(tensor.get_shape())
return ret
def ones(shape, dtype=dtypes.float32, name=None):
"""Creates a tensor with all elements set to 1.
This operation returns a tensor of type `dtype` with shape `shape` and all
elements set to 1.
For example:
```python
tf.ones([2, 3], int32) ==> [[1, 1, 1], [1, 1, 1]]
```
Args:
shape: Either a list of integers, or a 1-D `Tensor` of type `int32`.
dtype: The type of an element in the resulting `Tensor`.
name: A name for the operation (optional).
Returns:
A `Tensor` with all elements set to 1.
"""
with ops.name_scope(name, "ones", [shape]) as name:
try:
shape = tensor_shape.as_shape(shape)
output = constant(1, shape=shape, dtype=dtype, name=name)
except (TypeError, ValueError):
shape = ops.convert_to_tensor(shape, dtype=dtypes.int32, name="shape")
output = fill(shape, constant(1, dtype=dtype), name=name)
assert output.dtype.base_dtype == dtypes.as_dtype(dtype).base_dtype
return output
def placeholder(dtype, shape=None, name=None):
"""Inserts a placeholder for a tensor that will be always fed.
**Important**: This tensor will produce an error if evaluated. Its value must
be fed using the `feed_dict` optional argument to `Session.run()`,
`Tensor.eval()`, or `Operation.run()`.
For example:
```python
x = tf.placeholder(tf.float32, shape=(1024, 1024))
y = tf.matmul(x, x)
with tf.Session() as sess:
print(sess.run(y)) # ERROR: will fail because x was not fed.
rand_array = np.random.rand(1024, 1024)
print(sess.run(y, feed_dict={x: rand_array})) # Will succeed.
```
Args:
dtype: The type of elements in the tensor to be fed.
shape: The shape of the tensor to be fed (optional). If the shape is not
specified, you can feed a tensor of any shape.
name: A name for the operation (optional).
Returns:
A `Tensor` that may be used as a handle for feeding a value, but not
evaluated directly.
"""
shape = tensor_shape.as_shape(shape)
if shape.is_fully_defined():
dim_list = shape.as_list()
else:
dim_list = []
ret = gen_array_ops._placeholder(
dtype=dtype,
shape=dim_list,
name=name)
ret.set_shape(shape)
return ret
def sparse_placeholder(dtype, shape=None, name=None):
"""Inserts a placeholder for a sparse tensor that will be always fed.
**Important**: This sparse tensor will produce an error if evaluated.
Its value must be fed using the `feed_dict` optional argument to
`Session.run()`, `Tensor.eval()`, or `Operation.run()`.
For example:
```python
x = tf.sparse_placeholder(tf.float32)
y = tf.sparse_reduce_sum(x)
with tf.Session() as sess:
print(sess.run(y)) # ERROR: will fail because x was not fed.
indices = np.array([[3, 2, 0], [4, 5, 1]], dtype=np.int64)
values = np.array([1.0, 2.0], dtype=np.float32)
shape = np.array([7, 9, 2], dtype=np.int64)
print(sess.run(y, feed_dict={
x: tf.SparseTensorValue(indices, values, shape)})) # Will succeed.
print(sess.run(y, feed_dict={
x: (indices, values, shape)})) # Will succeed.
sp = tf.SparseTensor(indices=indices, values=values, shape=shape)
sp_value = sp.eval(session)
print(sess.run(y, feed_dict={x: sp_value})) # Will succeed.
```
Args:
dtype: The type of `values` elements in the tensor to be fed.
shape: The shape of the tensor to be fed (optional). If the shape is not
specified, you can feed a sparse tensor of any shape.
name: A name for prefixing the operations (optional).
Returns:
A `SparseTensor` that may be used as a handle for feeding a value, but not
evaluated directly.
"""
if shape is None:
shape = placeholder(
dtypes.int64, name=(name + "/shape") if name is not None else None)
else:
shape = ops.convert_to_tensor(
shape, name=(name + "/shape") if name is not None else None)
return ops.SparseTensor(
values=placeholder(
dtype, name=(name + "/values") if name is not None else None),
indices=placeholder(
dtypes.int64,
name=(name + "/indices") if name is not None else None),
shape=shape
)
def pad(tensor, paddings, mode="CONSTANT", name=None): # pylint: disable=invalid-name
"""Pads a tensor.
This operation pads a `tensor` according to the `paddings` you specify.
`paddings` is an integer tensor with shape `[n, 2]`, where n is the rank of
`tensor`. For each dimension D of `input`, `paddings[D, 0]` indicates how
many values to add before the contents of `tensor` in that dimension, and
`paddings[D, 1]` indicates how many values to add after the contents of
`tensor` in that dimension. If `mode` is "REFLECT" then both `paddings[D, 0]`
and `paddings[D, 1]` must be no greater than `tensor.dim_size(D) - 1`. If
`mode` is "SYMMETRIC" then both `paddings[D, 0]` and `paddings[D, 1]` must be
no greater than `tensor.dim_size(D)`.
The padded size of each dimension D of the output is:
`paddings[D, 0] + tensor.dim_size(D) + paddings[D, 1]`
For example:
```python
# 't' is [[1, 2, 3], [4, 5, 6]].
# 'paddings' is [[1, 1,], [2, 2]].
# rank of 't' is 2.
pad(t, paddings, "CONSTANT") ==> [[0, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 2, 3, 0, 0],
[0, 0, 4, 5, 6, 0, 0],
[0, 0, 0, 0, 0, 0, 0]]
pad(t, paddings, "REFLECT") ==> [[6, 5, 4, 5, 6, 5, 4],
[3, 2, 1, 2, 3, 2, 1],
[6, 5, 4, 5, 6, 5, 4],
[3, 2, 1, 2, 3, 2, 1]]
pad(t, paddings, "SYMMETRIC") ==> [[2, 1, 1, 2, 3, 3, 2],
[2, 1, 1, 2, 3, 3, 2],
[5, 4, 4, 5, 6, 6, 5],
[5, 4, 4, 5, 6, 6, 5]]
```
Args:
tensor: A `Tensor`.
paddings: A `Tensor` of type `int32`.
mode: One of "CONSTANT", "REFLECT", or "SYMMETRIC".
name: A name for the operation (optional).
Returns:
A `Tensor`. Has the same type as `tensor`.
Raises:
ValueError: When mode is not one of "CONSTANT", "REFLECT", or "SYMMETRIC".
"""
if mode == "CONSTANT":
return gen_array_ops._pad(tensor, paddings, name=name)
if mode == "REFLECT":
return gen_array_ops._mirror_pad(tensor,
paddings,
mode="REFLECT",
name=name)
if mode == "SYMMETRIC":
return gen_array_ops._mirror_pad(tensor,
paddings,
mode="SYMMETRIC",
name=name)
raise ValueError("Unknown padding mode: %s" % mode)
def meshgrid(*args, **kwargs):
"""Broadcasts parameters for evaluation on an N-D grid.
Given N one-dimensional coordinate arrays `*args`, returns a list `outputs`
of N-D coordinate arrays for evaluating expressions on an N-D grid.
Notes:
`meshgrid` supports cartesian ('xy') and matrix ('ij') indexing conventions.
When the `indexing` argument is set to 'xy' (the default), the broadcasting
instructions for the first two dimensions are swapped.
Examples:
Calling `X, Y = meshgrid(x, y)` with the tensors
```prettyprint
x = [1, 2, 3]
y = [4, 5, 6]
```
results in
```prettyprint
X = [[1, 1, 1],
[2, 2, 2],
[3, 3, 3]]
Y = [[4, 5, 6],
[4, 5, 6],
[4, 5, 6]]
```
Args:
*args: `Tensor`s with rank 1
indexing: Either 'xy' or 'ij' (optional, default: 'xy')
name: A name for the operation (optional).
Returns:
outputs: A list of N `Tensor`s with rank N
"""
indexing = kwargs.pop("indexing", "xy")
name = kwargs.pop("name", "meshgrid")
if len(kwargs) > 0:
key = list(kwargs.keys())[0]
raise TypeError("'{}' is an invalid keyword argument "
"for this function".format(key))
if indexing not in ("xy", "ij"):
raise ValueError("indexing parameter must be either 'xy' or 'ij'")
with ops.name_scope(name, "meshgrid", args) as name:
num_inputs = len(args)
ones = (1,) * num_inputs
asserts = [logging_ops.Assert(
gen_math_ops.equal(rank(x), 1),
["Input %d needs to have rank 1: " % i, rank(x)],
) for i, x in enumerate(args)]
# Prepare reshape by inserting dimensions with size 1 where needed
shapes = [ones[:i] + (-1,) + ones[i + 1:] for i in range(num_inputs)]
# Create parameters for broadcasting each tensor to the full size
sizes = [size(x) for x in args]
bcast = [sizes[:i] + [1] + sizes[i + 1:] for i in range(num_inputs)]
# By default, the numpy version swaps the instructions
# for the first and second dimension
if indexing == "xy" and num_inputs > 1:
shapes[0], shapes[1] = shapes[1], shapes[0]
bcast[0], bcast[1] = bcast[1], bcast[0]
results = []
with ops.control_dependencies(asserts):
for a, r, e in zip(args, shapes, bcast):
results.append(tile(reshape(a, r), e))
return results
@ops.RegisterShape("Placeholder")
def _PlaceholderShape(op):
given_shape = tensor_util.TensorShapeProtoToList(op.get_attr("shape"))
if given_shape:
return [tensor_shape.TensorShape(given_shape)]
else:
return [tensor_shape.unknown_shape()]
@ops.RegisterShape("CheckNumerics")
@ops.RegisterShape("Identity")
@ops.RegisterShape("RefIdentity")
@ops.RegisterShape("StopGradient")
@ops.RegisterShape("BatchMatrixBandPart")
@ops.RegisterShape("QuantizeAndDequantize")
def _UnchangedShape(op):
return [op.inputs[0].get_shape()]
@ops.RegisterShape("Rank")
@ops.RegisterShape("Size")
def _ScalarShape(unused_op):
return [tensor_shape.scalar()]
@ops.RegisterShape("Slice")
def _SliceShape(op):
"""Shape function for array_ops.slice."""
input_shape = op.inputs[0].get_shape()
begin_shape = op.inputs[1].get_shape().with_rank(1)
sizes_shape = op.inputs[2].get_shape().with_rank(1)
ndims = begin_shape.merge_with(sizes_shape)[0].value
if ndims is not None:
input_shape.assert_has_rank(ndims)
# NOTE(mrry): Use `constant_value_as_shape()` to handle
# partially-known values.
begin_value = tensor_util.constant_value_as_shape(
op.inputs[1]).with_rank(ndims)
# NOTE(mrry): We can't use `constant_value_as_shape()` for `sizes`
# because it might contain -1, which can't be represented as a
# `TensorShape`.
sizes_value = tensor_util.constant_value(op.inputs[2])
if sizes_value is not None:
returned_dims = []
for i, (slice_size, begin_dim) in enumerate(zip(sizes_value.ravel(),
begin_value.dims)):
if slice_size != -1:
returned_dims.append(slice_size)
else:
returned_dims.append(input_shape[i] - begin_dim)
return [tensor_shape.TensorShape(returned_dims)]
else:
if input_shape.ndims is not None:
return [tensor_shape.unknown_shape(ndims=input_shape.ndims)]
elif ndims is not None:
return [tensor_shape.unknown_shape(ndims=ndims)]
else:
return [tensor_shape.unknown_shape()]
NEW_AXIS = -1
SHRINK_AXIS = -2
# PEP-8 naming
# pylint: disable=invalid-name
def _compute_size_of_strided_dim(shrink, spec, size):
"""Computes the size of a single strided slice dimension."""
unknown = None # Document what None means here.
use_full_range = None # Document other use of None.
# if this is a shrink axis (i.e. a non-range index)
# it either will produce an error or return 1
if shrink:
return 1
if size is unknown or size.value is unknown:
return unknown
size = size.value
stride = spec.step
if stride is not unknown:
if stride == 0:
return unknown
stride = spec.step
valid_range = [0, size] if stride > 0 else [-1, size - 1]
# PEP-8 naming
# pylint: disable=invalid-name
def canonical(x, c):
if x is use_full_range:
return valid_range[c] if stride > 0 else valid_range[(c + 1) & 1]
else:
x_fwd = size + x if x < 0 else x # make negative indices positive
return max(valid_range[0], min(valid_range[1], x_fwd))
begin = canonical(spec.start, 0)
end = canonical(spec.stop, 1)
interval_length = end - begin
if interval_length == 0 or ((interval_length < 0) != (stride < 0)):
return 0
else:
remainder = 1 if interval_length % stride != 0 else 0
return interval_length // stride + remainder
else:
return unknown # unknown because stride is unknown
@ops.RegisterShape("StridedSliceGrad")
def _StridedSliceGradShape(op):
"""Shape function for gradient of array_ops.slice."""
return [tensor_util.constant_value(op.inputs[0])]
@ops.RegisterShape("StridedSlice")
def _StridedSliceShape(op):
"""Shape function for array_ops.slice."""
input_shape = op.inputs[0].get_shape()
if input_shape.ndims is None:
return [tensor_shape.unknown_shape()]
ndims = len(input_shape)
begin_shape = op.inputs[1].get_shape().with_rank(1)
end_shape = op.inputs[2].get_shape().with_rank(1)
strides_shape = op.inputs[3].get_shape().with_rank(1)
# get constant values if available
begin_value = tensor_util.constant_value(op.inputs[1])
end_value = tensor_util.constant_value(op.inputs[2])
strides_value = tensor_util.constant_value(op.inputs[3])
sparse_dims = begin_shape.merge_with(end_shape).merge_with(strides_shape)[
0].value
if (sparse_dims is None or begin_value is None or end_value is None or
strides_value is None):
return [tensor_shape.unknown_shape()]
begin_mask = op.get_attr("begin_mask")
end_mask = op.get_attr("end_mask")
ellipsis_mask = op.get_attr("ellipsis_mask")
new_axis_mask = op.get_attr("new_axis_mask")
shrink_axis_mask = op.get_attr("shrink_axis_mask")
# find the ellipsis
ellipsis_index = -1
# look for ellipses
num_add_axis_after_ellipsis = 0
for i in range(sparse_dims):
if ellipsis_index != -1 and ((1 << i) & new_axis_mask) != 0:
num_add_axis_after_ellipsis += 1
if (1 << i) & ellipsis_mask:
if ellipsis_index != -1:
raise ValueError("Multiple ellipses not allowed")
ellipsis_index = i
# insert a virtual ellipsis if not seen
if ellipsis_index == -1:
ellipsis_mask |= (1 << sparse_dims)
sparse_dims += 1
# build the dense specification
dense_dims = ndims # not accounting for newaxis and shrink
final_shape_gather = []
full_index = 0
dense_shrink_axis = 0
dense_specs = []
for dim in range(sparse_dims):
bit = 1 << dim
if bit & ellipsis_mask:
next_index = min(dense_dims -
(sparse_dims - dim) + 1 + num_add_axis_after_ellipsis,
dense_dims)
while full_index < next_index:
dense_specs.append(_baseslice(None, None, 1))
final_shape_gather.append(full_index)
full_index += 1
elif bit & new_axis_mask:
final_shape_gather.append(NEW_AXIS)
else:
dense_specs.append(_baseslice(
None if (begin_mask & bit) else begin_value[dim], None if (
end_mask & bit) else end_value[dim], strides_value[dim]))
if shrink_axis_mask & bit:
dense_shrink_axis |= (1 << full_index)
final_shape_gather.append(SHRINK_AXIS)
else:
final_shape_gather.append(full_index)
full_index += 1
# Compute each dimensions contribution to the "processing" shape
final_dims = []
for dim in range(dense_dims):
shrink = (dense_shrink_axis & (1 << dim)) != 0
final_dims.append(
_compute_size_of_strided_dim(shrink, dense_specs[dim], input_shape.dims[
dim]))
# Gather the final shape from the processing shape
final_shape = []
for index in final_shape_gather:
if index == NEW_AXIS:
final_shape.append(1)
elif index == SHRINK_AXIS:
pass
else:
final_shape.append(final_dims[index])
return [tensor_shape.TensorShape(final_shape)]
@ops.RegisterShape("Gather")
def _GatherShape(op):
"""Shape function for array_ops.gather."""
params_shape = op.inputs[0].get_shape()
indices_shape = op.inputs[1].get_shape()
return [indices_shape.concatenate(params_shape[1:])]
@ops.RegisterShape("GatherNd")
def _GatherNdShape(op):
"""Shape function for array_ops.gather_nd."""
params_shape = op.inputs[0].get_shape()
indices_shape = op.inputs[1].get_shape().with_rank_at_least(1)
indices_rank = indices_shape.ndims
indices_lookup_rank = (
None if indices_rank is None else indices_shape[-1].value)
if params_shape.ndims is None or indices_lookup_rank is None:
return [tensor_shape.unknown_shape()]
else:
if indices_lookup_rank > params_shape.ndims:
raise ValueError(
"indices.shape[-1] must be <= params.rank, but saw indices shape: %s "
" and params shape: %s" % (indices_shape, params_shape))
indices_lookup_shape = indices_shape[:-1]
params_slices_shape = params_shape[indices_lookup_rank:]
return [indices_lookup_shape.concatenate(params_slices_shape)]
@ops.RegisterShape("Unique")
def _UniqueShape(op):
"""Shape function for array_ops.Unique."""
# The output is a vector with data-dependent length.
input_shape = op.inputs[0].get_shape()
input_shape.assert_has_rank(1)
return [tensor_shape.vector(None), input_shape]
@ops.RegisterShape("UniqueWithCounts")
def _UniqueWithCountsShape(op):
"""Shape function for array_ops.Unique."""
# The output is a vector with data-dependent length.
input_shape = op.inputs[0].get_shape()
input_shape.assert_has_rank(1)
return [tensor_shape.vector(None), input_shape, tensor_shape.vector(None)]
@ops.RegisterShape("BatchMatrixDiag")
def _BatchMatrixDiagShape(op):
"""Shape function for array_ops.batch_matrix_diag."""
diag_shape = op.inputs[0].get_shape().with_rank_at_least(1)
return [diag_shape.concatenate(diag_shape[-1])]
@ops.RegisterShape("BatchMatrixSetDiag")
def _BatchMatrixSetDiagShape(op):
"""Shape function for array_ops.batch_matrix_set_diag."""
input_shape = op.inputs[0].get_shape().with_rank_at_least(2)
diag_shape = op.inputs[1].get_shape().with_rank_at_least(1)
output_shape = diag_shape.concatenate(diag_shape[-1])
output_shape = output_shape.merge_with(input_shape)
return [output_shape]
@ops.RegisterShape("BatchMatrixDiagPart")
def _BatchMatrixDiagPartShape(op):
"""Shape function for array_ops.batch_matrix_diag_part."""
input_shape = op.inputs[0].get_shape().with_rank_at_least(2)
# Last two dims must match
input_shape[-1].assert_is_compatible_with(input_shape[-2])
return [input_shape[:-1]]
@ops.RegisterShape("Diag")
def _DiagShape(op):
"""Shape function for array_ops.diag.
This op has one input (of rank k <= 3), and one output (of rank 2k),
where the shape of the output is the concatenation of the input
shape with itself.
Args:
op: A Diag Operation.
Returns:
A single-element list containing the shape of the output.
"""
input_shape = op.inputs[0].get_shape().with_rank_at_most(3)
return [input_shape.concatenate(input_shape)]
@ops.RegisterShape("DiagPart")
def _DiagPartShape(op):
"""Shape function for array_ops.diag_part.
This op has one input (of rank k = 2, 4, or 6), and one output (of rank k/2),
where the shape of the output is the diagonal of the input shape.
Args:
op: A DiagPart Operation.
Returns:
A single-element list containing the shape of the output.
Raises:
ValueError: If input has odd rank or greater than 6, or the first and
second halves of the shape are incompatible.
"""
input_shape = op.inputs[0].get_shape().with_rank_at_most(6)
rank = input_shape.ndims
if rank is None:
return [tensor_shape.unknown_shape()]
if rank % 2:
raise ValueError("Input must be even rank, got rank = " + str(rank) + ".")
mid = rank // 2
return [input_shape[:mid].merge_with(input_shape[mid:])]
@ops.RegisterShape("ExpandDims")
def _ExpandDimsShape(op):
"""Determine shape for expand op's output tensor.
Args:
op: Operation for which to determine shape.
op.inputs[0] is the input tensor.
op.inputs[1] is the dimension in which to expand.
Returns:
Shape of op's output tensor.
Raises:
ValueError: If dim is outside of [-rank - 1, rank], where rank is the number
of dimensions in the input tensor.
"""
input_shape = op.inputs[0].get_shape()
if input_shape.dims is None:
return [tensor_shape.unknown_shape()]
dim = tensor_util.constant_value(op.inputs[1])
input_ndims = input_shape.ndims
if dim < -input_ndims - 1 or dim > input_ndims:
raise ValueError(
"dim %d not in [%d, %d]." % (dim, -input_ndims, input_ndims))
if dim < 0:
dim += (input_ndims + 1)
result_shape = list(input_shape.dims)
result_shape.insert(dim, 1)
return [tensor_shape.TensorShape(result_shape)]
@ops.RegisterShape("Squeeze")
def _SqueezeShape(op):
"""Determine shape for squeeze op's output tensor.
Args:
op: Operation for which to determine shape.
Returns:
Shape of op's output tensor.
Raises:
ValueError: if squeeze_dims includes a dimension outside of [-rank, rank),
where rank is the number of dimensions in the input tensor. Or, if
squeeze_dims includes a dimension for which input shape has a value
not equal to 1.
"""
input_shape = op.inputs[0].get_shape()
if input_shape.dims is None:
return [tensor_shape.unknown_shape()]
squeeze_dims = op.get_attr("squeeze_dims") or []
wrapped_squeeze_dims = []
input_ndims = input_shape.ndims
for i, squeeze_dim in enumerate(squeeze_dims):
if squeeze_dim < -input_ndims or squeeze_dim >= input_ndims:
raise ValueError(
"squeeze_dims[%d]=%d not in [%d, %d)." % (
i, squeeze_dim, -input_ndims, input_ndims))
if squeeze_dim < 0:
squeeze_dim += input_ndims
wrapped_squeeze_dims.append(squeeze_dim)
result_shape = []
for i, dim in enumerate([d.value for d in input_shape.dims]):
is_explicit_match = i in wrapped_squeeze_dims
if dim is None:
if is_explicit_match:
# Assume that the squeezed dimension will be 1 at runtime.
continue
if not wrapped_squeeze_dims:
# If squeezing all 1 dimensions and we see a None, give up.
return [tensor_shape.unknown_shape()]
elif dim == 1:
if is_explicit_match or not wrapped_squeeze_dims:
continue
elif is_explicit_match:
raise ValueError(
"Can not squeeze dim[%d], expected a dimension of 1, got %d." % (
i, dim))
result_shape.append(dim)
return [tensor_shape.TensorShape(result_shape)]
@ops.RegisterShape("Bitcast")
def _BitcastShape(op):
"""Shape function for Bitcast op."""
input_shape = op.inputs[0].get_shape()
if input_shape == tensor_shape.unknown_shape():
return [tensor_shape.unknown_shape()]
input_type = op.inputs[0].dtype
size_of_input = input_type.size
output = dtypes.as_dtype(op.get_attr("type"))
size_of_output = output.size
if size_of_input == size_of_output:
return [input_shape]
else:
if size_of_output > size_of_input:
new_shape = input_shape.with_rank_at_least(1).as_list()
last_val = new_shape[-1]
if last_val is None or last_val == (size_of_output // size_of_input):
new_shape = new_shape[:-1]
else:
raise ValueError(
"Cannot bitcast due to shape. %d is not evenly divisible by %d." %
(new_shape[-1], size_of_input // size_of_output))
else:
new_shape = input_shape
new_shape = new_shape.concatenate([size_of_input // size_of_output])
return [tensor_shape.TensorShape(new_shape)]
@ops.RegisterShape("Reshape")
def _ReshapeShape(op):
"""Shape function for Reshape op."""
input_shape = op.inputs[0].get_shape()
if input_shape.ndims is not None:
num_elements = tensor_shape.Dimension(1)
for dim in input_shape.dims:
num_elements *= dim
else:
num_elements = tensor_shape.Dimension(None)
new_shape = tensor_util.constant_value_as_shape(op.inputs[1])
if new_shape.ndims is None:
# We have no information about the shape of the output.
return [new_shape]
if None not in new_shape.as_list():
# The new shape is fully defined.
if (num_elements.value is not None
and num_elements.value != np.prod(new_shape)):
raise ValueError(
"Cannot reshape a tensor with %d elements to shape %s (%d elements)"
% (num_elements.value, new_shape, np.prod(new_shape)))
elif num_elements.value is not None:
# We know the number of elements, so we can calculate the missing
# dimension in the new_shape.
known_elements = 1
unknown_indices = []
for i, dim in enumerate(new_shape):
if dim.value is None:
unknown_indices.append(i)
else:
known_elements *= dim.value
if known_elements != 0:
if num_elements % known_elements != 0:
raise ValueError("input has %s elements, which isn't divisible by %d" %
(num_elements, known_elements))
if len(unknown_indices) == 1:
unknown_index = unknown_indices[0]
new_shape = new_shape.merge_with(
new_shape[:unknown_index].concatenate(
[num_elements // known_elements]).concatenate(
new_shape[unknown_index+1:]))
return [new_shape]
@ops.RegisterShape("BroadcastGradientArgs")
def _BroadcastGradientArgsShape(op):
"""Shape function for the BroadcastGradientArgs op."""
# TODO(mrry): Implement constant_value for BroadcastGradientArgs?
op.inputs[0].get_shape().assert_has_rank(1)
op.inputs[1].get_shape().assert_has_rank(1)
return [tensor_shape.vector(None), tensor_shape.vector(None)]
@ops.RegisterShape("Fill")
def _FillShape(op):
"""Shape function for the Fill op.
This op takes a vector of dimensions and a scalar, and produces a
tensor with the given dimensions.
Args:
op: A Fill Operation.
Returns:
A single-element list containing the shape of the output.
Raises:
ValueError: If the shapes or arguments are known to be invalid.
"""
op.inputs[0].get_shape().assert_has_rank(1)
op.inputs[1].get_shape().assert_has_rank(0)
fill_dims = tensor_util.constant_value(op.inputs[0])
if fill_dims is not None and any(d < 0 for d in fill_dims):
raise ValueError("Fill dimensions must be >= 0")
return [tensor_util.constant_value_as_shape(op.inputs[0])]
@ops.RegisterShape("InvertPermutation")
def _InvertPermutationShape(op):
"""Shape function for the InvertPermutation op."""
return [op.inputs[0].get_shape().with_rank(1)]
@ops.RegisterShape("ListDiff")
def _ListDiffShape(op):
"""Shape function for the ListDiff op."""
op.inputs[0].get_shape().assert_has_rank(1)
op.inputs[1].get_shape().assert_has_rank(1)
# TODO(mrry): Indicate that the length falls within an interval?
return [tensor_shape.vector(None)] * 2
@ops.RegisterShape("Pad")
@ops.RegisterShape("MirrorPad")
def _PadShape(op):
"""Shape function for the Pad op.
This op has two inputs:
* input: A rank-N tensor.
* paddings: An N-by-2 matrix, in which the i^th row contains the
number of padding elements to add before and after `input` in the
i^th dimension.
It has one output, which has the same rank as input, and additional
elements according to the values in paddings.
Args:
op: A Pad Operation.
Returns:
A single-element list containing the shape of the output.
Raises:
ValueError: If the input shapes are incompatible.
"""
paddings_shape = op.inputs[1].get_shape().with_rank(2)
input_shape = op.inputs[0].get_shape()
input_shape = input_shape.with_rank(paddings_shape[0].value)
paddings_shape = paddings_shape.merge_with(
tensor_shape.matrix(input_shape.ndims, 2))
paddings = tensor_util.constant_value(op.inputs[1])
if paddings is None:
return [tensor_shape.unknown_shape(ndims=input_shape.ndims)]
else:
output_dims = []
for i, dim in enumerate(input_shape.dims):
if paddings[i, 0] < 0 or paddings[i, 1] < 0:
raise ValueError("paddings must be non-negative")
output_dims.append(dim + paddings[i, 0] + paddings[i, 1])
return [tensor_shape.TensorShape(output_dims)]
@ops.RegisterShape("MirrorPadGrad")
def _MirrorPadGradShape(op):
"""Shape function for the MirrorPadGrad op."""
paddings_shape = op.inputs[1].get_shape().with_rank(2)
input_shape = op.inputs[0].get_shape().with_rank(paddings_shape[0].value)
paddings_shape = paddings_shape.merge_with(tensor_shape.matrix(
input_shape.ndims, 2))
paddings = tensor_util.constant_value(op.inputs[1])
if paddings is None:
return [tensor_shape.unknown_shape(ndims=input_shape.ndims)]
output_dims = []
for i, dim in enumerate(input_shape.dims):
if paddings[i, 0] < 0 or paddings[i, 1] < 0:
raise ValueError("Paddings must be non-negative.")
if dim < paddings[i, 0] + paddings[i, 1]:
raise ValueError("Output dimension is negative.")
output_dims.append(dim - paddings[i, 0] - paddings[i, 1])
return [tensor_shape.TensorShape(output_dims)]
@ops.RegisterShape("ReverseSequence")
def _ReverseSequenceShape(op):
"""Shape function for the ReverseSequence op.
This op has two inputs:
* input: A rank-N tensor with size B in the 0th dimension.
* seq_lens: A vector of length B.
It has one output, with the same size as input.
Args:
op: A ReverseSequence Operation.
Returns:
A single-element list containing the shape of the output.
Raises:
ValueError: If the input shapes are incompatible or seq_dim == batch_dim.
"""
input_shape = op.inputs[0].get_shape()
seq_lens_shape = op.inputs[1].get_shape().with_rank(1)
if input_shape.ndims is None:
return [None]
seq_dim = op.get_attr("seq_dim")
batch_dim = op.get_attr("batch_dim")
if input_shape.ndims is not None:
if batch_dim >= input_shape.ndims:
raise ValueError("batch_dim must be < input.dims() (%d vs %d)" %
(batch_dim, input_shape.ndims))
if seq_dim >= input_shape.ndims:
raise ValueError("seq_dim must be < input.dims() (%d vs %d)" %
(seq_dim, input_shape.ndims))
batch_size = input_shape[batch_dim].merge_with(seq_lens_shape[0])
input_shape = tensor_shape.TensorShape([
value if ix != batch_dim else batch_size
for ix, value in enumerate(input_shape)])
return [input_shape]
@ops.RegisterShape("Shape")
@ops.RegisterShape("ShapeN")
def _ShapeNShape(op):
"""Shape function for the Shape/ShapeN op."""
return [tensor_shape.vector(x.get_shape().ndims) for x in op.inputs]
@ops.RegisterShape("Transpose")
def _TransposeShape(op):
"""Shape function for the Transpose op.
This op takes two inputs:
* input: a rank-N tensor of arbitrary shape.
* shuffle: a length-N vector.
Its output is the rank-N tensor computed by permuting the dimensions
of input according to shuffle.
Args:
op: A Transpose op.
Returns:
A single-element list containing the shape of the output.
Raises:
ValueError: If the shapes of input and shuffle are incompatible.
IndexError: If shuffle contains an index that is >= the rank of input.
"""
input_shape = op.inputs[0].get_shape()
transpose_shape = op.inputs[1].get_shape().merge_with(tensor_shape.vector(
input_shape.ndims))
transpose_vec = tensor_util.constant_value(op.inputs[1])
if transpose_vec is None:
return [tensor_shape.unknown_shape(ndims=transpose_shape[0].value)]
else:
return [tensor_shape.TensorShape([input_shape[i]
for i in transpose_vec.tolist()])]
@ops.RegisterShape("Split")
def _SplitShape(op):
"""Shape function for the Split op."""
split_dim = tensor_util.constant_value(op.inputs[0])
num_split = len(op.outputs)
input_shape = op.inputs[1].get_shape()
if split_dim is None:
return [tensor_shape.unknown_shape(ndims=input_shape.ndims)] * num_split
else:
split_dim = int(split_dim)
input_shape = input_shape.with_rank_at_least(split_dim + 1)
if not (input_shape[split_dim] % num_split).is_compatible_with(0):
raise ValueError(
"Number of ways to split should evenly divide the split "
"dimension but got split_dim %d (size = %d) and num_split %d" %
(split_dim, input_shape[split_dim].value, num_split))
prefix = input_shape[:split_dim]
size_in_split_dim = input_shape[split_dim] // num_split
suffix = input_shape[split_dim + 1:]
output_shape = prefix.concatenate(size_in_split_dim).concatenate(suffix)
return [output_shape] * num_split
@ops.RegisterShape("Tile")
def _TileShape(op):
"""Shape function for the Tile op.
This op has two inputs:
* input: A rank-N tensor.
* multiples: A length-N vector, in which the i^th element contains
the factor by which `input` will be tiled in the i^th dimension.
It has one output, which has the same rank as input, and additional
elements according to the values in multiples
Args:
op: A Tile Operation.
Returns:
A single-element list containing the shape of the output.
"""
multiples_shape = op.inputs[1].get_shape().with_rank(1)
input_shape = op.inputs[0].get_shape().with_rank(multiples_shape[0].value)
# NOTE(mrry): Represent `multiples` as a `TensorShape` because (i)
# it is a vector of non-negative integers, and (ii) doing so allows
# us to handle partially-known multiples.
multiples = tensor_util.constant_value_as_shape(op.inputs[1]).with_rank(
input_shape.ndims)
if multiples.ndims is None:
return [tensor_shape.unknown_shape()]
else:
output_dims = []
for dim, multiple in zip(input_shape.dims, multiples.dims):
output_dims.append(dim * multiple)
return [tensor_shape.TensorShape(output_dims)]
@ops.RegisterShape("TileGrad")
def _TileGradShape(op):
"""Shape function for the TileGrad op."""
multiples_shape = op.inputs[1].get_shape().with_rank(1)
input_shape = op.inputs[0].get_shape().with_rank(multiples_shape[0])
# NOTE(mrry): Represent `multiples` as a `TensorShape` because (i)
# it is a vector of non-negative integers, and (ii) doing so allows
# us to handle partially-known multiples.
multiples = tensor_util.constant_value_as_shape(op.inputs[1]).with_rank(
input_shape.ndims)
if multiples.ndims is None:
return [tensor_shape.unknown_shape()]
else:
output_dims = []
for dim, multiple in zip(input_shape.dims, multiples.dims):
output_dims.append(dim // multiple)
return [tensor_shape.TensorShape(output_dims)]
@ops.RegisterShape("Where")
def _WhereShape(op):
"""Shape function for the Where op."""
input_shape = op.inputs[0].get_shape()
return [tensor_shape.matrix(None, input_shape.ndims)]
@ops.RegisterShape("ZerosLike")
def _ZerosLikeShape(op):
"""Shape function for the ZerosLike op."""
return [op.inputs[0].get_shape()]
def edit_distance(hypothesis, truth, normalize=True, name="edit_distance"):
"""Computes the Levenshtein distance between sequences.
This operation takes variable-length sequences (`hypothesis` and `truth`),
each provided as a `SparseTensor`, and computes the Levenshtein distance.
You can normalize the edit distance by length of `truth` by setting
`normalize` to true.
For example, given the following input:
```python
# 'hypothesis' is a tensor of shape `[2, 1]` with variable-length values:
# (0,0) = ["a"]
# (1,0) = ["b"]
hypothesis = tf.SparseTensor(
[[0, 0, 0],
[1, 0, 0]],
["a", "b"]
(2, 1, 1))
# 'truth' is a tensor of shape `[2, 2]` with variable-length values:
# (0,0) = []
# (0,1) = ["a"]
# (1,0) = ["b", "c"]
# (1,1) = ["a"]
truth = tf.SparseTensor(
[[0, 1, 0],
[1, 0, 0],
[1, 0, 1],
[1, 1, 0]]
["a", "b", "c", "a"],
(2, 2, 2))
normalize = True
```
This operation would return the following:
```python
# 'output' is a tensor of shape `[2, 2]` with edit distances normalized
# by 'truth' lengths.
output ==> [[inf, 1.0], # (0,0): no truth, (0,1): no hypothesis
[0.5, 1.0]] # (1,0): addition, (1,1): no hypothesis
```
Args:
hypothesis: A `SparseTensor` containing hypothesis sequences.
truth: A `SparseTensor` containing truth sequences.
normalize: A `bool`. If `True`, normalizes the Levenshtein distance by
length of `truth.`
name: A name for the operation (optional).
Returns:
A dense `Tensor` with rank `R - 1`, where R is the rank of the
`SparseTensor` inputs `hypothesis` and `truth`.
Raises:
TypeError: If either `hypothesis` or `truth` are not a `SparseTensor`.
"""
if not isinstance(hypothesis, ops.SparseTensor):
raise TypeError("Hypothesis must be a SparseTensor")
if not isinstance(truth, ops.SparseTensor):
raise TypeError("Truth must be a SparseTensor")
return gen_array_ops._edit_distance(hypothesis.indices,
hypothesis.values,
hypothesis.shape,
truth.indices,
truth.values,
truth.shape,
normalize=normalize,
name=name)
@ops.RegisterShape("EditDistance")
def _EditDistanceShape(op):
"""Shape function for the EditDistance op."""
hypothesis_shape = tensor_util.constant_value(op.inputs[2])
truth_shape = tensor_util.constant_value(op.inputs[5])
if hypothesis_shape is not None and truth_shape is not None:
if len(hypothesis_shape) != len(truth_shape):
raise ValueError(
"Inconsistent ranks in hypothesis and truth. Saw shapes: %s and %s" %
(str(hypothesis_shape), str(truth_shape)))
return [tensor_shape.TensorShape(
[max(h, t) for h, t in zip(hypothesis_shape[:-1], truth_shape[:-1])])]
return [tensor_shape.unknown_shape()]
# The remaining ops do not change the shape of their inputs.
@ops.RegisterShape("Quantize")
@ops.RegisterShape("Dequantize")
def _QuantizeDequantizeShape(op):
unused_min_range = op.inputs[1].get_shape().merge_with(tensor_shape.scalar())
unused_max_range = op.inputs[2].get_shape().merge_with(tensor_shape.scalar())
return common_shapes.unchanged_shape(op)
@ops.RegisterShape("ExtractImagePatches")
def _ExtractImagePatchesShape(op):
"""Shape function for the ExtractImagePatches op.
Args:
op: An ExtractImagePatches op.
Raises:
ValueError: If the strides or padding are invalid.
Returns:
The shape of the op output.
"""
images_shape = op.inputs[0].get_shape().with_rank(4)
batch = images_shape[0]
in_rows = images_shape[1]
in_cols = images_shape[2]
in_depth = images_shape[3]
ksize_b, ksize_r, ksize_c, ksize_d = op.get_attr("ksizes")
if ksize_b != 1 or ksize_d != 1:
raise ValueError("Current implementation does not yet support "
"ksizes in the batch and depth dimensions.")
stride_b, stride_r, stride_c, stride_d = op.get_attr("strides")
if stride_b != 1 or stride_d != 1:
raise ValueError("Current implementation does not yet support "
"strides in the batch and depth dimensions.")
rate_b, rate_r, rate_c, rate_d = op.get_attr("rates")
if rate_b != 1 or rate_d != 1:
raise ValueError("Current implementation does not yet support "
"rates in the batch and depth dimensions.")
# Effective patch size, taking into account filter upsampling by rates.
ksize_r_eff = ksize_r + (ksize_r - 1) * (rate_r - 1)
ksize_c_eff = ksize_c + (ksize_c - 1) * (rate_c - 1)
padding = op.get_attr("padding")
out_rows, out_cols = common_shapes.get2d_conv_output_size(in_rows, in_cols,
ksize_r_eff,
ksize_c_eff,
stride_r, stride_c,
padding)
out_depth = None if in_depth is None else ksize_r * ksize_c * int(in_depth)
output_shape = [batch, out_rows, out_cols, out_depth]
return [tensor_shape.TensorShape(output_shape)]
@ops.RegisterShape("SpaceToBatch")
def _SpaceToBatchShape(op):
"""Shape function for the SpaceToBatch op.
The output shape is determined by the following inputs/ attributes:
* input: A rank-4 tensor with shape [B, H, W, D]
* paddings: A 2-by-2 matrix, specified as follows:
paddings = [[pad_top, pad_bottom], [pad_left, pad_right]],
implying effective padded spatial dimensions:
Hp = pad_top + H + pad_bottom
Wp = pad_left + W + pad_right
Both Hp and Wp must be multiples of block_size.
* block_size: an int.
Its output is also a rank-4 tensor with shape:
[B*block_size*block_size, Hp/block_size, Wp/block_size, D]
Args:
op: A SpaceToBatch op.
Returns:
A single-element list containing the shape of the output.
Raises:
ValueError: If the shapes of inputs are not as expected.
IndexError: If block_size does not divide Wp or Hp.
"""
# Check that the input tensor is 4-D.
try:
input_shape = op.inputs[0].get_shape().with_rank(4)
except ValueError:
raise ValueError(
"tf.space_to_batch() requires 4-D input tensor.")
# Check that the paddings tensor is a matrix with shape [2, 2].
try:
paddings_shape = op.inputs[1].get_shape().with_rank(2)
except ValueError:
raise ValueError(
"tf.space_to_batch() requires 2-D paddings tensor.")
if paddings_shape[0] != 2 or paddings_shape[1] != 2:
raise ValueError(
"tf.space_to_batch() requires input paddings with shape [2, 2].")
block_size = op.get_attr("block_size")
if block_size <= 1:
raise ValueError("Attribute block_size has to be > 1.")
paddings = tensor_util.constant_value(op.inputs[1])
if paddings is not None:
if (paddings[0, 0] < 0 or paddings[0, 1] < 0 or
paddings[1, 0] < 0 or paddings[1, 1] < 0):
raise ValueError("paddings cannot be negative.")
input_height = input_shape[1] + paddings[0, 0] + paddings[0, 1]
input_width = input_shape[2] + paddings[1, 0] + paddings[1, 1]
if input_height % block_size > 0 or input_width % block_size > 0:
raise IndexError("block_size needs to divide both width and height.")
else:
input_height = tensor_shape.Dimension(None)
input_width = tensor_shape.Dimension(None)
batch = input_shape[0] * block_size * block_size
height = input_height // block_size
width = input_width // block_size
depth = input_shape[3]
return [tensor_shape.TensorShape([batch, height, width, depth])]
@ops.RegisterShape("BatchToSpace")
def _BatchToSpaceShape(op):
"""Shape function for the BatchToSpace op.
The output shape is determined by the following inputs/ attributes:
* input: A rank-4 tensor with shape
[B*block_size*block_size, Hp/block_size, Wp/block_size, D]
Note that the batch size of the input tensor must be divisible by
`block_size * block_size`.
* crops: A 2-by-2 matrix, specified as follows:
crops = [[crop_top, crop_bottom], [crop_left, crop_right]].
* block_size: an int.
Its output is also a rank-4 tensor with shape [B, H, W, D], where:
H = Hp - crop_top - crop_bottom
W = Wp - crop_left - crop_right
Args:
op: A BatchToSpace op.
Returns:
A single-element list containing the shape of the output.
Raises:
ValueError: If the shapes of the inputs are not as expected.
IndexError: If block_size*block_size does not divide the input batch size.
"""
# Check that the input tensor is 4-D.
try:
input_shape = op.inputs[0].get_shape().with_rank(4)
except ValueError:
raise ValueError("tf.batch_to_space() requires 4-D input tensor.")
# Check that the crops tensor is a matrix with shape [2, 2].
try:
crops_shape = op.inputs[1].get_shape().with_rank(2)
except ValueError:
raise ValueError(
"tf.space_to_batch() requires 2-D crops tensor.")
if crops_shape[0] != 2 or crops_shape[1] != 2:
raise ValueError(
"tf.space_to_batch() requires input crops with shape [2, 2].")
crops = tensor_util.constant_value(op.inputs[1])
if (crops is not None and
(crops[0, 0] < 0 or crops[0, 1] < 0 or
crops[1, 0] < 0 or crops[1, 1] < 0)):
raise ValueError("crops cannot be negative.")
block_size = op.get_attr("block_size")
if block_size <= 1:
raise ValueError("Attribute block_size has to be > 1.")
input_batch = input_shape[0]
if input_batch % (block_size * block_size) > 0:
raise IndexError("input batch must be divisible by block_size*block_size.")
batch = input_batch // (block_size * block_size)
if crops is not None:
height = input_shape[1] * block_size - crops[0, 0] - crops[0, 1]
width = input_shape[2] * block_size - crops[1, 0] - crops[1, 1]
if height <= 0 or width <= 0:
raise ValueError("Output height or width is not positive.")
else:
height = tensor_shape.Dimension(None)
width = tensor_shape.Dimension(None)
depth = input_shape[3]
return [tensor_shape.TensorShape([batch, height, width, depth])]
@ops.RegisterShape("SpaceToDepth")
def _SpaceToDepthShape(op):
"""Shape function for the SpaceToDepth op.
This op takes two inputs:
* input: a tensor of shape like that [B, H, W, D]
* block_size: an int.
Its output is the same-rank tensor but with changed
dimensions like that: [B, H/block_size, W/block_size, D*block_size*block_size]
Args:
op: A SpaceToDepth op.
Returns:
A single-element list containing the shape of the output.
Raises:
ValueError: If the shapes of input are not as expected.
IndexError: If block_size does not divide W or H.
"""
# Check that the input tensor is of 4 dimensions.
try:
input_shape = op.inputs[0].get_shape().with_rank(4)
except ValueError:
raise ValueError(
"tf.space_to_depth() requires tensors with exactly 4 dimensions.")
block_size = op.get_attr("block_size")
if block_size <= 1:
raise ValueError("Attribute block_size has to be > 1.")
input_height = input_shape[1]
input_width = input_shape[2]
if (input_width % block_size > 0) or (input_height % block_size > 0):
raise IndexError(
"block_size needs to divide both width and height.")
width = input_width // block_size
height = input_height // block_size
new_depth = input_shape[3] * block_size * block_size
return [tensor_shape.TensorShape(
[input_shape[0], height, width, new_depth])]
@ops.RegisterShape("DepthToSpace")
def _DepthToSpaceShape(op):
"""Shape function for the DepthToSpace op.
This op takes two inputs:
* input: a tensor of shape like that [B, H, W, D]
* block_size: an int.
Its output is the same-rank tensor but with changed
dimensions like that:
[B, H*block_size, W*block_size, D/(block_size*block_size)]
Args:
op: A DepthToSpace op.
Returns:
A single-element list containing the shape of the output.
Raises:
ValueError: If the shapes of input are not as expected.
IndexError: If block_size*block_size does not divide D.
"""
# Check that the input tensor is of 4 dimensions.
try:
input_shape = op.inputs[0].get_shape().with_rank(4)
except ValueError:
raise ValueError(
"tf.depth_to_space() requires tensors with exactly 4 dimensions.")
block_size = op.get_attr("block_size")
if block_size <= 1:
raise ValueError("Attribute block_size has to be > 1.")
input_height = input_shape[1]
input_width = input_shape[2]
input_depth = input_shape[3]
width = input_width * block_size
height = input_height * block_size
if input_depth % (block_size * block_size) > 0:
raise IndexError(
"block_size*block_size needs to divide the input depth.")
new_depth = input_depth // (block_size * block_size)
return [tensor_shape.TensorShape(
[input_shape[0], height, width, new_depth])]
def one_hot(indices, depth, on_value=None, off_value=None,
axis=None, dtype=None, name=None):
"""Returns a one-hot tensor.
The locations represented by indices in `indices` take value `on_value`,
while all other locations take value `off_value`.
`on_value` and `off_value` must have matching data types. If `dtype` is also
provided, they must be the same data type as specified by `dtype`.
If `on_value` is not provided, it will default to the value `1` with type
`dtype`
If `off_value` is not provided, it will default to the value `0` with type
`dtype`
If the input `indices` is rank `N`, the output will have rank `N+1`. The
new axis is created at dimension `axis` (default: the new axis is appended
at the end).
If `indices` is a scalar the output shape will be a vector of length `depth`
If `indices` is a vector of length `features`, the output shape will be:
```
features x depth if axis == -1
depth x features if axis == 0
```
If `indices` is a matrix (batch) with shape `[batch, features]`, the output
shape will be:
```
batch x features x depth if axis == -1
batch x depth x features if axis == 1
depth x batch x features if axis == 0
```
If `dtype` is not provided, it will attempt to assume the data type of
`on_value` or `off_value`, if one or both are passed in. If none of
`on_value`, `off_value`, or `dtype` are provided, `dtype` will default to the
value `tf.float32`
Note: If a non-numeric data type output is desired (tf.string, tf.bool, etc.),
both `on_value` and `off_value` _must_ be provided to `one_hot`
Examples
=========
Suppose that
```
indices = [0, 2, -1, 1]
depth = 3
on_value = 5.0
off_value = 0.0
axis = -1
```
Then output is `[4 x 3]`:
```
output =
[5.0 0.0 0.0] // one_hot(0)
[0.0 0.0 5.0] // one_hot(2)
[0.0 0.0 0.0] // one_hot(-1)
[0.0 5.0 0.0] // one_hot(1)
```
Suppose that
```
indices = [[0, 2], [1, -1]]
depth = 3
on_value = 1.0
off_value = 0.0
axis = -1
```
Then output is `[2 x 2 x 3]`:
```
output =
[
[1.0, 0.0, 0.0] // one_hot(0)
[0.0, 0.0, 1.0] // one_hot(2)
][
[0.0, 1.0, 0.0] // one_hot(1)
[0.0, 0.0, 0.0] // one_hot(-1)
]
```
Using default values for `on_value` and `off_value`:
```
indices = [0, 1, 2]
depth = 3
```
The output will be
```
output =
[[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]]
```
Args:
indices: A `Tensor` of indices.
depth: A scalar defining the depth of the one hot dimension.
on_value: A scalar defining the value to fill in output when `indices[j]
= i`. (default: 1)
off_value: A scalar defining the value to fill in output when `indices[j]
!= i`. (default: 0)
axis: The axis to fill (default: -1, a new inner-most axis).
dtype: The data type of the output tensor.
Returns:
output: The one-hot tensor.
Raises:
TypeError: If dtype of either `on_value` or `off_value` don't match `dtype`
TypeError: If dtype of `on_value` and `off_value` don't match one another
"""
with ops.name_scope(name, "one_hot", [indices, depth, on_value, off_value,
axis, dtype]) as name:
on_exists = on_value is not None
off_exists = off_value is not None
on_dtype = ops.convert_to_tensor(on_value).dtype.base_dtype if on_exists \
else None
off_dtype = ops.convert_to_tensor(off_value).dtype.base_dtype if off_exists\
else None
if on_exists or off_exists:
if dtype is not None:
# Ensure provided on_value and/or off_value match dtype
if (on_exists and on_dtype != dtype):
raise TypeError("dtype {0} of on_value does not match " \
"dtype parameter {1}".format(on_dtype, dtype))
if (off_exists and off_dtype != dtype):
raise TypeError("dtype {0} of off_value does not match " \
"dtype parameter {1}".format(off_dtype, dtype))
else:
# dtype not provided: automatically assign it
dtype = on_dtype if on_exists else off_dtype
elif dtype is None:
# None of on_value, off_value, or dtype provided. Default dtype to float32
dtype = dtypes.float32
if not on_exists:
# on_value not provided: assign to value 1 of type dtype
on_value = ops.convert_to_tensor(1, dtype, name="on_value")
on_dtype = dtype
if not off_exists:
# off_value not provided: assign to value 0 of type dtype
off_value = ops.convert_to_tensor(0, dtype, name="off_value")
off_dtype = dtype
if on_dtype != off_dtype:
raise TypeError("dtype {0} of on_value does not match " \
"dtype {1} of off_value".format(on_dtype, off_dtype))
return gen_array_ops._one_hot(indices, depth, on_value, off_value, axis,
name)
@ops.RegisterShape("OneHot")
def _OneHotShape(op):
"""Shape function for the OneHot op.
It closely follows the code in the .cc implementation.
Args:
op: A OneHot Operation.
Returns:
A single-element list containing the shape of the output.
Raises:
ValueError: if axis < -1.
"""
indices_shape = op.inputs[0].get_shape()
indices_dims = indices_shape.ndims
depth = tensor_util.constant_value(op.inputs[1])
axis = op.get_attr("axis")
if axis < -1:
raise ValueError("axis must be >= -1")
new_shape = None
if indices_dims is not None:
new_shape = indices_shape.as_list()
new_shape.insert(axis % (indices_dims + 1), depth)
return [tensor_shape.TensorShape(new_shape)]
@ops.RegisterShape("PlaceholderWithDefault")
def _PlaceholderWithDefaultShape(op):
"""Shape function for the PlaceholderWithDefault op.
This op acts as an identity when it is not fed (passing through a
default value), but allows the user to feed it with tensors of a
possibly less precise shape than its default value.
Args:
op: A PlaceholderWithDefault `Operation`.
Returns:
A single-element list containing the shape of the output.
"""
input_shape = op.inputs[0].get_shape()
output_shape = tensor_shape.TensorShape(op.get_attr("shape"))
# NOTE(mrry): We don't merge these shapes, because `output_shape`
# may be *less* precise than `input_shape`.
input_shape.assert_is_compatible_with(output_shape)
return [output_shape]
| apache-2.0 | 7,509,335,684,078,603,000 | 32.012601 | 86 | 0.633067 | false |
kubeflow/pipelines | samples/core/parallel_join/parallel_join.py | 1 | 1802 | #!/usr/bin/env python3
# Copyright 2019 The Kubeflow 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.
import kfp
from kfp import dsl
def gcs_download_op(url):
return dsl.ContainerOp(
name='GCS - Download',
image='google/cloud-sdk:279.0.0',
command=['sh', '-c'],
arguments=['gsutil cat $0 | tee $1', url, '/tmp/results.txt'],
file_outputs={
'data': '/tmp/results.txt',
}
)
def echo2_op(text1, text2):
return dsl.ContainerOp(
name='echo',
image='library/bash:4.4.23',
command=['sh', '-c'],
arguments=['echo "Text 1: $0"; echo "Text 2: $1"', text1, text2]
)
@dsl.pipeline(
name='parallel-pipeline',
description='Download two messages in parallel and prints the concatenated result.'
)
def download_and_join(
url1='gs://ml-pipeline/sample-data/shakespeare/shakespeare1.txt',
url2='gs://ml-pipeline/sample-data/shakespeare/shakespeare2.txt'
):
"""A three-step pipeline with first two running in parallel."""
download1_task = gcs_download_op(url1)
download2_task = gcs_download_op(url2)
echo_task = echo2_op(download1_task.output, download2_task.output)
if __name__ == '__main__':
kfp.compiler.Compiler().compile(download_and_join, __file__ + '.yaml')
| apache-2.0 | 2,698,934,252,417,545,000 | 30.614035 | 85 | 0.667037 | false |
SynapticNulship/Anibots | sim_py/anibots_breve_pushtest.py | 1 | 4900 | # Anibots (anigraf robots) physical/visual sim
#
# Copyright (c) 2007-2012 Samuel H. Kenyon. <[email protected]>
# http://synapticnulship.com
# This is open source, made available under the MIT License (see the
# accompanying file LICENSE).
#
# This python script connects my anibots C++ program (with the help of SWIG)
# to the Breve simulation environment. It also defines low-level physical
# actions triggered by higher-level anigraf actions.
#
# For final project 9.343J Fall 2006
# Experiment 0: The block task
#
from anibots import *
import breve
class AnibotPhysicsSim( breve.PhysicalControl ):
def __init__( self ):
breve.Control.__init__( self )
self.bots = breve.objectList()
self.actionDuration = 45
self.iterCount=self.actionDuration
self.videoLog = breve.Movie()
self.block = None
#configure the anibots
self.env = None
self.numBots = 1
self.iterations = 20
self.kDepth = 3
self.takeTurns = True
self.anibotConfig = AnibotConfig("final-x-g.dat", "final-x-pedge.dat","pweights-alt.dat")
self.anibotConfig.proxify = False
# bool proxyWeightsProportional;
# float proxyWeightsProportion;
#bool randomizeEdges
self.anibotConfig.randomize = False
#self.anibotConfig.quant = 11
#self.anibotConfig.quantDiff = 1
#anibotConfig.quantIrregular;
#self.anibotConfig.randMin = 0
#self.anibotConfig.randMax = 10
# bool singleTops;
AnibotPhysicsSim.init( self )
def init( self ):
print '''Setting up Anibot environment'''
# start the anibots environment (mental simulation)
self.env = AgentEnv("test_anibots_exp0.py",self.kDepth,self.takeTurns)
self.env.NewAnibot(self.numBots,self.anibotConfig)
self.env.InitLoner(0)
#self.env.InitTransaction(0,1)
print '''Setting up Physics Sim.'''
#start the visual/physical environment in Breve
self.setDisplayText( "Anibots Sim", -1.0, 0.8, 1 )
self.setRandomSeedFromDevRandom()
self.enableFastPhysics()
self.setFastPhysicsIterations( 15 )
#self.setGravity( breve.vector(0.0,-3.0,0.0) )
self.enableLighting()
self.enableSmoothDrawing()
self.moveLight( breve.vector( 20, 30, 20 ) )
floor = breve.createInstances( breve.Floor, 1 )
floor.catchShadows()
#floor.setE( 1.000000 )
floor.setMu(0.0)
#floor.showAxis()
self.cloudTexture = breve.createInstances( breve.Image, 1 ).load( 'images/clouds.png' )
self.enableShadowVolumes()
self.enableReflections()
self.setBackgroundColor( breve.vector( 0.400000, 0.600000, 0.900000 ) )
self.setBackgroundTextureImage( self.cloudTexture )
#self.offsetCamera( breve.vector( 3, 13, -13 ) )
self.pointCamera( breve.vector( 0, 0, 0 ), breve.vector( 20, 20, 60 ) )
#the virtual bodies
self.bots = breve.createInstances( breve.AnibotBody, 1 )
self.bots.move( breve.vector( 0.0, self.bots.radius, 14 ) )
self.env.Next()
#the block
self.block = breve.createInstances( breve.Mobile, 1 )
shape = breve.createInstances( breve.Cube, 1 ).initWith( breve.vector(15,3,4) )
shape.setMass(0.5)
self.block.setShape(shape)
self.block.setColor(breve.vector( 1.0, 0.5 ,0.0 ))
self.block.move( breve.vector( 0.0, 1.5 ,0.0 ) )
self.block.setMu(0.0)
#self.block.setE(0.1)
self.block.enablePhysics()
print self.block.getMass()
#self.block.setForce( breve.vector( 500.0, 500.0 , 500.0 ) )
#self.block.setVelocity( breve.vector( 0, 0, -10 ) )
#self.watch( self.bots[0] )
self.watch( self.block )
self.videoLog.record("anibots-pushtest.mpg")
def iterate( self ):
s2 = "block dist: %.2f" % (-self.block.getLocation()[2])
self.setDisplayText(s2, -1.0, 0.5, 6)
breve.Control.iterate( self )
breve.AnibotPhysicsSim = AnibotPhysicsSim
class AnibotBody( breve.Mobile ):
def __init__( self ):
breve.Mobile.__init__( self )
self.radius = 1.5
AnibotBody.init( self )
def init( self ):
shape = breve.createInstances( breve.Sphere, 1 ).initWith( self.radius )
shape.setDensity(100)
self.setShape( shape )
#self.setShape( breve.createInstances( breve.Cube, 1 ).initWith( breve.vector(self.radius,self.radius,self.radius) ))
self.setColor( breve.randomExpression( breve.vector( 1.000000, 1.000000, 1.000000 ) ) )
#self.move( breve.vector( breve.randomExpression(8.0)-4.0, self.radius, breve.randomExpression(20.0) + 8.0 ) )
self.move( breve.vector( 0.0, self.radius, 14.0 ) )
print self.getMass()
self.enablePhysics()
#self.setVelocity( breve.vector( 0.0, 0.0, -2.0 ) )
#self.setForce( breve.vector( 0.0, 0.0, -100.0 ) )
def moveX( self, x ):
if self.getLocation()[0] != x:
z = self.getLocation()[2]
self.move( breve.vector( x, self.radius, z+2 ) )
def iterate( self ):
#print self.getVelocity()
self.setVelocity( breve.vector( 0.0, 0.0, -2.0 ) )
breve.AnibotBody = AnibotBody
# Create an instance of our controller object to initialize the simulation
AnibotPhysicsSim()
| mit | -8,022,276,696,269,012,000 | 32.108108 | 119 | 0.696531 | false |
CSD-Public/stonix | src/tests/framework/unit_tests/zzzTestFrameworkCommandHelper.py | 1 | 4182 | #!/usr/bin/env python3
###############################################################################
# #
# Copyright 2019. Triad National Security, LLC. All rights reserved. #
# This program was produced under U.S. Government contract 89233218CNA000001 #
# for Los Alamos National Laboratory (LANL), which is operated by Triad #
# National Security, LLC for the U.S. Department of Energy/National Nuclear #
# Security Administration. #
# #
# All rights in the program are reserved by Triad National Security, LLC, and #
# the U.S. Department of Energy/National Nuclear Security Administration. The #
# Government is granted for itself and others acting on its behalf a #
# nonexclusive, paid-up, irrevocable worldwide license in this material to #
# reproduce, prepare derivative works, distribute copies to the public, #
# perform publicly and display publicly, and to permit others to do so. #
# #
###############################################################################
'''
Created on 11/27/2012
Perform tests on different parts of the functionality for framework CommandHelper
@author: ekkehard
@change: roy - adding sys.path.append for both test framework and individual
test runs.
@change: Breen Malmberg - 04/11/2018 - added class doc string; removed
testinvalidcommand test since it was just essentially testing whether
python threw a typeerror exception when given an argument that was the wrong type
(it wasn't testing our framework - it was testing python itself)
@todo: fill out all remaining empty method doc strings
@note: If you're going to write assertRaises tests, make sure that you are not
catching them somewhere else in the call chain and throwing them as exceptions
(tracebacks) there, before it can come back to the assertRaise() method call, here.
'''
import unittest
import sys
sys.path.append("../../../..")
from src.tests.lib.logdispatcher_lite import LogPriority
from src.tests.lib.logdispatcher_lite import LogDispatcher
from src.stonix_resources.environment import Environment
from src.stonix_resources.CommandHelper import CommandHelper
class zzzTestFrameworkCommandHelper(unittest.TestCase):
'''Perform tests on different parts of the functionality for framework CommandHelper
:param unittest: TestCase: unittest TestCase class inheritance object reference
@author: ekkehard
@change: Breen Malmberg - 04/11/2018 - removed assertion tests -
you can't test for exception assertions in code that is wrapped by try
except because the try except intercepts the exception and throws it
and it never gets back to the assertraises call (see tf ticket for documentation)
'''
def setUp(self):
''' '''
self.enviro = Environment()
self.enviro.setdebugmode(True)
self.logger = LogDispatcher(self.enviro)
self.commandhelper = CommandHelper(self.logger)
def tearDown(self):
''' '''
pass
def testExecuteValidCommand(self):
''' '''
self.assertTrue(self.commandhelper.executeCommand("ls -l /"),
"Execute Valid Command string Failed!")
self.assertTrue(self.commandhelper.executeCommand(["ls", "-l", "/"]),
"Execute Valid Command List Failed!")
def testSetLogPriority(self):
''' '''
self.assertTrue(self.commandhelper.setLogPriority(LogPriority.INFO),
"Execute setLogPriority(0) Command string Failed!")
self.assertTrue(self.commandhelper.executeCommand(["ls", "-l", "/"]),
"Execute commandhelper.executeCommand(['ls','-l','/'])"
+ " Command List Failed!")
if __name__ == "__main__":
#import sys;sys.argv = ['', 'Test.testName']
unittest.main()
| gpl-2.0 | 561,659,646,466,533,760 | 42.113402 | 97 | 0.609995 | false |
openstack/networking-odl | networking_odl/journal/journal.py | 1 | 10979 | # Copyright (c) 2015 OpenStack Foundation
# 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.
import copy
from datetime import datetime
import threading
import time
from neutron_lib.callbacks import registry
from neutron_lib import context as nl_context
from neutron_lib.db import api as db_api
from neutron_lib.plugins import directory
from oslo_config import cfg
from oslo_db import exception
from oslo_log import log as logging
from requests import exceptions
from networking_odl.common import client
from networking_odl.common import constants as odl_const
from networking_odl.common import filters
from networking_odl.common import utils
from networking_odl.db import db
from networking_odl.journal import dependency_validations
LOG = logging.getLogger(__name__)
MAKE_URL = {}
LOG_ENTRY_TEMPLATE = ("%(log_type)s (Entry ID: %(entry_id)s) - %(op)s "
"%(obj_type)s %(obj_id)s (Time stamp: %(timestamp)s)")
LOG_RECORDED = 'Recorded'
LOG_PROCESSING = 'Processing'
LOG_COMPLETED = 'Completed'
LOG_ERROR_PROCESSING = 'Error while processing'
def call_thread_on_end(func):
def new_func(obj, *args, **kwargs):
return_value = func(obj, *args, **kwargs)
obj.journal.set_sync_event()
return return_value
return new_func
def _enrich_port(plugin_context, ml2_context, object_type, operation, data):
"""Enrich the port with additional information needed by ODL"""
# NOTE(yamahata): work around of ODL neutron northbound
# It passes security groups in port as list of dict for historical reasons.
# keep its format for compatibility.
# TODO(yamahata): drop this format conversion.
if data[odl_const.ODL_SGS]:
groups = [{'id': id_} for id_ in data['security_groups']]
else:
groups = []
new_data = copy.deepcopy(data)
new_data[odl_const.ODL_SGS] = groups
# NOTE(yamahata): work around for port creation for router
# tenant_id=''(empty string) is passed when port is created
# by l3 plugin internally for router.
# On the other hand, ODL doesn't accept empty string for tenant_id.
# In that case, deduce tenant_id from network_id for now.
# Right fix: modify Neutron so that don't allow empty string
# for tenant_id even for port for internal use.
# TODO(yamahata): eliminate this work around when neutron side
# is fixed
# assert port['tenant_id'] != ''
if ('tenant_id' not in new_data or new_data['tenant_id'] == ''):
if ml2_context:
network = ml2_context._network_context._network
else:
plugin = directory.get_plugin()
network = plugin.get_network(plugin_context,
new_data['network_id'])
new_data['tenant_id'] = network['tenant_id']
return new_data
def _log_entry(log_type, entry, log_level=logging.INFO, **kwargs):
delta = datetime.now() - datetime.min
timestamp = delta.total_seconds()
log_dict = {'log_type': log_type, 'op': entry.operation,
'obj_type': entry.object_type, 'obj_id': entry.object_uuid,
'entry_id': entry.seqnum, 'timestamp': timestamp}
LOG.log(log_level, LOG_ENTRY_TEMPLATE, log_dict, **kwargs)
def record(plugin_context, object_type, object_uuid, operation, data,
ml2_context=None):
if (object_type == odl_const.ODL_PORT and
operation in (odl_const.ODL_CREATE, odl_const.ODL_UPDATE)):
data = _enrich_port(
plugin_context, ml2_context, object_type, operation, data)
# Calculate depending_on on other journal entries
depending_on = dependency_validations.calculate(
plugin_context, operation, object_type, object_uuid, data)
# NOTE(mpeterson): Between the moment that a dependency is calculated and
# the new entry is recorded in the journal, an operation can ocurr that
# would make the dependency irrelevant. In that case we request a retry.
# For more details, read the commit message that introduced this comment.
try:
entry = db.create_pending_row(
plugin_context, object_type, object_uuid, operation, data,
depending_on=depending_on)
except exception.DBReferenceError as e:
raise exception.RetryRequest(e)
_log_entry(LOG_RECORDED, entry)
LOG.debug('Entry with ID %(entry_id)s depends on these entries: '
'%(depending_on)s',
{'entry_id': entry.seqnum,
'depending_on': [d.seqnum for d in depending_on]})
@db_api.retry_if_session_inactive()
@db_api.CONTEXT_WRITER.savepoint
def entry_complete(context, entry):
if cfg.CONF.ml2_odl.completed_rows_retention == 0:
db.delete_row(context, entry)
else:
db.update_db_row_state(context, entry, odl_const.COMPLETED)
db.delete_dependency(context, entry)
@db_api.retry_if_session_inactive()
@db_api.CONTEXT_WRITER.savepoint
def entry_reset(context, entry):
db.update_db_row_state(context, entry, odl_const.PENDING)
@db_api.retry_if_session_inactive()
@db_api.CONTEXT_WRITER.savepoint
def entry_update_state_by_retry_count(context, entry, retry_count):
db.update_pending_db_row_retry(context, entry, retry_count)
def _make_url(row):
url_object = utils.make_url_object(row.object_type)
urlpath = ''
if row.operation == odl_const.ODL_CREATE:
urlpath = url_object
else:
urlpath = url_object + '/' + row.object_uuid
return urlpath
def register_url_builder(object_type, method):
MAKE_URL[object_type] = method
def _build_url(row):
return MAKE_URL.get(row.object_type, _make_url)(row)
class OpenDaylightJournalThread(object):
"""Thread worker for the OpenDaylight Journal Database."""
# make those parameter configurable?
_RETRY_SLEEP_MIN = 0.1
_RETRY_SLEEP_MAX = 60
def __init__(self, start_thread=True):
self.client = client.OpenDaylightRestClient.create_client()
self._max_retry_count = cfg.CONF.ml2_odl.retry_count
self._sleep_time = self._RETRY_SLEEP_MIN
self.event = threading.Event()
self._odl_sync_thread = self._create_odl_sync_thread()
self._odl_sync_thread_stop = threading.Event()
if start_thread:
self.start()
def _create_odl_sync_thread(self):
return threading.Thread(name='sync', target=self.run_sync_thread)
def start(self):
# Start the sync thread
LOG.debug("Starting a new sync thread")
if self._odl_sync_thread_stop.is_set():
self._odl_sync_thread_stop.clear()
self._odl_sync_thread = self._create_odl_sync_thread()
if not self._odl_sync_thread.is_alive():
self._odl_sync_thread.start()
def stop(self, timeout=None):
"""Allows to stop the sync thread.
Args:
timeout (float): Time in seconds to wait for joining or None for
no timeout.
"""
# Stop the sync thread
LOG.debug("Stopping the sync thread")
if self._odl_sync_thread.is_alive():
self._odl_sync_thread_stop.set()
# Process the journal one last time before stopping.
self.set_sync_event()
self._odl_sync_thread.join(timeout)
def set_sync_event(self):
self.event.set()
@staticmethod
def _json_data(row):
data = copy.deepcopy(row.data)
filters.filter_for_odl(row.object_type, row.operation, data)
if row.operation == odl_const.ODL_CREATE:
method = 'post'
to_send = {row.object_type: data}
elif row.operation == odl_const.ODL_UPDATE:
method = 'put'
to_send = {row.object_type: data}
elif row.operation == odl_const.ODL_DELETE:
method = 'delete'
to_send = None
return method, _build_url(row), to_send
def run_sync_thread(self):
while not self._odl_sync_thread_stop.is_set():
try:
self.event.wait()
self.event.clear()
self.sync_pending_entries()
except Exception:
# Catch exceptions to protect the thread while running
LOG.exception("Error on run_sync_thread")
def sync_pending_entries(self):
LOG.debug("Start processing journal entries")
context = nl_context.get_admin_context()
entry = db.get_oldest_pending_db_row_with_lock(context)
if entry is None:
LOG.debug("No journal entries to process")
return
while entry is not None:
stop_processing = self._sync_entry(context, entry)
if stop_processing:
break
entry = db.get_oldest_pending_db_row_with_lock(context)
LOG.debug("Finished processing journal entries")
def _retry_sleep(self):
# When something happened in the connection to ODL, don't busy loop
# because it's likely to hit same issue.
# Wait for a while for recovery
time.sleep(self._sleep_time)
self._sleep_time = min(self._sleep_time * 2, self._RETRY_SLEEP_MAX)
def _retry_reset(self):
self._sleep_time = self._RETRY_SLEEP_MIN
def _sync_entry(self, context, entry):
_log_entry(LOG_PROCESSING, entry)
method, urlpath, to_send = self._json_data(entry)
# TODO(mkolesni): This logic is weirdly written, need to refactor it.
try:
self.client.sendjson(method, urlpath, to_send)
registry.notify(entry.object_type, odl_const.BEFORE_COMPLETE,
self, context=context, operation=entry.operation,
row=entry)
entry_complete(context, entry)
self._retry_reset()
_log_entry(LOG_COMPLETED, entry)
except exceptions.ConnectionError:
# Don't raise the retry count, just log an error & break
entry_reset(context, entry)
LOG.error("Cannot connect to the OpenDaylight Controller,"
" will not process additional entries")
self._retry_sleep()
return True
except Exception:
_log_entry(LOG_ERROR_PROCESSING, entry,
log_level=logging.ERROR, exc_info=True)
entry_update_state_by_retry_count(
context, entry, self._max_retry_count)
return False
| apache-2.0 | 8,686,914,835,769,035,000 | 35.596667 | 79 | 0.637034 | false |
tgbugs/pyontutils | ilxutils/ilxutils/nltklib.py | 1 | 6030 | '''
nltk.download(['wordnet', 'stopwords', 'punkt']) if not already downloaded.
Should add to wordnet if you want more words to compare as reference to.
'''
from nltk import word_tokenize, pos_tag
from nltk.corpus import wordnet as wn
from nltk.corpus import stopwords
from fuzzywuzzy import fuzz, process
stop_words = stopwords.words('english')
states = {
'ak': 'alaska',
'al': 'alabama',
'ar': 'arkansas',
'as': 'american samoa',
'az': 'arizona',
'ca': 'california',
'co': 'colorado',
'ct': 'connecticut',
'dc': 'district of columbia',
'de': 'delaware',
'fl': 'florida',
'ga': 'georgia',
'gu': 'guam',
'hi': 'hawaii',
'ia': 'iowa',
'id': 'idaho',
'il': 'illinois',
'in': 'indiana',
'ks': 'kansas',
'ky': 'kentucky',
'la': 'louisiana',
'ma': 'massachusetts',
'md': 'maryland',
'me': 'maine',
'mi': 'michigan',
'mn': 'minnesota',
'mo': 'missouri',
'mp': 'northern mariana islands',
'ms': 'mississippi',
'mt': 'montana',
'na': 'national',
'nc': 'north carolina',
'nd': 'north dakota',
'ne': 'nebraska',
'nh': 'new hampshire',
'nj': 'new jersey',
'nm': 'new mexico',
'nv': 'nevada',
'ny': 'new york',
'oh': 'ohio',
'ok': 'oklahoma',
'or': 'oregon',
'pa': 'pennsylvania',
'pr': 'puerto rico',
'ri': 'rhode island',
'sc': 'south carolina',
'sd': 'south dakota',
'tn': 'tennessee',
'tx': 'texas',
'ut': 'utah',
'va': 'virginia',
'vi': 'virgin islands',
'vt': 'vermont',
'wa': 'washington',
'wi': 'wisconsin',
'wv': 'west virginia',
'wy': 'wyoming'
}
def penn_to_wn(tag):
""" Convert between a Penn Treebank tag to a simplified Wordnet tag """
if tag.startswith('N'):
return 'n'
if tag.startswith('V'):
return 'v'
if tag.startswith('J'):
return 'a'
if tag.startswith('R'):
return 'r'
return None
def tagged_to_synset(word, tag):
wn_tag = penn_to_wn(tag)
# wn_tag is None if no definition is found
if wn_tag is None:
return word
# try:
# most probable english word
return wn.synsets(word, wn_tag)[0]
# except:
# return word
def fix_state_abbrev(tokens):
token = [
states[token] if states.get(token) else token
for token in tokens
]
return token
def clean_tokens(tokens, ignore_integers=False):
punctuations = ['(',')',';',':','[',']',',','.','/']
keywords = [
word for word in tokens
if not word in stop_words and not word in punctuations
]
keywords = fix_state_abbrev(keywords)
if ignore_integers:
keywords = [word for word in keywords if not is_possible_integer(word)]
return keywords
def clean(word):
word = str(word).lower().strip()
punctuations = ['(',')',';',':','[',']',',','.','/']
for punctuation in punctuations:
word = word.replace(punctuation, '')
return word
def is_possible_integer(word):
try:
int(word)
return True
except:
return False
def sentence_similarity(sentence1, sentence2, ignore_integers=False):
""" compute the sentence similarity using Wordnet """
# Tokenize and tag
sentence1 = ' '.join([clean(word) for word in sentence1.split()])
sentence2 = ' '.join([clean(word) for word in sentence2.split()])
tokens1 = word_tokenize(sentence1)
tokens2 = word_tokenize(sentence2)
tokens1 = clean_tokens(tokens1, ignore_integers)
tokens2 = clean_tokens(tokens2, ignore_integers)
# tag
sentence1 = pos_tag(tokens1)
sentence2 = pos_tag(tokens2)
# Get the synsets for the tagged words
synsets1 = [tagged_to_synset(*tagged_word) for tagged_word in sentence1]
synsets2 = [tagged_to_synset(*tagged_word) for tagged_word in sentence2]
print(synsets1)
print(synsets2)
# Filter out the Nones
synsets1 = [ss for ss in synsets1 if ss]
synsets2 = [ss for ss in synsets2 if ss]
score, count = 0.0, 0.0
# For each word in the first sentence
for synset1 in synsets1:
# Get the similarity value of the most similar word in the other sentence
best_score=[
wn.path_similarity(synset1, synset2)
if not isinstance(synset1, str) and not isinstance(synset2, str)
# just in case there are scientific words wordnet does not have
else fuzz.ratio(str(synset1), str(synset2)) / 100
for synset2 in synsets2
]
best_score=[s if s else 0 for s in best_score]
# print(synsets1, synsets2)
# Check that the similarity could have been computed
if best_score:
score += max(best_score)
count += 1
# Average the values
if count > 0:
score /= count
else:
score = 0
return score
def get_tokenized_sentence(sentence):
# Tokenize and tag
sentence = pos_tag(word_tokenize(sentence))
# Get the synsets for the tagged words
synsets = []
for tagged_word in sentence:
synset = tagged_to_synset(*tagged_word)
if synset:
synsets.append(synset)
else:
synsets.append(tagged_word[0])
return synsets # str(sorted(synsets))
def main():
sentences = [
"life is good in pa 92092",
"life is good in pa",
"life is good within pa 92092/2",
"life is good pa 92092/2",
"life is good in pa 92092/2",
"testing for difference"
]
focus_sentence = "life is good in pennsylvania"
for sentence in sentences:
# print ("Similarity(\"%s\", \"%s\") = %s" % (focus_sentence, sentence, sentence_similarity(focus_sentence, sentence)))
print ("Similarity(\"%s\", \"%s\") = %s" % (focus_sentence, sentence, sentence_similarity(focus_sentence, sentence, ignore_integers=True)))
# print(sentence_similarity(focus_sentence, sentences[2], ignore_integers=True))
if __name__ == '__main__':
main()
| mit | -8,744,749,470,656,482,000 | 27.443396 | 147 | 0.587231 | false |
Vayel/WAMPLab | transaction/v1/locator.py | 1 | 1589 | from twisted.internet.defer import inlineCallbacks
from autobahn import wamp
from autobahn.twisted.wamp import ApplicationSession
from autobahn.twisted.wamp import ApplicationRunner
class Locator(ApplicationSession):
@inlineCallbacks
def onJoin(self, details):
yield self.register(self)
@wamp.register(u'locator.move')
@inlineCallbacks
def move(self):
"""Try to mark the current position and to go to the next one. Fail if
the current position is not markable or if the next position does not
exist.
"""
print('Move!')
pos = yield self.call('data.get_position')
direction = yield self.call('data.get_direction')
next_pos = pos + direction
markable = yield self.call('data.is_markable', pos)
next_existing = yield self.call('data.is_pos', next_pos)
if markable and next_existing:
self.call('data.mark_pos', pos)
self.call('data.set_position', next_pos)
elif not markable:
self.publish(
'error',
'The pos {} is not markable.'.format(pos)
)
else:
self.publish(
'error',
'The pos {} does not exist.'.format(next_pos)
)
# Always done
self.call('data.sth')
if __name__ == "__main__":
print('Starting Locator component...')
ApplicationRunner(url='ws://localhost:8080/ws', realm='realm1').run(Locator)
| gpl-2.0 | -6,945,406,505,201,642,000 | 28.981132 | 80 | 0.563247 | false |
iiitv/algos | breadth_first_traversal/breadth_first_traversal.py | 1 | 2410 | """
Breadth-first-traversal is an algorithm for traversing a tree or
graph data structure. Starting at the tree root (or some arbitrary node of a
graph, sometimes referred to as a 'search key'[1]) and explores the neighbor
nodes at that level first, before moving to the next level.
"""
from collections import deque
def breadth_first_traversal(graph, source):
""" Performs a breadth-first traversal on a graph
Args:
graph (list of list of int): Adjacency matrix representation of graph
source (int): Index of source vertex to begin search from
Returns:
list of dicts describing each vertex in the searched graph
-> [{distance: _, predecessor: _ }]
"""
vertex_info = []
for i in range(len(graph)):
vertex_info.append({"distance": None, "predecessor": None})
vertex_info[source]["distance"] = 0
search_queue = deque()
search_queue.append(source)
while search_queue:
u = search_queue.popleft()
for v in graph[u]:
if vertex_info[v]["distance"] is None:
vertex_info[v]["distance"] = vertex_info[u]["distance"] + 1
vertex_info[v]["predecessor"] = u
search_queue.append(v)
return vertex_info
def main():
graph_adj_list = [
[1],
[0, 4, 5],
[3, 4, 5],
[2, 6],
[1, 2],
[1, 2, 6],
[3, 5],
[]
]
vertex_info = breadth_first_traversal(graph_adj_list, 3)
for i in range(len(graph_adj_list)):
print("vertex %s : distance = %s, predecessor = %s" %
(i, vertex_info[i]["distance"], vertex_info[i]["predecessor"]))
assert(vertex_info[0] == {
"distance": 4,
"predecessor": 1
})
assert(vertex_info[1] == {
"distance": 3,
"predecessor": 4
})
assert(vertex_info[2] == {
"distance": 1,
"predecessor": 3
})
assert(vertex_info[3] == {
"distance": 0,
"predecessor": None
})
assert(vertex_info[4] == {
"distance": 2,
"predecessor": 2
})
assert(vertex_info[5] == {
"distance": 2,
"predecessor": 2
})
assert(vertex_info[6] == {
"distance": 1,
"predecessor": 3
})
assert(vertex_info[7] == {
"distance": None,
"predecessor": None
})
if __name__ == '__main__':
main()
| mit | -3,733,688,494,333,147,000 | 25.195652 | 77 | 0.544813 | false |
Kortemme-Lab/protein_feature_analysis | ProteinFeatureAnalyzer/features/data_loading.py | 1 | 3308 | import os
import io
import Bio.PDB as PDB
from . import topology
from . import secondary_structures
def structure_from_pdb_file(file_path, name=''):
'''Read the structure stored in a PDB file.'''
parser = PDB.PDBParser()
return parser.get_structure(name, file_path)
def structure_from_pdb_string(pdb_string, name=''):
'''Read the structure stored in a PDB string.'''
parser = PDB.PDBParser()
pdb_sf = io.StringIO(pdb_string)
return parser.get_structure(name, pdb_sf)
def load_data_from_cath_pmls(input_path, output_path, job_list, dssp_path):
'''Load data from structures in the input path.
The input data should be stored in .pml files of superposed homologous
superfamilies from the CATH database.
'''
superfamilies = []
for f in job_list:
if f.endswith('.pml'):
# Make a scratch directory
scratch_path = os.path.join(output_path, f[0:-4])
if not os.path.exists(scratch_path):
os.mkdir(scratch_path)
# Load data from one file
load_from_one_cath_pml_file(os.path.join(input_path, f), scratch_path, superfamilies, dssp_path)
return superfamilies
def load_from_one_cath_pml_file(pml_file, scratch_path, superfamilies, dssp_path):
'''Load data from a .pml file of superposed
homologous superfamilies from the CATH database.
'''
superfamilies.append([])
candidate_proteins = []
with open(pml_file, 'r') as f:
while True:
line = f.readline()
if not line: break
# Read one structure
if line.strip().startswith('cmd.read_pdbstr'):
pdb_lines = [line.strip()[19:].strip('\\')]
pdb_id = ''
while True:
line = f.readline()
if line.strip().startswith('"""'):
pdb_id = line.strip()[5:12]
break
pdb_line = line.strip().strip('\\')
if len(pdb_line) > 17:
pdb_line = pdb_line[0:16] + ' ' + pdb_line[17:] # Remove all altLoc flags
pdb_lines.append(pdb_line) # Remove all altLoc flags
# Make a pdb file of the structure for DSSP analysis
structure = structure_from_pdb_string('\n'.join(pdb_lines), pdb_id)
# Store structures without chain breaks
if len(topology.find_structure_chain_breaks(structure)) == 0:
structure_path = os.path.join(scratch_path, pdb_id + '.pdb')
io = PDB.PDBIO()
io.set_structure(structure)
io.save(structure_path)
candidate_proteins.append({'structure' : structure, 'path' : structure_path})
for p in candidate_proteins:
try:
find_secondary_structures(p, dssp_path)
except:
continue
superfamilies[-1].append(p) # Add a protein to a superfamily if there's no exception
def find_secondary_structures(protein_dict, dssp_path):
'''Find secondary structures of a protein.
Arguements:
- protein_dict - a dictionary to store informations of a protein
'''
protein_dict['dssp_dict'], protein_dict['dssp_key_map'] = \
secondary_structures.make_dssp_dict(protein_dict['path'], dssp_path)
protein_dict['ss_list'], protein_dict['sheet_list'] = \
secondary_structures.pack_dssp_dict_into_ss_list(protein_dict['structure'][0],
protein_dict['dssp_dict'], protein_dict['dssp_key_map'])
| mit | -2,651,815,429,011,390,500 | 29.62963 | 102 | 0.637848 | false |
jralls/gramps | gramps/plugins/webreport/person.py | 1 | 75620 | # -*- coding: utf-8 -*-
#!/usr/bin/env python
#
# Gramps - a GTK+/GNOME based genealogy program
#
# Copyright (C) 2000-2007 Donald N. Allingham
# Copyright (C) 2007 Johan Gonqvist <[email protected]>
# Copyright (C) 2007-2009 Gary Burton <[email protected]>
# Copyright (C) 2007-2009 Stephane Charette <[email protected]>
# Copyright (C) 2008-2009 Brian G. Matherly
# Copyright (C) 2008 Jason M. Simanek <[email protected]>
# Copyright (C) 2008-2011 Rob G. Healey <[email protected]>
# Copyright (C) 2010 Doug Blank <[email protected]>
# Copyright (C) 2010 Jakim Friant
# Copyright (C) 2010-2017 Serge Noiraud
# Copyright (C) 2011 Tim G L Lyons
# Copyright (C) 2013 Benny Malengier
# Copyright (C) 2016 Allen Crider
#
# 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, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
"""
Narrative Web Page generator.
Classe:
PersonPage - Person index page and individual `Person pages
"""
#------------------------------------------------
# python modules
#------------------------------------------------
from collections import defaultdict
from operator import itemgetter
from decimal import Decimal, getcontext
import logging
#------------------------------------------------
# Gramps module
#------------------------------------------------
from gramps.gen.const import GRAMPS_LOCALE as glocale
from gramps.gen.lib import (ChildRefType, Date, Name, Person, EventRoleType)
from gramps.gen.lib.date import Today
from gramps.gen.plug.report import Bibliography
from gramps.gen.plug.report import utils
from gramps.gen.utils.alive import probably_alive
from gramps.gen.constfunc import win
from gramps.gen.display.name import displayer as _nd
from gramps.gen.utils.db import get_birth_or_fallback, get_death_or_fallback
from gramps.plugins.lib.libhtml import Html
from gramps.gen.utils.place import conv_lat_lon
#------------------------------------------------
# specific narrative web import
#------------------------------------------------
from gramps.plugins.webreport.basepage import BasePage
from gramps.plugins.webreport.common import (get_first_letters, _KEYPERSON,
alphabet_navigation, sort_people,
_NAME_STYLE_FIRST, first_letter,
get_index_letter, add_birthdate,
primary_difference, FULLCLEAR,
_find_birth_date, _find_death_date,
MARKER_PATH, OSM_MARKERS,
GOOGLE_MAPS, MARKERS, html_escape,
DROPMASTERS, FAMILYLINKS)
_ = glocale.translation.sgettext
LOG = logging.getLogger(".NarrativeWeb")
getcontext().prec = 8
_WIDTH = 160
_HEIGHT = 64
_VGAP = 10
_HGAP = 30
_SHADOW = 5
_XOFFSET = 5
#################################################
#
# creates the Individual List Page and IndividualPages
#
#################################################
class PersonPages(BasePage):
"""
This class is responsible for displaying information about the 'Person'
database objects. It displays this information under the 'Individuals'
tab. It is told by the 'add_instances' call which 'Person's to display,
and remembers the list of persons. A single call to 'display_pages'
displays both the Individual List (Index) page and all the Individual
pages.
The base class 'BasePage' is initialised once for each page that is
displayed.
"""
def __init__(self, report):
"""
@param: report -- The instance of the main report class for this report
"""
BasePage.__init__(self, report, title="")
self.ind_dict = defaultdict(set)
self.mapservice = None
self.sort_name = None
self.googleopts = None
self.googlemapkey = None
self.birthorder = None
self.person = None
self.familymappages = None
self.rel_class = None
self.placemappages = None
self.name = None
def display_pages(self, title):
"""
Generate and output the pages under the Individuals tab, namely the
individual index and the individual pages.
@param: title -- Is the title of the web page
"""
LOG.debug("obj_dict[Person]")
for item in self.report.obj_dict[Person].items():
LOG.debug(" %s", str(item))
with self.r_user.progress(_("Narrated Web Site Report"),
_('Creating individual pages'),
len(self.report.obj_dict[Person]) + 1
) as step:
self.individuallistpage(self.report, title,
self.report.obj_dict[Person].keys())
for person_handle in sorted(self.report.obj_dict[Person]):
step()
person = self.r_db.get_person_from_handle(person_handle)
self.individualpage(self.report, title, person)
#################################################
#
# creates the Individual List Page
#
#################################################
def individuallistpage(self, report, title, ppl_handle_list):
"""
Creates an individual page
@param: report -- The instance of the main report class
for this report
@param: title -- Is the title of the web page
@param: ppl_handle_list -- The list of people for whom we need
to create a page.
"""
BasePage.__init__(self, report, title)
prev_letter = " "
# plugin variables for this module
showbirth = report.options['showbirth']
showdeath = report.options['showdeath']
showpartner = report.options['showpartner']
showparents = report.options['showparents']
output_file, sio = self.report.create_file("individuals")
indlistpage, head, body = self.write_header(self._("Individuals"))
date = 0
# begin Individuals division
with Html("div", class_="content", id="Individuals") as individuallist:
body += individuallist
# Individual List page message
msg = self._("This page contains an index of all the individuals "
"in the database, sorted by their last names. "
"Selecting the person’s "
"name will take you to that "
"person’s individual page.")
individuallist += Html("p", msg, id="description")
# add alphabet navigation
index_list = get_first_letters(self.r_db, ppl_handle_list,
_KEYPERSON, rlocale=self.rlocale)
alpha_nav = alphabet_navigation(index_list, self.rlocale)
if alpha_nav is not None:
individuallist += alpha_nav
# begin table and table head
with Html("table",
class_="infolist primobjlist IndividualList") as table:
individuallist += table
thead = Html("thead")
table += thead
trow = Html("tr")
thead += trow
# show surname and first name
trow += Html("th", self._("Surname"), class_="ColumnSurname",
inline=True)
trow += Html("th", self._("Given Name"), class_="ColumnName",
inline=True)
if showbirth:
trow += Html("th", self._("Birth"), class_="ColumnDate",
inline=True)
if showdeath:
trow += Html("th", self._("Death"), class_="ColumnDate",
inline=True)
if showpartner:
trow += Html("th", self._("Partner"),
class_="ColumnPartner",
inline=True)
if showparents:
trow += Html("th", self._("Parents"),
class_="ColumnParents",
inline=True)
tbody = Html("tbody")
table += tbody
ppl_handle_list = sort_people(self.r_db, ppl_handle_list,
self.rlocale)
first = True
for (surname, handle_list) in ppl_handle_list:
if surname and not surname.isspace():
letter = get_index_letter(first_letter(surname), index_list,
self.rlocale)
else:
letter = ' '
surname = self._("<absent>")
first_surname = True
for person_handle in sorted(handle_list,
key=self.sort_on_name_and_grampsid):
person = self.r_db.get_person_from_handle(person_handle)
if person.get_change_time() > date:
date = person.get_change_time()
# surname column
trow = Html("tr")
tbody += trow
tcell = Html("td", class_="ColumnSurname", inline=True)
trow += tcell
if first or primary_difference(letter, prev_letter,
self.rlocale):
first = False
first_surname = False
prev_letter = letter
trow.attr = 'class = "BeginSurname"'
ttle = self._("Surnames %(surname)s beginning "
"with letter %(letter)s" %
{'surname' : surname,
'letter' : letter})
tcell += Html(
"a", html_escape(surname), name=letter,
id_=letter,
title=ttle)
elif first_surname:
first_surname = False
tcell += Html("a", html_escape(surname),
title=self._("Surnames") + " " + surname)
else:
tcell += " "
# firstname column
link = self.new_person_link(person_handle, person=person,
name_style=_NAME_STYLE_FIRST)
trow += Html("td", link, class_="ColumnName")
# birth column
if showbirth:
tcell = Html("td", class_="ColumnBirth", inline=True)
trow += tcell
birth_date = _find_birth_date(self.r_db, person)
if birth_date is not None:
if birth_date.fallback:
tcell += Html('em',
self.rlocale.get_date(birth_date),
inline=True)
else:
tcell += self.rlocale.get_date(birth_date)
else:
tcell += " "
# death column
if showdeath:
tcell = Html("td", class_="ColumnDeath", inline=True)
trow += tcell
death_date = _find_death_date(self.r_db, person)
if death_date is not None:
if death_date.fallback:
tcell += Html('em',
self.rlocale.get_date(death_date),
inline=True)
else:
tcell += self.rlocale.get_date(death_date)
else:
tcell += " "
# partner column
if showpartner:
family_list = person.get_family_handle_list()
first_family = True
#partner_name = None
tcell = () # pylint: disable=R0204
if family_list:
for family_handle in family_list:
family = self.r_db.get_family_from_handle(
family_handle)
partner_handle = utils.find_spouse(
person, family)
if partner_handle:
if not first_family:
# have to do this to get the comma on
# the same line as the link
if isinstance(tcell[-1], Html):
# tcell is an instance of Html (or
# of a subclass thereof)
tcell[-1].inside += ","
else:
tcell = tcell[:-1] + (
# TODO for Arabic, translate?
(tcell[-1] + ", "),)
# Have to manipulate as tuples so that
# subsequent people are not nested
# within the first link
tcell += (
self.new_person_link(partner_handle),)
first_family = False
else:
tcell = " "
trow += Html("td", class_="ColumnPartner") + tcell
# parents column
if showparents:
parent_hdl_list = person.get_parent_family_handle_list()
if parent_hdl_list:
parent_handle = parent_hdl_list[0]
family = self.r_db.get_family_from_handle(
parent_handle)
father_handle = family.get_father_handle()
mother_handle = family.get_mother_handle()
if father_handle:
father = self.r_db.get_person_from_handle(
father_handle)
else:
father = None
if mother_handle:
mother = self.r_db.get_person_from_handle(
mother_handle)
else:
mother = None
if father:
father_name = self.get_name(father)
if mother:
mother_name = self.get_name(mother)
samerow = False
if mother and father:
tcell = (Html("span", father_name,
class_="father fatherNmother",
inline=True),
Html("span", mother_name,
class_="mother", inline=True))
elif mother:
tcell = Html("span", mother_name,
class_="mother", inline=True)
elif father:
tcell = Html("span", father_name,
class_="father", inline=True)
else:
tcell = " "
samerow = True
else:
tcell = " "
samerow = True
trow += Html("td", class_="ColumnParents",
inline=samerow) + tcell
# create clear line for proper styling
# create footer section
footer = self.write_footer(date)
body += (FULLCLEAR, footer)
# send page out for processing
# and close the file
self.xhtml_writer(indlistpage, output_file, sio, date)
#################################################
#
# creates an Individual Page
#
#################################################
gender_map = {
Person.MALE : _('male'),
Person.FEMALE : _('female'),
Person.UNKNOWN : _('unknown'),
}
def individualpage(self, report, title, person):
"""
Creates an individual page
@param: report -- The instance of the main report class for this report
@param: title -- Is the title of the web page
@param: person -- The person to use for this page.
"""
BasePage.__init__(self, report, title, person.get_gramps_id())
place_lat_long = []
self.person = person
self.bibli = Bibliography()
self.sort_name = self.get_name(person)
self.name = self.get_name(person)
date = self.person.get_change_time()
# to be used in the Family Map Pages...
self.familymappages = self.report.options['familymappages']
self.placemappages = self.report.options['placemappages']
self.mapservice = self.report.options['mapservice']
self.googleopts = self.report.options['googleopts']
self.googlemapkey = self.report.options['googlemapkey']
# decide if we will sort the birth order of siblings...
self.birthorder = self.report.options['birthorder']
# get the Relationship Calculator so that we can determine
# bio, half, step- siblings for use in display_ind_parents() ...
self.rel_class = self.report.rel_class
output_file, sio = self.report.create_file(person.get_handle(), "ppl")
self.uplink = True
indivdetpage, head, body = self.write_header(self.sort_name)
# attach the ancestortree style sheet if ancestor
# graph is being created?
if self.report.options["ancestortree"]:
if self.usecms:
fname = "/".join([self.target_uri, "css", "ancestortree.css"])
else:
fname = "/".join(["css", "ancestortree.css"])
url = self.report.build_url_fname(fname, None, self.uplink)
head += Html("link", href=url, type="text/css", media="screen",
rel="stylesheet")
# begin individualdetail division
with Html("div", class_="content",
id='IndividualDetail') as individualdetail:
body += individualdetail
# display a person's general data
thumbnail, name, summary = self.display_ind_general()
if thumbnail is not None:
individualdetail += thumbnail
individualdetail += (name, summary)
# display a person's events
sect2 = self.display_ind_events(place_lat_long)
if sect2 is not None:
individualdetail += sect2
# display relationship to the center person
sect3 = self.display_ind_center_person()
if sect3 is not None:
individualdetail += sect3
# display parents
sect4 = self.display_ind_parents()
if sect4 is not None:
individualdetail += sect4
# display relationships
relationships = self.display_relationships(self.person,
place_lat_long)
if relationships is not None:
individualdetail += relationships
# display LDS ordinance
sect5 = self.display_lds_ordinance(self.person)
if sect5 is not None:
individualdetail += sect5
# display address(es) and show sources
sect6 = self.display_addr_list(self.person.get_address_list(), True)
if sect6 is not None:
individualdetail += sect6
photo_list = self.person.get_media_list()
media_list = photo_list[:]
# if Family Pages are not being created, then include the Family
# Media objects? There is no reason to add these objects to the
# Individual Pages...
if not self.inc_families:
for handle in self.person.get_family_handle_list():
family = self.r_db.get_family_from_handle(handle)
if family:
media_list += family.get_media_list()
for evt_ref in family.get_event_ref_list():
event = self.r_db.get_event_from_handle(evt_ref.ref)
media_list += event.get_media_list()
# if the Event Pages are not being created, then include the Event
# Media objects? There is no reason to add these objects to the
# Individual Pages...
if not self.inc_events:
for evt_ref in self.person.get_primary_event_ref_list():
event = self.r_db.get_event_from_handle(evt_ref.ref)
if event:
media_list += event.get_media_list()
# display additional images as gallery
sect7 = self.disp_add_img_as_gallery(media_list, person)
if sect7 is not None:
individualdetail += sect7
# display Narrative Notes
notelist = person.get_note_list()
sect8 = self.display_note_list(notelist)
if sect8 is not None:
individualdetail += sect8
# display attributes
attrlist = person.get_attribute_list()
if attrlist:
attrsection, attrtable = self.display_attribute_header()
self.display_attr_list(attrlist, attrtable)
individualdetail += attrsection
# display web links
sect10 = self.display_url_list(self.person.get_url_list())
if sect10 is not None:
individualdetail += sect10
# display associations
assocs = person.get_person_ref_list()
if assocs:
individualdetail += self.display_ind_associations(assocs)
# for use in family map pages...
if len(place_lat_long) > 0:
if self.report.options["familymappages"]:
# save output_file, string_io and cur_fname
# before creating a new page
sof = output_file
sstring_io = sio
sfname = self.report.cur_fname
individualdetail += self.__display_family_map(
person, place_lat_long)
# restore output_file, string_io and cur_fname
# after creating a new page
output_file = sof
sio = sstring_io
self.report.cur_fname = sfname
# display pedigree
sect13 = self.display_ind_pedigree()
if sect13 is not None:
individualdetail += sect13
# display ancestor tree
if report.options['ancestortree']:
sect14 = self.display_tree()
if sect14 is not None:
individualdetail += sect14
# display source references
sect14 = self.display_ind_sources(person)
if sect14 is not None:
individualdetail += sect14
# add clearline for proper styling
# create footer section
footer = self.write_footer(date)
body += (FULLCLEAR, footer)
# send page out for processing
# and close the file
self.xhtml_writer(indivdetpage, output_file, sio, date)
def __create_family_map(self, person, place_lat_long):
"""
creates individual family map page
@param: person -- person from database
@param: place_lat_long -- for use in Family Map Pages
"""
if not place_lat_long:
return
output_file, sio = self.report.create_file(person.get_handle(), "maps")
self.uplink = True
familymappage, head, body = self.write_header(self._("Family Map"))
minx, maxx = Decimal("0.00000001"), Decimal("0.00000001")
miny, maxy = Decimal("0.00000001"), Decimal("0.00000001")
xwidth, yheight = [], []
midx_, midy_, spanx, spany = [None]*4
number_markers = len(place_lat_long)
if number_markers > 1:
for (latitude, longitude, placetitle, handle,
date, etype) in place_lat_long:
xwidth.append(latitude)
yheight.append(longitude)
xwidth.sort()
yheight.sort()
minx = xwidth[0] if xwidth[0] else minx
maxx = xwidth[-1] if xwidth[-1] else maxx
minx, maxx = Decimal(minx), Decimal(maxx)
midx_ = str(Decimal((minx + maxx) /2))
miny = yheight[0] if yheight[0] else miny
maxy = yheight[-1] if yheight[-1] else maxy
miny, maxy = Decimal(miny), Decimal(maxy)
midy_ = str(Decimal((miny + maxy) /2))
midx_, midy_ = conv_lat_lon(midx_, midy_, "D.D8")
# get the integer span of latitude and longitude
spanx = int(maxx - minx)
spany = int(maxy - miny)
# set zoom level based on span of Longitude?
tinyset = [value for value in (-3, -2, -1, 0, 1, 2, 3)]
smallset = [value for value in (-4, -5, -6, -7, 4, 5, 6, 7)]
middleset = [value for value in (-8, -9, -10, -11, 8, 9, 10, 11)]
largeset = [value for value in (-11, -12, -13, -14, -15, -16,
-17, 11, 12, 13, 14, 15, 16, 17)]
if spany in tinyset or spany in smallset:
zoomlevel = 6
elif spany in middleset:
zoomlevel = 5
elif spany in largeset:
zoomlevel = 4
else:
zoomlevel = 3
# 0 = latitude, 1 = longitude, 2 = place title,
# 3 = handle, and 4 = date, 5 = event type...
# being sorted by date, latitude, and longitude...
place_lat_long = sorted(place_lat_long, key=itemgetter(4, 0, 1))
# for all plugins
# if family_detail_page
# if active
# call_(report, up, head)
# add narrative-maps style sheet
if self.usecms:
fname = "/".join([self.target_uri, "css", "narrative-maps.css"])
else:
fname = "/".join(["css", "narrative-maps.css"])
url = self.report.build_url_fname(fname, None, self.uplink)
head += Html("link", href=url, type="text/css", media="screen",
rel="stylesheet")
# add MapService specific javascript code
if self.mapservice == "Google":
src_js = GOOGLE_MAPS + "api/js?sensor=false"
if self.googlemapkey:
src_js += "&key=" + self.googlemapkey
head += Html("script", type="text/javascript",
src=src_js, inline=True)
else:
url = self.secure_mode
url += ("maxcdn.bootstrapcdn.com/bootstrap/3.3.7/"
"css/bootstrap.min.css")
head += Html("link", href=url, type="text/javascript",
rel="stylesheet")
src_js = self.secure_mode
src_js += "ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"
head += Html("script", type="text/javascript",
src=src_js, inline=True)
src_js = self.secure_mode
src_js += "openlayers.org/en/v3.17.1/build/ol.js"
head += Html("script", type="text/javascript",
src=src_js, inline=True)
url = self.secure_mode
url += "openlayers.org/en/v3.17.1/css/ol.css"
head += Html("link", href=url, type="text/javascript",
rel="stylesheet")
src_js = self.secure_mode
src_js += ("maxcdn.bootstrapcdn.com/bootstrap/3.3.7/"
"js/bootstrap.min.js")
head += Html("script", type="text/javascript",
src=src_js, inline=True)
if number_markers > 0:
tracelife = "["
seq_ = 1
for index in range(0, (number_markers - 1)):
(latitude, longitude, placetitle, handle, date,
etype) = place_lat_long[index]
# are we using Google?
if self.mapservice == "Google":
# are we creating Family Links?
if self.googleopts == "FamilyLinks":
tracelife += """
new google.maps.LatLng(%s, %s),""" % (latitude, longitude)
# are we creating Drop Markers or Markers?
elif self.googleopts in ["Drop", "Markers"]:
tracelife += """
['%s', %s, %s, %d],""" % (placetitle.replace("'", "\\'"), latitude,
longitude, seq_)
# are we using OpenStreetMap?
else:
tracelife += """
[%f, %f, \'%s\'],""" % (float(longitude), float(latitude),
placetitle.replace("'", "\\'"))
seq_ += 1
# FIXME: The last element in the place_lat_long list is treated
# specially, and the code above is apparently repeated so as to
# avoid a comma at the end, and get the right closing. This is very
# ugly.
(latitude, longitude, placetitle, handle, date,
etype) = place_lat_long[-1]
# are we using Google?
if self.mapservice == "Google":
# are we creating Family Links?
if self.googleopts == "FamilyLinks":
tracelife += """
new google.maps.LatLng(%s, %s)
];""" % (latitude, longitude)
# are we creating Drop Markers or Markers?
elif self.googleopts in ["Drop", "Markers"]:
tracelife += """
['%s', %s, %s, %d]
];""" % (placetitle.replace("'", "\\'"), latitude, longitude, seq_)
# are we using OpenStreetMap?
elif self.mapservice == "OpenStreetMap":
tracelife += """
[%f, %f, \'%s\']
];""" % (float(longitude), float(latitude), placetitle.replace("'", "\\'"))
# begin MapDetail division...
with Html("div", class_="content", id="FamilyMapDetail") as mapdetail:
body += mapdetail
# add page title
mapdetail += Html("h3",
html_escape(self._("Tracking %s")
% self.get_name(person)),
inline=True)
# page description
msg = self._("This map page represents that person "
"and any descendants with all of their event/ places. "
"If you place your mouse over "
"the marker it will display the place name. "
"The markers and the Reference "
"list are sorted in date order (if any?). "
"Clicking on a place’s "
"name in the Reference section will take you "
"to that place’s page.")
mapdetail += Html("p", msg, id="description")
# this is the style element where the Map is held in the CSS...
with Html("div", id="map_canvas") as canvas:
mapdetail += canvas
# begin javascript inline code...
with Html("script", deter="deter",
style='width =100%; height =100%;',
type="text/javascript", indent=False) as jsc:
head += jsc
# Link to Gramps marker
fname = "/".join(['images', 'marker.png'])
marker_path = self.report.build_url_image("marker.png",
"images",
self.uplink)
jsc += MARKER_PATH % marker_path
# are we using Google?
if self.mapservice == "Google":
# are we creating Family Links?
if self.googleopts == "FamilyLinks":
if midy_ is None:
jsc += FAMILYLINKS % (tracelife, latitude,
longitude, int(10))
else:
jsc += FAMILYLINKS % (tracelife, midx_, midy_,
zoomlevel)
# are we creating Drop Markers?
elif self.googleopts == "Drop":
if midy_ is None:
jsc += DROPMASTERS % (tracelife, latitude,
longitude, int(10))
else:
jsc += DROPMASTERS % (tracelife, midx_, midy_,
zoomlevel)
# we are creating Markers only...
else:
if midy_ is None:
jsc += MARKERS % (tracelife, latitude,
longitude, int(10))
else:
jsc += MARKERS % (tracelife, midx_, midy_,
zoomlevel)
# we are using OpenStreetMap...
else:
if midy_ is None:
jsc += OSM_MARKERS % (tracelife,
longitude,
latitude, 10)
else:
jsc += OSM_MARKERS % (tracelife, midy_, midx_,
zoomlevel)
# if Google and Drop Markers are selected,
# then add "Drop Markers" button?
if self.mapservice == "Google" and self.googleopts == "Drop":
mapdetail += Html("button", _("Drop Markers"),
id="drop", onclick="drop()", inline=True)
# add div for popups.
with Html("div", id="popup", inline=True) as popup:
mapdetail += popup
# begin place reference section and its table...
with Html("div", class_="subsection", id="references") as section:
mapdetail += section
section += Html("h4", self._("References"), inline=True)
with Html("table", class_="infolist") as table:
section += table
thead = Html("thead")
table += thead
trow = Html("tr")
thead += trow
trow.extend(
Html("th", label, class_=colclass, inline=True)
for (label, colclass) in [
(_("Date"), "ColumnDate"),
(_("Place Title"), "ColumnPlace"),
(_("Event Type"), "ColumnType")
]
)
tbody = Html("tbody")
table += tbody
for (latitude, longitude, placetitle, handle, date,
etype) in place_lat_long:
trow = Html("tr")
tbody += trow
trow.extend(
Html("td", data, class_=colclass, inline=True)
for data, colclass in [
(date, "ColumnDate"),
(self.place_link(handle, placetitle,
uplink=True),
"ColumnPlace"),
(str(etype), "ColumnType")
]
)
# add body id for this page...
body.attr = 'id ="FamilyMap" onload ="initialize()"'
# add clearline for proper styling
# add footer section
footer = self.write_footer(None)
body += (FULLCLEAR, footer)
# send page out for processing
# and close the file
self.xhtml_writer(familymappage, output_file, sio, 0)
def __display_family_map(self, person, place_lat_long):
"""
Create the family map link
@param: person -- The person to set in the box
@param: place_lat_long -- The center of the box
"""
# create family map page
self.__create_family_map(person, place_lat_long)
# begin family map division plus section title
with Html("div", class_="subsection", id="familymap") as familymap:
familymap += Html("h4", self._("Family Map"), inline=True)
# add family map link
person_handle = person.get_handle()
url = self.report.build_url_fname_html(person_handle, "maps", True)
familymap += self.family_map_link(person_handle, url)
# return family map link to its caller
return familymap
def draw_box(self, center, col, person):
"""
Draw the box around the AncestorTree Individual name box...
@param: center -- The center of the box
@param: col -- The generation number
@param: person -- The person to set in the box
"""
top = center - _HEIGHT/2
xoff = _XOFFSET+col*(_WIDTH+_HGAP)
sex = person.gender
if sex == Person.MALE:
divclass = "male"
elif sex == Person.FEMALE:
divclass = "female"
else:
divclass = "unknown"
boxbg = Html("div", class_="boxbg %s AncCol%s" % (divclass, col),
style="top: %dpx; left: %dpx;" % (top, xoff+1)
)
person_name = self.get_name(person)
# This does not use [new_]person_link because the requirements are
# unique
result = self.report.obj_dict.get(Person).get(person.handle)
if result is None or result[0] == "":
# The person is not included in the webreport or there is no link
# to them
boxbg += Html("span", person_name, class_="unlinked", inline=True)
else:
thumbnail_url = None
if self.create_media and col < 5:
photolist = person.get_media_list()
if photolist:
photo_handle = photolist[0].get_reference_handle()
photo = self.r_db.get_media_from_handle(photo_handle)
mime_type = photo.get_mime_type()
if mime_type:
region = self.media_ref_region_to_object(photo_handle,
person)
if region:
# make a thumbnail of this region
newpath = self.copy_thumbnail(
photo_handle, photo, region)
# TODO. Check if build_url_fname can be used.
newpath = "/".join(['..']*3 + [newpath])
if win():
newpath = newpath.replace('\\', "/")
thumbnail_url = newpath
else:
(photo_url,
thumbnail_url) = self.report.prepare_copy_media(
photo)
thumbnail_url = "/".join(['..']*3 + [thumbnail_url])
if win():
thumbnail_url = thumbnail_url.replace('\\', "/")
url = self.report.build_url_fname_html(person.handle, "ppl", True)
birth = death = ""
bd_event = get_birth_or_fallback(self.r_db, person)
if bd_event:
birth = self.rlocale.get_date(bd_event.get_date_object())
dd_event = get_death_or_fallback(self.r_db, person)
if dd_event:
death = self.rlocale.get_date(dd_event.get_date_object())
if death == "":
death = "..."
value = person_name + "<br/>*", birth, "<br/>+", death
if thumbnail_url is None:
boxbg += Html("a", href=url, class_="noThumb") + value
else:
thumb = Html("span", class_="thumbnail") + (
Html("img", src=thumbnail_url, alt="Image: " + person_name))
boxbg += Html("a", href=url) + thumb + value
shadow = Html(
"div", class_="shadow", inline=True,
style="top: %dpx; left: %dpx;" % (top + _SHADOW, xoff + _SHADOW))
return [boxbg, shadow]
def extend_line(self, coord_y0, coord_x0):
"""
Draw and extended line
@param: coord_y0 -- The starting point
@param: coord_x0 -- The end of the line
"""
style = "top: %dpx; left: %dpx; width: %dpx"
ext_bv = Html("div", class_="bvline", inline=True,
style=style % (coord_y0, coord_x0, _HGAP/2)
)
ext_gv = Html("div", class_="gvline", inline=True,
style=style % (coord_y0+_SHADOW,
coord_x0, _HGAP/2+_SHADOW)
)
return [ext_bv, ext_gv]
def connect_line(self, coord_y0, coord_y1, col):
"""
We need to draw a line between to points
@param: coord_y0 -- The starting point
@param: coord_y1 -- The end of the line
@param: col -- The generation number
"""
coord_y = min(coord_y0, coord_y1)
stylew = "top: %dpx; left: %dpx; width: %dpx;"
styleh = "top: %dpx; left: %dpx; height: %dpx;"
coord_x0 = _XOFFSET + col * _WIDTH + (col-1)*_HGAP + _HGAP/2
cnct_bv = Html("div", class_="bvline", inline=True,
style=stylew % (coord_y1, coord_x0, _HGAP/2))
cnct_gv = Html("div", class_="gvline", inline=True,
style=stylew % (coord_y1+_SHADOW,
coord_x0+_SHADOW,
_HGAP/2+_SHADOW))
cnct_bh = Html("div", class_="bhline", inline=True,
style=styleh % (coord_y, coord_x0,
abs(coord_y0-coord_y1)))
cnct_gh = Html("div", class_="gvline", inline=True,
style=styleh % (coord_y+_SHADOW,
coord_x0+_SHADOW,
abs(coord_y0-coord_y1)))
return [cnct_bv, cnct_gv, cnct_bh, cnct_gh]
def draw_connected_box(self, center1, center2, col, handle):
"""
Draws the connected box for Ancestor Tree on the Individual Page
@param: center1 -- The first box to connect
@param: center2 -- The destination box to draw
@param: col -- The generation number
@param: handle -- The handle of the person to set in the new box
"""
box = []
if not handle:
return box
person = self.r_db.get_person_from_handle(handle)
box = self.draw_box(center2, col, person)
box += self.connect_line(center1, center2, col)
return box
def display_tree(self):
"""
Display the Ancestor Tree
"""
tree = []
if not self.person.get_main_parents_family_handle():
return None
generations = self.report.options['graphgens']
max_in_col = 1 << (generations-1)
max_size = _HEIGHT*max_in_col + _VGAP*(max_in_col+1)
center = int(max_size/2)
with Html("div", id="tree", class_="subsection") as tree:
tree += Html("h4", self._('Ancestors'), inline=True)
with Html("div", id="treeContainer",
style="width:%dpx; height:%dpx;" % (
_XOFFSET+(generations)*_WIDTH+(generations-1)*_HGAP,
max_size)
) as container:
tree += container
container += self.draw_tree(1, generations, max_size,
0, center, self.person.handle)
return tree
def draw_tree(self, gen_nr, maxgen, max_size, old_center,
new_center, person_handle):
"""
Draws the Ancestor Tree
@param: gen_nr -- The generation number to draw
@param: maxgen -- The maximum number of generations to draw
@param: max_size -- The maximum size of the drawing area
@param: old_center -- The position of the old box
@param: new_center -- The position of the new box
@param: person_handle -- The handle of the person to draw
"""
tree = []
if gen_nr > maxgen:
return tree
gen_offset = int(max_size / pow(2, gen_nr+1))
if person_handle:
person = self.r_db.get_person_from_handle(person_handle)
else:
person = None
if not person:
return tree
if gen_nr == 1:
tree = self.draw_box(new_center, 0, person)
else:
tree = self.draw_connected_box(old_center, new_center,
gen_nr-1, person_handle)
if gen_nr == maxgen:
return tree
family_handle = person.get_main_parents_family_handle()
if family_handle:
line_offset = _XOFFSET + gen_nr*_WIDTH + (gen_nr-1)*_HGAP
tree += self.extend_line(new_center, line_offset)
family = self.r_db.get_family_from_handle(family_handle)
f_center = new_center-gen_offset
f_handle = family.get_father_handle()
tree += self.draw_tree(gen_nr+1, maxgen, max_size,
new_center, f_center, f_handle)
m_center = new_center+gen_offset
m_handle = family.get_mother_handle()
tree += self.draw_tree(gen_nr+1, maxgen, max_size,
new_center, m_center, m_handle)
return tree
def display_ind_associations(self, assoclist):
"""
Display an individual's associations
@param: assoclist -- The list of persons for association
"""
# begin Associations division
with Html("div", class_="subsection", id="Associations") as section:
section += Html("h4", self._('Associations'), inline=True)
with Html("table", class_="infolist assoclist") as table:
section += table
thead = Html("thead")
table += thead
trow = Html("tr")
thead += trow
assoc_row = [
(self._("Person"), 'Person'),
(self._('Relationship'), 'Relationship'),
(self._("Notes"), 'Notes'),
(self._("Sources"), 'Sources'),
]
trow.extend(
Html("th", label, class_="Column" + colclass, inline=True)
for (label, colclass) in assoc_row)
tbody = Html("tbody")
table += tbody
for person_ref in assoclist:
trow = Html("tr")
tbody += trow
person_lnk = self.new_person_link(person_ref.ref,
uplink=True)
index = 0
for data in [
person_lnk,
person_ref.get_relation(),
self.dump_notes(person_ref.get_note_list()),
self.get_citation_links(
person_ref.get_citation_list()),
]:
# get colclass from assoc_row
colclass = assoc_row[index][1]
trow += Html("td", data, class_="Column" + colclass,
inline=True)
index += 1
# return section to its callers
return section
def display_ind_pedigree(self):
"""
Display an individual's pedigree
"""
birthorder = self.report.options["birthorder"]
# Define helper functions
def children_ped(ol_html):
"""
Create a children list
@param: ol_html -- The html element to complete
"""
if family:
childlist = family.get_child_ref_list()
childlist = [child_ref.ref for child_ref in childlist]
children = add_birthdate(self.r_db, childlist, self.rlocale)
if birthorder:
children = sorted(children)
for birthdate, birth, death, handle in children:
if handle == self.person.get_handle():
child_ped(ol_html)
elif handle:
child = self.r_db.get_person_from_handle(handle)
if child:
ol_html += Html("li") + self.pedigree_person(child)
else:
child_ped(ol_html)
return ol_html
def child_ped(ol_html):
"""
Create a child element list
@param: ol_html -- The html element to complete
"""
with Html("li", self.name, class_="thisperson") as pedfam:
family = self.pedigree_family()
if family:
pedfam += Html("ol", class_="spouselist") + family
return ol_html + pedfam
# End of helper functions
parent_handle_list = self.person.get_parent_family_handle_list()
if parent_handle_list:
parent_handle = parent_handle_list[0]
family = self.r_db.get_family_from_handle(parent_handle)
father_handle = family.get_father_handle()
mother_handle = family.get_mother_handle()
if mother_handle:
mother = self.r_db.get_person_from_handle(mother_handle)
else:
mother = None
if father_handle:
father = self.r_db.get_person_from_handle(father_handle)
else:
father = None
else:
family = None
father = None
mother = None
with Html("div", id="pedigree", class_="subsection") as ped:
ped += Html("h4", self._('Pedigree'), inline=True)
with Html("ol", class_="pedigreegen") as pedol:
ped += pedol
if father and mother:
pedfa = Html("li") + self.pedigree_person(father)
pedol += pedfa
with Html("ol") as pedma:
pedfa += pedma
pedma += (Html("li", class_="spouse") +
self.pedigree_person(mother) +
children_ped(Html("ol"))
)
elif father:
pedol += (Html("li") + self.pedigree_person(father) +
children_ped(Html("ol"))
)
elif mother:
pedol += (Html("li") + self.pedigree_person(mother) +
children_ped(Html("ol"))
)
else:
pedol += (Html("li") + children_ped(Html("ol")))
return ped
def display_ind_general(self):
"""
display an individual's general information...
"""
self.page_title = self.sort_name
thumbnail = self.disp_first_img_as_thumbnail(
self.person.get_media_list(), self.person)
section_title = Html("h3", html_escape(self.page_title),
inline=True) + (
Html('sup') + (
Html('small') +
self.get_citation_links(
self.person.get_citation_list())))
# begin summaryarea division
with Html("div", id='summaryarea') as summaryarea:
# begin general details table
with Html("table", class_="infolist") as table:
summaryarea += table
primary_name = self.person.get_primary_name()
all_names = [primary_name] + self.person.get_alternate_names()
# if the callname or the nickname is the same as the 'first
# name' (given name), then they are not displayed.
first_name = primary_name.get_first_name()
# Names [and their sources]
for name in all_names:
pname = html_escape(_nd.display_name(name))
pname += self.get_citation_links(name.get_citation_list())
# if we have just a firstname, then the name is preceeded
# by ", " which doesn't exactly look very nice printed on
# the web page
if pname[:2] == ', ': # TODO for Arabic, translate this?
pname = pname[2:]
if name != primary_name:
datetext = self.rlocale.get_date(name.date)
if datetext:
pname = datetext + ': ' + pname
type_ = self._(name.get_type().xml_str())
trow = Html("tr") + (
Html("td", type_, class_="ColumnAttribute",
inline=True)
)
tcell = Html("td", pname, class_="ColumnValue")
# display any notes associated with this name
notelist = name.get_note_list()
if len(notelist):
unordered = Html("ul")
for notehandle in notelist:
note = self.r_db.get_note_from_handle(notehandle)
if note:
note_text = self.get_note_format(note, True)
# attach note
unordered += note_text
tcell += unordered
trow += tcell
table += trow
# display the callname associated with this name.
call_name = name.get_call_name()
if call_name and call_name != first_name:
trow = Html("tr") + (
Html("td", _("Call Name"), class_="ColumnAttribute",
inline=True),
Html("td", call_name, class_="ColumnValue",
inline=True)
)
table += trow
# display the nickname associated with this name. Note that
# this no longer displays the Nickname attribute (if
# present), because the nickname attribute is deprecated in
# favour of the nick_name property of the name structure
# (see http://gramps.1791082.n4.nabble.com/Where-is-
# nickname-stored-tp4469779p4484272.html), and also because
# the attribute is (normally) displayed lower down the
# wNarrative Web report.
nick_name = name.get_nick_name()
if nick_name and nick_name != first_name:
trow = Html("tr") + (
Html("td", self._("Nick Name"),
class_="ColumnAttribute",
inline=True),
Html("td", nick_name, class_="ColumnValue",
inline=True)
)
table += trow
# Gramps ID
person_gid = self.person.get_gramps_id()
if not self.noid and person_gid:
trow = Html("tr") + (
Html("td", self._("Gramps ID"),
class_="ColumnAttribute",
inline=True),
Html("td", person_gid, class_="ColumnValue",
inline=True)
)
table += trow
# Gender
gender = self._(self.gender_map[self.person.gender])
trow = Html("tr") + (
Html("td", self._("Gender"), class_="ColumnAttribute",
inline=True),
Html("td", gender, class_="ColumnValue", inline=True)
)
table += trow
# Age At Death???
birth_date = Date.EMPTY
birth_ref = self.person.get_birth_ref()
if birth_ref:
birth = self.r_db.get_event_from_handle(birth_ref.ref)
if birth:
birth_date = birth.get_date_object()
if birth_date and birth_date is not Date.EMPTY:
alive = probably_alive(self.person, self.r_db, Today())
death_date = _find_death_date(self.r_db, self.person)
if not alive and death_date is not None:
nyears = death_date - birth_date
nyears = nyears.format(precision=3,
dlocale=self.rlocale)
trow = Html("tr") + (
Html("td", self._("Age at Death"),
class_="ColumnAttribute", inline=True),
Html("td", nyears,
class_="ColumnValue", inline=True)
)
table += trow
# return all three pieces to its caller
# do NOT combine before returning
return thumbnail, section_title, summaryarea
def display_ind_events(self, place_lat_long):
"""
will create the events table
@param: place_lat_long -- For use in Family Map Pages. This will be None
if called from Family pages, which do not
create a Family Map
"""
event_ref_list = self.person.get_event_ref_list()
if not event_ref_list:
return None
# begin events division and section title
with Html("div", id="events", class_="subsection") as section:
section += Html("h4", self._("Events"), inline=True)
# begin events table
with Html("table", class_="infolist eventlist") as table:
section += table
thead = Html("thead")
table += thead
# attach event header row
thead += self.event_header_row()
tbody = Html("tbody")
table += tbody
for evt_ref in event_ref_list:
event = self.r_db.get_event_from_handle(evt_ref.ref)
if event:
# display event row
tbody += self.display_event_row(event, evt_ref,
place_lat_long,
True, True,
EventRoleType.PRIMARY)
return section
def display_parent(self, handle, title, rel):
"""
This will display a parent ...
@param: handle -- The person handle
@param: title -- Is the title of the web page
@param: rel -- The relation
"""
tcell1 = Html("td", title, class_="ColumnAttribute", inline=True)
tcell2 = Html("td", class_="ColumnValue", close=False, inline=True)
tcell2 += self.new_person_link(handle, uplink=True)
if rel and rel != ChildRefType(ChildRefType.BIRTH):
tcell2 += ''.join([' '] *3 + ['(%s)']) % str(rel)
person = self.r_db.get_person_from_handle(handle)
birth = death = ""
if person:
bd_event = get_birth_or_fallback(self.r_db, person)
if bd_event:
birth = self.rlocale.get_date(bd_event.get_date_object())
dd_event = get_death_or_fallback(self.r_db, person)
if dd_event:
death = self.rlocale.get_date(dd_event.get_date_object())
tcell3 = Html("td", birth, class_="ColumnDate",
inline=False, close=False, indent=False)
tcell4 = Html("td", death, class_="ColumnDate",
inline=True, close=False, indent=False)
tcell2 += tcell3
tcell2 += tcell4
# return table columns to its caller
return tcell1, tcell2
def get_reln_in_family(self, ind, family):
"""
Display the relation of the indiv in the family
@param: ind -- The person to use
@param: family -- The family
"""
child_handle = ind.get_handle()
child_ref_list = family.get_child_ref_list()
for child_ref in child_ref_list:
if child_ref.ref == child_handle:
return (child_ref.get_father_relation(),
child_ref.get_mother_relation())
return (None, None)
def display_ind_parent_family(self, birthmother, birthfather, family,
table,
first=False):
"""
Display the individual parent family
@param: birthmother -- The birth mother
@param: birthfather -- The birth father
@param: family -- The family
@param: table -- The html document to complete
@param: first -- Is this the first indiv ?
"""
if not first:
trow = Html("tr") + (Html("td", " ", colspan=3,
inline=True))
table += trow
# get the father
father_handle = family.get_father_handle()
if father_handle:
if father_handle == birthfather:
# The parent may not be birth father in ths family, because it
# may be a step family. However, it will be odd to display the
# parent as anything other than "Father"
reln = self._("Father")
else:
# Stepfather may not always be quite right (for example, it may
# actually be StepFather-in-law), but it is too expensive to
# calculate out the correct relationship using the Relationship
# Calculator
reln = self._("Stepfather")
trow = Html("tr") + (self.display_parent(father_handle, reln, None))
table += trow
# get the mother
mother_handle = family.get_mother_handle()
if mother_handle:
if mother_handle == birthmother:
reln = self._("Mother")
else:
reln = self._("Stepmother")
trow = Html("tr") + (self.display_parent(mother_handle, reln, None))
table += trow
for child_ref in family.get_child_ref_list():
child_handle = child_ref.ref
child = self.r_db.get_person_from_handle(child_handle)
if child:
if child == self.person:
reln = ""
else:
try:
# We have a try except block here, because the two
# people MUST be siblings for the called Relationship
# routines to work. Depending on your definition of
# sibling, we cannot necessarily guarantee that.
sibling_type = self.rel_class.get_sibling_type(
self.r_db, self.person, child)
reln = self.rel_class.get_sibling_relationship_string(
sibling_type, self.person.gender, child.gender)
# We have a problem here : reln is never in the choosen
# language but in the default language.
# Does get_sibling_relationship_string work ?
reln = reln[0].upper() + reln[1:]
except:
reln = self._("Not siblings")
val1 = " "
reln = val1 + reln
# Now output reln, child_link, (frel, mrel)
frel = child_ref.get_father_relation()
mrel = child_ref.get_mother_relation()
if frel != ChildRefType.BIRTH or mrel != ChildRefType.BIRTH:
frelmrel = "(%s, %s)" % (str(frel), str(mrel))
else:
frelmrel = ""
trow = Html("tr") + (
Html("td", reln, class_="ColumnAttribute", inline=True))
tcell = Html("td", val1, class_="ColumnValue", inline=True)
tcell += self.display_child_link(child_handle)
birth = death = ""
bd_event = get_birth_or_fallback(self.r_db, child)
if bd_event:
birth = self.rlocale.get_date(bd_event.get_date_object())
dd_event = get_death_or_fallback(self.r_db, child)
if dd_event:
death = self.rlocale.get_date(dd_event.get_date_object())
tcell2 = Html("td", birth, class_="ColumnDate",
inline=True)
tcell3 = Html("td", death, class_="ColumnDate",
inline=True)
trow += tcell
trow += tcell2
trow += tcell3
tcell = Html("td", frelmrel, class_="ColumnValue",
inline=True)
trow += tcell
table += trow
def display_step_families(self, parent_handle,
family,
all_family_handles,
birthmother, birthfather,
table):
"""
Display step families
@param: parent_handle -- The family parent handle to display
@param: family -- The family
@param: all_family_handles -- All known family handles
@param: birthmother -- The birth mother
@param: birthfather -- The birth father
@param: table -- The html document to complete
"""
if parent_handle:
parent = self.r_db.get_person_from_handle(parent_handle)
for parent_family_handle in parent.get_family_handle_list():
if parent_family_handle not in all_family_handles:
parent_family = self.r_db.get_family_from_handle(
parent_family_handle)
self.display_ind_parent_family(birthmother, birthfather,
parent_family, table)
all_family_handles.append(parent_family_handle)
def display_ind_center_person(self):
"""
Display the person's relationship to the center person
"""
center_person = self.r_db.get_person_from_gramps_id(
self.report.options['pid'])
if center_person is None:
return
relationship = self.rel_class.get_one_relationship(self.r_db,
self.person,
center_person)
if relationship == "": # No relation to display
return
# begin center_person division
section = ""
with Html("div", class_="subsection", id="parents") as section:
message = self._("Relation to the center person")
message += " ("
name_format = self.report.options['name_format']
primary_name = center_person.get_primary_name()
name = Name(primary_name)
name.set_display_as(name_format)
message += _nd.display_name(name)
message += ") : "
message += relationship
section += Html("h4", message, inline=True)
return section
def display_ind_parents(self):
"""
Display a person's parents
"""
parent_list = self.person.get_parent_family_handle_list()
if not parent_list:
return None
# begin parents division
with Html("div", class_="subsection", id="parents") as section:
section += Html("h4", self._("Parents"), inline=True)
# begin parents table
with Html("table", class_="infolist") as table:
section += table
thead = Html("thead")
table += thead
trow = Html("tr")
thead += trow
trow.extend(
Html("th", label, class_=colclass, inline=True)
for (label, colclass) in [
(self._("Relation to main person"), "ColumnAttribute"),
(self._("Name"), "ColumnValue"),
(self._("Birth date"), "ColumnValue"),
(self._("Death date"), "ColumnValue"),
(self._("Relation within this family "
"(if not by birth)"),
"ColumnValue")
]
)
tbody = Html("tbody")
all_family_handles = list(parent_list)
(birthmother, birthfather) = self.rel_class.get_birth_parents(
self.r_db, self.person)
first = True
for family_handle in parent_list:
family = self.r_db.get_family_from_handle(family_handle)
if family:
# Display this family
self.display_ind_parent_family(birthmother,
birthfather,
family, tbody, first)
first = False
if self.report.options['showhalfsiblings']:
# Display all families in which the parents are
# involved. This displays half siblings and step
# siblings
self.display_step_families(
family.get_father_handle(), family,
all_family_handles,
birthmother, birthfather, tbody)
self.display_step_families(
family.get_mother_handle(), family,
all_family_handles,
birthmother, birthfather, tbody)
table += tbody
return section
def pedigree_person(self, person):
"""
will produce a hyperlink for a pedigree person ...
@param: person -- The person
"""
hyper = self.new_person_link(person.handle, person=person, uplink=True)
return hyper
def pedigree_family(self):
"""
Returns a family pedigree
"""
ped = []
for family_handle in self.person.get_family_handle_list():
rel_family = self.r_db.get_family_from_handle(family_handle)
spouse_handle = utils.find_spouse(self.person, rel_family)
if spouse_handle:
spouse = self.r_db.get_person_from_handle(spouse_handle)
pedsp = (Html("li", class_="spouse") +
self.pedigree_person(spouse)
)
else:
pedsp = (Html("li", class_="spouse"))
ped += [pedsp]
childlist = rel_family.get_child_ref_list()
if childlist:
with Html("ol") as childol:
pedsp += [childol]
for child_ref in childlist:
child = self.r_db.get_person_from_handle(child_ref.ref)
if child:
childol += (Html("li") +
self.pedigree_person(child)
)
return ped
| gpl-2.0 | -1,617,659,728,472,627,700 | 41.24581 | 80 | 0.463608 | false |
faddai/newfies-dialer | newfies/user_profile/views.py | 1 | 11084 | #
# Newfies-Dialer License
# http://www.newfies-dialer.org
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this file,
# You can obtain one at http://mozilla.org/MPL/2.0/.
#
# Copyright (C) 2011-2012 Star2Billing S.L.
#
# The Initial Developer of the Original Code is
# Arezqui Belaid <[email protected]>
#
from django.contrib.auth.models import User
from django.contrib.auth.decorators import login_required
from django.contrib.auth.forms import PasswordChangeForm
from django.shortcuts import render_to_response
from django.http import HttpResponseRedirect, HttpResponse, Http404
from django.template.context import RequestContext
from django.utils.translation import ugettext_lazy as _
from django.utils import simplejson
from django.db.models import Q
from django.conf import settings
from notification import models as notification
from dialer_campaign.models import common_contact_authorization
from dialer_campaign.views import current_view, notice_count, grid_common_function
from dialer_campaign.function_def import user_dialer_setting_msg, variable_value
from dialer_settings.models import DialerSetting
from user_profile.models import UserProfile
from user_profile.forms import UserChangeDetailForm, \
UserChangeDetailExtendForm, \
CheckPhoneNumberForm,\
UserProfileForm
@login_required
def customer_detail_change(request):
"""User Detail change on Customer UI
**Attributes**:
* ``form`` - UserChangeDetailForm, UserChangeDetailExtendForm, PasswordChangeForm, CheckPhoneNumberForm
* ``template`` - 'frontend/registration/user_detail_change.html'
**Logic Description**:
* User is able to change his/her detail.
"""
user_detail = User.objects.get(username=request.user)
try:
user_detail_extened = UserProfile.objects.get(user=user_detail)
except UserProfile.DoesNotExist:
#create UserProfile
user_detail_extened = UserProfile(user=user_detail)
user_detail_extened.save()
user_detail_form = UserChangeDetailForm(request.user,
instance=user_detail)
user_detail_extened_form = UserChangeDetailExtendForm(request.user,
instance=user_detail_extened)
user_password_form = PasswordChangeForm(user=request.user)
check_phone_no_form = CheckPhoneNumberForm()
try:
user_ds = UserProfile.objects.get(user=request.user)
dialer_set = DialerSetting.objects.get(id=user_ds.dialersetting.id)
except:
dialer_set = ''
user_notification = \
notification.Notice.objects.filter(recipient=request.user)
# Search on sender name
q = (Q(sender=request.user))
if q:
user_notification = user_notification.filter(q)
msg_detail = ''
msg_pass = ''
msg_number = ''
msg_note = ''
error_detail = ''
error_pass = ''
error_number = ''
action = ''
if 'action' in request.GET:
action = request.GET['action']
if request.GET.get('msg_note') == 'true':
msg_note = request.session['msg_note']
# Mark all notification as read
if request.GET.get('notification') == 'mark_read_all':
notification_list = notification.Notice.objects.filter(unseen=1, recipient=request.user)
notification_list.update(unseen=0)
msg_note = _('All notifications are marked as read.')
if request.method == 'POST':
if request.POST['form-type'] == "change-detail":
user_detail_form = UserChangeDetailForm(request.user, request.POST,
instance=user_detail)
user_detail_extened_form = UserChangeDetailExtendForm(request.user,
request.POST,
instance=user_detail_extened)
action = 'tabs-1'
if user_detail_form.is_valid() and user_detail_extened_form.is_valid():
user_detail_form.save()
user_detail_extened_form.save()
msg_detail = _('Detail has been changed.')
else:
error_detail = _('Please correct the errors below.')
elif request.POST['form-type'] == "check-number": # check phone no
action = 'tabs-5'
check_phone_no_form = CheckPhoneNumberForm(data=request.POST)
if check_phone_no_form.is_valid():
if not common_contact_authorization(request.user,
request.POST['phone_number']):
error_number = _('This phone number is not authorized.')
else:
msg_number = _('This phone number is authorized.')
else:
error_number = _('Please correct the errors below.')
else: # "change-password"
user_password_form = PasswordChangeForm(user=request.user,
data=request.POST)
action = 'tabs-2'
if user_password_form.is_valid():
user_password_form.save()
msg_pass = _('Your password has been changed.')
else:
error_pass = _('Please correct the errors below.')
template = 'frontend/registration/user_detail_change.html'
data = {
'module': current_view(request),
'user_detail_form': user_detail_form,
'user_detail_extened_form': user_detail_extened_form,
'user_password_form': user_password_form,
'check_phone_no_form': check_phone_no_form,
'user_notification': user_notification,
'msg_detail': msg_detail,
'msg_pass': msg_pass,
'msg_number': msg_number,
'msg_note': msg_note,
'error_detail': error_detail,
'error_pass': error_pass,
'error_number': error_number,
'notice_count': notice_count(request),
'dialer_set': dialer_set,
'dialer_setting_msg': user_dialer_setting_msg(request.user),
'action': action,
}
return render_to_response(template, data,
context_instance=RequestContext(request))
def call_style(val):
"""Notification icon style"""
unseen_style = \
'style="text-decoration:none;background-image:url(%snewfies/icons/new.png);"' \
% settings.STATIC_URL
seen_style = \
'style="text-decoration:none;background-image:url(%snewfies/icons/tick.png);"' \
% settings.STATIC_URL
if val:
return unseen_style
else:
return seen_style
# Notification
@login_required
def notification_grid(request):
"""notification list in json format for flexigrid
**Model**: notification.Notice
"""
grid_data = grid_common_function(request)
page = int(grid_data['page'])
start_page = int(grid_data['start_page'])
end_page = int(grid_data['end_page'])
sortorder_sign = grid_data['sortorder_sign']
sortname = grid_data['sortname']
user_notification = \
notification.Notice.objects.filter(recipient=request.user)
# Search on sender name
q = (Q(sender=request.user))
if q:
user_notification = user_notification.filter(q)
count = user_notification.count()
user_notification_list = \
user_notification.order_by(sortorder_sign + sortname)[start_page:end_page]
rows = [{'id': row.id,
'cell': ['<input type="checkbox" name="select" class="checkbox"\
value="' + str(row.id) + '" />',
str(row.message),
str(row.notice_type),
str(row.sender),
str(row.added),
str('<a href="../update_notice_status_cust/' + str(row.id) + '/" class="icon" ' \
+ call_style(row.unseen) + '> </a>' ),
]}for row in user_notification_list ]
data = {'rows': rows,
'page': page,
'total': count}
return HttpResponse(simplejson.dumps(data), mimetype='application/json',
content_type="application/json")
@login_required
def notification_del_read(request, object_id):
"""Delete notification for the logged in user
**Attributes**:
* ``object_id`` - Selected notification object
* ``object_list`` - Selected notification objects
**Logic Description**:
* Delete/Mark as Read the selected notification from the notification list
"""
try:
# When object_id is not 0
notification_obj = notification.Notice.objects.get(pk=object_id)
# Delete/Read notification
if object_id:
if request.POST.get('mark_read') == 'false':
request.session["msg_note"] = _('"%(name)s" is deleted.') \
% {'name': notification_obj.notice_type}
notification_obj.delete()
else:
request.session["msg_note"] = _('"%(name)s" is marked as read.') \
% {'name': notification_obj.notice_type}
notification_obj.update(unseen=0)
return HttpResponseRedirect('/user_detail_change/?action=tabs-3&msg_note=true')
except:
# When object_id is 0 (Multiple records delete/mark as read)
values = request.POST.getlist('select')
values = ", ".join(["%s" % el for el in values])
notification_list = notification.Notice.objects.extra(where=['id IN (%s)' % values])
if request.POST.get('mark_read') == 'false':
request.session["msg_note"] = _('%(count)s notification(s) are deleted.')\
% {'count': notification_list.count()}
notification_list.delete()
else:
request.session["msg_note"] = _('%(count)s notification(s) are marked as read.')\
% {'count': notification_list.count()}
notification_list.update(unseen=0)
return HttpResponseRedirect('/user_detail_change/?action=tabs-3&msg_note=true')
def common_notification_status(request, id):
"""Notification Status (e.g. seen/unseen) need to be change.
It is a common function for admin and customer UI
**Attributes**:
* ``pk`` - primary key of notice record
**Logic Description**:
* Selected Notification's status need to be changed.
Changed status can be seen or unseen.
"""
notice = notification.Notice.objects.get(pk=id)
if notice.unseen == 1:
notice.unseen = 0
else:
notice.unseen = 1
notice.save()
return True
@login_required
def update_notice_status_cust(request, id):
"""Notification Status (e.g. seen/unseen) can be changed from
customer interface"""
common_notification_status(request, id)
return HttpResponseRedirect('/user_detail_change/?action=tabs-3')
| mpl-2.0 | 5,991,948,951,880,823,000 | 37.352941 | 111 | 0.603934 | false |
jiasir/pycs | vulpo/pyami/scriptbase.py | 1 | 1430 | import os
import sys
from vulpo.utils import ShellCommand, get_ts
import vulpo
import vulpo.utils
class ScriptBase(object):
def __init__(self, config_file=None):
self.instance_id = vulpo.config.get('Instance', 'instance-id', 'default')
self.name = self.__class__.__name__
self.ts = get_ts()
if config_file:
vulpo.config.read(config_file)
def notify(self, subject, body=''):
vulpo.utils.notify(subject, body)
def mkdir(self, path):
if not os.path.isdir(path):
try:
os.mkdir(path)
except:
vulpo.log.error('Error creating directory: %s' % path)
def umount(self, path):
if os.path.ismount(path):
self.run('umount %s' % path)
def run(self, command, notify=True, exit_on_error=False, cwd=None):
self.last_command = ShellCommand(command, cwd=cwd)
if self.last_command.status != 0:
vulpo.log.error('Error running command: "%s". Output: "%s"' % (command, self.last_command.output))
if notify:
self.notify('Error encountered', \
'Error running the following command:\n\t%s\n\nCommand output:\n\t%s' % \
(command, self.last_command.output))
if exit_on_error:
sys.exit(-1)
return self.last_command.status
def main(self):
pass
| mit | -3,219,314,286,743,809,500 | 31.5 | 110 | 0.565734 | false |
platipy/spyral | examples/collisions.py | 1 | 1514 | try:
import _path
except NameError:
pass
import spyral
SIZE = (640, 480)
BG_COLOR = (0, 0, 0)
class Square(spyral.Sprite):
def __init__(self, scene, direction, color=(255, 0,0)):
spyral.Sprite.__init__(self, scene)
self.image = spyral.Image(size=(16, 16)).fill(color)
self.direction = direction
self.anchor = 'center'
spyral.event.register("director.update", self.update)
def update(self):
self.x += self.direction * 4
if not self.collide_rect(self.scene.rect):
self.x -= self.direction * 4
self.flip()
def flip(self):
self.direction *= -1
class Game(spyral.Scene):
def __init__(self):
spyral.Scene.__init__(self, SIZE)
self.background = spyral.Image(size=SIZE).fill(BG_COLOR)
self.left_square = Square(self, 1, (0,255,0))
self.left_square.pos = self.rect.midleft
self.right_square = Square(self, -1)
self.right_square.pos = self.rect.midright
spyral.event.register("system.quit", spyral.director.quit)
spyral.event.register("director.update", self.update)
def update(self):
# Collision test
if self.left_square.collide_sprite(self.right_square):
self.right_square.flip()
self.left_square.flip()
if __name__ == "__main__":
spyral.director.init(SIZE) # the director is the manager for your scenes
spyral.director.run(scene=Game()) # This will run your game. It will not return.
| lgpl-2.1 | -6,099,856,198,345,127,000 | 30.541667 | 84 | 0.612285 | false |
DOAJ/doaj | portality/formcontext/formcontext.py | 1 | 82183 | import json
import uuid
from datetime import datetime
from flask import render_template, url_for, request
from flask_login import current_user
import portality.formcontext.forms
from portality.crosswalks.journal_form import JournalFormXWalk
from portality.crosswalks.article_form import ArticleFormXWalk
from portality.crosswalks.application_form import ApplicationFormXWalk
from portality import constants
from portality import models, app_email, util
from portality.bll import DOAJ
from portality.core import app
from portality.formcontext import forms, render, choices, FormContextException
from portality.lcc import lcc_jstree
from portality.ui.messages import Messages
import portality.notifications.application_emails as emails
from portality.forms.application_forms import JAVASCRIPT_FUNCTIONS
ACC_MSG = 'Please note you <span class="red">cannot edit</span> this application as it has been accepted into the DOAJ.'
SCOPE_MSG = 'Please note you <span class="red">cannot edit</span> this application as you don\'t have the necessary ' \
'account permissions to edit applications which are {0}.'
FIELDS_WITH_DESCRIPTION = ["publisher", "society_institution", "platform", "title", "alternative_title"]
URL_FIELDS = ["url", "processing_charges_url", "submission_charges_url", "articles_last_year_url", "digital_archiving_policy_url", "editorial_board_url", "review_process_url", "instructions_authors_url", "oa_statement_url", "license_url", "waiver_policy_url", "download_statistics_url", "copyright_url", "publishing_rights_url", "plagiarism_screening_url", "license_embedded_url", "aims_scope_url"]
class FormContext(object):
def __init__(self, form_data=None, source=None, formulaic_context=None):
# initialise our core properties
self._source = source
self._target = None
self._form_data = form_data
self._form = None
self._renderer = None
self._template = None
self._alert = []
self._info = ''
self._formulaic = formulaic_context
# initialise the renderer (falling back to a default if necessary)
self.make_renderer()
if self.renderer is None:
self.renderer = render.Renderer()
# specify the jinja template that will wrap the renderer
self.set_template()
# now create our form instance, with the form_data (if there is any)
if form_data is not None:
self.data2form()
# if there isn't any form data, then we should create the form properties from source instead
elif source is not None:
self.source2form()
# if there is no source, then a blank form object
else:
self.blank_form()
############################################################
# getters and setters on the main FormContext properties
############################################################
@property
def form(self):
return self._form
@form.setter
def form(self, val):
self._form = val
@property
def source(self):
return self._source
@property
def form_data(self):
return self._form_data
@property
def target(self):
return self._target
@target.setter
def target(self, val):
self._target = val
@property
def renderer(self):
return self._renderer
@renderer.setter
def renderer(self, val):
self._renderer = val
@property
def template(self):
return self._template
@template.setter
def template(self, val):
self._template = val
@property
def alert(self):
return self._alert
def add_alert(self, val):
self._alert.append(val)
@property
def info(self):
return self._info
@info.setter
def info(self, val):
self._info = val
############################################################
# Lifecycle functions that subclasses should implement
############################################################
def make_renderer(self):
"""
This will be called during init, and must populate the self.render property
"""
pass
def set_template(self):
"""
This will be called during init, and must populate the self.template property with the path to the jinja template
"""
pass
def pre_validate(self):
"""
This will be run before validation against the form is run.
Use it to patch the form with any relevant data, such as fields which were disabled
"""
pass
def blank_form(self):
"""
This will be called during init, and must populate the self.form_data property with an instance of the form in this
context, based on no originating source or form data
"""
pass
def data2form(self):
"""
This will be called during init, and must convert the form_data into an instance of the form in this context,
and write to self.form
"""
pass
def source2form(self):
"""
This will be called during init, and must convert the source object into an instance of the form in this
context, and write to self.form
"""
pass
def form2target(self):
"""
Convert the form object into a the target system object, and write to self.target
"""
pass
def patch_target(self):
"""
Patch the target with data from the source. This will be run by the finalise method (unless you override it)
"""
pass
def finalise(self, *args, **kwargs):
"""
Finish up with the FormContext. Carry out any final workflow tasks, etc.
"""
self.form2target()
self.patch_target()
############################################################
# Functions which can be called directly, but may be overridden if desired
############################################################
def validate(self):
self.pre_validate()
f = self.form
valid = False
if f is not None:
valid = f.validate()
# if this isn't a valid form, record the fields that have errors
# with the renderer for use later
if not valid:
error_fields = []
for field in self.form:
if field.errors:
error_fields.append(field.short_name)
return valid
@property
def errors(self):
f = self.form
if f is not None:
return f.errors
return False
def render_template(self, **kwargs):
return render_template(self.template, form_context=self, **kwargs)
#def render_field_group(self, field_group_name=None, **kwargs):
# return self.renderer.render_field_group(self, field_group_name, **kwargs)
def fieldset(self, fieldset_name=None):
return self._formulaic.fieldset(fieldset_name)
def fieldsets(self):
return self._formulaic.fieldsets()
def check_field_group_exists(self, field_group_name):
return self.renderer.check_field_group_exists(field_group_name)
@property
def ui_settings(self):
return self._formulaic.ui_settings
class PrivateContext(FormContext):
def _expand_descriptions(self, fields):
# add the contents of a few fields to their descriptions since select2 autocomplete
# would otherwise obscure the full values
for field in fields:
if field in self.form.data:
if self.form[field].data:
if not self.form[field].description:
self.form[field].description = '<small>Full contents: ' + self.form[field].data + '</small>'
else:
self.form[field].description += '<br><br><small>Full contents: ' + self.form[field].data + '</small>'
def _expand_url_descriptions(self, fields):
# add the contents of a few fields to their descriptions since select2 autocomplete
# would otherwise obscure the full values
for field in fields:
if field in self.form.data:
if self.form[field].data:
if not self.form[field].description:
self.form[field].description = '<small>Full contents: <a href=' + self.form[field].data + " target='_blank'>" + self.form[field].data + "</a><small>"
else:
self.form[field].description += '<br><br><small>Full contents: <a href=' + self.form[field].data + " target='_blank'>" + self.form[field].data + "</a><small>"
def _carry_fixed_aspects(self):
if self.source is None:
raise FormContextException("Cannot carry data from a non-existent source")
now = datetime.now().strftime("%Y-%m-%dT%H:%M:%SZ")
# copy over any important fields from the previous version of the object
created_date = self.source.created_date if self.source.created_date else now
self.target.set_created(created_date)
if "id" in self.source.data:
self.target.data['id'] = self.source.data['id']
try:
if self.source.current_application:
self.target.set_current_application(self.source.current_application)
except AttributeError:
# this means that the source doesn't know about current_applications, which is fine
pass
try:
if self.source.current_journal:
self.target.set_current_journal(self.source.current_journal)
except AttributeError:
# this means that the source doesn't know about current_journals, which is fine
pass
try:
if self.source.related_journal:
self.target.set_related_journal(self.source.related_journal)
except AttributeError:
# this means that the source doesn't know about related_journals, which is fine
pass
try:
if self.source.related_applications:
related = self.source.related_applications
for rel in related:
self.target.add_related_application(rel.get("application_id"), rel.get("date_accepted"))
except AttributeError:
# this means that the source doesn't know about related_applications, which is fine
pass
# if the source is a journal, we need to carry the in_doaj flag
if isinstance(self.source, models.Journal):
self.target.set_in_doaj(self.source.is_in_doaj())
@staticmethod
def _subjects2str(subjects):
subject_strings = []
for sub in subjects:
subject_strings.append('{term}'.format(term=sub.get('term')))
return ', '.join(subject_strings)
def _merge_notes_forward(self, allow_delete=False):
if self.source is None:
raise FormContextException("Cannot carry data from a non-existent source")
if self.target is None:
raise FormContextException("Cannot carry data on to a non-existent target - run the xwalk first")
# first off, get the notes (by reference) in the target and the notes from the source
tnotes = self.target.notes
snotes = self.source.notes
# if there are no notes, we might not have the notes by reference, so later will
# need to set them by value
apply_notes_by_value = len(tnotes) == 0
# for each of the target notes we need to get the original dates from the source notes
for n in tnotes:
for sn in snotes:
if n.get("note") == sn.get("note"):
n["date"] = sn.get("date")
# record the positions of any blank notes
i = 0
removes = []
for n in tnotes:
if n.get("note").strip() == "":
removes.append(i)
i += 1
# actually remove all the notes marked for deletion
removes.sort(reverse=True)
for r in removes:
tnotes.pop(r)
# finally, carry forward any notes that aren't already in the target
if not allow_delete:
for sn in snotes:
found = False
for tn in tnotes:
if sn.get("note") == tn.get("note"):
found = True
if not found:
tnotes.append(sn)
if apply_notes_by_value:
self.target.set_notes(tnotes)
def _populate_editor_field(self, editor_group_name):
"""Set the editor field choices from a given editor group name"""
if editor_group_name is None:
self.form.editor.choices = [("", "")]
else:
eg = models.EditorGroup.pull_by_key("name", editor_group_name)
if eg is not None:
editors = [eg.editor]
editors += eg.associates
editors = list(set(editors))
self.form.editor.choices = [("", "Choose an editor")] + [(editor, editor) for editor in editors]
else:
self.form.editor.choices = [("", "")]
def _validate_editor_field(self):
""" Validate the choice of editor, which could be out of sync with the group in exceptional circumstances """
editor = self.form.editor.data
if editor is not None and editor != "":
editor_group_name = self.form.editor_group.data
if editor_group_name is not None and editor_group_name != "":
eg = models.EditorGroup.pull_by_key("name", editor_group_name)
if eg is not None:
all_eds = eg.associates + [eg.editor]
if editor in all_eds:
return # success - an editor group was found and our editor was in it
raise FormContextException("Editor '{0}' not found in editor group '{1}'".format(editor, editor_group_name))
else:
raise FormContextException("An editor has been assigned without an editor group")
def _carry_continuations(self):
if self.source is None:
raise FormContextException("Cannot carry data from a non-existent source")
try:
sbj = self.source.bibjson()
tbj = self.target.bibjson()
if sbj.replaces:
tbj.replaces = sbj.replaces
if sbj.is_replaced_by:
tbj.is_replaced_by = sbj.is_replaced_by
if sbj.discontinued_date:
tbj.discontinued_date = sbj.discontinued_date
except AttributeError:
# this means that the source doesn't know about current_applications, which is fine
pass
class ApplicationContext(PrivateContext):
ERROR_MSG_TEMPLATE = \
"""Problem while creating account while turning suggestion into journal.
There should be a {missing_thing} on user {username} but there isn't.
Created the user but not sending the email.
""".replace("\n", ' ')
def _carry_fixed_aspects(self):
super(ApplicationContext, self)._carry_fixed_aspects()
if self.source.suggested_on is not None:
self.target.suggested_on = self.source.suggested_on
def _create_account_on_suggestion_approval(self, suggestion, journal):
o = models.Account.pull(suggestion.owner)
if o:
self.add_alert('Account {username} already exists, so simply associating the journal with it.'.format(username=o.id))
o.add_journal(journal.id)
if not o.has_role('publisher'):
o.add_role('publisher')
o.save()
return o
suggestion_contact = util.listpop(suggestion.contacts())
if not suggestion_contact.get('email'):
msg = self.ERROR_MSG_TEMPLATE.format(username=o.id, missing_thing='journal contact email in the application')
app.logger.error(msg)
self.add_alert(msg)
return o
send_info_to = suggestion_contact.get('email')
o = models.Account.make_account(
suggestion.owner,
name=suggestion_contact.get('name'),
email=send_info_to,
roles=['publisher'],
associated_journal_ids=[journal.id]
)
o.save()
if not o.reset_token:
msg = self.ERROR_MSG_TEMPLATE.format(username=o.id, missing_thing='reset token')
app.logger.error(msg)
self.add_alert(msg)
return o
url_root = request.url_root
if url_root.endswith("/"):
url_root = url_root[:-1]
reset_url = url_root + url_for('account.reset', reset_token=o.reset_token)
forgot_pw_url = url_root + url_for('account.forgot')
password_create_timeout_seconds = int(app.config.get("PASSWORD_CREATE_TIMEOUT", app.config.get('PASSWORD_RESET_TIMEOUT', 86400) * 14))
password_create_timeout_days = password_create_timeout_seconds / (60*60*24)
to = [send_info_to]
fro = app.config.get('SYSTEM_EMAIL_FROM', '[email protected]')
subject = app.config.get("SERVICE_NAME","") + " - account created"
try:
if app.config.get("ENABLE_PUBLISHER_EMAIL", False):
app_email.send_mail(to=to,
fro=fro,
subject=subject,
template_name="email/account_created.txt",
reset_url=reset_url,
username=o.id,
timeout_days=password_create_timeout_days,
forgot_pw_url=forgot_pw_url
)
self.add_alert('Sent email to ' + send_info_to + ' to tell them about the new account.')
else:
self.add_alert('Did not email to ' + send_info_to + ' to tell them about the new account, as publisher emailing is disabled.')
if app.config.get('DEBUG', False):
self.add_alert('Debug mode - url for create is <a href="{url}">{url}</a>'.format(url=reset_url))
except app_email.EmailException:
magic = str(uuid.uuid1())
self.add_alert('Hm, sending the account creation email didn\'t work. Please quote this magic number when reporting the issue: ' + magic + ' . Thank you!')
if app.config.get('DEBUG', False):
self.add_alert('Debug mode - url for create is <a href="{url}">{url}</a>'.format(url=reset_url))
app.logger.exception('Error sending account creation email - ' + magic)
self.add_alert('Account {username} created'.format(username=o.id))
return o
def _send_application_approved_email(self, journal_title, publisher_name, email, journal_contact, update_request=False):
"""Email the publisher when an application is accepted (it's here because it's too troublesome to factor out)"""
url_root = request.url_root
if url_root.endswith("/"):
url_root = url_root[:-1]
to = [email]
fro = app.config.get('SYSTEM_EMAIL_FROM', '[email protected]')
subject = app.config.get("SERVICE_NAME", "") + " - journal accepted"
publisher_name = publisher_name if publisher_name is not None else "Journal Owner"
try:
if app.config.get("ENABLE_PUBLISHER_EMAIL", False):
msg = Messages.SENT_ACCEPTED_APPLICATION_EMAIL.format(email=email)
template = "email/publisher_application_accepted.txt"
if update_request:
msg = Messages.SENT_ACCEPTED_UPDATE_REQUEST_EMAIL.format(email=email)
template = "email/publisher_update_request_accepted.txt"
jn = journal_title #.encode('utf-8', 'replace')
app_email.send_mail(to=to,
fro=fro,
subject=subject,
template_name=template,
journal_title=jn,
publisher_name=publisher_name,
journal_contact=journal_contact,
url_root=url_root
)
self.add_alert(msg)
else:
msg = Messages.NOT_SENT_ACCEPTED_APPLICATION_EMAIL.format(email=email)
if update_request:
msg = Messages.NOT_SENT_ACCEPTED_UPDATE_REQUEST_EMAIL.format(email=email)
self.add_alert(msg)
except Exception as e:
magic = str(uuid.uuid1())
self.add_alert('Hm, sending the journal acceptance information email didn\'t work. Please quote this magic number when reporting the issue: ' + magic + ' . Thank you!')
app.logger.exception('Error sending application approved email failed - ' + magic)
def _send_contact_approved_email(self, journal_title, journal_contact, email, publisher_name, update_request=False):
"""Email the journal contact when an application is accepted """
url_root = request.url_root
if url_root.endswith("/"):
url_root = url_root[:-1]
to = [email]
fro = app.config.get('SYSTEM_EMAIL_FROM', '[email protected]')
subject = app.config.get("SERVICE_NAME", "") + " - journal accepted"
try:
if app.config.get("ENABLE_PUBLISHER_EMAIL", False):
template = "email/contact_application_accepted.txt"
alert = Messages.SENT_JOURNAL_CONTACT_ACCEPTED_APPLICATION_EMAIL.format(email=to[0])
if update_request: # NOTE: right now, the way this is called, update request is always False. Should deprecate and remove this code.
template = "email/contact_update_request_accepted.txt"
alert = Messages.SENT_JOURNAL_CONTACT_ACCEPTED_UPDATE_REQUEST_EMAIL.format(email=to[0])
jn = journal_title #.encode('utf-8', 'replace')
app_email.send_mail(to=to,
fro=fro,
subject=subject,
template_name=template,
journal_title=jn,
journal_contact=journal_contact,
publisher=publisher_name,
url_root=url_root
)
self.add_alert(alert)
else:
alert = Messages.NOT_SENT_JOURNAL_CONTACT_ACCEPTED_APPLICATION_EMAIL.format(email=to[0])
self.add_alert(alert)
except Exception as e:
magic = str(uuid.uuid1())
self.add_alert('Hm, sending the journal contact acceptance information email didn\'t work. Please quote this magic number when reporting the issue: ' + magic + ' . Thank you!')
app.logger.exception('Error sending accepted email to journal contact - ' + magic)
def render_template(self, **kwargs):
diff = None
cj = None
if self.source is not None:
current_journal = self.source.current_journal
if current_journal is not None:
cj = models.Journal.pull(current_journal)
if cj is not None:
jform = JournalFormXWalk.obj2form(cj)
if "notes" in jform:
del jform["notes"]
aform = ApplicationFormXWalk.obj2form(self.source)
if "notes" in aform:
del aform["notes"]
diff = self._form_diff(jform, aform)
return super(ApplicationContext, self).render_template(
form_diff=diff,
current_journal=cj,
js_functions=JAVASCRIPT_FUNCTIONS,
**kwargs)
def _form_diff(self, journal_form, application_form):
diff = []
for k, v in application_form.items():
try:
q = self.form[k].label
except KeyError:
continue
q_num = self.renderer.question_number(k)
if q_num is None or q_num == "":
q_num = 0
else:
q_num = int(q_num)
if k in journal_form and journal_form[k] != v:
diff.append((k, q_num, q.text, journal_form[k], v))
elif k not in journal_form and q_num != 0:
diff.append((k, q_num, q.text, Messages.DIFF_TABLE_NOT_PRESENT, v))
diff = sorted(diff, key=lambda x: x[1])
return diff
class ApplicationFormFactory(object):
@classmethod
def get_form_context(cls, role=None, source=None, form_data=None):
if role is None:
# return PublicApplication(source=source, form_data=form_data)
return None
elif role == "admin":
return ManEdApplicationReview(source=source, form_data=form_data)
elif role == "editor":
return EditorApplicationReview(source=source, form_data=form_data)
elif role == "associate_editor":
return AssEdApplicationReview(source=source, form_data=form_data)
elif role == "publisher":
return PublisherUpdateRequest(source=source, form_data=form_data)
elif role == "update_request_readonly":
return PublisherUpdateRequestReadOnly(source=source, form_data=form_data)
class JournalFormFactory(object):
@classmethod
def get_form_context(cls, role, source=None, form_data=None):
if role == "admin":
return ManEdJournalReview(source=source, form_data=form_data)
elif role == "editor":
return EditorJournalReview(source=source, form_data=form_data)
elif role == "associate_editor":
return AssEdJournalReview(source=source, form_data=form_data)
elif role == "readonly":
return ReadOnlyJournal(source=source, form_data=form_data)
elif role == "bulk_edit":
return ManEdBulkEdit(source=source, form_data=form_data)
class ManEdApplicationReview(ApplicationContext):
"""
Managing Editor's Application Review form. Should be used in a context where the form warrants full
admin priviledges. It will permit conversion of applications to journals, and assignment of owner account
as well as assignment to editorial group.
"""
def make_renderer(self):
self.renderer = render.ManEdApplicationReviewRenderer()
def set_template(self):
self.template = "formcontext/maned_application_review.html"
def blank_form(self):
self.form = forms.ManEdApplicationReviewForm()
self._set_choices()
def data2form(self):
self.form = forms.ManEdApplicationReviewForm(formdata=self.form_data)
self._set_choices()
self._expand_descriptions(FIELDS_WITH_DESCRIPTION)
self._expand_url_descriptions(URL_FIELDS)
def source2form(self):
self.form = forms.ManEdApplicationReviewForm(data=ApplicationFormXWalk.obj2form(self.source))
self._set_choices()
self._expand_descriptions(FIELDS_WITH_DESCRIPTION)
self._expand_url_descriptions(URL_FIELDS)
if self.source.application_status == constants.APPLICATION_STATUS_ACCEPTED:
self.info = ACC_MSG
def pre_validate(self):
# Editor field is populated in JS after page load - check the selected editor is actually in that editor group
self._validate_editor_field()
def form2target(self):
self.target = ApplicationFormXWalk.form2obj(self.form)
def patch_target(self):
if self.source is None:
raise FormContextException("You cannot patch a target from a non-existent source")
self._carry_fixed_aspects()
self._merge_notes_forward(allow_delete=True)
# NOTE: this means you can't unset an owner once it has been set. But you can change it.
if (self.target.owner is None or self.target.owner == "") and (self.source.owner is not None):
self.target.set_owner(self.source.owner)
def finalise(self):
# FIXME: this first one, we ought to deal with outside the form context, but for the time being this
# can be carried over from the old implementation
if self.source is None:
raise FormContextException("You cannot edit a not-existent application")
if self.source.application_status == constants.APPLICATION_STATUS_ACCEPTED:
raise FormContextException("You cannot edit applications which have been accepted into DOAJ.")
# if we are allowed to finalise, kick this up to the superclass
super(ManEdApplicationReview, self).finalise()
# FIXME: may want to factor this out of the suggestionformxwalk
# If we have changed the editors assinged to this application, let them know.
is_editor_group_changed = ApplicationFormXWalk.is_new_editor_group(self.form, self.source)
is_associate_editor_changed = ApplicationFormXWalk.is_new_editor(self.form, self.source)
# record the event in the provenance tracker
models.Provenance.make(current_user, "edit", self.target)
# delayed import of the DOAJ BLL
from portality.bll.doaj import DOAJ
applicationService = DOAJ.applicationService()
# if this application is being accepted, then do the conversion to a journal
if self.target.application_status == constants.APPLICATION_STATUS_ACCEPTED:
# remember whether this was an update request or not
is_update_request = self.target.current_journal is not None
j = applicationService.accept_application(self.target, current_user._get_current_object())
# record the url the journal is available at in the admin are and alert the user
jurl = url_for("doaj.toc", identifier=j.toc_id)
if self.source.current_journal is not None:
self.add_alert('<a href="{url}" target="_blank">Existing journal updated</a>.'.format(url=jurl))
else:
self.add_alert('<a href="{url}" target="_blank">New journal created</a>.'.format(url=jurl))
# create the user account for the owner and send the notification email
try:
owner = self._create_account_on_suggestion_approval(self.target, j)
names = []
for contact in j.contacts():
names.append(contact.get("name"))
journal_contacts = ", ".join(names)
# for all acceptances, send an email to the owner of the journal
self._send_application_approved_email(j.bibjson().title, owner.name, owner.email, journal_contacts, self.source.current_journal is not None)
# in the case of a new application, also send emails to the journal contacts
if not is_update_request:
for contact in j.contacts():
self._send_contact_approved_email(j.bibjson().title, contact.get("name"), contact.get("email"), owner.name, self.source.current_journal is not None)
except app_email.EmailException:
self.add_alert("Problem sending email to suggester - probably address is invalid")
app.logger.exception("Acceptance email to owner failed.")
# if the application was instead rejected, carry out the rejection actions
elif self.source.application_status != constants.APPLICATION_STATUS_REJECTED and self.target.application_status == constants.APPLICATION_STATUS_REJECTED:
# remember whether this was an update request or not
is_update_request = self.target.current_journal is not None
# reject the application
applicationService.reject_application(self.target, current_user._get_current_object())
# if this was an update request, send an email to the owner
if is_update_request:
sent = False
send_report = []
try:
send_report = emails.send_publisher_reject_email(self.target, update_request=is_update_request, send_to_owner=True, send_to_suggester=False)
sent = True
except app_email.EmailException as e:
pass
if sent:
self.add_alert(Messages.SENT_REJECTED_UPDATE_REQUEST_EMAIL.format(user=self.target.owner, email=send_report[0].get("email"), name=send_report[0].get("name")))
else:
self.add_alert(Messages.NOT_SENT_REJECTED_UPDATE_REQUEST_EMAIL.format(user=self.target.owner))
# the application was neither accepted or rejected, so just save it
else:
self.target.set_last_manual_update()
self.target.save()
# if revisions were requested, email the publisher
if self.source.application_status != constants.APPLICATION_STATUS_REVISIONS_REQUIRED and self.target.application_status == constants.APPLICATION_STATUS_REVISIONS_REQUIRED:
try:
emails.send_publisher_update_request_revisions_required(self.target)
self.add_alert(Messages.SENT_REJECTED_UPDATE_REQUEST_REVISIONS_REQUIRED_EMAIL.format(user=self.target.owner))
except app_email.EmailException as e:
self.add_alert(Messages.NOT_SENT_REJECTED_UPDATE_REQUEST_REVISIONS_REQUIRED_EMAIL.format(user=self.target.owner))
# if we need to email the editor and/or the associate, handle those here
if is_editor_group_changed:
try:
emails.send_editor_group_email(self.target)
except app_email.EmailException:
self.add_alert("Problem sending email to editor - probably address is invalid")
app.logger.exception("Email to associate failed.")
if is_associate_editor_changed:
try:
emails.send_assoc_editor_email(self.target)
except app_email.EmailException:
self.add_alert("Problem sending email to associate editor - probably address is invalid")
app.logger.exception("Email to associate failed.")
# If this is the first time this application has been assigned to an editor, notify the publisher.
old_ed = self.source.editor
if (old_ed is None or old_ed == '') and self.target.editor is not None:
is_update_request = self.target.current_journal is not None
if is_update_request:
alerts = emails.send_publisher_update_request_editor_assigned_email(self.target)
else:
alerts = emails.send_publisher_application_editor_assigned_email(self.target)
for alert in alerts:
self.add_alert(alert)
# Inform editor and associate editor if this application was 'ready' or 'completed', but has been changed to 'in progress'
if (self.source.application_status == constants.APPLICATION_STATUS_READY or self.source.application_status == constants.APPLICATION_STATUS_COMPLETED) and self.target.application_status == constants.APPLICATION_STATUS_IN_PROGRESS:
# First, the editor
try:
emails.send_editor_inprogress_email(self.target)
self.add_alert('An email has been sent to notify the editor of the change in status.')
except AttributeError:
magic = str(uuid.uuid1())
self.add_alert('Couldn\'t find a recipient for this email - check editor groups are correct. Please quote this magic number when reporting the issue: ' + magic + ' . Thank you!')
app.logger.exception('No editor recipient for failed review email - ' + magic)
except app_email.EmailException:
magic = str(uuid.uuid1())
self.add_alert('Sending the failed review email to editor didn\'t work. Please quote this magic number when reporting the issue: ' + magic + ' . Thank you!')
app.logger.exception('Error sending review failed email to editor - ' + magic)
# Then the associate
try:
emails.send_assoc_editor_inprogress_email(self.target)
self.add_alert('An email has been sent to notify the assigned associate editor of the change in status.')
except AttributeError:
magic = str(uuid.uuid1())
self.add_alert('Couldn\'t find a recipient for this email - check an associate editor is assigned. Please quote this magic number when reporting the issue: ' + magic + ' . Thank you!')
app.logger.exception('No associate editor recipient for failed review email - ' + magic)
except app_email.EmailException:
magic = str(uuid.uuid1())
self.add_alert('Sending the failed review email to associate editor didn\'t work. Please quote this magic number when reporting the issue: ' + magic + ' . Thank you!')
app.logger.exception('Error sending review failed email to associate editor - ' + magic)
# email other managing editors if this was newly set to 'ready'
if self.source.application_status != constants.APPLICATION_STATUS_READY and self.target.application_status == constants.APPLICATION_STATUS_READY:
# this template requires who made the change, say it was an Admin
ed_id = 'an administrator'
try:
emails.send_admin_ready_email(self.target, editor_id=ed_id)
self.add_alert('A confirmation email has been sent to the Managing Editors.')
except app_email.EmailException:
magic = str(uuid.uuid1())
self.add_alert('Hm, sending the ready status to managing editors didn\'t work. Please quote this magic number when reporting the issue: ' + magic + ' . Thank you!')
app.logger.exception('Error sending ready status email to managing editors - ' + magic)
def render_template(self, **kwargs):
if self.source is None:
raise FormContextException("You cannot edit a not-existent application")
return super(ManEdApplicationReview, self).render_template(
lcc_jstree=json.dumps(lcc_jstree),
subjectstr=self._subjects2str(self.source.bibjson().subjects()),
**kwargs)
def _set_choices(self):
self.form.application_status.choices = choices.Choices.choices_for_status('admin', self.source.application_status)
# The first time the form is rendered, it needs to populate the editor drop-down from saved group
egn = self.form.editor_group.data
self._populate_editor_field(egn)
class EditorApplicationReview(ApplicationContext):
"""
Editors Application Review form. This should be used in a context where an editor who owns an editorial group
is accessing an application. This prevents re-assignment of Editorial group, but permits assignment of associate
editor. It also permits change in application state, except to "accepted"; therefore this form context cannot
be used to create journals from applications. Deleting notes is not allowed, but adding is.
"""
def make_renderer(self):
self.renderer = render.EditorApplicationReviewRenderer()
self.renderer.set_disabled_fields(["editor_group"])
def set_template(self):
self.template = "formcontext/editor_application_review.html"
def blank_form(self):
self.form = forms.EditorApplicationReviewForm()
self._set_choices()
def data2form(self):
self.form = forms.EditorApplicationReviewForm(formdata=self.form_data)
self._set_choices()
self._expand_descriptions(FIELDS_WITH_DESCRIPTION)
self._expand_url_descriptions(URL_FIELDS)
def source2form(self):
self.form = forms.EditorApplicationReviewForm(data=ApplicationFormXWalk.obj2form(self.source))
self._set_choices()
self._expand_descriptions(FIELDS_WITH_DESCRIPTION)
self._expand_url_descriptions(URL_FIELDS)
editor_choices = list(sum(choices.Choices.application_status('editor'), ())) # flattens the list of tuples
if self.source.application_status not in editor_choices:
self.info = SCOPE_MSG.format(self.source.application_status)
if self.source.application_status == constants.APPLICATION_STATUS_ACCEPTED:
self.info = ACC_MSG # This is after so we can supersede the last message
def pre_validate(self):
self.form.editor_group.data = self.source.editor_group
if "application_status" in self.renderer.disabled_fields:
self.form.application_status.data = constants.APPLICATION_STATUS_ACCEPTED
def form2target(self):
self.target = ApplicationFormXWalk.form2obj(self.form)
def patch_target(self):
if self.source is None:
raise FormContextException("You cannot patch a target from a non-existent source")
self._carry_fixed_aspects()
self._merge_notes_forward()
self.target.set_owner(self.source.owner)
self.target.set_editor_group(self.source.editor_group)
self._carry_continuations()
def finalise(self):
# FIXME: this first one, we ought to deal with outside the form context, but for the time being this
# can be carried over from the old implementation
if self.source is None:
raise FormContextException("You cannot edit a not-existent application")
if self.source.application_status == constants.APPLICATION_STATUS_ACCEPTED:
raise FormContextException("You cannot edit applications which have been accepted into DOAJ.")
# if we are allowed to finalise, kick this up to the superclass
super(EditorApplicationReview, self).finalise()
# Check the status change is valid
choices.Choices.validate_status_change('editor', self.source.application_status, self.target.application_status)
# FIXME: may want to factor this out of the suggestionformxwalk
new_associate_assigned = ApplicationFormXWalk.is_new_editor(self.form, self.source)
# Save the target
self.target.set_last_manual_update()
self.target.save()
# record the event in the provenance tracker
models.Provenance.make(current_user, "edit", self.target)
# if we need to email the associate because they have just been assigned, handle that here.
if new_associate_assigned:
try:
emails.send_assoc_editor_email(self.target)
except app_email.EmailException:
self.add_alert("Problem sending email to associate editor - probably address is invalid")
app.logger.exception('Error sending associate assigned email')
# If this is the first time this application has been assigned to an editor, notify the publisher.
old_ed = self.source.editor
if (old_ed is None or old_ed == '') and self.target.editor is not None:
is_update_request = self.target.current_journal is not None
if is_update_request:
alerts = emails.send_publisher_update_request_editor_assigned_email(self.target)
else:
alerts = emails.send_publisher_application_editor_assigned_email(self.target)
for alert in alerts:
self.add_alert(alert)
# Email the assigned associate if the application was reverted from 'completed' to 'in progress' (failed review)
if self.source.application_status == constants.APPLICATION_STATUS_COMPLETED and self.target.application_status == constants.APPLICATION_STATUS_IN_PROGRESS:
try:
emails.send_assoc_editor_inprogress_email(self.target)
self.add_alert('An email has been sent to notify the assigned associate editor of the change in status.')
except AttributeError as e:
magic = str(uuid.uuid1())
self.add_alert('Couldn\'t find a recipient for this email - check an associate editor is assigned. Please quote this magic number when reporting the issue: ' + magic + ' . Thank you!')
app.logger.exception('No associate editor recipient for failed review email - ' + magic)
except app_email.EmailException:
magic = str(uuid.uuid1())
self.add_alert('Sending the failed review email to associate editor didn\'t work. Please quote this magic number when reporting the issue: ' + magic + ' . Thank you!')
app.logger.exception('Error sending failed review email to associate editor - ' + magic)
# email managing editors if the application was newly set to 'ready'
if self.source.application_status != constants.APPLICATION_STATUS_READY and self.target.application_status == constants.APPLICATION_STATUS_READY:
# Tell the ManEds who has made the status change - the editor in charge of the group
editor_group_name = self.target.editor_group
editor_group_id = models.EditorGroup.group_exists_by_name(name=editor_group_name)
editor_group = models.EditorGroup.pull(editor_group_id)
editor_acc = editor_group.get_editor_account()
# record the event in the provenance tracker
models.Provenance.make(current_user, "status:ready", self.target)
editor_id = editor_acc.id
try:
emails.send_admin_ready_email(self.target, editor_id=editor_id)
self.add_alert('A confirmation email has been sent to the Managing Editors.')
except app_email.EmailException:
magic = str(uuid.uuid1())
self.add_alert('Hm, sending the ready status to managing editors didn\'t work. Please quote this magic number when reporting the issue: ' + magic + ' . Thank you!')
app.logger.exception('Error sending ready status email to managing editors - ' + magic)
def render_template(self, **kwargs):
if self.source is None:
raise FormContextException("You cannot edit a not-existent application")
return super(EditorApplicationReview, self).render_template(
lcc_jstree=json.dumps(lcc_jstree),
subjectstr=self._subjects2str(self.source.bibjson().subjects()),
**kwargs)
def _set_choices(self):
if self.source is None:
raise FormContextException("You cannot set choices for a non-existent source")
if self.form.application_status.data == constants.APPLICATION_STATUS_ACCEPTED:
self.form.application_status.choices = choices.Choices.application_status("accepted")
self.renderer.set_disabled_fields(self.renderer.disabled_fields + ["application_status"])
else:
try:
# Assign the choices to the form
self.form.application_status.choices = choices.Choices.choices_for_status('editor', self.source.application_status)
except ValueError:
# If the current status isn't in the editor's status list, it must be out of bounds. Show it greyed out.
self.form.application_status.choices = choices.Choices.application_status("admin")
self.renderer.set_disabled_fields(self.renderer.disabled_fields + ["application_status"])
# get the editor group from the source because it isn't in the form
egn = self.source.editor_group
self._populate_editor_field(egn)
class AssEdApplicationReview(ApplicationContext):
"""
Associate Editors Application Review form. This is to be used in a context where an associate editor (fewest rights)
needs to access an application for review. This editor cannot change the editorial group or the assigned editor.
They also cannot change the owner of the application. They cannot set an application to "Accepted" so this form can't
be used to create a journal from an application. They cannot delete, only add notes.
"""
def make_renderer(self):
self.renderer = render.AssEdApplicationReviewRenderer()
def set_template(self):
self.template = "formcontext/assed_application_review.html"
def blank_form(self):
self.form = forms.AssEdApplicationReviewForm()
self._set_choices()
def data2form(self):
self.form = forms.AssEdApplicationReviewForm(formdata=self.form_data)
self._set_choices()
self._expand_descriptions(FIELDS_WITH_DESCRIPTION)
self._expand_url_descriptions(URL_FIELDS)
def source2form(self):
self.form = forms.AssEdApplicationReviewForm(data=ApplicationFormXWalk.obj2form(self.source))
self._set_choices()
self._expand_descriptions(FIELDS_WITH_DESCRIPTION)
self._expand_url_descriptions(URL_FIELDS)
associate_editor_choices = list(sum(choices.Choices.application_status(), ())) # flattens the list of tuples
if self.source.application_status not in associate_editor_choices:
self.info = SCOPE_MSG.format(self.source.application_status)
if self.source.application_status == constants.APPLICATION_STATUS_ACCEPTED:
self.info = ACC_MSG # This is after so we can supersede the last message
def pre_validate(self):
if "application_status" in self.renderer.disabled_fields:
self.form.application_status.data = constants.APPLICATION_STATUS_ACCEPTED
def form2target(self):
self.target = ApplicationFormXWalk.form2obj(self.form)
def patch_target(self):
if self.source is None:
raise FormContextException("You cannot patch a target from a non-existent source")
self._carry_fixed_aspects()
self._merge_notes_forward()
self.target.set_owner(self.source.owner)
self.target.set_editor_group(self.source.editor_group)
self.target.set_editor(self.source.editor)
self.target.set_seal(self.source.has_seal())
self._carry_continuations()
def finalise(self):
# FIXME: this first one, we ought to deal with outside the form context, but for the time being this
# can be carried over from the old implementation
if self.source is None:
raise FormContextException("You cannot edit a not-existent application")
if self.source.application_status == constants.APPLICATION_STATUS_ACCEPTED:
raise FormContextException("You cannot edit applications which have been accepted into DOAJ.")
# if we are allowed to finalise, kick this up to the superclass
super(AssEdApplicationReview, self).finalise()
# Check the status change is valid
choices.Choices.validate_status_change('associate', self.source.application_status, self.target.application_status)
# Save the target
self.target.set_last_manual_update()
self.target.save()
# record the event in the provenance tracker
models.Provenance.make(current_user, "edit", self.target)
# inform publisher if this was set to 'in progress' from 'pending'
if self.source.application_status == constants.APPLICATION_STATUS_PENDING and self.target.application_status == constants.APPLICATION_STATUS_IN_PROGRESS:
if app.config.get("ENABLE_PUBLISHER_EMAIL", False):
is_update_request = self.target.current_journal is not None
if is_update_request:
alerts = emails.send_publisher_update_request_inprogress_email(self.target)
else:
alerts = emails.send_publisher_application_inprogress_email(self.target)
for alert in alerts:
self.add_alert(alert)
else:
self.add_alert(Messages.IN_PROGRESS_NOT_SENT_EMAIL_DISABLED)
# inform editor if this was newly set to 'completed'
if self.source.application_status != constants.APPLICATION_STATUS_COMPLETED and self.target.application_status == constants.APPLICATION_STATUS_COMPLETED:
# record the event in the provenance tracker
models.Provenance.make(current_user, "status:completed", self.target)
try:
emails.send_editor_completed_email(self.target)
self.add_alert('A confirmation email has been sent to notify the editor of the change in status.')
except app_email.EmailException:
magic = str(uuid.uuid1())
self.add_alert('Hm, sending the ready status to editor email didn\'t work. Please quote this magic number when reporting the issue: ' + magic + ' . Thank you!')
app.logger.exception('Error sending completed status email to editor - ' + magic)
def render_template(self, **kwargs):
if self.source is None:
raise FormContextException("You cannot edit a not-existent application")
return super(AssEdApplicationReview, self).render_template(
lcc_jstree=json.dumps(lcc_jstree),
subjectstr=self._subjects2str(self.source.bibjson().subjects()),
**kwargs)
def _set_choices(self):
if self.form.application_status.data == constants.APPLICATION_STATUS_ACCEPTED:
self.form.application_status.choices = choices.Choices.application_status("accepted")
self.renderer.set_disabled_fields(self.renderer.disabled_fields + ["application_status"])
else:
try:
# Assign the choices to the form
self.form.application_status.choices = choices.Choices.choices_for_status('associate_editor', self.source.application_status)
except ValueError:
# If the current status isn't in the associate editor's status list, it must be out of bounds. Show it greyed out.
self.form.application_status.choices = choices.Choices.application_status("admin")
self.renderer.set_disabled_fields(self.renderer.disabled_fields + ["application_status"])
class PublisherUpdateRequest(ApplicationContext):
def make_renderer(self):
self.renderer = render.PublisherUpdateRequestRenderer()
def set_template(self):
self.template = "formcontext/publisher_update_request.html"
def blank_form(self):
self.form = forms.PublisherUpdateRequestForm()
def data2form(self):
self.form = forms.PublisherUpdateRequestForm(formdata=self.form_data)
self._expand_descriptions(FIELDS_WITH_DESCRIPTION)
self._expand_url_descriptions(URL_FIELDS)
self._disable_fields()
def source2form(self):
self.form = forms.PublisherUpdateRequestForm(data=ApplicationFormXWalk.obj2form(self.source))
self._expand_descriptions(FIELDS_WITH_DESCRIPTION)
self._expand_url_descriptions(URL_FIELDS)
self._disable_fields()
def pre_validate(self):
if self.source is None:
raise FormContextException("You cannot validate a form from a non-existent source")
# carry forward the disabled fields
bj = self.source.bibjson()
contact = self.source.contact
self.form.title.data = bj.title
self.form.alternative_title.data = bj.alternative_title
pissn = bj.get_one_identifier(bj.P_ISSN)
if pissn == "": pissn = None
self.form.pissn.data = pissn
eissn = bj.get_one_identifier(bj.E_ISSN)
if eissn == "": eissn = None
self.form.eissn.data = eissn
if len(contact) == 0:
# this will cause a validation failure if the form does not provide them
return
# we copy across the contacts if they are necessary. The contact details are conditionally
# disabled, so they /may/ be set
if "contact_name" in self.renderer.disabled_fields:
self.form.contact_name.data = contact.get("name")
if "contact_email" in self.renderer.disabled_fields:
self.form.contact_email.data = contact.get("email")
if "confirm_contact_email" in self.renderer.disabled_fields:
self.form.confirm_contact_email.data = contact.get("email")
def form2target(self):
self.target = ApplicationFormXWalk.form2obj(self.form)
def patch_target(self):
if self.source is None:
raise FormContextException("You cannot patch a target from a non-existent source")
self._carry_subjects_and_seal()
self._carry_fixed_aspects()
self._merge_notes_forward()
self.target.set_owner(self.source.owner)
self.target.set_editor_group(self.source.editor_group)
self.target.set_editor(self.source.editor)
self._carry_continuations()
# set the suggester to the account owner
acc = models.Account.pull(self.target.owner)
if acc is not None:
self.target.set_suggester(acc.name, acc.email)
# we carry this over for completeness, although it will be overwritten in the finalise() method
self.target.set_application_status(self.source.application_status)
def finalise(self, save_target=True, email_alert=True):
# FIXME: this first one, we ought to deal with outside the form context, but for the time being this
# can be carried over from the old implementation
if self.source is None:
raise FormContextException("You cannot edit a not-existent application")
# if we are allowed to finalise, kick this up to the superclass
super(PublisherUpdateRequest, self).finalise()
# set the status to update_request (if not already)
self.target.set_application_status(constants.APPLICATION_STATUS_UPDATE_REQUEST)
# Save the target
self.target.set_last_manual_update()
if save_target:
saved = self.target.save()
if saved is None:
raise FormContextException("Save on application failed")
# obtain the related journal, and attach the current application id to it
journal_id = self.target.current_journal
from portality.bll.doaj import DOAJ
journalService = DOAJ.journalService()
if journal_id is not None:
journal, _ = journalService.journal(journal_id)
if journal is not None:
journal.set_current_application(self.target.id)
if save_target:
saved = journal.save()
if saved is None:
raise FormContextException("Save on journal failed")
else:
self.target.remove_current_journal()
# email the publisher to tell them we received their update request
if email_alert:
try:
self._send_received_email()
except app_email.EmailException as e:
self.add_alert("We were unable to send you an email confirmation - possible problem with your email address")
app.logger.exception('Error sending reapplication received email to publisher')
def render_template(self, **kwargs):
if self.source is None:
raise FormContextException("You cannot edit a not-existent application")
return super(PublisherUpdateRequest, self).render_template(**kwargs)
def _carry_subjects_and_seal(self):
# carry over the subjects
source_subjects = self.source.bibjson().subjects()
self.target.bibjson().set_subjects(source_subjects)
# carry over the seal
self.target.set_seal(self.source.has_seal())
def _disable_fields(self):
if self.source is None:
raise FormContextException("You cannot disable fields on a not-existent application")
disable = ["title", "alternative_title", "pissn", "eissn"] # these are always disabled
# contact fields are only disabled if they already have content in source
contact = self.source.contact
if contact.get("name"):
disable.append("contact_name")
if contact.get("email"):
disable += ["contact_email", "confirm_contact_email"]
self.renderer.set_disabled_fields(disable)
def _send_received_email(self):
acc = models.Account.pull(self.target.owner)
if acc is None:
self.add_alert("Unable to locate account for specified owner")
return
journal_name = self.target.bibjson().title #.encode('utf-8', 'replace')
to = [acc.email]
fro = app.config.get('SYSTEM_EMAIL_FROM', '[email protected]')
subject = app.config.get("SERVICE_NAME","") + " - update request received"
try:
if app.config.get("ENABLE_PUBLISHER_EMAIL", False):
app_email.send_mail(to=to,
fro=fro,
subject=subject,
template_name="email/publisher_update_request_received.txt",
journal_name=journal_name,
username=self.target.owner
)
self.add_alert('A confirmation email has been sent to ' + acc.email + '.')
except app_email.EmailException as e:
magic = str(uuid.uuid1())
self.add_alert('Hm, sending the "update request received" email didn\'t work. Please quote this magic number when reporting the issue: ' + magic + ' . Thank you!')
app.logger.error(magic + "\n" + repr(e))
raise e
class PublisherUpdateRequestReadOnly(PrivateContext):
"""
Read Only Application form for publishers. Nothing can be changed. Useful to show publishers what they
currently have submitted for review
"""
def make_renderer(self):
self.renderer = render.PublisherUpdateRequestReadOnlyRenderer()
def set_template(self):
self.template = "formcontext/readonly_application.html"
def blank_form(self):
self.form = forms.PublisherUpdateRequestForm()
self.renderer.disable_all_fields(False)
# self._set_choices()
def data2form(self):
self.form = forms.PublisherUpdateRequestForm(formdata=self.form_data)
# self._set_choices()
self._expand_descriptions(FIELDS_WITH_DESCRIPTION)
self._expand_url_descriptions(URL_FIELDS)
self.renderer.disable_all_fields(False)
def source2form(self):
self.form = forms.PublisherUpdateRequestForm(data=JournalFormXWalk.obj2form(self.source))
# self._set_choices()
self._expand_descriptions(FIELDS_WITH_DESCRIPTION)
self._expand_url_descriptions(URL_FIELDS)
self.renderer.set_disabled_fields(["digital_archiving_policy"])
# self.renderer.disable_all_fields(True)
def form2target(self):
pass # you can't edit objects using this form
def patch_target(self):
pass # you can't edit objects using this form
def finalise(self):
raise FormContextException("You cannot edit applications using the read-only form")
"""
def render_template(self, **kwargs):
if self.source is None:
raise FormContextException("You cannot view a not-existent journal")
return super(ReadOnlyJournal, self).render_template(
lcc_jstree=json.dumps(lcc_jstree),
subjectstr=self._subjects2str(self.source.bibjson().subjects()),
**kwargs
)
"""
"""
def _set_choices(self):
# no application status (this is a journal) or editorial info (it's not even in the form) to set
pass
"""
### Journal form contexts ###
class ManEdJournalReview(PrivateContext):
"""
Managing Editor's Journal Review form. Should be used in a context where the form warrants full
admin privileges. It will permit doing every action.
"""
def make_renderer(self):
self.renderer = render.ManEdJournalReviewRenderer()
def set_template(self):
self.template = "formcontext/maned_journal_review.html"
def render_template(self, **kwargs):
if self.source is None:
raise FormContextException("You cannot edit a not-existent journal")
return super(ManEdJournalReview, self).render_template(
lcc_jstree=json.dumps(lcc_jstree),
subjectstr=self._subjects2str(self.source.bibjson().subjects()),
**kwargs)
def blank_form(self):
self.form = forms.ManEdApplicationReviewForm()
self._set_choices()
def data2form(self):
self.form = forms.ManEdJournalReviewForm(formdata=self.form_data)
self._set_choices()
self._expand_descriptions(FIELDS_WITH_DESCRIPTION)
self._expand_url_descriptions(URL_FIELDS)
def source2form(self):
self.form = forms.ManEdJournalReviewForm(data=JournalFormXWalk.obj2form(self.source))
self._set_choices()
self._expand_descriptions(FIELDS_WITH_DESCRIPTION)
self._expand_url_descriptions(URL_FIELDS)
def pre_validate(self):
# Editor field is populated in JS after page load - check the selected editor is actually in that editor group
self._validate_editor_field()
def form2target(self):
self.target = JournalFormXWalk.form2obj(self.form)
def patch_target(self):
if self.source is None:
raise FormContextException("You cannot patch a target from a non-existent source")
self._carry_fixed_aspects()
# NOTE: this means you can't unset an owner once it has been set. But you can change it.
if (self.target.owner is None or self.target.owner == "") and (self.source.owner is not None):
self.target.set_owner(self.source.owner)
self._merge_notes_forward(allow_delete=True)
def _set_choices(self):
# The first time this is rendered, it needs to populate the editor drop-down from saved group
egn = self.form.editor_group.data
self._populate_editor_field(egn)
def finalise(self):
# FIXME: this first one, we ought to deal with outside the form context, but for the time being this
# can be carried over from the old implementation
if self.source is None:
raise FormContextException("You cannot edit a not-existent journal")
# if we are allowed to finalise, kick this up to the superclass
super(ManEdJournalReview, self).finalise()
# FIXME: may want to factor this out of the suggestionformxwalk
# If we have changed the editors assinged to this application, let them know.
is_editor_group_changed = JournalFormXWalk.is_new_editor_group(self.form, self.source)
is_associate_editor_changed = JournalFormXWalk.is_new_editor(self.form, self.source)
# Save the target
self.target.set_last_manual_update()
self.target.save()
# if we need to email the editor and/or the associate, handle those here
if is_editor_group_changed:
try:
emails.send_editor_group_email(self.target)
except app_email.EmailException:
self.add_alert("Problem sending email to editor - probably address is invalid")
app.logger.exception('Error sending assignment email to editor.')
if is_associate_editor_changed:
try:
emails.send_assoc_editor_email(self.target)
except app_email.EmailException:
self.add_alert("Problem sending email to associate editor - probably address is invalid")
app.logger.exception('Error sending assignment email to associate.')
def validate(self):
# make use of the ability to disable validation, otherwise, let it run
if self.form is not None:
if self.form.make_all_fields_optional.data:
self.pre_validate()
return True
return super(ManEdJournalReview, self).validate()
class ManEdBulkEdit(PrivateContext):
"""
Managing Editor's Journal Review form. Should be used in a context where the form warrants full
admin privileges. It will permit doing every action.
"""
def make_renderer(self):
self.renderer = render.ManEdJournalBulkEditRenderer()
def set_template(self):
self.template = "formcontext/maned_journal_bulk_edit.html"
def blank_form(self):
self.form = forms.ManEdBulkEditJournalForm()
def data2form(self):
self.form = forms.ManEdBulkEditJournalForm(formdata=self.form_data)
self._expand_descriptions(FIELDS_WITH_DESCRIPTION)
self._expand_url_descriptions(URL_FIELDS)
class EditorJournalReview(PrivateContext):
"""
Editors Journal Review form. This should be used in a context where an editor who owns an editorial group
is accessing a journal. This prevents re-assignment of Editorial group, but permits assignment of associate
editor.
"""
def make_renderer(self):
self.renderer = render.EditorJournalReviewRenderer()
self.renderer.set_disabled_fields(["editor_group"])
def set_template(self):
self.template = "formcontext/editor_journal_review.html"
def render_template(self, **kwargs):
if self.source is None:
raise FormContextException("You cannot edit a not-existent journal")
return super(EditorJournalReview, self).render_template(
lcc_jstree=json.dumps(lcc_jstree),
subjectstr=self._subjects2str(self.source.bibjson().subjects()),
**kwargs)
def blank_form(self):
self.form = forms.EditorJournalReviewForm()
self._set_choices()
def data2form(self):
self.form = forms.EditorJournalReviewForm(formdata=self.form_data)
self._set_choices()
self._expand_descriptions(FIELDS_WITH_DESCRIPTION)
self._expand_url_descriptions(URL_FIELDS)
def source2form(self):
self.form = forms.EditorJournalReviewForm(data=JournalFormXWalk.obj2form(self.source))
self._set_choices()
self._expand_descriptions(FIELDS_WITH_DESCRIPTION)
self._expand_url_descriptions(URL_FIELDS)
def form2target(self):
self.target = JournalFormXWalk.form2obj(self.form)
def patch_target(self):
if self.source is None:
raise FormContextException("You cannot patch a target from a non-existent source")
self._carry_fixed_aspects()
self.target.set_owner(self.source.owner)
self.target.set_editor_group(self.source.editor_group)
self._merge_notes_forward()
self._carry_continuations()
def pre_validate(self):
self.form.editor_group.data = self.source.editor_group
def _set_choices(self):
if self.source is None:
raise FormContextException("You cannot set choices for a non-existent source")
# get the editor group from the source because it isn't in the form
egn = self.source.editor_group
self._populate_editor_field(egn)
def finalise(self):
# FIXME: this first one, we ought to deal with outside the form context, but for the time being this
# can be carried over from the old implementation
if self.source is None:
raise FormContextException("You cannot edit a not-existent journal")
# if we are allowed to finalise, kick this up to the superclass
super(EditorJournalReview, self).finalise()
# FIXME: may want to factor this out of the suggestionformxwalk
email_associate = ApplicationFormXWalk.is_new_editor(self.form, self.source)
# Save the target
self.target.set_last_manual_update()
self.target.save()
# if we need to email the associate, handle that here.
if email_associate:
try:
emails.send_assoc_editor_email(self.target)
except app_email.EmailException:
self.add_alert("Problem sending email to associate editor - probably address is invalid")
app.logger.exception('Error sending assignment email to associate.')
class AssEdJournalReview(PrivateContext):
"""
Associate Editors Journal Review form. This is to be used in a context where an associate editor (fewest rights)
needs to access a journal for review. This editor cannot change the editorial group or the assigned editor.
They also cannot change the owner of the journal. They cannot delete, only add notes.
"""
def make_renderer(self):
self.renderer = render.AssEdJournalReviewRenderer()
def set_template(self):
self.template = "formcontext/assed_journal_review.html"
def blank_form(self):
self.form = forms.AssEdJournalReviewForm()
self._set_choices()
def data2form(self):
self.form = forms.AssEdJournalReviewForm(formdata=self.form_data)
self._set_choices()
self._expand_descriptions(FIELDS_WITH_DESCRIPTION)
self._expand_url_descriptions(URL_FIELDS)
def source2form(self):
self.form = forms.AssEdJournalReviewForm(data=JournalFormXWalk.obj2form(self.source))
self._set_choices()
self._expand_descriptions(FIELDS_WITH_DESCRIPTION)
self._expand_url_descriptions(URL_FIELDS)
def form2target(self):
self.target = JournalFormXWalk.form2obj(self.form)
def patch_target(self):
if self.source is None:
raise FormContextException("You cannot patch a target from a non-existent source")
self._carry_fixed_aspects()
self._merge_notes_forward()
self.target.set_owner(self.source.owner)
self.target.set_editor_group(self.source.editor_group)
self.target.set_editor(self.source.editor)
self._carry_continuations()
def finalise(self):
# FIXME: this first one, we ought to deal with outside the form context, but for the time being this
# can be carried over from the old implementation
if self.source is None:
raise FormContextException("You cannot edit a not-existent journal")
# if we are allowed to finalise, kick this up to the superclass
super(AssEdJournalReview, self).finalise()
# Save the target
self.target.set_last_manual_update()
self.target.save()
def render_template(self, **kwargs):
if self.source is None:
raise FormContextException("You cannot edit a not-existent journal")
return super(AssEdJournalReview, self).render_template(
lcc_jstree=json.dumps(lcc_jstree),
subjectstr=self._subjects2str(self.source.bibjson().subjects()),
**kwargs
)
def _set_choices(self):
# no application status (this is a journal) or editorial info (it's not even in the form) to set
pass
class ReadOnlyJournal(PrivateContext):
"""
Read Only Journal form. Nothing can be changed. Useful for reviewing a journal and an application
(or update request) side by side in 2 browser windows or tabs.
"""
def make_renderer(self):
self.renderer = render.ReadOnlyJournalRenderer()
def set_template(self):
self.template = "formcontext/readonly_journal.html"
def blank_form(self):
self.form = forms.ReadOnlyJournalForm()
self._set_choices()
def data2form(self):
self.form = forms.ReadOnlyJournalForm(formdata=self.form_data)
self._set_choices()
self._expand_descriptions(FIELDS_WITH_DESCRIPTION)
self._expand_url_descriptions(URL_FIELDS)
def source2form(self):
self.form = forms.ReadOnlyJournalForm(data=JournalFormXWalk.obj2form(self.source))
self._set_choices()
self._expand_descriptions(FIELDS_WITH_DESCRIPTION)
self._expand_url_descriptions(URL_FIELDS)
def form2target(self):
pass # you can't edit objects using this form
def patch_target(self):
pass # you can't edit objects using this form
def finalise(self):
raise FormContextException("You cannot edit journals using the read-only form")
def render_template(self, **kwargs):
if self.source is None:
raise FormContextException("You cannot view a not-existent journal")
return super(ReadOnlyJournal, self).render_template(
lcc_jstree=json.dumps(lcc_jstree),
subjectstr=self._subjects2str(self.source.bibjson().subjects()),
**kwargs
)
def _set_choices(self):
# no application status (this is a journal) or editorial info (it's not even in the form) to set
pass
class ArticleFormFactory(object):
@classmethod
def get_from_context(cls, role, source=None, form_data=None, user=None):
if role == "admin":
return AdminMetadataArticleForm(source=source, form_data=form_data, user=user)
if role == "publisher":
return PublisherMetadataForm(source=source, form_data=form_data, user=user)
class MetadataForm(FormContext):
def __init__(self, source, form_data, user):
self.user = user
self.author_error = False
super(MetadataForm, self).__init__(source=source, form_data=form_data)
def _set_choices(self):
try:
ic = choices.Choices.choices_for_article_issns(user=self.user, article_id=self.source.id)
self.form.pissn.choices = ic
self.form.eissn.choices = ic
except Exception as e:
print (str(e))
# not logged in, and current_user is broken
# probably you are loading the class from the command line
pass
def modify_authors_if_required(self, request_data):
more_authors = request_data.get("more_authors")
remove_author = None
for v in list(request.values.keys()):
if v.startswith("remove_authors"):
remove_author = v.split("-")[1]
# if the user wants more authors, add an extra entry
if more_authors:
return self.render_template(more_authors=True)
# if the user wants to remove an author, do the various back-flips required
if remove_author is not None:
return self.render_template(remove_authors=remove_author)
def _check_for_author_errors(self, **kwargs):
if "more_authors" in kwargs and kwargs["more_authors"] == True:
self.form.authors.append_entry()
if "remove_authors" in kwargs:
keep = []
while len(self.form.authors.entries) > 0:
entry = self.form.authors.pop_entry()
if entry.short_name == "authors-" + kwargs["remove_author"]:
break
else:
keep.append(entry)
while len(keep) > 0:
self.form.authors.append_entry(keep.pop().data)
def _validate_authors(self):
counted = 0
for entry in self.form.authors.entries:
name = entry.data.get("name")
if name is not None and name != "":
counted += 1
return counted >= 1
def blank_form(self):
self.form = portality.formcontext.forms.ArticleForm()
self._set_choices()
def source2form(self):
self.form = portality.formcontext.forms.ArticleForm()
ArticleFormXWalk.obj2form(self.form, article=self.source)
self._set_choices()
def data2form(self):
self.form = portality.formcontext.forms.ArticleForm(formdata=self.form_data)
self._set_choices()
def form2target(self):
self.target = ArticleFormXWalk.form2obj(form=self.form)
def validate(self):
if not self._validate_authors():
self.author_error = True
if not self.form.validate():
return False
return True
def finalise(self, duplicate_check = True):
self.form2target()
if not self.author_error:
article_service = DOAJ.articleService()
article_service.create_article(self.target, self.user, add_journal_info=True,
update_article_id=self.source.id if self.source is not None else None,
duplicate_check = duplicate_check)
article_url = url_for('doaj.article_page', identifier=self.target.id)
msg, how = Messages.ARTICLE_METADATA_SUBMITTED_FLASH
Messages.flash_with_url(msg.format(url=article_url), how)
else:
return
class PublisherMetadataForm(MetadataForm):
def __init__(self, source, form_data, user):
super(PublisherMetadataForm, self).__init__(source=source, form_data=form_data, user=user)
def set_template(self):
self.template = "publisher/metadata.html"
def render_template(self, **kwargs):
self._check_for_author_errors(**kwargs)
if "validated" in kwargs and kwargs["validated"] == True:
self.blank_form()
return render_template(self.template, form=self.form, form_context=self, author_error=self.author_error)
class AdminMetadataArticleForm(MetadataForm):
def __init__(self, source, form_data, user):
super(AdminMetadataArticleForm, self).__init__(source=source, form_data=form_data, user=user)
def set_template(self):
self.template = "admin/article_metadata.html"
def render_template(self, **kwargs):
self._check_for_author_errors(**kwargs)
return render_template(self.template, form=self.form, form_context=self, author_error=self.author_error)
| apache-2.0 | -3,858,372,472,115,063,000 | 43.59197 | 398 | 0.630581 | false |
mushtaqak/edx-platform | openedx/core/djangoapps/credit/api.py | 1 | 28489 | """
Contains the APIs for course credit requirements.
"""
import logging
import uuid
import datetime
import pytz
from django.db import transaction
from util.date_utils import to_timestamp
from opaque_keys import InvalidKeyError
from opaque_keys.edx.keys import CourseKey
from student.models import User
from .exceptions import (
InvalidCreditRequirements,
InvalidCreditCourse,
UserIsNotEligible,
CreditProviderNotConfigured,
RequestAlreadyCompleted,
CreditRequestNotFound,
InvalidCreditStatus,
)
from .models import (
CreditCourse,
CreditProvider,
CreditRequirement,
CreditRequirementStatus,
CreditRequest,
CreditEligibility,
)
from .signature import signature, get_shared_secret_key
log = logging.getLogger(__name__)
def set_credit_requirements(course_key, requirements):
"""
Add requirements to given course.
Args:
course_key(CourseKey): The identifier for course
requirements(list): List of requirements to be added
Example:
>>> set_credit_requirements(
"course-v1-edX-DemoX-1T2015",
[
{
"namespace": "reverification",
"name": "i4x://edX/DemoX/edx-reverification-block/assessment_uuid",
"display_name": "Assessment 1",
"criteria": {},
},
{
"namespace": "proctored_exam",
"name": "i4x://edX/DemoX/proctoring-block/final_uuid",
"display_name": "Final Exam",
"criteria": {},
},
{
"namespace": "grade",
"name": "grade",
"display_name": "Grade",
"criteria": {"min_grade": 0.8},
},
])
Raises:
InvalidCreditRequirements
Returns:
None
"""
invalid_requirements = _validate_requirements(requirements)
if invalid_requirements:
invalid_requirements = ", ".join(invalid_requirements)
raise InvalidCreditRequirements(invalid_requirements)
try:
credit_course = CreditCourse.get_credit_course(course_key=course_key)
except CreditCourse.DoesNotExist:
raise InvalidCreditCourse()
old_requirements = CreditRequirement.get_course_requirements(course_key=course_key)
requirements_to_disable = _get_requirements_to_disable(old_requirements, requirements)
if requirements_to_disable:
CreditRequirement.disable_credit_requirements(requirements_to_disable)
for requirement in requirements:
CreditRequirement.add_or_update_course_requirement(credit_course, requirement)
def get_credit_requirements(course_key, namespace=None):
"""
Get credit eligibility requirements of a given course and namespace.
Args:
course_key(CourseKey): The identifier for course
namespace(str): Namespace of requirements
Example:
>>> get_credit_requirements("course-v1-edX-DemoX-1T2015")
{
requirements =
[
{
"namespace": "reverification",
"name": "i4x://edX/DemoX/edx-reverification-block/assessment_uuid",
"display_name": "Assessment 1",
"criteria": {},
},
{
"namespace": "proctored_exam",
"name": "i4x://edX/DemoX/proctoring-block/final_uuid",
"display_name": "Final Exam",
"criteria": {},
},
{
"namespace": "grade",
"name": "grade",
"display_name": "Grade",
"criteria": {"min_grade": 0.8},
},
]
}
Returns:
Dict of requirements in the given namespace
"""
requirements = CreditRequirement.get_course_requirements(course_key, namespace)
return [
{
"namespace": requirement.namespace,
"name": requirement.name,
"display_name": requirement.display_name,
"criteria": requirement.criteria
}
for requirement in requirements
]
@transaction.commit_on_success
def create_credit_request(course_key, provider_id, username):
"""
Initiate a request for credit from a credit provider.
This will return the parameters that the user's browser will need to POST
to the credit provider. It does NOT calculate the signature.
Only users who are eligible for credit (have satisfied all credit requirements) are allowed to make requests.
A provider can be configured either with *integration enabled* or not.
If automatic integration is disabled, this method will simply return
a URL to the credit provider and method set to "GET", so the student can
visit the URL and request credit directly. No database record will be created
to track these requests.
If automatic integration *is* enabled, then this will also return the parameters
that the user's browser will need to POST to the credit provider.
These parameters will be digitally signed using a secret key shared with the credit provider.
A database record will be created to track the request with a 32-character UUID.
The returned dictionary can be used by the user's browser to send a POST request to the credit provider.
If a pending request already exists, this function should return a request description with the same UUID.
(Other parameters, such as the user's full name may be different than the original request).
If a completed request (either accepted or rejected) already exists, this function will
raise an exception. Users are not allowed to make additional requests once a request
has been completed.
Arguments:
course_key (CourseKey): The identifier for the course.
provider_id (str): The identifier of the credit provider.
user (User): The user initiating the request.
Returns: dict
Raises:
UserIsNotEligible: The user has not satisfied eligibility requirements for credit.
CreditProviderNotConfigured: The credit provider has not been configured for this course.
RequestAlreadyCompleted: The user has already submitted a request and received a response
from the credit provider.
Example Usage:
>>> create_credit_request(course.id, "hogwarts", "ron")
{
"url": "https://credit.example.com/request",
"method": "POST",
"parameters": {
"request_uuid": "557168d0f7664fe59097106c67c3f847",
"timestamp": 1434631630,
"course_org": "HogwartsX",
"course_num": "Potions101",
"course_run": "1T2015",
"final_grade": 0.95,
"user_username": "ron",
"user_email": "[email protected]",
"user_full_name": "Ron Weasley",
"user_mailing_address": "",
"user_country": "US",
"signature": "cRCNjkE4IzY+erIjRwOQCpRILgOvXx4q2qvx141BCqI="
}
}
"""
try:
user_eligibility = CreditEligibility.objects.select_related('course').get(
username=username,
course__course_key=course_key
)
credit_course = user_eligibility.course
credit_provider = credit_course.providers.get(provider_id=provider_id)
except (CreditEligibility.DoesNotExist, CreditProvider.DoesNotExist):
log.warning(u'User tried to initiate a request for credit, but the user is not eligible for credit')
raise UserIsNotEligible
# Check if we've enabled automatic integration with the credit
# provider. If not, we'll show the user a link to a URL
# where the user can request credit directly from the provider.
# Note that we do NOT track these requests in our database,
# since the state would always be "pending" (we never hear back).
if not credit_provider.enable_integration:
return {
"url": credit_provider.provider_url,
"method": "GET",
"parameters": {}
}
else:
# If automatic credit integration is enabled, then try
# to retrieve the shared signature *before* creating the request.
# That way, if there's a misconfiguration, we won't have requests
# in our system that we know weren't sent to the provider.
shared_secret_key = get_shared_secret_key(credit_provider.provider_id)
if shared_secret_key is None:
msg = u'Credit provider with ID "{provider_id}" does not have a secret key configured.'.format(
provider_id=credit_provider.provider_id
)
log.error(msg)
raise CreditProviderNotConfigured(msg)
# Initiate a new request if one has not already been created
credit_request, created = CreditRequest.objects.get_or_create(
course=credit_course,
provider=credit_provider,
username=username,
)
# Check whether we've already gotten a response for a request,
# If so, we're not allowed to issue any further requests.
# Skip checking the status if we know that we just created this record.
if not created and credit_request.status != "pending":
log.warning(
(
u'Cannot initiate credit request because the request with UUID "%s" '
u'exists with status "%s"'
), credit_request.uuid, credit_request.status
)
raise RequestAlreadyCompleted
if created:
credit_request.uuid = uuid.uuid4().hex
# Retrieve user account and profile info
user = User.objects.select_related('profile').get(username=username)
# Retrieve the final grade from the eligibility table
try:
final_grade = CreditRequirementStatus.objects.get(
username=username,
requirement__namespace="grade",
requirement__name="grade",
status="satisfied"
).reason["final_grade"]
except (CreditRequirementStatus.DoesNotExist, TypeError, KeyError):
log.exception(
"Could not retrieve final grade from the credit eligibility table "
"for user %s in course %s.",
user.id, course_key
)
raise UserIsNotEligible
parameters = {
"request_uuid": credit_request.uuid,
"timestamp": to_timestamp(datetime.datetime.now(pytz.UTC)),
"course_org": course_key.org,
"course_num": course_key.course,
"course_run": course_key.run,
"final_grade": final_grade,
"user_username": user.username,
"user_email": user.email,
"user_full_name": user.profile.name,
"user_mailing_address": (
user.profile.mailing_address
if user.profile.mailing_address is not None
else ""
),
"user_country": (
user.profile.country.code
if user.profile.country.code is not None
else ""
),
}
credit_request.parameters = parameters
credit_request.save()
if created:
log.info(u'Created new request for credit with UUID "%s"', credit_request.uuid)
else:
log.info(
u'Updated request for credit with UUID "%s" so the user can re-issue the request',
credit_request.uuid
)
# Sign the parameters using a secret key we share with the credit provider.
parameters["signature"] = signature(parameters, shared_secret_key)
return {
"url": credit_provider.provider_url,
"method": "POST",
"parameters": parameters
}
def update_credit_request_status(request_uuid, provider_id, status):
"""
Update the status of a credit request.
Approve or reject a request for a student to receive credit in a course
from a particular credit provider.
This function does NOT check that the status update is authorized.
The caller needs to handle authentication and authorization (checking the signature
of the message received from the credit provider)
The function is idempotent; if the request has already been updated to the status,
the function does nothing.
Arguments:
request_uuid (str): The unique identifier for the credit request.
provider_id (str): Identifier for the credit provider.
status (str): Either "approved" or "rejected"
Returns: None
Raises:
CreditRequestNotFound: No request exists that is associated with the given provider.
InvalidCreditStatus: The status is not either "approved" or "rejected".
"""
if status not in ["approved", "rejected"]:
raise InvalidCreditStatus
try:
request = CreditRequest.objects.get(uuid=request_uuid, provider__provider_id=provider_id)
old_status = request.status
request.status = status
request.save()
log.info(
u'Updated request with UUID "%s" from status "%s" to "%s" for provider with ID "%s".',
request_uuid, old_status, status, provider_id
)
except CreditRequest.DoesNotExist:
msg = (
u'Credit provider with ID "{provider_id}" attempted to '
u'update request with UUID "{request_uuid}", but no request '
u'with this UUID is associated with the provider.'
).format(provider_id=provider_id, request_uuid=request_uuid)
log.warning(msg)
raise CreditRequestNotFound(msg)
def get_credit_requests_for_user(username):
"""
Retrieve the status of a credit request.
Returns either "pending", "accepted", or "rejected"
Arguments:
username (unicode): The username of the user who initiated the requests.
Returns: list
Example Usage:
>>> get_credit_request_status_for_user("bob")
[
{
"uuid": "557168d0f7664fe59097106c67c3f847",
"timestamp": 1434631630,
"course_key": "course-v1:HogwartsX+Potions101+1T2015",
"provider": {
"id": "HogwartsX",
"display_name": "Hogwarts School of Witchcraft and Wizardry",
},
"status": "pending" # or "approved" or "rejected"
}
]
"""
return CreditRequest.credit_requests_for_user(username)
def get_credit_requirement_status(course_key, username, namespace=None, name=None):
""" Retrieve the user's status for each credit requirement in the course.
Args:
course_key (CourseKey): The identifier for course
username (str): The identifier of the user
Example:
>>> get_credit_requirement_status("course-v1-edX-DemoX-1T2015", "john")
[
{
"namespace": "reverification",
"name": "i4x://edX/DemoX/edx-reverification-block/assessment_uuid",
"display_name": "In Course Reverification",
"criteria": {},
"status": "failed",
},
{
"namespace": "proctored_exam",
"name": "i4x://edX/DemoX/proctoring-block/final_uuid",
"display_name": "Proctored Mid Term Exam",
"criteria": {},
"status": "satisfied",
},
{
"namespace": "grade",
"name": "i4x://edX/DemoX/proctoring-block/final_uuid",
"display_name": "Minimum Passing Grade",
"criteria": {"min_grade": 0.8},
"status": "failed",
},
]
Returns:
list of requirement statuses
"""
requirements = CreditRequirement.get_course_requirements(course_key, namespace=namespace, name=name)
requirement_statuses = CreditRequirementStatus.get_statuses(requirements, username)
requirement_statuses = dict((o.requirement, o) for o in requirement_statuses)
statuses = []
for requirement in requirements:
requirement_status = requirement_statuses.get(requirement)
statuses.append({
"namespace": requirement.namespace,
"name": requirement.name,
"display_name": requirement.display_name,
"criteria": requirement.criteria,
"status": requirement_status.status if requirement_status else None,
"status_date": requirement_status.modified if requirement_status else None,
})
return statuses
def is_user_eligible_for_credit(username, course_key):
"""Returns a boolean indicating if the user is eligible for credit for
the given course
Args:
username(str): The identifier for user
course_key (CourseKey): The identifier for course
Returns:
True if user is eligible for the course else False
"""
return CreditEligibility.is_user_eligible_for_credit(course_key, username)
def get_credit_requirement(course_key, namespace, name):
"""Returns the requirement of a given course, namespace and name.
Args:
course_key(CourseKey): The identifier for course
namespace(str): Namespace of requirement
name(str): Name of the requirement
Returns: dict
Example:
>>> get_credit_requirement_status(
"course-v1-edX-DemoX-1T2015", "proctored_exam", "i4x://edX/DemoX/proctoring-block/final_uuid"
)
{
"course_key": "course-v1-edX-DemoX-1T2015"
"namespace": "reverification",
"name": "i4x://edX/DemoX/edx-reverification-block/assessment_uuid",
"display_name": "reverification"
"criteria": {},
}
"""
requirement = CreditRequirement.get_course_requirement(course_key, namespace, name)
return {
"course_key": requirement.course.course_key,
"namespace": requirement.namespace,
"name": requirement.name,
"display_name": requirement.display_name,
"criteria": requirement.criteria
} if requirement else None
def set_credit_requirement_status(username, course_key, req_namespace, req_name, status="satisfied", reason=None):
"""
Update the user's requirement status.
This will record whether the user satisfied or failed a particular requirement
in a course. If the user has satisfied all requirements, the user will be marked
as eligible for credit in the course.
Args:
username (str): Username of the user
course_key (CourseKey): Identifier for the course associated with the requirement.
req_namespace (str): Namespace of the requirement (e.g. "grade" or "reverification")
req_name (str): Name of the requirement (e.g. "grade" or the location of the ICRV XBlock)
Keyword Arguments:
status (str): Status of the requirement (either "satisfied" or "failed")
reason (dict): Reason of the status
Example:
>>> set_credit_requirement_status(
"staff",
CourseKey.from_string("course-v1-edX-DemoX-1T2015"),
"reverification",
"i4x://edX/DemoX/edx-reverification-block/assessment_uuid",
status="satisfied",
reason={}
)
"""
# Check if we're already eligible for credit.
# If so, short-circuit this process.
if CreditEligibility.is_user_eligible_for_credit(course_key, username):
return
# Retrieve all credit requirements for the course
# We retrieve all of them to avoid making a second query later when
# we need to check whether all requirements have been satisfied.
reqs = CreditRequirement.get_course_requirements(course_key)
# Find the requirement we're trying to set
req_to_update = next((
req for req in reqs
if req.namespace == req_namespace
and req.name == req_name
), None)
# If we can't find the requirement, then the most likely explanation
# is that there was a lag updating the credit requirements after the course
# was published. We *could* attempt to create the requirement here,
# but that could cause serious performance issues if many users attempt to
# lock the row at the same time.
# Instead, we skip updating the requirement and log an error.
if req_to_update is None:
log.error(
(
u'Could not update credit requirement in course "%s" '
u'with namespace "%s" and name "%s" '
u'because the requirement does not exist. '
u'The user "%s" should have had his/her status updated to "%s".'
),
unicode(course_key), req_namespace, req_name, username, status
)
return
# Update the requirement status
CreditRequirementStatus.add_or_update_requirement_status(
username, req_to_update, status=status, reason=reason
)
# If we're marking this requirement as "satisfied", there's a chance
# that the user has met all eligibility requirements.
if status == "satisfied":
CreditEligibility.update_eligibility(reqs, username, course_key)
def _get_requirements_to_disable(old_requirements, new_requirements):
"""
Get the ids of 'CreditRequirement' entries to be disabled that are
deleted from the courseware.
Args:
old_requirements(QuerySet): QuerySet of CreditRequirement
new_requirements(list): List of requirements being added
Returns:
List of ids of CreditRequirement that are not in new_requirements
"""
requirements_to_disable = []
for old_req in old_requirements:
found_flag = False
for req in new_requirements:
# check if an already added requirement is modified
if req["namespace"] == old_req.namespace and req["name"] == old_req.name:
found_flag = True
break
if not found_flag:
requirements_to_disable.append(old_req.id)
return requirements_to_disable
def _validate_requirements(requirements):
"""
Validate the requirements.
Args:
requirements(list): List of requirements
Returns:
List of strings of invalid requirements
"""
invalid_requirements = []
for requirement in requirements:
invalid_params = []
if not requirement.get("namespace"):
invalid_params.append("namespace")
if not requirement.get("name"):
invalid_params.append("name")
if not requirement.get("display_name"):
invalid_params.append("display_name")
if "criteria" not in requirement:
invalid_params.append("criteria")
if invalid_params:
invalid_requirements.append(
u"{requirement} has missing/invalid parameters: {params}".format(
requirement=requirement,
params=invalid_params,
)
)
return invalid_requirements
def is_credit_course(course_key):
"""API method to check if course is credit or not.
Args:
course_key(CourseKey): The course identifier string or CourseKey object
Returns:
Bool True if the course is marked credit else False
"""
try:
course_key = CourseKey.from_string(unicode(course_key))
except InvalidKeyError:
return False
return CreditCourse.is_credit_course(course_key=course_key)
def get_credit_request_status(username, course_key):
"""Get the credit request status.
This function returns the status of credit request of user for given course.
It returns the latest request status for the any credit provider.
The valid status are 'pending', 'approved' or 'rejected'.
Args:
username(str): The username of user
course_key(CourseKey): The course locator key
Returns:
A dictionary of credit request user has made if any
"""
credit_request = CreditRequest.get_user_request_status(username, course_key)
if credit_request:
credit_status = {
"uuid": credit_request.uuid,
"timestamp": credit_request.modified,
"course_key": credit_request.course.course_key,
"provider": {
"id": credit_request.provider.provider_id,
"display_name": credit_request.provider.display_name
},
"status": credit_request.status
}
else:
credit_status = {}
return credit_status
def _get_duration_and_providers(credit_course):
"""Returns the credit providers and eligibility durations.
The eligibility_duration is the max of the credit duration of
all the credit providers of given course.
Args:
credit_course(CreditCourse): The CreditCourse object
Returns:
Tuple of eligibility_duration and credit providers of given course
"""
providers = credit_course.providers.all()
seconds_good_for_display = 0
providers_list = []
for provider in providers:
providers_list.append(
{
"id": provider.provider_id,
"display_name": provider.display_name,
"eligibility_duration": provider.eligibility_duration,
"provider_url": provider.provider_url
}
)
eligibility_duration = int(provider.eligibility_duration) if provider.eligibility_duration else 0
seconds_good_for_display = max(eligibility_duration, seconds_good_for_display)
return seconds_good_for_display, providers_list
def get_credit_eligibility(username):
"""
Returns the all the eligibility the user has meet.
Args:
username(str): The username of user
Example:
>> get_credit_eligibility('Aamir'):
{
"edX/DemoX/Demo_Course": {
"created_at": "2015-12-21",
"providers": [
"id": 12,
"display_name": "Arizona State University",
"eligibility_duration": 60,
"provider_url": "http://arizona/provideere/link"
],
"seconds_good_for_display": 90
}
}
Returns:
A dict of eligibilities
"""
eligibilities = CreditEligibility.get_user_eligibility(username)
user_credit_requests = get_credit_requests_for_user(username)
request_dict = {}
# Change the list to dict for iteration
for request in user_credit_requests:
request_dict[unicode(request["course_key"])] = request
user_eligibilities = {}
for eligibility in eligibilities:
course_key = eligibility.course.course_key
duration, providers_list = _get_duration_and_providers(eligibility.course)
user_eligibilities[unicode(course_key)] = {
"created_at": eligibility.created,
"seconds_good_for_display": duration,
"providers": providers_list,
}
# Default status is requirements_meet
user_eligibilities[unicode(course_key)]["status"] = "requirements_meet"
# If there is some request user has made for this eligibility then update the status
if unicode(course_key) in request_dict:
user_eligibilities[unicode(course_key)]["status"] = request_dict[unicode(course_key)]["status"]
user_eligibilities[unicode(course_key)]["provider"] = request_dict[unicode(course_key)]["provider"]
return user_eligibilities
def get_purchased_credit_courses(username): # pylint: disable=unused-argument
"""
Returns the purchased credit courses.
Args:
username(str): Username of the student
Returns:
A dict of courses user has purchased from the credit provider after completion
"""
# TODO: How to track the purchased courses. It requires Will's work for credit provider integration
return {}
| agpl-3.0 | 8,880,496,703,872,569,000 | 35.062025 | 114 | 0.614097 | false |
qacafe/cdrouter.py | cdrouter/jobs.py | 1 | 8582 | #
# Copyright (c) 2017-2020 by QA Cafe.
# All Rights Reserved.
#
"""Module for accessing CDRouter Jobs."""
import collections
from marshmallow import Schema, fields, post_load
from .cdr_datetime import DateTime
class Options(object):
"""Model for CDRouter Job Options.
:param tags: (optional) Tags as string list.
:param skip_tests: (optional) Tests to skip as string list.
:param begin_at: (optional) Test name to begin testing at as string.
:param end_at: (optional) Test name to end testing at as string.
:param extra_cli_args: (optional) Extra `cdrouter-cli` arguments as string.
"""
def __init__(self, **kwargs):
self.tags = kwargs.get('tags', None)
self.skip_tests = kwargs.get('skip_tests', None)
self.begin_at = kwargs.get('begin_at', None)
self.end_at = kwargs.get('end_at', None)
self.extra_cli_args = kwargs.get('extra_cli_args', None)
class OptionsSchema(Schema):
tags = fields.List(fields.Str(), missing=None)
skip_tests = fields.List(fields.Str(), missing=None)
begin_at = fields.Str()
end_at = fields.Str()
extra_cli_args = fields.Str()
@post_load
def post_load(self, data):
return Options(**data)
class Job(object):
"""Model for CDRouter Jobs.
:param id: (optional) Job ID as an int.
:param status: (optional) Bool `True` if user is an administrator.
:param options: (optional) :class:`jobs.Options <jobs.Options>` object
:param package_id: (optional) Package ID as an int.
:param package_name: (optional) Package name as string.
:param config_id: (optional) Config ID as an int.
:param config_name: (optional) Config name as string.
:param device_id: (optional) Device ID as an int.
:param device_name: (optional) Device name as string.
:param result_id: (optional) Result ID as an int.
:param user_id: (optional) User ID as an int.
:param created: (optional) Job creation time as `DateTime`.
:param updated: (optional) Job last-updated time as `DateTime`.
:param automatic: (optional) Bool `True` if job scheduled automatically `DateTime`.
:param run_at: (optional) Job scheduled run-time `DateTime`.
"""
def __init__(self, **kwargs):
self.id = kwargs.get('id', None)
self.status = kwargs.get('status', None)
self.options = kwargs.get('options', None)
self.package_id = kwargs.get('package_id', None)
self.package_name = kwargs.get('package_name', None)
self.config_id = kwargs.get('config_id', None)
self.config_name = kwargs.get('config_name', None)
self.device_id = kwargs.get('device_id', None)
self.device_name = kwargs.get('device_name', None)
self.result_id = kwargs.get('result_id', None)
self.user_id = kwargs.get('user_id', None)
self.created = kwargs.get('created', None)
self.updated = kwargs.get('updated', None)
self.automatic = kwargs.get('automatic', None)
self.run_at = kwargs.get('run_at', None)
class JobSchema(Schema):
id = fields.Int(as_string=True)
status = fields.Str()
options = fields.Nested(OptionsSchema)
package_id = fields.Int(as_string=True)
package_name = fields.Str()
config_id = fields.Int(as_string=True)
config_name = fields.Str()
device_id = fields.Int(as_string=True)
device_name = fields.Str()
result_id = fields.Int(as_string=True, missing=None)
user_id = fields.Int(as_string=True)
created = DateTime()
updated = DateTime()
automatic = fields.Bool()
run_at = DateTime()
@post_load
def post_load(self, data):
return Job(**data)
class Page(collections.namedtuple('Page', ['data', 'links'])):
"""Named tuple for a page of list response data.
:param data: :class:`jobs.Job <jobs.Job>` list
:param links: :class:`cdrouter.Links <cdrouter.Links>` object
"""
class JobsService(object):
"""Service for accessing CDRouter Jobs."""
RESOURCE = 'jobs'
BASE = RESOURCE + '/'
def __init__(self, service):
self.service = service
self.base = self.BASE
def list(self, filter=None, type=None, sort=None, limit=None, page=None, detailed=None): # pylint: disable=redefined-builtin
"""Get a list of jobs.
:param filter: (optional) Filters to apply as a string list.
:param type: (optional) `union` or `inter` as string.
:param sort: (optional) Sort fields to apply as string list.
:param limit: (optional) Limit returned list length.
:param page: (optional) Page to return.
:param detailed: (optional) Return all fields if Bool `True`.
:return: :class:`jobs.Page <jobs.Page>` object
"""
schema = JobSchema()
resp = self.service.list(self.base, filter, type, sort, limit, page, detailed=detailed)
js, l = self.service.decode(schema, resp, many=True, links=True)
return Page(js, l)
def iter_list(self, *args, **kwargs):
"""Get a list of jobs. Whereas ``list`` fetches a single page of jobs
according to its ``limit`` and ``page`` arguments,
``iter_list`` returns all jobs by internally making successive
calls to ``list``.
:param args: Arguments that ``list`` takes.
:param kwargs: Optional arguments that ``list`` takes.
:return: :class:`jobs.Job <jobs.Job>` list
"""
return self.service.iter_list(self.list, *args, **kwargs)
def get(self, id): # pylint: disable=invalid-name,redefined-builtin
"""Get a job.
:param id: Job ID as an int.
:return: :class:`jobs.Job <jobs.Job>` object
:rtype: jobs.Job
"""
schema = JobSchema()
resp = self.service.get_id(self.base, id)
return self.service.decode(schema, resp)
def edit(self, resource):
"""Edit a job.
:param resource: :class:`jobs.Job <jobs.Job>` object
:return: :class:`jobs.Job <jobs.Job>` object
:rtype: jobs.Job
"""
schema = JobSchema(exclude=('id', 'status', 'options', 'package_name', 'config_name', 'device_name', 'result_id', 'user_id', 'created', 'updated', 'automatic', 'run_at'))
json = self.service.encode(schema, resource)
schema = JobSchema()
resp = self.service.edit(self.base, resource.name, json)
return self.service.decode(schema, resp)
def launch(self, resource):
"""Launch a new job.
:param resource: :class:`jobs.Job <jobs.Job>` object
:return: :class:`jobs.Job <jobs.Job>` object
:rtype: jobs.Job
"""
schema = JobSchema(exclude=('id', 'status', 'package_name', 'config_name', 'device_name', 'result_id', 'user_id', 'created', 'updated', 'automatic'))
json = self.service.encode(schema, resource)
schema = JobSchema()
resp = self.service.create(self.base, json)
return self.service.decode(schema, resp)
def delete(self, id): # pylint: disable=invalid-name,redefined-builtin
"""Delete a job.
:param id: Job ID as an int.
"""
return self.service.delete_id(self.base, id)
def bulk_launch(self, jobs=None, filter=None, all=False): # pylint: disable=redefined-builtin
"""Bulk launch a set of jobs.
:param jobs: :class:`jobs.Job <jobs.Job>` list
:param filter: (optional) Filters to apply as a string list.
:param all: (optional) Apply to all if bool `True`.
"""
json = None
if jobs is not None:
schema = JobSchema(exclude=('id', 'status', 'package_name', 'config_name', 'device_name', 'result_id', 'user_id', 'created', 'updated', 'automatic'))
jobs_json = self.service.encode(schema, jobs, many=True)
json = {self.RESOURCE: jobs_json}
schema = JobSchema()
resp = self.service.post(self.base,
params={'bulk': 'launch', 'filter': filter, 'all': all}, json=json)
return self.service.decode(schema, resp, many=True)
def bulk_delete(self, ids=None, filter=None, type=None, all=False): # pylint: disable=redefined-builtin
"""Bulk delete a set of jobs.
:param ids: (optional) Int list of job IDs.
:param filter: (optional) String list of filters.
:param type: (optional) `union` or `inter` as string.
:param all: (optional) Apply to all if bool `True`.
"""
return self.service.bulk_delete(self.base, self.RESOURCE, ids=ids, filter=filter, type=type, all=all)
| mit | -3,121,657,317,393,191,000 | 38.916279 | 178 | 0.622233 | false |
jonashaag/django-autocomplete-light | autocomplete_light/widgets.py | 1 | 6373 | """
ChoiceWidget is intended to work as a replacement for django's Select widget,
and MultipleChoiceWidget for django's SelectMultiple.
Constructing a widget needs an Autocomplete class or registered autocomplete
name.
The choice autocomplete widget renders from autocomplete_light/widget.html
template.
"""
from django import forms
from django.forms.util import flatatt
from django.utils import safestring
from django.template.loader import render_to_string
from django.utils.translation import ugettext_lazy as _
__all__ = ['WidgetBase', 'ChoiceWidget', 'MultipleChoiceWidget', 'TextWidget']
class WidgetBase(object):
"""
Base widget for autocompletes.
Mainly handles passing arguments from Python to HTML data-* attributes,
via widget_js_attributes and autocomplete_js_attributes. Javascript will
parse these data-* attributes.
This widget also renders the widget template.
"""
def __init__(self, autocomplete,
widget_js_attributes=None, autocomplete_js_attributes=None,
extra_context=None):
if isinstance(autocomplete, basestring):
self.autocomplete_name = autocomplete
from autocomplete_light import registry
self.autocomplete = registry[self.autocomplete_name]
else:
self.autocomplete = autocomplete
self.autocomplete_name = autocomplete.__class__.__name__
if extra_context is None:
self.extra_context = {}
else:
self.extra_context = extra_context
if widget_js_attributes is None:
self.widget_js_attributes = {}
else:
self.widget_js_attributes = widget_js_attributes
if autocomplete_js_attributes is None:
self.autocomplete_js_attributes = {}
else:
self.autocomplete_js_attributes = autocomplete_js_attributes
def process_js_attributes(self):
extra_autocomplete_js_attributes = getattr(self.autocomplete,
'autocomplete_js_attributes', {})
self.autocomplete_js_attributes.update(
extra_autocomplete_js_attributes)
extra_widget_js_attributes = getattr(self.autocomplete,
'widget_js_attributes', {})
self.widget_js_attributes.update(
extra_widget_js_attributes)
if 'bootstrap' not in self.widget_js_attributes.keys():
self.widget_js_attributes['bootstrap'] = 'normal'
if 'choice_selector' not in self.autocomplete_js_attributes.keys():
self.autocomplete_js_attributes['choice_selector'] = '[data-value]'
if 'url' not in self.autocomplete_js_attributes.keys():
url = self.autocomplete().get_absolute_url()
self.autocomplete_js_attributes['url'] = url
if 'placeholder' not in self.autocomplete_js_attributes.keys():
self.autocomplete_js_attributes['placeholder'] = _(
'type some text to search in this autocomplete').capitalize()
def render(self, name, value, attrs=None):
final_attrs = self.build_attrs(attrs)
self.html_id = final_attrs.pop('id', name)
if value is not None and not isinstance(value, (list, tuple)):
values = [value]
else:
values = value
autocomplete = self.autocomplete(values=values)
if values and not autocomplete.validate_values():
raise forms.ValidationError('%s cannot validate %s' % (
self.autocomplete_name, values))
self.process_js_attributes()
autocomplete_name = self.autocomplete_name.lower()
context = {
'name': name,
'values': values,
'widget': self,
'extra_attrs': safestring.mark_safe(flatatt(final_attrs)),
'autocomplete': autocomplete,
}
context.update(self.extra_context)
return safestring.mark_safe(render_to_string([
getattr(autocomplete, 'widget_template', ''),
'autocomplete_light/%s/widget.html' % autocomplete_name,
'autocomplete_light/%s/widget.html' % getattr(autocomplete,
'widget_template_name', ''),
'autocomplete_light/widget.html',
], context))
class ChoiceWidget(WidgetBase, forms.Select):
"""
Widget that provides an autocomplete for zero to one choice.
"""
def __init__(self, autocomplete,
widget_js_attributes=None, autocomplete_js_attributes=None,
extra_context=None, *args, **kwargs):
forms.Select.__init__(self, *args, **kwargs)
WidgetBase.__init__(self, autocomplete,
widget_js_attributes, autocomplete_js_attributes, extra_context)
self.widget_js_attributes['max_values'] = 1
class MultipleChoiceWidget(WidgetBase, forms.SelectMultiple):
"""
Widget that provides an autocomplete for zero to n choices.
"""
def __init__(self, autocomplete=None,
widget_js_attributes=None, autocomplete_js_attributes=None,
extra_context=None, *args, **kwargs):
forms.SelectMultiple.__init__(self, *args, **kwargs)
WidgetBase.__init__(self, autocomplete,
widget_js_attributes, autocomplete_js_attributes, extra_context)
class TextWidget(forms.TextInput, WidgetBase):
""" Widget that just adds an autocomplete to fill a text input """
def __init__(self, autocomplete,
widget_js_attributes=None, autocomplete_js_attributes=None,
*args, **kwargs):
forms.TextInput.__init__(self, *args, **kwargs)
WidgetBase.__init__(self, autocomplete,
widget_js_attributes, autocomplete_js_attributes)
def build_attrs(self, extra_attrs=None, **kwargs):
attrs = forms.TextInput.build_attrs(self, extra_attrs, **kwargs)
def update_attrs(source, prefix=''):
for key, value in source.items():
key = u'data-%s%s' % (prefix, key.replace('_', '-'))
attrs[key] = value
self.process_js_attributes()
update_attrs(self.widget_js_attributes)
update_attrs(self.autocomplete_js_attributes, 'autocomplete-')
if 'class' not in attrs.keys():
attrs['class'] = ''
attrs['class'] += ' autocomplete-light-text-widget'
return attrs
| mit | 1,981,258,003,177,358,000 | 34.405556 | 79 | 0.630943 | false |
oliviermartin/pyOCD | pyOCD/flash/__init__.py | 1 | 2136 | """
mbed CMSIS-DAP debugger
Copyright (c) 2006-2015 ARM Limited
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 flash_cortex_m import Flash_cortex_m
from flash_klxx import Flash_klxx
from flash_kl28z import Flash_kl28z
from flash_k20d50m import Flash_k20d50m
from flash_k22f import Flash_k22f
from flash_k64f import Flash_k64f
from flash_lpc800 import Flash_lpc800
from flash_lpc11u24 import Flash_lpc11u24
from flash_lpc1768 import Flash_lpc1768
from flash_lpc4330 import Flash_lpc4330
from flash_nrf51 import Flash_nrf51
from flash_nrf52 import Flash_nrf52
from flash_stm32f103rc import Flash_stm32f103rc
from flash_stm32f051 import Flash_stm32f051
from flash_maxwsnenv import Flash_maxwsnenv
from flash_max32600mbed import Flash_max32600mbed
from flash_w7500 import Flash_w7500
from flash_lpc11xx_32 import Flash_lpc11xx_32
FLASH = {
'cortex_m': Flash_cortex_m,
'kinetis': Flash_cortex_m,
'kl02z': Flash_klxx,
'kl05z': Flash_klxx,
'kl25z': Flash_klxx,
'kl26z': Flash_klxx,
'kl28z': Flash_kl28z,
'kl46z': Flash_klxx,
'k20d50m': Flash_k20d50m,
'k22f': Flash_k22f,
'k64f': Flash_k64f,
'lpc800': Flash_lpc800,
'lpc11u24': Flash_lpc11u24,
'lpc1768': Flash_lpc1768,
'lpc4330': Flash_lpc4330,
'nrf51': Flash_nrf51,
'nrf52': Flash_nrf52,
'stm32f103rc': Flash_stm32f103rc,
'stm32f051': Flash_stm32f051,
'maxwsnenv': Flash_maxwsnenv,
'max32600mbed': Flash_max32600mbed,
'w7500': Flash_w7500,
'lpc11xx_32': Flash_lpc11xx_32,
}
| apache-2.0 | 4,962,502,064,367,315,000 | 34.016393 | 73 | 0.698034 | false |
paultcochrane/pyvisi | pyvisi/renderers/vtk/item.py | 1 | 1221 | # Copyright (C) 2004-2008 Paul Cochrane
#
# 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, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
"""
This is base class for items within a scene
"""
# generic imports
from pyvisi.renderers.vtk.common import debugMsg
from pyvisi.item import Item as BaseItem
__revision__ = '$Revision$'
class Item(BaseItem):
"""
This is the base class for items within a scene
"""
def __init__(self):
"""
Initialisation of Item class
"""
debugMsg("Called Item.__init__()")
BaseItem.__init__(self)
# vim: expandtab shiftwidth=4:
| gpl-2.0 | -3,891,547,595,315,248,000 | 29.525 | 77 | 0.70516 | false |
hearsaycorp/normalize | normalize/property/types.py | 1 | 5422 | #
# This file is a part of the normalize python library
#
# normalize is free software: you can redistribute it and/or modify
# it under the terms of the MIT License.
#
# normalize 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
# MIT License for more details.
#
# You should have received a copy of the MIT license along with
# normalize. If not, refer to the upstream repository at
# http://github.com/hearsaycorp/normalize
#
"""``normalize.property.types`` provides an assortment of pre-generated
types"""
import six
from past.builtins import basestring
import datetime
import numbers
from sys import maxsize
from . import make_property_type
from ..subtype import subtype
try:
from dateutil.parser import parse as parse_datetime
except ImportError:
formats = {
6: "%y%m%d",
8: "%Y%m%d",
13: "%Y%m%d%H:%M",
14: "%Y%m%d%H:%MZ",
16: "%Y%m%d%H:%M:%S",
17: "%Y%m%d%H:%M:%SZ",
}
def parse_datetime(not_a_datetime):
datetime_stripped = not_a_datetime.replace(
"-", "").replace("T", "").replace(" ", "")
if len(datetime_stripped) in formats:
return datetime.datetime.strptime(
datetime_stripped, formats[len(datetime_stripped)],
)
else:
raise Exception(
"``dateutil`` not installed, so can't parse %r" %
not_a_datetime
)
IntProperty = make_property_type(
"IntProperty", isa=int, trait_name="int",
attrs={
"__doc__": "A property which must be an ``int``",
},
)
LongProperty = make_property_type(
"LongProperty", isa=six.integer_types[-1], trait_name="long",
attrs={
"__doc__": "A property which must be a ``long``",
},
)
IntegerProperty = make_property_type(
"IntegerProperty", isa=numbers.Integral, trait_name="integer",
coerce=lambda x: (
int(x) if abs(float(x)) < maxsize else six.integer_types[-1](x)
),
attrs={
"__doc__": "A property which holds an integer, int or long",
},
)
NumberProperty = make_property_type(
"NumberProperty", isa=numbers.Number, trait_name="number",
coerce=lambda x: coerce_number(x),
attrs={
"__doc__": "A property which holds a number type (eg float, int) "
"with automatic cast from string",
},
)
StringProperty = make_property_type(
"StringProperty", isa=basestring, trait_name="str",
attrs={
"__doc__": "A property which must be a ``basestring`` or "
"``unicode``, and if not, throws a coerce error",
},
)
FloatProperty = make_property_type(
"FloatProperty", isa=float, trait_name="float",
attrs={
"__doc__": "A property which must be a floating point number.",
},
)
UnicodeProperty = make_property_type(
"UnicodeProperty", base_type=StringProperty,
isa=six.text_type, coerce=(lambda s: six.text_type(s)
if isinstance(s, str) else s),
trait_name="unicode",
attrs={
"__doc__": "A property which must be a ``unicode`` or ``str`` "
"(it is upgraded to ``unicode`` if it is passed in as "
"a ``str``)",
},
)
def coerce_datetime(not_a_datetime):
if isinstance(not_a_datetime, date):
tt = not_a_datetime.timetuple()
return datetime.datetime(*(tt[0:6]))
elif isinstance(not_a_datetime, basestring):
return parse_datetime(not_a_datetime)
else:
raise ValueError(
"Cannot coerce %r to a date/datetime" % not_a_datetime
)
def coerce_date(not_a_date):
if isinstance(not_a_date, datetime.datetime) or (
hasattr(not_a_date, "date") and callable(not_a_date.date)
):
return not_a_date.date()
else:
return coerce_datetime(not_a_date).date()
def coerce_number(not_a_number):
if isinstance(not_a_number, basestring):
try:
return six.integer_types[-1](not_a_number)
except ValueError:
return float(not_a_number)
else:
return float(not_a_number)
date = subtype(
"date",
of=datetime.date,
where=lambda x: not isinstance(x, datetime.datetime),
)
DateProperty = make_property_type(
"DateProperty",
trait_name="date", isa=date, coerce=coerce_date,
json_out=lambda dt: dt.isoformat(),
attrs={
"__doc__": "A property which must hold a python date; coercion "
"from string is provided via ``dateutil.parse``. "
"As of normalize v1, if a ``datetime.datetime`` "
"instance is assigned to a ``DateProperty``, it will "
"be truncated to a ``datetime.date``.",
},
)
DatetimeProperty = make_property_type(
"DatetimeProperty",
trait_name="datetime", isa=datetime.datetime,
coerce=coerce_datetime,
json_out=lambda dt: dt.isoformat(),
attrs={
"__doc__": "A property which must holds a python datetime. "
"Correct timezone handling is currently TODO and "
"users should not depend on timezone behavior until "
"this message is removed (submit tests and a patch!)",
},
)
__all__ = tuple(k for k in list(globals().keys()) if k.endswith("Property"))
| mit | -1,562,669,226,994,970,400 | 30.16092 | 76 | 0.601254 | false |
kewljedi/octoprint-pushbullet | setup.py | 1 | 1047 | # coding=utf-8
import setuptools
def package_data_dirs(source, sub_folders):
import os
dirs = []
for d in sub_folders:
for dirname, _, files in os.walk(os.path.join(source, d)):
dirname = os.path.relpath(dirname, source)
for f in files:
dirs.append(os.path.join(dirname, f))
return dirs
def params():
name = "OctoPrint-Pushbullet"
version = "0.0.1"
description = "Adds support to push OctoPrint events to a Pushbullet channel"
long_description = "TODO"
author = "kewljedi"
author_email = "[email protected]"
url = "https://github.com/kewljedi/octoprint-pushbullet"
license = "GPLv3"
packages = ["octoprint_pushbullet"]
package_data = {"octoprint_pushbullet": package_data_dirs('octoprint_pushbullet', ['static', 'templates'])}
include_package_data = True
zip_safe = False
install_requires = open("requirements.txt").read().split("\n")
entry_points = {
"octoprint.plugin": [
"pushbullet = octoprint_pushbullet"
]
}
return locals()
setuptools.setup(**params()) | gpl-3.0 | 8,190,900,412,091,826,000 | 23.952381 | 109 | 0.671442 | false |
mateoqac/unqTip | language/vxgbs/lang/gbs_compiler.py | 1 | 29369 | #
# Copyright (C) 2011, 2012 Pablo Barenbaum <[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 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/>.
#
"Gobstones compiler from source ASTs to virtual machine code."
import lang.gbs_vm
import lang.gbs_builtins
import lang.gbs_type
import lang.gbs_def_helper as def_helper
import common.i18n as i18n
import common.position
import common.utils
class GbsCompileException(common.utils.StaticException):
"Base exception for Gobstones compiler errors."
pass
def parse_literal(tok):
"""Given a token, parse its string value and return the denotated
Gobstones value.
"""
if tok.type == 'symbol':
val = tok.value
else:
val = lang.gbs_builtins.parse_constant(tok.value)
#assert val is not None
if val is None:
val = tok.value
return val
class GbsLabel(object):
"Represents a unique label in the program."
def __repr__(self):
return 'L_%s' % (id(self),)
class GbsCompiler(object):
"Compiler of Gobstones programs."
def __init__(self):
self.code = None
self.temp_counter = None
self.module_handler = None
self._current_def_name = None
self.constructor_of_type = {"Arreglo":"Arreglo"}
def compile_program(self, tree, module_prefix='', explicit_board=None):
"""Given an AST for a full program, compile it to virtual machine
code, returning an instance of lang.gbs_vm.GbsCompiledProgram.
The Main module should be given the empty module prefix ''.
Every other module should be given the module name as a prefix.
"""
if explicit_board is None:
entrypoint_tree = def_helper.find_def(tree.children[2], def_helper.is_entrypoint_def)
self.explicit_board = len(entrypoint_tree.children[2].children) != 0
else:
self.explicit_board = explicit_board
self.module_handler = tree.module_handler
self.compile_imported_modules(tree)
imports = tree.children[1].children
defs = tree.children[2]
self.code = lang.gbs_vm.GbsCompiledProgram(
tree, module_prefix=module_prefix)
self.compile_imports(imports)
self.user_defined_routine_names = list(self.code.external_routines.keys())
self.user_defined_routine_names += def_helper.get_routine_names(defs)
self.compile_defs(defs)
return self.code
def compile_imported_modules(self, tree):
"Recursively compile the imported modules."
for mdl_name, mdl_tree in self.module_handler.parse_trees():
compiler = GbsCompiler()
try:
code = compiler.compile_program(
mdl_tree, module_prefix=mdl_name, explicit_board=self.explicit_board
)
self.constructor_of_type.update(compiler.constructor_of_type)
except common.utils.SourceException as exception:
self.module_handler.reraise(
GbsCompileException,
exception,
i18n.i18n(
'Error compiling module %s'
) % (
mdl_name,
),
common.position.ProgramAreaNear(tree.children[1]))
self.module_handler.set_compiled_code(mdl_name, code)
def compile_imports(self, imports):
"""Add the imported procedures and functions to the local
namespace of routines.
"""
for imp in imports:
mdl_name = imp.children[1].value
rtns = imp.children[2].children
for rtn in rtns:
if (not isinstance(rtn, lang.gbs_constructs.UserType) and
not isinstance(rtn, lang.gbs_constructs.BuiltinFieldGetter)):
mdl_code = self.module_handler.compiled_code_for(mdl_name)
if rtn.name() in mdl_code.routines:
self.code.external_routines[rtn.name()] = (
mdl_code,
mdl_code.routines[rtn.name()]
)
else:
assert rtn.name() in mdl_code.external_routines
val = mdl_code.external_routines[rtn.name()]
self.code.external_routines[rtn.name()] = val
def compile_defs(self, tree):
"Compile a list of definitions."
self.temp_counter = 0
for def_ in tree.children:
if def_helper.is_type_def(def_):
self.gather_type_data(def_)
else:
self.compile_routine_def(def_)
def gather_type_data(self, def_):
_, type_name, type_or_def = def_.children
if type_or_def.children[0] == 'record':
self.constructor_of_type[type_name.value] = type_name.value
else:
body = type_or_def.children[1]
for case in body.children:
_, cname, _ = case.children
self.constructor_of_type[cname.value] = type_name.value
def temp_varname(self):
"Make a temporary variable name."
self.temp_counter += 1
return '_tempvar%i' % (self.temp_counter)
def compile_routine_def(self, tree):
"Compile a single definition."
prfn = def_helper.get_def_keyword(tree)
name = def_helper.get_def_name(tree).value
self._current_def_name = name
params = [param.value for param in def_helper.get_def_params(tree)]
immutable_params = []
if prfn == 'function':
immutable_params = params
elif prfn == 'procedure' and len(params) > 1:
immutable_params = params[1:]
code = lang.gbs_vm.GbsCompiledCode(tree, prfn, name, params, self.explicit_board)
code.add_enter()
for p in immutable_params:
code.push(('setImmutable', p), near=tree)
self.compile_commands(def_helper.get_def_body(tree), code)
if prfn == 'procedure' and self.explicit_board:
code.push(('pushFrom', params[0]), near=tree)
code.add_leave_return()
code.build_label_table()
self.code.routines[name] = code
#### The following methods take a program fragment in form of an AST
#### and a "code" argument, which should be an instance of
#### lang.gbs_vm.GbsCompiledCode.
####
#### The compilation process appends to the compiled code the virtual
#### machine code corresponding to the given program fragment.
#### Commands
def compile_commands(self, tree, code):
"Compile a sequence of commands."
for cmd in tree.children:
self.compile_cmd(cmd, code)
def compile_cmd(self, tree, code):
"Compile a single command."
command = tree.children[0]
dispatch = {
'Skip': self.compile_skip,
'THROW_ERROR': self.compile_boom,
'procCall': self.compile_proc_call,
'assignVarName': self.compile_assign_var_name,
'assignVarTuple1': self.compile_assign_var_tuple1,
'if': self.compile_if,
'case': self.compile_case,
'while': self.compile_while,
'repeat': self.compile_repeat,
'repeatWith': self.compile_repeat_with,
'foreach': self.compile_foreach,
'block': self.compile_block,
'return': self.compile_return,
}
assert command in dispatch
dispatch[command](tree, code)
def compile_type(self, tree, code):
"""Compile a type expression. Just fill a hole in construct() function.
In a future, it could be usefull for runtime type checks. [CHECK]"""
tok = tree.children[1]
type = self.constructor_of_type[tok.value] + "::" + tok.value
code.push(('pushConst', type), near=tree)
def compile_skip(self, tree, code):
"Compile a Skip command."
pass
def compile_boom(self, tree, code):
"Compile a THROW_ERROR command."
code.push(('THROW_ERROR', tree.children[1].value), near=tree)
def compile_proc_call(self, tree, code):
"Compile a procedure call."
procname = tree.children[1].value
args = tree.children[2].children
if self.explicit_board:
inout_var = args[0]
type_annotation = None
if hasattr(tree, 'type_annotation'):
type_annotation = tree.type_annotation
for i, arg in zip(range(len(args)), args):
self.compile_expression(arg, code)
code.push(('call', procname, len(args)), near=tree)
if self.explicit_board:
code.push(('popTo', inout_var.children[1].value), near=tree)
def compile_projectable_var_check(self, tree, code, var):
"Compile a projectable variable check. Varname is pushed to stack."
code.push(('pushConst', var), near=tree)
code.push(('call', '_checkProjectableVar', 1), near=tree)
def compile_assign_var_name(self, tree, code):
"Compile an assignment: <lvalue> := <expr>"
offsets = tree.children[2].children
if len(offsets) > 0:
#calculate assignment reference
var = tree.children[1].children[1].value
self.compile_projectable_var_check(tree, code, var)
code.push(('pushFrom', var), near=tree)
for offset in offsets:
if offset.children[0] == 'index':
self.compile_expression(offset.children[1], code)
else:
code.push(('pushConst', parse_literal(offset.children[1].children[1])), near=tree)
code.push(('call', '_getRef', 2), near=tree)
#compile expression
self.compile_expression(tree.children[3], code)
#Set ref
code.push(('call', '_SetRefValue', 2), near=tree)
else:
#compile expression
self.compile_expression(tree.children[3], code)
#assign varname
full_varname = '.'.join([tok.value for tok in tree.children[1].children[1:]])
code.push(('popTo', full_varname), near=tree)
def compile_assign_var_tuple1(self, tree, code):
"Compile a tuple assignment: (v1, ..., vN) := f(...)"
self.compile_expression(tree.children[2], code)
varnames = [var.value for var in tree.children[1].children]
for var in common.utils.seq_reversed(varnames):
code.push(('popTo', var), near=tree)
def compile_if(self, tree, code):
"Compile a conditional statement."
lelse = GbsLabel()
self.compile_expression(tree.children[1], code) # cond
code.push((('jumpIfFalse'), lelse), near=tree)
self.compile_block(tree.children[2], code) # then
if tree.children[3] is None:
code.push(('label', lelse), near=tree)
else:
lend = GbsLabel()
code.push(('jump', lend), near=tree)
code.push(('label', lelse), near=tree)
self.compile_block(tree.children[3], code) # else
code.push(('label', lend), near=tree)
def compile_case(self, tree, code):
"Compile a case statement."
# case (Value) of
# Lits1 -> {Body1}
# LitsN -> {BodyN}
# _ -> {BodyElse}
#
# Compiles to code corresponding to:
#
# value0 := Value
# if (value0 in Lits1) {Body1}
# elif (value0 in Lits2) {Body2}
# ...
# elif (value0 in LitsN) {BodyN}
# else {BodyElse}
value = tree.children[1]
value0 = self.temp_varname()
self.compile_expression(value, code)
# value0 := value
code.push(('popTo', value0), near=tree)
lend = GbsLabel()
next_label = None
for branch in tree.children[2].children:
if next_label is not None:
code.push(('label', next_label), near=tree)
if branch.children[0] == 'branch':
lits = [parse_literal(lit) for lit in branch.children[1].children]
next_label = GbsLabel()
# if value0 in LitsI
code.push(('pushFrom', value0), near=tree)
code.push(('jumpIfNotIn', lits, next_label), near=tree)
# BodyI
self.compile_block(branch.children[2], code)
code.push(('jump', lend), near=tree)
else: # defaultBranch
# BodyElse
self.compile_block(branch.children[1], code)
code.push(('label', lend), near=tree)
def compile_match(self, tree, code):
"Compile a match statement."
# match (<Expr-V>) of
# <Case-1> -> <Expr-1>
# <Case-2> -> <Expr-2>
# ...
# <Case-N> -> <Expr-N>
# _ -> <Expr-Else>
#
# Compiles to code corresponding to:
#
# case := _extract_case(<Expr-V>)
# if (case == <Case-1>) <Expr-1>
# elif (case == <Case-2>) <Expr-2>
# ...
# elif (case == <Case-N>) <Expr-N>
# else <Expr-Else>
value = tree.children[1]
value0 = self.temp_varname()
self.compile_expression(value, code)
# This is a runtime function to extract type name
code.push(('call', '_extract_case', 1), near=tree)
# value0 := value
code.push(('popTo', value0), near=tree)
lend = GbsLabel()
next_label = None
default_branch = False
for branch in tree.children[2].children:
if not next_label is None:
code.push(('label', next_label), near=tree)
if branch.children[0] == 'branch':
case_i = parse_literal(branch.children[1])
next_label = GbsLabel()
# if value0 in LitsI
code.push(('pushFrom', value0), near=tree)
code.push(('pushConst', case_i), near=tree)
code.push(('call', '==', 2), near=tree)
code.push(('jumpIfFalse', next_label), near=tree)
# BodyI
self.compile_expression(branch.children[2], code)
code.push(('jump', lend), near=tree)
else: # defaultBranch
# BodyElse
default_branch = True
self.compile_expression(branch.children[1], code)
if not default_branch:
code.push(('label', next_label), near=tree)
code.push(('THROW_ERROR', '"' + i18n.i18n('Expression has no matching branch.') + '"'), near=tree)
code.push(('label', lend), near=tree)
def compile_while(self, tree, code):
"Compile a while statement."
lbegin = GbsLabel()
lend = GbsLabel()
code.push(('label', lbegin), near=tree)
self.compile_expression(tree.children[1], code) # cond
code.push(('jumpIfFalse', lend), near=tree)
self.compile_block(tree.children[2], code) # body
code.push(('jump', lbegin), near=tree)
code.push(('label', lend), near=tree)
def compile_repeat(self, tree, code):
"Compile a repeat statement."
#
# repeat (<Expr>) <Block>
#
# Compiles to code corresponding to
# the following fragment:
#
# counter := <Expr>
# while (true) {
# if (not (counter > 0)) { break }
# <Block>
# counter := counter - 1
# }
#
times = tree.children[1]
body = tree.children[2]
counter = self.temp_varname()
lbegin = GbsLabel()
lend = GbsLabel()
# counter := <Expr>
self.compile_expression(times, code)
code.push(('popTo', counter), near=tree)
# while (true) {
code.push(('label', lbegin), near=tree)
# if (not (counter > 0) { break }
code.push(('pushFrom', counter), near=tree)
code.push(('pushConst', 0), near=tree)
code.push(('call', '>', 2), near=tree)
code.push(('jumpIfFalse', lend), near=tree)
# <Block>
self.compile_block(body, code)
# counter := counter - 1
code.push(('pushFrom', counter), near=tree)
code.push(('pushConst', 1), near=tree)
code.push(('call', '-', 2), near=tree)
code.push(('popTo', counter), near=tree)
# end while
code.push(('jump', lbegin), near=tree)
code.push(('label', lend), near=tree)
code.push(('delVar', counter), near=tree)
def compile_foreach(self, tree, code):
"Compile a foreach statement."
#
# foreach <Index> in <List> <Block>
#
# Compiles to code corresponding to
# the following fragment:
#
# xs0 := <List>
# while (true) {
# if (isEmpty(xs0)) break;
# <Index> := head(xs0)
# setImmutable(<Index>)
# <Block>
# unsetImmutable(<Index>)
# xs0 := tail(xs)
# }
#
def jumpIfIsEmpty(var, label):
code.push(('pushFrom', var), near=tree)
code.push(('call', i18n.i18n('isEmpty'), 1), near=tree)
code.push(('call', 'not', 1), near=tree)
code.push(('jumpIfFalse', label), near=tree)
def head(listVar, var):
code.push(('pushFrom', listVar), near=tree)
code.push(('call', i18n.i18n('head'), 1), near=tree)
code.push(('popTo', var), near=tree)
def tail(listVar, var):
code.push(('pushFrom', listVar), near=tree)
code.push(('call', i18n.i18n('tail'), 1), near=tree)
code.push(('popTo', var), near=tree)
index = tree.children[1].value
list_ = tree.children[2]
body = tree.children[3]
xs0 = self.temp_varname()
lbegin = GbsLabel()
lend = GbsLabel()
lend2 = GbsLabel()
# xs0 := <List>
self.compile_expression(list_, code)
code.push(('popTo', xs0), near=tree)
# while (true) {
code.push(('label', lbegin), near=tree)
# if (isEmpty(xs0)) break;
jumpIfIsEmpty(xs0, lend)
# <Index> := head(xs0)
head(xs0, index)
# setImmutable(<Index>)
code.push(('setImmutable', index), near=tree)
# <Block>
self.compile_block(body, code)
# setImmutable(<Index>)
code.push(('unsetImmutable', index), near=tree)
# xs0 := tail(xs0)
tail(xs0, xs0)
# }
code.push(('jump', lbegin), near=tree)
code.push(('label', lend2), near=tree)
code.push(('delVar', index), near=tree)
code.push(('label', lend), near=tree)
def compile_repeat_with(self, tree, code):
"Compile a repeatWith statement."
#
# repeatWith i in Lower..Upper {BODY}
#
# Compiles to code corresponding to
# the following fragment:
#
# i := Lower
# upper0 := Upper
# if (i <= upper0) {
# while (true) {
# {BODY}
# if (i == upper0) break;
# i := next(i)
# }
# }
#
def call_next():
"""Add a VM instruction for calling the builtin 'next' function,
which operates on any iterable value.
"""
name = i18n.i18n('next')
if hasattr(tree, 'index_type_annotation'):
name = lang.gbs_builtins.polyname(
name,
[repr(tree.index_type_annotation)])
code.push(('call', name, 1), near=tree)
# upper0 is preserved in the stack
i = tree.children[1].value
limit_lower = tree.children[2].children[1]
limit_upper = tree.children[2].children[2]
body = tree.children[3]
upper0 = self.temp_varname()
lbegin = GbsLabel()
lend = GbsLabel()
# i := Lower
self.compile_expression(limit_lower, code)
code.push(('popTo', i), near=tree)
code.push(('setImmutable', i), near=tree)
# upper0 := Upper
self.compile_expression(limit_upper, code)
code.push(('popTo', upper0), near=tree)
# if i <= upper0
code.push(('pushFrom', i), near=tree)
code.push(('pushFrom', upper0), near=tree)
code.push(('call', '<=', 2), near=tree)
code.push(('jumpIfFalse', lend), near=tree)
# while true
code.push(('label', lbegin), near=tree)
# body
self.compile_block(body, code)
# if (i == upper0) break
code.push(('pushFrom', i), near=tree)
code.push(('pushFrom', upper0), near=tree)
code.push(('call', '/=', 2), near=tree)
code.push(('jumpIfFalse', lend), near=tree)
# i := next(i)
code.push(('pushFrom', i), near=tree)
call_next()
code.push(('unsetImmutable', i), near=tree)
code.push(('popTo', i), near=tree)
code.push(('setImmutable', i), near=tree)
# end while
code.push(('jump', lbegin), near=tree)
code.push(('label', lend), near=tree)
code.push(('delVar', i), near=tree)
def compile_block(self, tree, code):
"Compile a block statement."
self.compile_commands(tree.children[1], code)
def compile_return(self, tree, code):
"Compile a return statement."
vals = tree.children[1].children
for val in vals:
self.compile_expression(val, code)
if self._current_def_name == 'program':
vrs = []
expr_count = 1
for v in tree.children[1].children:
if v.children[0] == 'varName':
vrs.append(v.children[1].value)
else:
vrs.append("#%s" % (expr_count,))
expr_count += 1
if hasattr(tree, 'type_annot'):
# Decorate the return variables with their types.
types = [
repr(subtype)
for subtype in tree.type_annot.subtypes()
]
vrs = [
lang.gbs_builtins.polyname(vname, [vtype])
for vname, vtype in zip(vrs, types)
]
code.push(('returnVars', len(vals), vrs), near=tree)
else:
code.push(('return', len(vals)), near=tree)
#### Expressions
def compile_expression(self, tree, code):
"Compile an expression."
exptype = tree.children[0]
dispatch = {
'or': self.compile_or,
'and': self.compile_and,
'not': self.compile_not,
'relop': self.compile_binary_op,
'addsub': self.compile_binary_op,
'mul': self.compile_binary_op,
'divmod': self.compile_binary_op,
'pow': self.compile_binary_op,
'listop': self.compile_binary_op,
'projection': self.compile_binary_op,
'constructor': self.compile_func_call,
'varName': self.compile_var_name,
'funcCall': self.compile_func_call,
'match': self.compile_match,
'unaryMinus': self.compile_unary_minus,
'literal': self.compile_literal,
'type': self.compile_type,
}
if exptype in dispatch:
dispatch[exptype](tree, code)
else:
msg = i18n.i18n('Unknown expression: %s') % (exptype,)
area = common.position.ProgramAreaNear(tree)
raise GbsCompileException(msg, area)
def get_type_annotation(self, tree):
if hasattr(tree, 'type_annotation'):
return tree.type_annotation
else:
return None
def compile_binary_op(self, tree, code):
"Compile a binary operator expression."
type_annotation = self.get_type_annotation(tree)
self.compile_expression(tree.children[2], code)
self.compile_expression(tree.children[3], code)
code.push(('call', tree.children[1].value, 2), near=tree)
def compile_not(self, tree, code):
"Compile a boolean not expression."
self.compile_expression(tree.children[1], code)
code.push(('call', 'not', 1), near=tree)
def compile_or(self, tree, code):
"Compile a short-circuiting disjunction."
lcontinue = GbsLabel()
lend = GbsLabel()
type_annotation = self.get_type_annotation(tree)
self.compile_expression(tree.children[2], code)
code.push(('jumpIfFalse', lcontinue), near=tree)
code.push(('pushConst', lang.gbs_builtins.parse_constant('True')),
near=tree)
code.push(('jump', lend), near=tree)
code.push(('label', lcontinue), near=tree)
self.compile_expression(tree.children[3], code)
code.push(('label', lend), near=tree)
def compile_and(self, tree, code):
"Compile a short-circuiting conjunction."
lcontinue = GbsLabel()
lend = GbsLabel()
type_annotation = self.get_type_annotation(tree)
self.compile_expression(tree.children[2], code)
code.push(('jumpIfFalse', lcontinue), near=tree)
self.compile_expression(tree.children[3], code)
code.push(('jump', lend), near=tree)
code.push(('label', lcontinue), near=tree)
code.push(('pushConst', lang.gbs_builtins.parse_constant('False')),
near=tree)
code.push(('label', lend), near=tree)
def compile_unary_minus(self, tree, code):
"Compile a unary minus expression."
funcname = 'unary-'
args = tree.children[1:]
self._compile_func_call_poly(tree, funcname, args, code)
def compile_var_name(self, tree, code):
"Compile a variable name expression."
offsets = tree.children[2].children
var = tree.children[1].value
code.push(('pushFrom', var), near=tree)
if len(offsets) > 0:
self.compile_projectable_var_check(tree, code, var)
#calculate assignment reference
for offset in offsets:
self.compile_expression(offset.children[1], code)
code.push(('call', '_getRef', 2), near=tree)
code.push(('call', '_getRefValue', 1), near=tree)
def compile_func_call(self, tree, code):
"Compile a function call."
funcname = tree.children[1].value
args = tree.children[2].children
if lang.gbs_builtins.is_defined(funcname) or funcname in self.user_defined_routine_names:
self._compile_func_call_poly(tree, funcname, args, code)
else:
self._compile_field_getter(tree, funcname, args, code)
def _compile_field_getter(self, tree, field_name, args, code):
self.compile_expression(args[0], code)
field = tree.children[1]
field.type = 'symbol'
code.push(('pushConst', parse_literal(field)), near=tree)
code.push(('call', '_get_field', 2), near=tree)
def _compile_func_call_poly(self, tree, funcname, args, code):
"Compile a potentially polymorphic function call."
polys = lang.gbs_builtins.BUILTINS_POLYMORPHIC
annotate = True
annotate = annotate and funcname in polys
annotate = annotate and hasattr(tree, 'type_annotation')
annotate = annotate and isinstance(tree.type_annotation, list)
type_annotation = None
if hasattr(tree, 'type_annotation'):
type_annotation = tree.type_annotation
for i, arg in zip(range(len(args)),args):
self.compile_expression(arg, code)
if annotate:
funcname = lang.gbs_builtins.polyname(
funcname,
[repr(ann) for ann in tree.type_annotation])
code.push(('call', funcname, len(args)), near=tree)
def compile_literal(self, tree, code):
"Compile a constant expression."
tok = tree.children[1]
code.push(('pushConst', parse_literal(tok)), near=tree)
def compile_program(tree):
"Compile a full Gobstones program."
compiler = GbsCompiler()
return compiler.compile_program(tree)
| gpl-3.0 | -6,050,560,207,559,410,000 | 37.899338 | 110 | 0.548367 | false |
altair-viz/altair | altair/utils/core.py | 1 | 20886 | """
Utility routines
"""
from collections.abc import Mapping
from copy import deepcopy
import json
import itertools
import re
import sys
import traceback
import warnings
import jsonschema
import pandas as pd
import numpy as np
from .schemapi import SchemaBase, Undefined
try:
from pandas.api.types import infer_dtype as _infer_dtype
except ImportError:
# Import for pandas < 0.20.0
from pandas.lib import infer_dtype as _infer_dtype
def infer_dtype(value):
"""Infer the dtype of the value.
This is a compatibility function for pandas infer_dtype,
with skipna=False regardless of the pandas version.
"""
if not hasattr(infer_dtype, "_supports_skipna"):
try:
_infer_dtype([1], skipna=False)
except TypeError:
# pandas < 0.21.0 don't support skipna keyword
infer_dtype._supports_skipna = False
else:
infer_dtype._supports_skipna = True
if infer_dtype._supports_skipna:
return _infer_dtype(value, skipna=False)
else:
return _infer_dtype(value)
TYPECODE_MAP = {
"ordinal": "O",
"nominal": "N",
"quantitative": "Q",
"temporal": "T",
"geojson": "G",
}
INV_TYPECODE_MAP = {v: k for k, v in TYPECODE_MAP.items()}
# aggregates from vega-lite version 4.6.0
AGGREGATES = [
"argmax",
"argmin",
"average",
"count",
"distinct",
"max",
"mean",
"median",
"min",
"missing",
"product",
"q1",
"q3",
"ci0",
"ci1",
"stderr",
"stdev",
"stdevp",
"sum",
"valid",
"values",
"variance",
"variancep",
]
# window aggregates from vega-lite version 4.6.0
WINDOW_AGGREGATES = [
"row_number",
"rank",
"dense_rank",
"percent_rank",
"cume_dist",
"ntile",
"lag",
"lead",
"first_value",
"last_value",
"nth_value",
]
# timeUnits from vega-lite version 4.6.0
TIMEUNITS = [
"utcyear",
"utcquarter",
"utcmonth",
"utcday",
"utcdate",
"utchours",
"utcminutes",
"utcseconds",
"utcmilliseconds",
"utcyearquarter",
"utcyearquartermonth",
"utcyearmonth",
"utcyearmonthdate",
"utcyearmonthdatehours",
"utcyearmonthdatehoursminutes",
"utcyearmonthdatehoursminutesseconds",
"utcquartermonth",
"utcmonthdate",
"utcmonthdatehours",
"utchoursminutes",
"utchoursminutesseconds",
"utcminutesseconds",
"utcsecondsmilliseconds",
"year",
"quarter",
"month",
"day",
"date",
"hours",
"minutes",
"seconds",
"milliseconds",
"yearquarter",
"yearquartermonth",
"yearmonth",
"yearmonthdate",
"yearmonthdatehours",
"yearmonthdatehoursminutes",
"yearmonthdatehoursminutesseconds",
"quartermonth",
"monthdate",
"monthdatehours",
"hoursminutes",
"hoursminutesseconds",
"minutesseconds",
"secondsmilliseconds",
]
def infer_vegalite_type(data):
"""
From an array-like input, infer the correct vega typecode
('ordinal', 'nominal', 'quantitative', or 'temporal')
Parameters
----------
data: Numpy array or Pandas Series
"""
# Otherwise, infer based on the dtype of the input
typ = infer_dtype(data)
# TODO: Once this returns 'O', please update test_select_x and test_select_y in test_api.py
if typ in [
"floating",
"mixed-integer-float",
"integer",
"mixed-integer",
"complex",
]:
return "quantitative"
elif typ in ["string", "bytes", "categorical", "boolean", "mixed", "unicode"]:
return "nominal"
elif typ in [
"datetime",
"datetime64",
"timedelta",
"timedelta64",
"date",
"time",
"period",
]:
return "temporal"
else:
warnings.warn(
"I don't know how to infer vegalite type from '{}'. "
"Defaulting to nominal.".format(typ)
)
return "nominal"
def merge_props_geom(feat):
"""
Merge properties with geometry
* Overwrites 'type' and 'geometry' entries if existing
"""
geom = {k: feat[k] for k in ("type", "geometry")}
try:
feat["properties"].update(geom)
props_geom = feat["properties"]
except (AttributeError, KeyError):
# AttributeError when 'properties' equals None
# KeyError when 'properties' is non-existing
props_geom = geom
return props_geom
def sanitize_geo_interface(geo):
"""Santize a geo_interface to prepare it for serialization.
* Make a copy
* Convert type array or _Array to list
* Convert tuples to lists (using json.loads/dumps)
* Merge properties with geometry
"""
geo = deepcopy(geo)
# convert type _Array or array to list
for key in geo.keys():
if str(type(geo[key]).__name__).startswith(("_Array", "array")):
geo[key] = geo[key].tolist()
# convert (nested) tuples to lists
geo = json.loads(json.dumps(geo))
# sanitize features
if geo["type"] == "FeatureCollection":
geo = geo["features"]
if len(geo) > 0:
for idx, feat in enumerate(geo):
geo[idx] = merge_props_geom(feat)
elif geo["type"] == "Feature":
geo = merge_props_geom(geo)
else:
geo = {"type": "Feature", "geometry": geo}
return geo
def sanitize_dataframe(df): # noqa: C901
"""Sanitize a DataFrame to prepare it for serialization.
* Make a copy
* Convert RangeIndex columns to strings
* Raise ValueError if column names are not strings
* Raise ValueError if it has a hierarchical index.
* Convert categoricals to strings.
* Convert np.bool_ dtypes to Python bool objects
* Convert np.int dtypes to Python int objects
* Convert floats to objects and replace NaNs/infs with None.
* Convert DateTime dtypes into appropriate string representations
* Convert Nullable integers to objects and replace NaN with None
* Convert Nullable boolean to objects and replace NaN with None
* convert dedicated string column to objects and replace NaN with None
* Raise a ValueError for TimeDelta dtypes
"""
df = df.copy()
if isinstance(df.columns, pd.RangeIndex):
df.columns = df.columns.astype(str)
for col in df.columns:
if not isinstance(col, str):
raise ValueError(
"Dataframe contains invalid column name: {0!r}. "
"Column names must be strings".format(col)
)
if isinstance(df.index, pd.MultiIndex):
raise ValueError("Hierarchical indices not supported")
if isinstance(df.columns, pd.MultiIndex):
raise ValueError("Hierarchical indices not supported")
def to_list_if_array(val):
if isinstance(val, np.ndarray):
return val.tolist()
else:
return val
for col_name, dtype in df.dtypes.iteritems():
if str(dtype) == "category":
# XXXX: work around bug in to_json for categorical types
# https://github.com/pydata/pandas/issues/10778
col = df[col_name].astype(object)
df[col_name] = col.where(col.notnull(), None)
elif str(dtype) == "string":
# dedicated string datatype (since 1.0)
# https://pandas.pydata.org/pandas-docs/version/1.0.0/whatsnew/v1.0.0.html#dedicated-string-data-type
col = df[col_name].astype(object)
df[col_name] = col.where(col.notnull(), None)
elif str(dtype) == "bool":
# convert numpy bools to objects; np.bool is not JSON serializable
df[col_name] = df[col_name].astype(object)
elif str(dtype) == "boolean":
# dedicated boolean datatype (since 1.0)
# https://pandas.io/docs/user_guide/boolean.html
col = df[col_name].astype(object)
df[col_name] = col.where(col.notnull(), None)
elif str(dtype).startswith("datetime"):
# Convert datetimes to strings. This needs to be a full ISO string
# with time, which is why we cannot use ``col.astype(str)``.
# This is because Javascript parses date-only times in UTC, but
# parses full ISO-8601 dates as local time, and dates in Vega and
# Vega-Lite are displayed in local time by default.
# (see https://github.com/altair-viz/altair/issues/1027)
df[col_name] = (
df[col_name].apply(lambda x: x.isoformat()).replace("NaT", "")
)
elif str(dtype).startswith("timedelta"):
raise ValueError(
'Field "{col_name}" has type "{dtype}" which is '
"not supported by Altair. Please convert to "
"either a timestamp or a numerical value."
"".format(col_name=col_name, dtype=dtype)
)
elif str(dtype).startswith("geometry"):
# geopandas >=0.6.1 uses the dtype geometry. Continue here
# otherwise it will give an error on np.issubdtype(dtype, np.integer)
continue
elif str(dtype) in {
"Int8",
"Int16",
"Int32",
"Int64",
"UInt8",
"UInt16",
"UInt32",
"UInt64",
}: # nullable integer datatypes (since 24.0)
# https://pandas.pydata.org/pandas-docs/version/0.25/whatsnew/v0.24.0.html#optional-integer-na-support
col = df[col_name].astype(object)
df[col_name] = col.where(col.notnull(), None)
elif np.issubdtype(dtype, np.integer):
# convert integers to objects; np.int is not JSON serializable
df[col_name] = df[col_name].astype(object)
elif np.issubdtype(dtype, np.floating):
# For floats, convert to Python float: np.float is not JSON serializable
# Also convert NaN/inf values to null, as they are not JSON serializable
col = df[col_name]
bad_values = col.isnull() | np.isinf(col)
df[col_name] = col.astype(object).where(~bad_values, None)
elif dtype == object:
# Convert numpy arrays saved as objects to lists
# Arrays are not JSON serializable
col = df[col_name].apply(to_list_if_array, convert_dtype=False)
df[col_name] = col.where(col.notnull(), None)
return df
def parse_shorthand(
shorthand,
data=None,
parse_aggregates=True,
parse_window_ops=False,
parse_timeunits=True,
parse_types=True,
):
"""General tool to parse shorthand values
These are of the form:
- "col_name"
- "col_name:O"
- "average(col_name)"
- "average(col_name):O"
Optionally, a dataframe may be supplied, from which the type
will be inferred if not specified in the shorthand.
Parameters
----------
shorthand : dict or string
The shorthand representation to be parsed
data : DataFrame, optional
If specified and of type DataFrame, then use these values to infer the
column type if not provided by the shorthand.
parse_aggregates : boolean
If True (default), then parse aggregate functions within the shorthand.
parse_window_ops : boolean
If True then parse window operations within the shorthand (default:False)
parse_timeunits : boolean
If True (default), then parse timeUnits from within the shorthand
parse_types : boolean
If True (default), then parse typecodes within the shorthand
Returns
-------
attrs : dict
a dictionary of attributes extracted from the shorthand
Examples
--------
>>> data = pd.DataFrame({'foo': ['A', 'B', 'A', 'B'],
... 'bar': [1, 2, 3, 4]})
>>> parse_shorthand('name') == {'field': 'name'}
True
>>> parse_shorthand('name:Q') == {'field': 'name', 'type': 'quantitative'}
True
>>> parse_shorthand('average(col)') == {'aggregate': 'average', 'field': 'col'}
True
>>> parse_shorthand('foo:O') == {'field': 'foo', 'type': 'ordinal'}
True
>>> parse_shorthand('min(foo):Q') == {'aggregate': 'min', 'field': 'foo', 'type': 'quantitative'}
True
>>> parse_shorthand('month(col)') == {'field': 'col', 'timeUnit': 'month', 'type': 'temporal'}
True
>>> parse_shorthand('year(col):O') == {'field': 'col', 'timeUnit': 'year', 'type': 'ordinal'}
True
>>> parse_shorthand('foo', data) == {'field': 'foo', 'type': 'nominal'}
True
>>> parse_shorthand('bar', data) == {'field': 'bar', 'type': 'quantitative'}
True
>>> parse_shorthand('bar:O', data) == {'field': 'bar', 'type': 'ordinal'}
True
>>> parse_shorthand('sum(bar)', data) == {'aggregate': 'sum', 'field': 'bar', 'type': 'quantitative'}
True
>>> parse_shorthand('count()', data) == {'aggregate': 'count', 'type': 'quantitative'}
True
"""
if not shorthand:
return {}
valid_typecodes = list(TYPECODE_MAP) + list(INV_TYPECODE_MAP)
units = dict(
field="(?P<field>.*)",
type="(?P<type>{})".format("|".join(valid_typecodes)),
agg_count="(?P<aggregate>count)",
op_count="(?P<op>count)",
aggregate="(?P<aggregate>{})".format("|".join(AGGREGATES)),
window_op="(?P<op>{})".format("|".join(AGGREGATES + WINDOW_AGGREGATES)),
timeUnit="(?P<timeUnit>{})".format("|".join(TIMEUNITS)),
)
patterns = []
if parse_aggregates:
patterns.extend([r"{agg_count}\(\)"])
patterns.extend([r"{aggregate}\({field}\)"])
if parse_window_ops:
patterns.extend([r"{op_count}\(\)"])
patterns.extend([r"{window_op}\({field}\)"])
if parse_timeunits:
patterns.extend([r"{timeUnit}\({field}\)"])
patterns.extend([r"{field}"])
if parse_types:
patterns = list(itertools.chain(*((p + ":{type}", p) for p in patterns)))
regexps = (
re.compile(r"\A" + p.format(**units) + r"\Z", re.DOTALL) for p in patterns
)
# find matches depending on valid fields passed
if isinstance(shorthand, dict):
attrs = shorthand
else:
attrs = next(
exp.match(shorthand).groupdict() for exp in regexps if exp.match(shorthand)
)
# Handle short form of the type expression
if "type" in attrs:
attrs["type"] = INV_TYPECODE_MAP.get(attrs["type"], attrs["type"])
# counts are quantitative by default
if attrs == {"aggregate": "count"}:
attrs["type"] = "quantitative"
# times are temporal by default
if "timeUnit" in attrs and "type" not in attrs:
attrs["type"] = "temporal"
# if data is specified and type is not, infer type from data
if isinstance(data, pd.DataFrame) and "type" not in attrs:
if "field" in attrs and attrs["field"] in data.columns:
attrs["type"] = infer_vegalite_type(data[attrs["field"]])
return attrs
def use_signature(Obj):
"""Apply call signature and documentation of Obj to the decorated method"""
def decorate(f):
# call-signature of f is exposed via __wrapped__.
# we want it to mimic Obj.__init__
f.__wrapped__ = Obj.__init__
f._uses_signature = Obj
# Supplement the docstring of f with information from Obj
if Obj.__doc__:
doclines = Obj.__doc__.splitlines()
if f.__doc__:
doc = f.__doc__ + "\n".join(doclines[1:])
else:
doc = "\n".join(doclines)
try:
f.__doc__ = doc
except AttributeError:
# __doc__ is not modifiable for classes in Python < 3.3
pass
return f
return decorate
def update_subtraits(obj, attrs, **kwargs):
"""Recursively update sub-traits without overwriting other traits"""
# TODO: infer keywords from args
if not kwargs:
return obj
# obj can be a SchemaBase object or a dict
if obj is Undefined:
obj = dct = {}
elif isinstance(obj, SchemaBase):
dct = obj._kwds
else:
dct = obj
if isinstance(attrs, str):
attrs = (attrs,)
if len(attrs) == 0:
dct.update(kwargs)
else:
attr = attrs[0]
trait = dct.get(attr, Undefined)
if trait is Undefined:
trait = dct[attr] = {}
dct[attr] = update_subtraits(trait, attrs[1:], **kwargs)
return obj
def update_nested(original, update, copy=False):
"""Update nested dictionaries
Parameters
----------
original : dict
the original (nested) dictionary, which will be updated in-place
update : dict
the nested dictionary of updates
copy : bool, default False
if True, then copy the original dictionary rather than modifying it
Returns
-------
original : dict
a reference to the (modified) original dict
Examples
--------
>>> original = {'x': {'b': 2, 'c': 4}}
>>> update = {'x': {'b': 5, 'd': 6}, 'y': 40}
>>> update_nested(original, update) # doctest: +SKIP
{'x': {'b': 5, 'c': 4, 'd': 6}, 'y': 40}
>>> original # doctest: +SKIP
{'x': {'b': 5, 'c': 4, 'd': 6}, 'y': 40}
"""
if copy:
original = deepcopy(original)
for key, val in update.items():
if isinstance(val, Mapping):
orig_val = original.get(key, {})
if isinstance(orig_val, Mapping):
original[key] = update_nested(orig_val, val)
else:
original[key] = val
else:
original[key] = val
return original
def display_traceback(in_ipython=True):
exc_info = sys.exc_info()
if in_ipython:
from IPython.core.getipython import get_ipython
ip = get_ipython()
else:
ip = None
if ip is not None:
ip.showtraceback(exc_info)
else:
traceback.print_exception(*exc_info)
def infer_encoding_types(args, kwargs, channels):
"""Infer typed keyword arguments for args and kwargs
Parameters
----------
args : tuple
List of function args
kwargs : dict
Dict of function kwargs
channels : module
The module containing all altair encoding channel classes.
Returns
-------
kwargs : dict
All args and kwargs in a single dict, with keys and types
based on the channels mapping.
"""
# Construct a dictionary of channel type to encoding name
# TODO: cache this somehow?
channel_objs = (getattr(channels, name) for name in dir(channels))
channel_objs = (
c for c in channel_objs if isinstance(c, type) and issubclass(c, SchemaBase)
)
channel_to_name = {c: c._encoding_name for c in channel_objs}
name_to_channel = {}
for chan, name in channel_to_name.items():
chans = name_to_channel.setdefault(name, {})
key = "value" if chan.__name__.endswith("Value") else "field"
chans[key] = chan
# First use the mapping to convert args to kwargs based on their types.
for arg in args:
if isinstance(arg, (list, tuple)) and len(arg) > 0:
type_ = type(arg[0])
else:
type_ = type(arg)
encoding = channel_to_name.get(type_, None)
if encoding is None:
raise NotImplementedError("positional of type {}" "".format(type_))
if encoding in kwargs:
raise ValueError("encoding {} specified twice.".format(encoding))
kwargs[encoding] = arg
def _wrap_in_channel_class(obj, encoding):
try:
condition = obj["condition"]
except (KeyError, TypeError):
pass
else:
if condition is not Undefined:
obj = obj.copy()
obj["condition"] = _wrap_in_channel_class(condition, encoding)
if isinstance(obj, SchemaBase):
return obj
if isinstance(obj, str):
obj = {"shorthand": obj}
if isinstance(obj, (list, tuple)):
return [_wrap_in_channel_class(subobj, encoding) for subobj in obj]
if encoding not in name_to_channel:
warnings.warn("Unrecognized encoding channel '{}'".format(encoding))
return obj
classes = name_to_channel[encoding]
cls = classes["value"] if "value" in obj else classes["field"]
try:
# Don't force validation here; some objects won't be valid until
# they're created in the context of a chart.
return cls.from_dict(obj, validate=False)
except jsonschema.ValidationError:
# our attempts at finding the correct class have failed
return obj
return {
encoding: _wrap_in_channel_class(obj, encoding)
for encoding, obj in kwargs.items()
}
| bsd-3-clause | 6,587,024,043,765,292,000 | 29.269565 | 114 | 0.584123 | false |
seanbell/opensurfaces | server/photos/migrations/0011_auto__del_field_flickruser_displayname__del_field_flickruser_subname__.py | 1 | 29209 | # -*- coding: utf-8 -*-
from south.utils import datetime_utils as datetime
from south.db import db
from south.v2 import SchemaMigration
from django.db import models
class Migration(SchemaMigration):
def forwards(self, orm):
# Deleting field 'FlickrUser.displayname'
db.delete_column(u'photos_flickruser', 'displayname')
# Deleting field 'FlickrUser.subname'
db.delete_column(u'photos_flickruser', 'subname')
# Adding field 'FlickrUser.display_name'
db.add_column(u'photos_flickruser', 'display_name',
self.gf('django.db.models.fields.CharField')(default='', max_length=255, blank=True),
keep_default=False)
# Adding field 'FlickrUser.sub_name'
db.add_column(u'photos_flickruser', 'sub_name',
self.gf('django.db.models.fields.CharField')(default='', max_length=255, blank=True),
keep_default=False)
def backwards(self, orm):
# Adding field 'FlickrUser.displayname'
db.add_column(u'photos_flickruser', 'displayname',
self.gf('django.db.models.fields.CharField')(default='', max_length=255, blank=True),
keep_default=False)
# Adding field 'FlickrUser.subname'
db.add_column(u'photos_flickruser', 'subname',
self.gf('django.db.models.fields.CharField')(default='', max_length=255, blank=True),
keep_default=False)
# Deleting field 'FlickrUser.display_name'
db.delete_column(u'photos_flickruser', 'display_name')
# Deleting field 'FlickrUser.sub_name'
db.delete_column(u'photos_flickruser', 'sub_name')
models = {
u'accounts.userprofile': {
'Meta': {'object_name': 'UserProfile'},
'always_approve': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'blocked': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'blocked_reason': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'exclude_from_aggregation': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'mturk_worker_id': ('django.db.models.fields.CharField', [], {'max_length': '127', 'blank': 'True'}),
'user': ('django.db.models.fields.related.OneToOneField', [], {'related_name': "'user'", 'unique': 'True', 'primary_key': 'True', 'to': u"orm['auth.User']"})
},
u'auth.group': {
'Meta': {'object_name': 'Group'},
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': u"orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
},
u'auth.permission': {
'Meta': {'ordering': "(u'content_type__app_label', u'content_type__model', u'codename')", 'unique_together': "((u'content_type', u'codename'),)", 'object_name': 'Permission'},
'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['contenttypes.ContentType']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
u'auth.user': {
'Meta': {'object_name': 'User'},
'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'groups': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'related_name': "u'user_set'", 'blank': 'True', 'to': u"orm['auth.Group']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'related_name': "u'user_set'", 'blank': 'True', 'to': u"orm['auth.Permission']"}),
'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
},
u'contenttypes.contenttype': {
'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
u'licenses.license': {
'Meta': {'object_name': 'License'},
'added': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'cc_attribution': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'cc_no_deriv': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'cc_noncommercial': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'cc_share_alike': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'creative_commons': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'publishable': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'url': ('django.db.models.fields.URLField', [], {'max_length': '255', 'blank': 'True'})
},
u'mturk.experiment': {
'Meta': {'ordering': "['slug', 'variant']", 'unique_together': "(('slug', 'variant'),)", 'object_name': 'Experiment'},
'added': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'completed_id': ('django.db.models.fields.CharField', [], {'max_length': '32'}),
'cubam_dirty': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'examples_group_attr': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'has_tutorial': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'module': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'new_hit_settings': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'experiments'", 'null': 'True', 'to': u"orm['mturk.ExperimentSettings']"}),
'slug': ('django.db.models.fields.CharField', [], {'max_length': '32', 'db_index': 'True'}),
'template_dir': ('django.db.models.fields.CharField', [], {'default': "'mturk/experiments'", 'max_length': '255'}),
'test_contents_per_assignment': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'updated': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
'variant': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'version': ('django.db.models.fields.IntegerField', [], {'default': '1'})
},
u'mturk.experimentsettings': {
'Meta': {'object_name': 'ExperimentSettings'},
'added': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'auto_add_hits': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'auto_approval_delay': ('django.db.models.fields.IntegerField', [], {'default': '2592000'}),
'content_filter': ('django.db.models.fields.TextField', [], {'default': "'{}'"}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'experiment_settings_in'", 'to': u"orm['contenttypes.ContentType']"}),
'contents_per_hit': ('django.db.models.fields.IntegerField', [], {'default': '1'}),
'description': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'duration': ('django.db.models.fields.IntegerField', [], {'default': '1800'}),
'feedback_bonus': ('django.db.models.fields.DecimalField', [], {'null': 'True', 'max_digits': '8', 'decimal_places': '4', 'blank': 'True'}),
'frame_height': ('django.db.models.fields.IntegerField', [], {'default': '800'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'keywords': ('django.db.models.fields.CharField', [], {'max_length': '1000'}),
'lifetime': ('django.db.models.fields.IntegerField', [], {'default': '2678400'}),
'max_active_hits': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'max_total_hits': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'min_output_consensus': ('django.db.models.fields.IntegerField', [], {'default': '4'}),
'num_outputs_max': ('django.db.models.fields.IntegerField', [], {'default': '5'}),
'out_content_attr': ('django.db.models.fields.CharField', [], {'max_length': '127', 'blank': 'True'}),
'out_content_type': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'experiment_settings_out'", 'null': 'True', 'to': u"orm['contenttypes.ContentType']"}),
'out_count_ratio': ('django.db.models.fields.IntegerField', [], {'default': '1'}),
'qualifications': ('django.db.models.fields.TextField', [], {'default': "'{}'"}),
'requirements': ('django.db.models.fields.TextField', [], {'default': "'{}'"}),
'reward': ('django.db.models.fields.DecimalField', [], {'max_digits': '8', 'decimal_places': '4'}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'updated': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'})
},
u'mturk.experimenttestcontent': {
'Meta': {'ordering': "['-id']", 'object_name': 'ExperimentTestContent'},
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['contenttypes.ContentType']"}),
'experiment': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'test_contents'", 'to': u"orm['mturk.Experiment']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'object_id': ('django.db.models.fields.PositiveIntegerField', [], {}),
'priority': ('django.db.models.fields.FloatField', [], {'default': '0', 'db_index': 'True'})
},
u'mturk.mtassignment': {
'Meta': {'object_name': 'MtAssignment'},
'accept_time': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'action_log': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'added': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'approval_time': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'approve_message': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'auto_approval_time': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'bonus': ('django.db.models.fields.DecimalField', [], {'null': 'True', 'max_digits': '8', 'decimal_places': '2', 'blank': 'True'}),
'bonus_message': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'deadline': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'feedback': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'feedback_bonus_given': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'has_feedback': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'hit': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'assignments'", 'to': u"orm['mturk.MtHit']"}),
'id': ('django.db.models.fields.CharField', [], {'max_length': '128', 'primary_key': 'True'}),
'manually_rejected': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'num_test_contents': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
'num_test_correct': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
'num_test_incorrect': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
'partially_completed': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'post_data': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'post_meta': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'reject_message': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'rejection_time': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'screen_height': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
'screen_width': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
'status': ('django.db.models.fields.CharField', [], {'max_length': '1', 'null': 'True', 'blank': 'True'}),
'submission_complete': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'submit_time': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
'test_contents': ('django.db.models.fields.related.ManyToManyField', [], {'related_name': "'assignments'", 'symmetrical': 'False', 'to': u"orm['mturk.ExperimentTestContent']"}),
'time_active_ms': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
'time_load_ms': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
'time_ms': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
'updated': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
'user_agent': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'wage': ('django.db.models.fields.FloatField', [], {'null': 'True', 'blank': 'True'}),
'worker': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['accounts.UserProfile']", 'null': 'True', 'blank': 'True'})
},
u'mturk.mthit': {
'Meta': {'object_name': 'MtHit'},
'added': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'all_submitted_assignments': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'any_submitted_assignments': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'compatible_count': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'expired': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'hit_status': ('django.db.models.fields.CharField', [], {'max_length': '1', 'null': 'True', 'blank': 'True'}),
'hit_type': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'hits'", 'to': u"orm['mturk.MtHitType']"}),
'id': ('django.db.models.fields.CharField', [], {'max_length': '128', 'primary_key': 'True'}),
'incompatible_count': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'lifetime': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
'max_assignments': ('django.db.models.fields.IntegerField', [], {'default': '1'}),
'num_assignments_available': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
'num_assignments_completed': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
'num_assignments_pending': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
'num_contents': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
'out_count_ratio': ('django.db.models.fields.IntegerField', [], {'default': '1'}),
'review_status': ('django.db.models.fields.CharField', [], {'max_length': '1', 'null': 'True', 'blank': 'True'}),
'sandbox': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
'updated': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'})
},
u'mturk.mthittype': {
'Meta': {'object_name': 'MtHitType'},
'added': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'auto_approval_delay': ('django.db.models.fields.IntegerField', [], {'default': '2592000'}),
'description': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'duration': ('django.db.models.fields.IntegerField', [], {'default': '3600'}),
'experiment': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'hit_types'", 'to': u"orm['mturk.Experiment']"}),
'experiment_settings': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'hit_types'", 'to': u"orm['mturk.ExperimentSettings']"}),
'external_url': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
'feedback_bonus': ('django.db.models.fields.DecimalField', [], {'null': 'True', 'max_digits': '8', 'decimal_places': '2', 'blank': 'True'}),
'frame_height': ('django.db.models.fields.IntegerField', [], {'default': '800'}),
'id': ('django.db.models.fields.CharField', [], {'max_length': '128', 'primary_key': 'True'}),
'keywords': ('django.db.models.fields.CharField', [], {'max_length': '1000', 'blank': 'True'}),
'reward': ('django.db.models.fields.DecimalField', [], {'default': "'0.01'", 'max_digits': '8', 'decimal_places': '4'}),
'title': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'updated': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'})
},
u'photos.flickruser': {
'Meta': {'ordering': "['-id']", 'object_name': 'FlickrUser'},
'blacklisted': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'display_name': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'family_name': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'given_name': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'sub_name': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'username': ('django.db.models.fields.CharField', [], {'max_length': '127'}),
'website_name': ('django.db.models.fields.CharField', [], {'max_length': '1023', 'blank': 'True'}),
'website_url': ('django.db.models.fields.URLField', [], {'max_length': '1023', 'blank': 'True'})
},
u'photos.photo': {
'Meta': {'ordering': "['aspect_ratio', '-id']", 'object_name': 'Photo'},
'added': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'aspect_ratio': ('django.db.models.fields.FloatField', [], {'null': 'True'}),
'description': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'exif': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'flickr_id': ('django.db.models.fields.CharField', [], {'max_length': '64', 'null': 'True', 'blank': 'True'}),
'flickr_user': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'photos'", 'null': 'True', 'to': u"orm['photos.FlickrUser']"}),
'focal_y': ('django.db.models.fields.FloatField', [], {'null': 'True'}),
'fov': ('django.db.models.fields.FloatField', [], {'null': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'image_orig': ('django.db.models.fields.files.ImageField', [], {'max_length': '100'}),
'inappropriate': ('django.db.models.fields.NullBooleanField', [], {'null': 'True', 'blank': 'True'}),
'license': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'photos'", 'null': 'True', 'to': u"orm['licenses.License']"}),
'light_stack': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'photos'", 'null': 'True', 'to': u"orm['photos.PhotoLightStack']"}),
'md5': ('django.db.models.fields.CharField', [], {'max_length': '32'}),
'median_intrinsic_error': ('django.db.models.fields.FloatField', [], {'null': 'True', 'blank': 'True'}),
'nonperspective': ('django.db.models.fields.NullBooleanField', [], {'null': 'True', 'blank': 'True'}),
'num_intrinsic_comparisons': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'num_intrinsic_points': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'num_shapes': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'num_vertices': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
'orig_height': ('django.db.models.fields.IntegerField', [], {'null': 'True'}),
'orig_width': ('django.db.models.fields.IntegerField', [], {'null': 'True'}),
'rotated': ('django.db.models.fields.NullBooleanField', [], {'null': 'True', 'blank': 'True'}),
'scene_category': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'photos'", 'null': 'True', 'to': u"orm['photos.PhotoSceneCategory']"}),
'scene_category_correct': ('django.db.models.fields.NullBooleanField', [], {'null': 'True', 'blank': 'True'}),
'scene_category_correct_method': ('django.db.models.fields.CharField', [], {'max_length': '1', 'null': 'True', 'blank': 'True'}),
'scene_category_correct_score': ('django.db.models.fields.FloatField', [], {'null': 'True', 'blank': 'True'}),
'stylized': ('django.db.models.fields.NullBooleanField', [], {'null': 'True', 'blank': 'True'}),
'synthetic': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'user': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['accounts.UserProfile']"}),
'vanishing_length': ('django.db.models.fields.FloatField', [], {'null': 'True', 'blank': 'True'}),
'vanishing_lines': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'vanishing_points': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'whitebalanced': ('django.db.models.fields.NullBooleanField', [], {'null': 'True', 'blank': 'True'}),
'whitebalanced_score': ('django.db.models.fields.FloatField', [], {'null': 'True', 'blank': 'True'})
},
u'photos.photolightstack': {
'Meta': {'ordering': "['-id']", 'object_name': 'PhotoLightStack'},
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'slug': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '255'})
},
u'photos.photoscenecategory': {
'Meta': {'ordering': "['name']", 'object_name': 'PhotoSceneCategory'},
'description': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '127'}),
'parent': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['photos.PhotoSceneCategory']", 'null': 'True', 'blank': 'True'})
},
u'photos.photoscenequalitylabel': {
'Meta': {'ordering': "['photo', '-time_ms']", 'object_name': 'PhotoSceneQualityLabel'},
'added': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'correct': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'invalid': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'mturk_assignment': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'+'", 'null': 'True', 'on_delete': 'models.SET_NULL', 'to': u"orm['mturk.MtAssignment']"}),
'photo': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'scene_qualities'", 'to': u"orm['photos.Photo']"}),
'quality_method': ('django.db.models.fields.CharField', [], {'max_length': '1', 'null': 'True', 'blank': 'True'}),
'reward': ('django.db.models.fields.DecimalField', [], {'null': 'True', 'max_digits': '8', 'decimal_places': '4', 'blank': 'True'}),
'sandbox': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'time_active_ms': ('django.db.models.fields.IntegerField', [], {'db_index': 'True', 'null': 'True', 'blank': 'True'}),
'time_ms': ('django.db.models.fields.IntegerField', [], {'db_index': 'True', 'null': 'True', 'blank': 'True'}),
'user': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['accounts.UserProfile']"})
},
u'photos.photowhitebalancelabel': {
'Meta': {'ordering': "['photo', '-time_ms']", 'object_name': 'PhotoWhitebalanceLabel'},
'added': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'chroma_median': ('django.db.models.fields.FloatField', [], {'null': 'True', 'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'invalid': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'mturk_assignment': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'+'", 'null': 'True', 'on_delete': 'models.SET_NULL', 'to': u"orm['mturk.MtAssignment']"}),
'num_points': ('django.db.models.fields.IntegerField', [], {}),
'photo': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'whitebalances'", 'to': u"orm['photos.Photo']"}),
'points': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'quality_method': ('django.db.models.fields.CharField', [], {'max_length': '1', 'null': 'True', 'blank': 'True'}),
'reward': ('django.db.models.fields.DecimalField', [], {'null': 'True', 'max_digits': '8', 'decimal_places': '4', 'blank': 'True'}),
'sandbox': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'time_active_ms': ('django.db.models.fields.IntegerField', [], {'db_index': 'True', 'null': 'True', 'blank': 'True'}),
'time_ms': ('django.db.models.fields.IntegerField', [], {'db_index': 'True', 'null': 'True', 'blank': 'True'}),
'user': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['accounts.UserProfile']"}),
'whitebalanced': ('django.db.models.fields.BooleanField', [], {'default': 'False'})
}
}
complete_apps = ['photos'] | mit | 2,888,323,342,558,164,000 | 86.717718 | 209 | 0.561471 | false |
sacharya/nova | nova/api/openstack/compute/schemas/v3/flavor_access_schema.py | 1 | 1776 | # vim: tabstop=4 shiftwidth=4 softtabstop=4
#
# Copyright 2013 NEC Corporation. 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.
add_tenant_access = {
'type': 'object',
'properties': {
'add_tenant_access': {
'type': 'object',
'properties': {
'tenant_id': {
# defined from project_id in instance_type_projects table
'type': 'string', 'minLength': 1, 'maxLength': 255,
},
},
'required': ['tenant_id'],
'additionalProperties': False,
},
},
'required': ['add_tenant_access'],
'additionalProperties': False,
}
remove_tenant_access = {
'type': 'object',
'properties': {
'remove_tenant_access': {
'type': 'object',
'properties': {
'tenant_id': {
# defined from project_id in instance_type_projects table
'type': 'string', 'minLength': 1, 'maxLength': 255,
},
},
'required': ['tenant_id'],
'additionalProperties': False,
},
},
'required': ['remove_tenant_access'],
'additionalProperties': False,
}
| apache-2.0 | -7,900,809,347,432,931,000 | 31.888889 | 78 | 0.560248 | false |
msg/g2ools | nord/g2/file.py | 1 | 33799 | #!/usr/bin/env python2
#
# Copyright (c) 2006,2007 Matt Gerassimoff
#
# This file is part of g2ools.
#
# g2ools 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.
#
# g2ools 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 Foobar; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#
import string, sys
from struct import pack, unpack
import nord.g2.modules
from nord import printf
from nord.module import Module
from nord.file import hexdump, binhexdump
from nord.file import Patch, Performance, Note, Cable, Knob, Ctrl, MorphMap
from nord.g2 import modules
from nord.g2.crc import crc
from nord.g2.bits import setbits, getbits, BitStream
section_debug = 0 # outputs section debug
title_section = 0 # replace end of section with section title
NVARIATIONS = 9 # 1-8, init
NMORPHS = 8 # 8 morphs
NKNOBS = 120 # 120 knob settings
NMORPHMAPS = 25 # max morphmaps per variation
FX, VOICE, SETTINGS = 0, 1, 2
class G2Error(Exception):
'''G2Error - exception for throwing an unrecoverable error.'''
def __init__(self, value):
Exception.__init__(self)
self.value = value
def __str__(self):
return repr(self.value)
def read_string(bitstream, l, pad=False):
read_str = bitstream.read_str
if pad == True:
return read_str(l).strip('\0')
else:
s = bytearray(l)
for i in xrange(l):
s[i] = read_str(1)
if s[i] == 0:
return str(s[:i])
return str(s[:l])
def format_string(s, l, pad=False):
if len(s) < l:
s = s + '\0'
if pad == True:
s = s.ljust(l, '\0')
return s[:l] # in case the string is longer
def write_string(bitstream, s, l, pad=False):
bitstream.write_str(format_string(s, l, pad))
def get_patch_area(patch, area):
return [patch.fx, patch.voice][area]
class Section(object):
'''Section abstract class that represents a section of .pch2 file.
all sections objects have parse() and format() methods.
'''
default = [0] * (2 << 10) # max 64k section size
def __init__(self, **kw):
self.__dict__ = kw
self.data = bytearray(64<<10)
class SectionManager(object):
def add(self, class_):
self.__dict__[class_.type] = class_
def get(self, type, default=None):
return self.__dict__.get(type, default)
section_manager = SectionManager()
class Description(object):
'''Description class for patch/performance description.'''
pass
class PatchDescription(Section):
'''PatchDescription Section subclass'''
type = 0x21
description_attrs = [
['reserved', 5], ['voices', 5], ['height', 14], ['unk2', 3],
['red', 1], ['blue', 1], ['yellow', 1], ['orange', 1],
['green', 1], ['purple', 1], ['white', 1],
['monopoly', 2], ['variation', 8], ['category', 8],
]
def parse_description(self, description, bitstream):
for name, nbits in self.description_attrs:
setattr(description, name, bitstream.read_bits(nbits))
def format_description(self, description, bitstream):
for name, nbits in self.description_attrs:
bitstream.write_bits(nbits, getattr(description, name))
bitstream.write_bits(8, 0)
def parse(self, patch, data):
description = patch.description = Description() # G2Patch
bitstream = BitStream(data, 7*8)
self.parse_description(patch.description, bitstream)
def format(self, patch, data):
bitstream = BitStream(data, 7*8)
self.format_description(patch.description, bitstream)
return bitstream.tell_bit()
section_manager.add(PatchDescription)
class ModuleList(Section):
'''ModuleList Section subclass'''
type = 0x4a
# NOTE: module.leds seems to be related to a group of modules. i cannot
# see the relationship but I have got a list of modules
# that require this to be set. This will probably be handled
# without this property but added to the module types that
# set it.
# make sure leds bit is set for specific modules
# - some earlier generated .pch2 files where different
# these were emperically determined.
# NOTE2: these should be in nord/g2/modules.py
ledtypes = [
3, 4, 17, 38, 42, 48, 50, 57, 59, 60, 68, 69,
71, 75, 76, 81, 82, 83, 85,
105, 108, 112, 115, 141, 142, 143, 147, 148, 149, 150,
156, 157, 170, 171, 178, 188, 189, 198, 199, 208,
]
def fixleds(self, module):
module.leds = 0
#if module.type.id in ModuleList.ledtypes:
# module.leds = 1
#else:
# module.leds = 0
module_params = [
['index', 8 ], ['horiz', 7], ['vert', 7], ['color', 8],
['uprate', 1 ], ['leds', 1], ['reserved', 6],
]
def parse_area(self, area, bitstream):
read_bits = bitstream.read_bits
nmodules = read_bits(8)
area.modules = [ None ] * nmodules
for i in xrange(nmodules):
id = read_bits(8)
module = Module(modules.fromid(id), area)
area.modules[i] = module
for attr, nbits in self.module_params:
setattr(module, attr, read_bits(nbits))
nmodes = read_bits(4)
self.fixleds(module)
# mode data for module (if there is any)
for mode in module.modes:
mode.value = read_bits(6)
# add missing mode data. some .pch2 versions didn't contain
# all the modes in version 23 BUILD 266
module_type = module.type
if len(module.modes) < len(module_type.modes):
for mode in xrange(len(module.modes), len(module_type.modes)):
module.modes[mode].value = module_type.modes[mode].type.default
def format_area(self, area, bitstream):
write_bits = bitstream.write_bits
write_bits(2, self.area)
write_bits(8, len(area.modules))
for module in area.modules:
write_bits(8, module.type.id)
module.reserved = 0 # just in case is wasn't set
for attr, nbits in self.module_params:
bitstream.write_bits(nbits, getattr(module, attr))
self.fixleds(module)
write_bits(4, len(module.modes))
for mode in module.modes:
write_bits(6, mode.value)
def parse(self, patch, data):
bitstream = BitStream(data)
self.area = bitstream.read_bits(2)
area = get_patch_area(patch, self.area)
self.parse_area(area, bitstream)
def format(self, patch, data):
bitstream = BitStream(data)
area = get_patch_area(patch, self.area)
self.format_area(area, bitstream)
return bitstream.tell_bit()
section_manager.add(ModuleList)
class CurrentNote(Section):
'''CurrentNote Section subclass'''
type = 0x69
def parse(self, patch, data):
bitstream = BitStream(data)
lastnote = patch.lastnote = Note() # G2Patch
values = bitstream.read_bitsa([7] * 3)
lastnote.note, lastnote.attack, lastnote.release = values
nnotes = bitstream.read_bits(5) + 1
notes = patch.notes = [ Note() for i in xrange(nnotes) ] # G2Patch
for note in notes:
note.note, note.attack, note.release = bitstream.read_bitsa([7, 7, 7])
def format(self, patch, data):
bitstream = BitStream(data)
if len(patch.notes):
lastnote = patch.lastnote
if not lastnote:
values = [ 64, 0, 0 ]
else:
values = [ lastnote.note, lastnote.attack, lastnote.release ]
bitstream.write_bitsa([7, 7, 7], values)
bitstream.write_bits(5, len(patch.notes)-1)
for note in patch.notes:
bitstream.write_bitsa([7, 7, 7], [note.note, note.attack, note.release])
else:
bitstream.write_bits(24, 0x800000)
bitstream.write_bits(24, 0x200000)
return bitstream.tell_bit()
def invalid_cable(smodule, sconn, direction, dmodule, dconn):
'''invalid_cable(area, smodule, sconn, direction, dmodule, dconn) -> bool
if connection valid return 0, otherwise error.
'''
if direction == 1: # verify from
if sconn >= len(smodule.outputs): # out -> in
return 1
elif sconn >= len(smodule.inputs): # in -> in
return 2
if dconn >= len(dmodule.inputs): # verify to
return 3
return 0 # if we got here, everything's cool.
section_manager.add(CurrentNote)
class CableList(Section):
'''CableList Section subclass'''
type = 0x52
def parse_area(self, area, bitstream):
_, ncables = bitstream.read_bitsa([6, 16])
area.cables = [ None ] * ncables
for i in xrange(ncables):
cable = Cable(area)
cable.color, source, src_conn, direction, dest, dest_conn = \
bitstream.read_bitsa([3, 8, 6, 1, 8, 6])
src_module = area.find_module(source)
dest_module = area.find_module(dest)
if invalid_cable(src_module, src_conn, direction, dest_module, dest_conn):
printf('Invalid cable %d: "%s"(%d,%d) -%d-> "%s"(%d,%d)\n',
i, src_module.type.shortnm, src_module.index, src_conn, direction,
dest_module.type.shortnm, dest_module.index, dest_conn)
continue
if direction == 1:
cable.source = src_module.outputs[src_conn]
else:
cable.source = src_module.inputs[src_conn]
cable.dest = dest_module.inputs[dest_conn]
area.cables[i] = cable
cable.source.cables.append(cable)
cable.dest.cables.append(cable)
area.netlist.add(cable.source, cable.dest)
def format_area(self, area, bitstream):
bitstream.write_bitsa([2, 6, 16], [area.index, 0, len(area.cables)])
for cable in area.cables:
bitstream.write_bitsa([3, 8, 6, 1, 8, 6],
[ cable.color, cable.source.module.index, cable.source.index,
cable.source.direction, cable.dest.module.index, cable.dest.index])
def parse(self, patch, data):
bitstream = BitStream(data)
self.area = bitstream.read_bits(2)
area = get_patch_area(patch, self.area)
self.parse_area(area, bitstream)
def format(self, patch, data):
bitstream = BitStream(data)
area = get_patch_area(patch, self.area)
self.format_area(area, bitstream)
return bitstream.tell_bit()
section_manager.add(CableList)
class SettingsArea(object):
def __init__(self):
self.index = SETTINGS
self.name = 'settings'
class ParameterModule(object):
def __init__(self, area, index):
self.area = area
self.index = index
class Parameter(object):
'''Parameter class for module parameters/settings.'''
def __init__(self, area, mod_index, index, default=0, name='', module=None):
self.area = area
self.index = index
self.variations = [default]*NVARIATIONS
self.name = name
self.module = ParameterModule(area, mod_index)
self.knob = None
self.mmap = None
self.ctrl = None
class Morph(object):
'''Morph class for morph settings.'''
def __init__(self, area, index):
self.name = 'morph%d' % (index+1)
self.maps = [[] for variation in xrange(NVARIATIONS) ]
self.index = index
self.area = area
# morph "module" has 2 parameters dial and mode
self.dial = Parameter(area, 1, index, 0, name='dial')
self.mode = Parameter(area, 1, index+NMORPHS, 1, name='mode')
class Settings(object):
'''Settings class for patch settings.'''
groups = [
[ 'patchvol', 'activemuted' ],
[ 'glide', 'glidetime' ],
[ 'bend', 'semi' ],
[ 'vibrato', 'cents', 'rate' ],
[ 'arpeggiator', 'arptime', 'arptype', 'octaves' ],
[ 'octaveshift', 'sustain' ],
]
def __init__(self):
self.area = SettingsArea()
for i, group in enumerate(self.groups, 2):
for j, name in enumerate(group):
setattr(self, name, Parameter(self.area, i, j, name=name))
self.morphs = [ Morph(self.area, morph+1) for morph in xrange(NMORPHS) ]
self.morphmaps = [ [] for variation in xrange(NVARIATIONS) ]
class Parameters(Section):
'''Parameters Section subclass'''
type = 0x4d
def parse_settings(self, settings, bitstream):
read_bits = bitstream.read_bits
read_bitsa = bitstream.read_bitsa
nsections, nvariations, section, nentries = read_bitsa([8, 8, 8, 7])
# nentries: 16 parameters per variation: 8 dials, 8 modes
for i in xrange(nvariations): # usually 9
variation = read_bits(8)
for morph in settings.morphs:
dial = read_bits(7)
if variation < NVARIATIONS:
morph.dial.variations[variation] = dial
for morph in settings.morphs:
mode = read_bits(7)
if variation < NVARIATIONS:
morph.mode.variations[variation] = mode
for group in settings.groups:
section, nentries = read_bitsa([8, 7])
for i in xrange(nvariations):
variation = read_bits(8)
for entry in xrange(nentries):
value = read_bits(7)
if variation < NVARIATIONS:
getattr(settings, group[entry]).variations[variation] = value
def format_settings(self, settings, bitstream):
write_bits = bitstream.write_bits
write_bitsa = bitstream.write_bitsa
# 1 for morph--. .-- 16/var
write_bitsa([2, 8, 8, 8, 7], [SETTINGS, 7, NVARIATIONS, 1, 16])
for variation in xrange(NVARIATIONS): # morph groups
write_bits(8, variation)
for morph in settings.morphs:
write_bits(7, morph.dial.variations[variation])
for morph in settings.morphs:
write_bits(7, morph.mode.variations[variation])
section = 2 # starts at 2 (above: morph is section 1)
for group in settings.groups:
nentries = len(group)
write_bitsa([8, 7], [section, nentries])
for variation in xrange(NVARIATIONS):
write_bits(8, variation)
for entry in xrange(nentries):
value = getattr(settings, group[entry]).variations[variation]
write_bits(7, value)
section += 1
return bitstream.tell_bit()
def parse_area(self, area, bitstream):
read_bits = bitstream.read_bits
nmodules, nvariations = bitstream.read_bitsa([8, 8])
for i in xrange(nmodules):
index, nparams = bitstream.read_bitsa([8, 7])
module = area.find_module(index)
params = module.params
for i in xrange(nvariations):
variation = read_bits(8)
for param in xrange(nparams):
value = read_bits(7)
if param < len(params) and variation < NVARIATIONS:
params[param].variations[variation] = value
def format_area(self, area, bitstream):
modules = []
for module in area.modules:
try:
if not len(module.params):
continue
modules.append(module)
except:
pass
modules.sort(lambda a, b: cmp(a.index, b.index))
write_bits = bitstream.write_bits
mlen = len(modules)
bitstream.write_bitsa([2, 8], [area.index, mlen])
if mlen == 0:
write_bits(8, 0)
return bitstream.tell_bit()
write_bits(8, NVARIATIONS)
for module in modules:
write_bits(8, module.index)
params = module.params
write_bits(7, len(params))
for variation in xrange(NVARIATIONS):
write_bits(8, variation)
for param in params:
write_bits(7, param.variations[variation])
def parse(self, patch, data):
bitstream = BitStream(data)
self.area = bitstream.read_bits(2)
if self.area == SETTINGS:
patch.settings = Settings() # G2Patch
self.parse_settings(patch.settings, bitstream)
else:
area = get_patch_area(patch, self.area)
self.parse_area(area, bitstream)
def format(self, patch, data):
bitstream = BitStream(data)
if self.area == SETTINGS:
self.format_settings(patch.settings, bitstream)
else:
area = get_patch_area(patch, self.area)
self.format_area(area, bitstream)
return bitstream.tell_bit()
section_manager.add(Parameters)
def get_settings_param(patch, index, param):
if index < 2:
morph = patch.settings.morphs[param & 7]
if param < 8:
return morph.dial
else:
return morph.mode
else:
group = patch.settings.groups[index - 2]
return getattr(patch.settings, group[param])
class MorphParameters(Section):
'''MorphParameters Section subclass'''
type = 0x65
def parse(self, patch, data):
bitstream = BitStream(data)
read_bits = bitstream.read_bits
nvariations, nmorphs, _, _ = bitstream.read_bitsa([8, 4, 10, 10])
# variations seem to be 9 bytes with first nibble variation # from 0 ~ 8
# number of morph parameters starts at byte 7-bit 0 for 5-bits
morphs = patch.settings.morphs
morphmaps = patch.settings.morphmaps
for i in xrange(nvariations):
variation = read_bits(4)
bitstream.seek_bit(4 + (6*8) + 4, 1) # zeros
nmorphs = read_bits(8)
for j in xrange(nmorphs):
morph_map = MorphMap()
area, index, param, morph = bitstream.read_bitsa([2, 8, 7, 4])
morph_map.range = read_bits(8, 1)
module = get_patch_area(patch, area).find_module(index)
morph_map.param = module.params[param]
morph_map.variation = variation
morph_map.morph = morphs[morph-1]
morph_map.morph.maps[variation].append(morph_map)
morphmaps[variation].append(morph_map)
reserved = read_bits(4) # always 0
def format(self, patch, data):
bitstream = BitStream(data)
write_bits = bitstream.write_bits
bitstream.write_bitsa([8, 4, 10, 10], [ NVARIATIONS, NMORPHS, 0, 0])
# variations seem to be 9 bytes with first nibble variation # from 0 ~ 8
# number of morph parameters starts at byte 7-bit 0 for 5-bits
morphs = patch.settings.morphs
for variation in xrange(NVARIATIONS):
write_bits(4, variation)
bitstream.seek_bit(4 + (6 * 8) + 4, 1)
# collect all morph_maps of this variation into 1 array
morph_maps = []
for morph in morphs:
morph_maps.extend(morph.maps[variation])
def mod_param_index_cmp(a, b):
return cmp(a.param.module.index, b.param.module.index)
morph_maps.sort(mod_param_index_cmp)
write_bits(8, len(morph_maps))
for morph_map in morph_maps:
values = [
morph_map.param.module.area.index, morph_map.param.module.index,
morph_map.param.index, morph_map.morph.index, morph_map.range,
] # range is signed
bitstream.write_bitsa([2, 8, 7, 4, 8], values)
write_bits(4, 0) # always 0
bitstream.seek_bit(-4, 1) # remove last 4-bits
return bitstream.tell_bit()
section_manager.add(MorphParameters)
class KnobAssignments(Section):
'''KnobAssignments Section subclass'''
type = 0x62
def parse(self, patch, data):
bitstream = BitStream(data)
nknobs = bitstream.read_bits(16)
patch.knobs = [ Knob() for i in xrange(nknobs)] # G2Patch / G2Performance
for knob in patch.knobs:
knob.assigned = bitstream.read_bits(1)
if not knob.assigned:
continue
area, index, knob.isled, param = bitstream.read_bitsa([2, 8, 2, 7])
if type(patch) == Performance:
knob.slot = bitstream.read_bits(2)
perf = patch
patch = perf.slots[knob.slot].patch
else:
knob.slot = 0
if area == SETTINGS:
knob.param = get_settings_param(patch, index, param)
else:
module = get_patch_area(patch, area).find_module(index)
if module:
knob.param = module.params[param]
else:
knob.assigned = 0
continue
knob.param.knob = knob
def format(self, patch, data):
bitstream = BitStream(data)
bitstream.write_bits(16, NKNOBS)
for knob in patch.knobs:
bitstream.write_bits(1, knob.assigned)
if not knob.assigned:
continue
module = knob.param.module
bitstream.write_bitsa([2, 8, 2, 7],
[ module.area.index, module.index, knob.isled, knob.param.index ])
if type(patch) == Performance:
bitstream.write_bits(2, knob.slot)
return bitstream.tell_bit()
section_manager.add(KnobAssignments)
class CtrlAssignments(Section):
'''CtrlAssignments Section subclass'''
type = 0x60
def parse(self, patch, data):
bitstream = BitStream(data)
nctrls = bitstream.read_bits(7)
patch.ctrls = [ Ctrl() for i in xrange(nctrls)] # G2Patch? / G2Ctrl?
for ctrl in patch.ctrls:
ctrl.midicc, area, index, param = bitstream.read_bitsa([7, 2, 8, 7])
if area == SETTINGS:
ctrl.param = get_settings_param(patch, index, param)
else:
module = get_patch_area(patch, area).find_module(index)
ctrl.param = module.params[param]
ctrl.param.ctrl = ctrl
def format(self, patch, data):
bitstream = BitStream(data)
bitstream.write_bits(7, len(patch.ctrls))
for ctrl in patch.ctrls:
param = ctrl.param
bitstream.write_bitsa([7, 2, 8, 7], [ ctrl.midicc,
param.module.area.index, param.module.index, param.index ])
return bitstream.tell_bit()
section_manager.add(CtrlAssignments)
class Labels(Section):
'''Labels Section subclass'''
type = 0x5b
def parse_morphs(self, morphs, bitstream):
nentries, entry, length = bitstream.read_bitsa([8, 8, 8]) # 1, 1, 0x50
for morph in morphs:
index, morphlen, entry = bitstream.read_bytes(3)
morph.label = read_string(bitstream, 7, pad=True)
def format_morphs(self, morphs, bitstream):
bitstream.write_bits(2, SETTINGS)
bitstream.write_str('\1\1\x50')
s = bytearray([1, 1, 0])
for morph in morphs:
s[2] = 8 + morph.index
bitstream.write_str(str(s))
write_string(bitstream, morph.label, 7, pad=True)
return bitstream.tell_bit()
def parse_module(self, module, bitstream):
modlen = bitstream.read_bits(8)
if module.type.id == 121: # SeqNote
# extra editor parameters
# [0, 1, mag, 0, 1, octave]
# mag: 0=3-octaves, 1=2-octaves, 2=1-octave
# octave: 0-9 (c0-c9)
module.editmodes = bitstream.read_bytes(modlen)
else:
while modlen > 0:
stri, paramlen, parami = bitstream.read_bitsa([8, 8, 8])
modlen -= 3
param = module.params[parami]
paramlen -= 1 # decrease because we got param index
if paramlen:
param.labels = [ read_string(bitstream, 7, pad=True)
for i in xrange(paramlen / 7) ]
modlen -= paramlen
else:
param.labels = ['']
if section_debug:
printf('%d %s %d %d %s\n', module.index, module.type.shortnm,
paramlen, parami, param.labels)
def parse_area(self, area, bitstream):
read_bits = bitstream.read_bits
nmodules = read_bits(8)
for i in xrange(nmodules):
index = read_bits(8)
module = area.find_module(index)
self.parse_module(module, bitstream)
def format_module(self, module, bitstream):
s = ''
if module.type.id == 121: # SeqNote
s += str(bytearray(module.editmodes))
else:
# build up the labels and then write them
for i, param in enumerate(module.params):
if not hasattr(param, 'labels'):
continue
if section_debug:
printf('%d %s %d %d %s\n', module.index, module.type.shortnm,
7*len(param.labels), i, param.labels)
labels = [format_string(lbl, 7, pad=True) for lbl in param.labels]
ps = chr(i) + ''.join(labels)
s += chr(1)+chr(len(ps))+ps
bitstream.write_bitsa([8, 8], [module.index, len(s)])
bitstream.write_str(s)
def format_area(self, area, bitstream):
# collect all modules with parameters that have labels
modules = []
for module in area.modules:
if hasattr(module, 'params'):
for param in module.params:
if hasattr(param, 'labels'):
modules.append(module)
break
elif hasattr(module, 'editmodes'):
modules.append(module)
bitstream.write_bitsa([2, 8], [area.index, len(modules)])
for module in modules:
self.format_module(module, bitstream)
return bitstream.tell_bit()
def parse(self, patch, data):
bitstream = BitStream(data)
self.area = bitstream.read_bits(2)
if self.area == SETTINGS:
self.parse_morphs(patch.settings.morphs, bitstream)
else:
area = get_patch_area(patch, self.area)
self.parse_area(area, bitstream)
def format(self, patch, data):
bitstream = BitStream(data)
if self.area == SETTINGS:
return self.format_morphs(patch.settings.morphs, bitstream)
else:
area = get_patch_area(patch, self.area)
return self.format_area(area, bitstream)
section_manager.add(Labels)
class ModuleNames(Section):
'''ModuleNames Section subclass'''
type = 0x5a
def parse_area(self, area, bitstream):
areai, nmodules = bitstream.read_bitsa([6, 8])
for i in xrange(nmodules):
module = area.find_module(bitstream.read_bits(8))
module.name = read_string(bitstream, 16)
def parse(self, patch, data):
bitstream = BitStream(data)
self.area = bitstream.read_bits(2)
area = get_patch_area(patch, self.area)
self.parse_area(area, bitstream)
def format_area(self, area, bitstream):
bitstream.write_bitsa([2, 6, 8], [area.index, self.area, len(area.modules)])
for module in area.modules:
bitstream.write_bits(8, module.index)
write_string(bitstream, module.name, 16)
def format(self, patch, data):
bitstream = BitStream(data)
area = get_patch_area(patch, self.area)
self.format_area(area, bitstream)
return bitstream.tell_bit()
section_manager.add(ModuleNames)
class TextPad(Section):
'''TextPad Section subclass'''
type = 0x6f
def parse(self, patch, data):
patch.textpad = data
def format(self, patch, data):
bitstream = BitStream(data)
bitstream.write_str(patch.textpad)
return bitstream.tell_bit()
section_manager.add(TextPad)
class PerformanceDescription(Section):
'''PerformanceDescription Section subclass'''
type = 0x11
description_attrs = [
['unk1', 8],
['unk2', 4], ['focus', 2], [ 'unk3', 2 ],
['rangesel', 8], ['bpm', 8],
['split', 8], ['clock', 8], ['unk4', 8], ['unk5', 8],
]
slot_attrs = [
['active', 8], ['keyboard', 8], ['hold', 8], ['bank', 8 ], [ 'patch', 8 ],
['keylow', 8], ['keyhigh', 8], ['unk3', 8], ['unk4', 8], ['unk5', 8],
]
def parse(self, performance, data):
description = performance.description = Description() # G2Performance
bitstream = BitStream(data)
read_bits = bitstream.read_bits
for name, nbits in self.description_attrs:
value = read_bits(nbits)
setattr(description, name, value)
for slot in performance.slots:
slot.description = Description()
slot.name = read_string(bitstream, 16)
for name, nbits in self.slot_attrs:
value = read_bits(nbits)
setattr(slot.description, name, value)
def format(self, performance, data):
bitstream = BitStream(data)
write_bits = bitstream.write_bits
description = performance.description
for name, nbits in self.description_attrs:
write_bits(nbits, getattr(description, name))
for slot in performance.slots:
write_string(bitstream, slot.name, 16)
for name, nbits in self.slot_attrs:
write_bits(nbits, getattr(slot.description, name))
return bitstream.tell_bit()
section_manager.add(PerformanceDescription)
class GlobalKnobAssignments(KnobAssignments):
'''GlobalKnobAssignments Section subclasss'''
type = 0x5f
class Pch2File(object):
'''Pch2File(filename) - main reading/writing object for .pch2 files
this may become generic G2 file for .pch2 and .prf2 files
just by handling the performance sections (and perhaps others)
and parsing all 4 patches within the .prf2 file.
'''
patch_sections = [
PatchDescription(),
ModuleList(area=1),
ModuleList(area=0),
CurrentNote(),
CableList(area=1),
CableList(area=0),
Parameters(area=2),
Parameters(area=1),
Parameters(area=0),
MorphParameters(area=2),
KnobAssignments(),
CtrlAssignments(),
Labels(area=2),
Labels(area=1),
Labels(area=0),
ModuleNames(area=1),
ModuleNames(area=0),
TextPad(),
]
standard_text_header = '''Version=Nord Modular G2 File Format 1\r
Type=%s\r
Version=%d\r
Info=BUILD %d\r
\0''' # needs the null byte
binary_version = 23
build_version = 266
def __init__(self, filename=None):
self.type = 'Patch'
self.binary_revision = 0
self.patch = Patch(nord.g2.modules.fromname)
if filename:
self.read(filename)
def parse_section(self, section, patch_or_perf, memview):
type, l = unpack('>BH', memview[:3])
l += 3
if section_debug:
nm = section.__class__.__name__
printf('0x%02x %-25s len:0x%04x\n', type, nm, l)
printf('%s\n', binhexdump(memview[:l].tobytes()))
section.parse(patch_or_perf, memview[3:l])
return memview[l:]
def parse_patch(self, patch, memview):
memview = self.parse_section(PatchDescription(), patch, memview)
while len(memview) > 0:
type = ord(memview[0])
if type == PatchDescription.type: # prf2 concats patches
break
section_class = section_manager.get(type, None)
if not section_class:
break
memview = self.parse_section(section_class(), patch, memview)
return memview
def parse(self, memview):
return self.parse_patch(self.patch, memview)
def parse_header(self, memview, filename):
header2x = bytearray(memview[:2*len(self.standard_text_header)])
null = header2x.find('\0')
if null < 0:
raise G2Error('Invalid G2File "%s" missing null terminator.' % filename)
self.txthdr = str(header2x[:null])
self.binhdr = header2x[null+1], header2x[null+2]
if self.binhdr[0] != self.binary_version:
printf('Warning: %s version %d\n', filename, self.binhdr[0])
printf(' version %d supported. it may fail to load.\n',
self.binary_version)
return memview[null+1:] # include binhdr for crc
# read - this is where the rubber meets the road. it start here....
def read(self, filename):
self.filename = filename
self.data = bytearray(open(filename, 'rb').read())
memview = self.parse_header(memoryview(self.data), filename)
bytes = len(self.parse(memview[2:-2]))
ecrc = unpack('>H', self.data[-2:])[0]
acrc = crc(memview[:-2])
if ecrc != acrc:
printf('Bad CRC 0x%x 0x%x\n' % (ecrc, acrc))
def format_section(self, section, patch_or_perf, memview):
#print section.__class__.__name__
bits = section.format(patch_or_perf, memview[3:]) # skip type, size
bytes = (bits + 7) >> 3
# write type, size
memview[:3] = pack('>BH', section.type, bytes)
if section_debug:
nm = section.__class__.__name__
printf('0x%02x %-25s len:0x%04x\n', section.type, nm, bytes)
tbl = string.maketrans(string.ascii_lowercase, ' '*26)
nm = nm.translate(tbl).replace(' ', '')
printf('%s\n', nm)
#if title_section and len(nm) < len(f):
# f = nm+f[len(nm):]
return memview[bytes + 3:]
def format_patch(self, patch, memview):
for section in Pch2File.patch_sections:
memview = self.format_section(section, patch, memview)
return memview
def format(self, memview):
return self.format_patch(self.patch, memview)
def format_file(self):
data = bytearray(64<<10)
memview = memoryview(data)
hdr = Pch2File.standard_text_header % (self.type,
self.binary_version, self.build_version)
memview[:len(hdr)] = hdr
memview = memview[len(hdr):]
#memview = self.format_header(memview)
memview[0] = chr(self.binary_version)
memview[1] = chr(self.binary_revision)
fmemview = self.format(memview[2:])
bytes = len(memview) - len(fmemview)
data_crc = crc(memview[:bytes])
memview[bytes:bytes+2] = pack('>H', crc(memview[:bytes]))
bytes = len(data) - len(fmemview) + 2
return data[:bytes]
# write - this looks a lot easier then read ehhhh???
def write(self, filename=None):
out = open(filename, 'wb')
out.write(str(self.format_file()))
class Prf2File(Pch2File):
'''Prf2File(filename) -> load a nord modular g2 performance.'''
def __init__(self, filename=None):
self.type = 'Performance'
self.binary_revision = 1
self.performance = Performance(nord.g2.modules.fromname)
self.performance_section = PerformanceDescription()
self.globalknobs_section = GlobalKnobAssignments()
if filename:
self.read(filename)
def parse(self, memview):
performance = self.performance
performance_section = self.performance_section
globalknobs_section = self.globalknobs_section
memview = self.parse_section(performance_section, performance, memview)
for slot in performance.slots:
memview = self.parse_patch(slot.patch, memview)
memview = self.parse_section(globalknobs_section, performance, memview)
return memview
def format_performance(self, memview):
performance = self.performance
performace_section = self.performance_section
globalknobs_section = self.globalknobs_section
memview = self.format_section(performance_section, performance, memview)
for slot in performance.slots:
memview = self.format_patch(slot.patch, memview)
memview = self.format_section(globalknobs_section, performance, memview)
return memview
def format(self, memview):
return self.format_performace(memview)
if __name__ == '__main__':
prog = sys.argv.pop(0)
filename = sys.argv.pop(0)
printf('"%s"\n', filename)
pch2 = Pch2File(filename)
#pch2.write(sys.argv.pop(0))
| gpl-2.0 | -1,795,341,959,768,795,100 | 32.564052 | 80 | 0.641912 | false |
pdftables/python-pdftables-api | test/test_pdftables_api.py | 1 | 7244 | # Copyright 2016 The Sensible Code Company
#
# 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 io
import os
from tempfile import NamedTemporaryFile
import requests_mock
from unittest import TestCase
from pdftables_api import Client, APIException
class TestEnsureExtFormat(TestCase):
def test_wrong_format(self):
self.assertRaises(ValueError, Client.ensure_format_ext, 'foo.csv', 'txt')
self.assertRaises(ValueError, Client('key').dump, 'foo.pdf', 'txt')
def test_unmodified(self):
self.assertEqual(('foo.csv', 'csv'),
Client.ensure_format_ext('foo.csv', 'csv'))
self.assertEqual(('foo.xlsx', 'xlsx-multiple'),
Client.ensure_format_ext('foo.xlsx', 'xlsx-multiple'))
self.assertEqual(('foo.xlsx', 'xlsx-multiple'),
Client.ensure_format_ext('foo.xlsx', 'xlsx-multiple'))
self.assertEqual(('foo.xml', 'xml'),
Client.ensure_format_ext('foo.xml', 'xml'))
self.assertEqual(('foo.html', 'html'),
Client.ensure_format_ext('foo.html', 'html'))
def test_missing_format(self):
self.assertEqual(('foo.xlsx', 'xlsx-multiple'),
Client.ensure_format_ext('foo', None))
self.assertEqual(('foo.txt.xlsx', 'xlsx-multiple'),
Client.ensure_format_ext('foo.txt', None))
self.assertEqual(('foo.xlsx', 'xlsx-multiple'),
Client.ensure_format_ext('foo.xlsx', None))
def test_missing_ext(self):
self.assertEqual(('foo.csv', 'csv'),
Client.ensure_format_ext('foo', 'csv'))
def test_incorrect_ext(self):
self.assertEqual(('foo.txt.csv', 'csv'),
Client.ensure_format_ext('foo.txt', 'csv'))
self.assertEqual(('foo.xlsx.csv', 'csv'),
Client.ensure_format_ext('foo.xlsx', 'csv'))
def test_stdout(self):
self.assertEqual((None, 'xlsx-multiple'),
Client.ensure_format_ext(None, None))
self.assertEqual((None, 'csv'),
Client.ensure_format_ext(None, 'csv'))
class TestRequests(TestCase):
def test_successful_conversion(self):
with requests_mock.mock() as m:
m.post('https://pdftables.com/api?key=fake_key', text='xlsx output')
pdf_fo = io.BytesIO(b'pdf content')
c = Client('fake_key')
with NamedTemporaryFile(suffix="test.pdf") as tf:
filename = tf.name
tf.write(b"Hello world")
tf.file.close()
filename_out = filename.replace(".pdf", ".xlsx")
try:
s = c.convert(filename, filename_out)
with open(filename_out) as fd:
self.assertEqual(fd.read(), "xlsx output")
finally:
try:
os.unlink(filename_out)
except OSError:
pass
def test_successful_conversion_bytes(self):
with requests_mock.mock() as m:
m.post('https://pdftables.com/api?key=fake_key', content=b'xlsx output')
with NamedTemporaryFile(suffix="test.pdf") as tf:
filename = tf.name
tf.write(b"Hello world")
tf.file.close()
output = Client('fake_key').convert(filename)
self.assertEqual(b'xlsx output', output)
def test_successful_conversion_string(self):
with requests_mock.mock() as m:
m.post('https://pdftables.com/api?key=fake_key', text='csv output')
with NamedTemporaryFile(suffix="test.pdf") as tf:
filename = tf.name
tf.write(b"Hello world")
tf.file.close()
output = Client('fake_key').convert(filename, out_format="csv")
self.assertEqual('csv output', output)
def test_different_api_url(self):
with requests_mock.mock() as m:
m.post('http://example.com/api?key=fake_key', text='xlsx output')
pdf_fo = io.BytesIO(b'pdf content')
c = Client('fake_key', api_url='http://example.com/api')
s = c.dump(pdf_fo, 'csv')
self.assertEqual(b'xlsx output', consume(s))
def test_missing_api_key(self):
with requests_mock.mock() as m:
m.post('https://pdftables.com/api?key=fake_key', text='xlsx output')
pdf_fo = io.BytesIO(b'pdf content')
c = Client('')
self.assertRaisesRegexp(APIException, 'Invalid API key', c.dump, pdf_fo, 'csv')
def test_invalid_format(self):
with requests_mock.mock() as m:
m.post('https://pdftables.com/api?key=fake_key', text='xlsx output')
pdf_fo = io.BytesIO(b'pdf content')
c = Client('fake_key')
self.assertRaisesRegexp(ValueError, 'Invalid output format', c.dump, pdf_fo, 'invalid_format')
def test_remaining(self):
with requests_mock.mock() as m:
m.get('https://pdftables.com/api/remaining?key=fake_key', text='8584')
c = Client('fake_key')
self.assertEqual(c.remaining(), 8584)
def test_response_invalid_format(self):
with requests_mock.mock() as m:
m.post('https://pdftables.com/api?key=fake_key', status_code=400)
pdf_fo = io.BytesIO(b'pdf content')
c = Client('fake_key')
self.assertRaisesRegexp(APIException, 'Unknown file format', c.dump, pdf_fo)
def test_response_unauthorized(self):
with requests_mock.mock() as m:
m.post('https://pdftables.com/api?key=wrong_key', status_code=401)
pdf_fo = io.BytesIO(b'pdf content')
c = Client('wrong_key')
self.assertRaisesRegexp(APIException, 'Unauthorized API key', c.dump, pdf_fo)
def test_response_limit_exceeded(self):
with requests_mock.mock() as m:
m.post('https://pdftables.com/api?key=fake_key', status_code=402)
pdf_fo = io.BytesIO(b'pdf content')
c = Client('fake_key')
self.assertRaisesRegexp(APIException, 'Usage limit exceeded', c.dump, pdf_fo)
def test_response_unknown_file_format(self):
with requests_mock.mock() as m:
m.post('https://pdftables.com/api?key=fake_key', status_code=403)
png_fo = io.BytesIO(b'png content')
c = Client('fake_key')
self.assertRaisesRegexp(APIException, 'Unknown format requested', c.dump, png_fo)
def consume(s):
r = b''
for chunk in s:
r += chunk
return r
| bsd-3-clause | -621,245,369,902,256,800 | 37.531915 | 106 | 0.576615 | false |
rossant/spiky | spiky/colors.py | 1 | 2971 | import numpy as np
# from matplotlib.colors import hsv_to_rgb, rgb_to_hsv
__all__ = ['COLORMAP', 'HIGHLIGHT_COLORMAP', 'COLORS', 'COLORS_COUNT', 'generate_colors']
# Color creation routines
# -----------------------
def hue(H):
H = H.reshape((-1, 1))
R = np.abs(H * 6 - 3) - 1;
G = 2 - np.abs(H * 6 - 2);
B = 2 - np.abs(H * 6 - 4);
return np.clip(np.hstack((R,G,B)), 0, 1)
def hsv_to_rgb(HSV):
a = HSV[:,1].reshape((-1, 1))
b = HSV[:,2].reshape((-1, 1))
a = np.tile(a, (1, 3))
b = np.tile(b, (1, 3))
return ((hue(HSV[:,0]) - 1) * a + 1) * b
def generate_hsv(n0=20):
H = np.linspace(0., 1., n0)
i = np.arange(n0)
H = H[~((i==5) | (i==7) | (i==10) | (i==12) | (i==15) |(i==17) | (i==18) | (i==19))]
# H = H[((i==15) |(i==17) | (i==18) | (i==19))]
H = np.repeat(H, 4)
n = len(H)
S = np.ones(n)
V = np.ones(n)
# change V for half of the colors
V[1::2] = .75
# change S for half of the colors
S[2::4] = .75
S[3::4] = .75
hsv = np.zeros((n, 3))
hsv[:,0] = H
hsv[:,1] = S
hsv[:,2] = V
return hsv
# Global variables with all colors
# --------------------------------
# generate a list of RGB values for each color
hsv = generate_hsv()
hsv = np.clip(hsv, 0, 1)
# hsv = hsv.reshape((1, -1, 3))
COLORS = hsv_to_rgb(hsv)
COLORS = np.clip(COLORS, 0, 1)
COLORS_COUNT = len(COLORS)
step = 17 # needs to be prime with COLORS_COUNT
perm = np.mod(np.arange(0, step * 24, step), 24)
perm = np.hstack((2 * perm, 2 * perm + 1))
COLORMAP = COLORS[perm, ...]
# COLORMAP = np.array(COLORS)
# Highlight color map
# rgb = COLORMAP.reshape((1, -1, 3))
# hsv = rgb_to_hsv(rgb)
# decrease saturation, increase value
hsv[:,1] -= .5
hsv[:,2] += .5
hsv = np.clip(hsv, 0, 1)
hsv = hsv[perm, ...]
HIGHLIGHT_COLORMAP = hsv_to_rgb(hsv)
def generate_colors(n=None):
if n is None:
n = COLORS_COUNT
if n < COLORS_COUNT:
return COLORS[:n]
else:
return [COLORS[i % COLORS_COUNT] for i in xrange(n)]
if __name__ == "__main__":
def hsv_rect(hsv, coords):
col = hsv_to_rgb(hsv)
col = np.clip(col, 0, 1)
rgb_rect(col, coords)
def rgb_rect(rgb, coords):
x0, y0, x1, y1 = coords
a = 2./len(rgb)
c = np.zeros((len(rgb), 4))
c[:,0] = np.linspace(x0, x1-a, len(rgb))
c[:,1] = y0
c[:,2] = np.linspace(x0+a, x1, len(rgb))
c[:,3] = y1
rectangles(coordinates=c, color=rgb)
from galry import *
figure(constrain_navigation=False)
rgb_rect(COLORMAP, (-1,0,1,1))
rgb_rect(HIGHLIGHT_COLORMAP, (-1,-1,1,0))
ylim(-1,1)
show()
# hsv = generate_hsv()
# hsv_rect(hsv, (-1,0,1,1))
# highlight
# hsv[:,1] -= 0.5 # white -> color
# hsv[:,2] += 0.5 # black -> white
# hsv[:,1] -= 0.25 # white -> color
# hsv[:,2] += 0.5 # black -> white
# hsv_rect(hsv, (-1,-1,1,0)) | bsd-3-clause | -7,645,004,919,115,126,000 | 23.97479 | 89 | 0.499159 | false |
foxmask/django-th | django_th/management/commands/read.py | 1 | 1331 | #!/usr/bin/env python
# coding: utf-8
from __future__ import unicode_literals
from concurrent.futures import ThreadPoolExecutor
# django
from django.conf import settings
from django.core.management.base import BaseCommand
from django.db.models import Q
# trigger happy
from django_th.models import TriggerService
from django_th.read import Read
from logging import getLogger
# create logger
logger = getLogger('django_th.trigger_happy')
class Command(BaseCommand):
help = 'Trigger all the services and put them in cache'
def handle(self, *args, **options):
"""
get all the triggers that need to be handled
"""
from django.db import connection
connection.close()
failed_tries = settings.DJANGO_TH.get('failed_tries', 10)
trigger = TriggerService.objects.filter(
Q(provider_failed__lte=failed_tries) |
Q(consumer_failed__lte=failed_tries),
status=True,
user__is_active=True,
provider__name__status=True,
consumer__name__status=True,
).select_related('consumer__name', 'provider__name')
with ThreadPoolExecutor(max_workers=settings.DJANGO_TH.get('processes')) as executor:
r = Read()
for t in trigger:
executor.submit(r.reading, t)
| bsd-3-clause | 6,266,242,189,755,051,000 | 31.463415 | 93 | 0.6574 | false |
jmesteve/saas3 | openerp/addons_extra/l10n_es_payment_order/wizard/converter.py | 1 | 5200 | # -*- coding: utf-8 -*-
##############################################################################
#
# OpenERP, Open Source Management Solution
# Copyright (c) 2006 ACYSOS S.L. (http://acysos.com) All Rights Reserved.
# Pedro Tarrafeta <[email protected]>
# Copyright (c) 2008 Pablo Rocandio. All Rights Reserved.
# Copyright (c) 2009 Zikzakmedia S.L. (http://zikzakmedia.com) All Rights Reserved.
# Jordi Esteve <[email protected]>
# Copyright (c) 2009 NaN (http://www.nan-tic.com) All Rights Reserved.
# Albert Cervera i Areny <[email protected]>
# $Id$
# Refactorización. Acysos S.L. (http://www.acysos.com) 2012
# Ignacio Ibeas <[email protected]>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero 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 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/>.
#
##############################################################################
from openerp.osv import osv, fields
from openerp.tools.translate import _
from log import *
class payment_converter_spain(osv.osv):
_name= 'payment.converter.spain'
_auto = False
def digits_only(self, cr, uid, cc_in):
"""Discards non-numeric chars"""
cc = ""
for i in cc_in or '':
try:
int(i)
cc += i
except ValueError:
pass
return cc
def to_ascii(self, cr, uid, text):
"""Converts special characters such as those with accents to their ASCII equivalents"""
old_chars = ['á','é','í','ó','ú','à','è','ì','ò','ù','ä','ë','ï','ö','ü','â','ê','î','ô','û','Á','É','Í','Ú','Ó','À','È','Ì','Ò','Ù','Ä','Ë','Ï','Ö','Ü','Â','Ê','Î','Ô','Û','ñ','Ñ','ç','Ç','ª','º','·','\n']
new_chars = ['a','e','i','o','u','a','e','i','o','u','a','e','i','o','u','a','e','i','o','u','A','E','I','U','O','A','E','I','O','U','A','E','I','O','U','A','E','I','O','U','n','N','c','C','a','o','.',' ']
for old, new in zip(old_chars, new_chars):
text = text.replace(unicode(old,'UTF-8'), new)
return text
def convert_text(self, cr, uid, text, size, justified='left'):
if justified == 'left':
return self.to_ascii(cr,uid,text)[:size].ljust(size)
else:
return self.to_ascii(cr,uid,text)[:size].rjust(size)
def convert_float(self, cr, uid, number, size, context):
text = str( int( round( number * 100, 0 ) ) )
if len(text) > size:
raise Log(_('Error:\n\nCan not convert float number %(number).2f to fit in %(size)d characters.') % {
'number': number,
'size': size
})
return text.zfill(size)
def convert_int(self, cr, uid, number, size, context):
text = str( number )
if len(text) > size:
raise Log( _('Error:\n\nCan not convert integer number %(number)d to fit in %(size)d characters.') % {
'number': number,
'size': size
})
return text.zfill(size)
def convert(self, cr, uid, value, size, context, justified='left'):
if value == False:
return self.convert_text(cr, uid, '', size)
elif isinstance(value, float):
return self.convert_float(cr, uid, value, size, context)
elif isinstance(value, int):
return self.convert_int(cr, uid, value, size, context)
else:
return self.convert_text(cr, uid, value, size, justified)
def convert_bank_account(self, cr, uid, value, partner_name, context):
if not isinstance(value, basestring):
raise Log( _('User error:\n\nThe bank account number of %s is not defined.') % partner_name )
ccc = self.digits_only(cr, uid, value)
if len(ccc) != 20:
raise Log( _('User error:\n\nThe bank account number of %s does not have 20 digits.') % partner_name )
return ccc
def bank_account_parts(self, cr, uid, value, partner_name, context):
if not isinstance(value, basestring):
raise Log( _('User error:\n\nThe bank account number of %s is not defined.') % partner_name )
ccc = self.digits_only(cr, uid, value)
if len(ccc) != 20:
raise Log( _('User error:\n\nThe bank account number of %s does not have 20 digits.') % partner_name )
return {'bank':ccc[:4],
'office': ccc[4:8],
'dc': ccc[8:10],
'account': ccc[10:]}
payment_converter_spain()
| agpl-3.0 | -6,711,844,283,154,323,000 | 44.59292 | 214 | 0.542508 | false |
veblush/PyAuParser | sample/tutorial2.py | 1 | 1053 | import os
import sys
import pyauparser
def main():
g = pyauparser.Grammar.load_file("data/operator.egt")
# every production has a lambda handler which evaluates value from childs.
# Because LALR is a bottom-up parser, handler would be called from bottom.
h = pyauparser.ProductionHandler({
'<E> ::= <E> + <M>': lambda c: c[0] + c[2],
'<E> ::= <E> - <M>': lambda c: c[0] - c[2],
'<E> ::= <M>': lambda c: c[0],
'<M> ::= <M> * <N>': lambda c: c[0] * c[2],
'<M> ::= <M> / <N>': lambda c: c[0] / c[2],
'<M> ::= <N>': lambda c: c[0],
'<N> ::= - <V>': lambda c: -c[1],
'<N> ::= <V>': lambda c: c[0],
'<V> ::= Num': lambda c: int(c[0].lexeme),
'<V> ::= ( <E> )': lambda c: c[1],
}, g)
try:
pyauparser.parse_string(g, "-2*(3+4)-5", handler=h)
print "Result = {0}".format(h.result)
except pyauparser.ParseError as e:
print e
if __name__ == "__main__":
main()
| mit | 3,278,430,495,155,954,700 | 30.90625 | 78 | 0.449193 | false |
mattcaldwell/djangopypi | userpypi/migrations/0001_initial.py | 1 | 10447 | # encoding: utf-8
import datetime
from south.db import db
from south.v2 import SchemaMigration
from django.db import models
class Migration(SchemaMigration):
def forwards(self, orm):
# Adding model 'Classifier'
db.create_table('userpypi_classifier', (
('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
('name', self.gf('django.db.models.fields.CharField')(unique=True, max_length=255)),
))
db.send_create_signal('userpypi', ['Classifier'])
# Adding model 'Project'
db.create_table('userpypi_project', (
('updated', self.gf('django.db.models.fields.DateTimeField')(auto_now=True, blank=True)),
('license', self.gf('django.db.models.fields.TextField')(blank=True)),
('metadata_version', self.gf('django.db.models.fields.CharField')(default=1.0, max_length=64)),
('author', self.gf('django.db.models.fields.CharField')(max_length=128, blank=True)),
('home_page', self.gf('django.db.models.fields.URLField')(max_length=200, null=True, blank=True)),
('description', self.gf('django.db.models.fields.TextField')(blank=True)),
('download_url', self.gf('django.db.models.fields.CharField')(max_length=200, null=True, blank=True)),
('summary', self.gf('django.db.models.fields.TextField')(blank=True)),
('author_email', self.gf('django.db.models.fields.CharField')(max_length=255, blank=True)),
('owner', self.gf('django.db.models.fields.related.ForeignKey')(related_name='projects', to=orm['auth.User'])),
('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
('name', self.gf('django.db.models.fields.CharField')(unique=True, max_length=255)),
))
db.send_create_signal('userpypi', ['Project'])
# Adding M2M table for field classifiers on 'Project'
db.create_table('userpypi_project_classifiers', (
('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
('project', models.ForeignKey(orm['userpypi.project'], null=False)),
('classifier', models.ForeignKey(orm['userpypi.classifier'], null=False))
))
db.create_unique('userpypi_project_classifiers', ['project_id', 'classifier_id'])
# Adding model 'Release'
db.create_table('userpypi_release', (
('upload_time', self.gf('django.db.models.fields.DateTimeField')(auto_now=True, blank=True)),
('md5_digest', self.gf('django.db.models.fields.CharField')(max_length=255, blank=True)),
('filetype', self.gf('django.db.models.fields.CharField')(max_length=255, blank=True)),
('pyversion', self.gf('django.db.models.fields.CharField')(max_length=255, blank=True)),
('project', self.gf('django.db.models.fields.related.ForeignKey')(related_name='releases', to=orm['userpypi.Project'])),
('platform', self.gf('django.db.models.fields.CharField')(max_length=255, blank=True)),
('version', self.gf('django.db.models.fields.CharField')(max_length=128)),
('signature', self.gf('django.db.models.fields.CharField')(max_length=128, blank=True)),
('distribution', self.gf('django.db.models.fields.files.FileField')(max_length=100)),
('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
))
db.send_create_signal('userpypi', ['Release'])
# Adding unique constraint on 'Release', fields ['project', 'version', 'platform', 'distribution', 'pyversion']
db.create_unique('userpypi_release', ['project_id', 'version', 'platform', 'distribution', 'pyversion'])
def backwards(self, orm):
# Deleting model 'Classifier'
db.delete_table('userpypi_classifier')
# Deleting model 'Project'
db.delete_table('userpypi_project')
# Removing M2M table for field classifiers on 'Project'
db.delete_table('userpypi_project_classifiers')
# Deleting model 'Release'
db.delete_table('userpypi_release')
# Removing unique constraint on 'Release', fields ['project', 'version', 'platform', 'distribution', 'pyversion']
db.delete_unique('userpypi_release', ['project_id', 'version', 'platform', 'distribution', 'pyversion'])
models = {
'auth.group': {
'Meta': {'object_name': 'Group'},
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'blank': 'True'})
},
'auth.permission': {
'Meta': {'unique_together': "(('content_type', 'codename'),)", 'object_name': 'Permission'},
'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
},
'auth.user': {
'Meta': {'object_name': 'User'},
'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True', 'blank': 'True'}),
'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'blank': 'True'}),
'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
},
'contenttypes.contenttype': {
'Meta': {'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
},
'userpypi.classifier': {
'Meta': {'object_name': 'Classifier'},
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '255'})
},
'userpypi.project': {
'Meta': {'object_name': 'Project'},
'author': ('django.db.models.fields.CharField', [], {'max_length': '128', 'blank': 'True'}),
'author_email': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'classifiers': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['userpypi.Classifier']"}),
'description': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'download_url': ('django.db.models.fields.CharField', [], {'max_length': '200', 'null': 'True', 'blank': 'True'}),
'home_page': ('django.db.models.fields.URLField', [], {'max_length': '200', 'null': 'True', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'license': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'metadata_version': ('django.db.models.fields.CharField', [], {'default': '1.0', 'max_length': '64'}),
'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '255'}),
'owner': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'projects'", 'to': "orm['auth.User']"}),
'summary': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'updated': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'})
},
'userpypi.release': {
'Meta': {'unique_together': "(('project', 'version', 'platform', 'distribution', 'pyversion'),)", 'object_name': 'Release'},
'distribution': ('django.db.models.fields.files.FileField', [], {'max_length': '100'}),
'filetype': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'md5_digest': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'platform': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'project': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'releases'", 'to': "orm['userpypi.Project']"}),
'pyversion': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
'signature': ('django.db.models.fields.CharField', [], {'max_length': '128', 'blank': 'True'}),
'upload_time': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
'version': ('django.db.models.fields.CharField', [], {'max_length': '128'})
}
}
complete_apps = ['userpypi']
| bsd-3-clause | -2,172,781,878,352,863,500 | 67.281046 | 139 | 0.577965 | false |
tecan/xchat-rt | plugins/scripts/ss-autoaway.py | 1 | 2072 | #!/usr/bin/env python
#
# screensaverAutoAway.py - X-Chat script to monitor for the DBUS message
# emitted when the screensaver is activated and de-activated and set the user
# away.
#
# To install:
# o Copy this file to your ~/.xchat2/ directory and it will be loaded on startup.
# o To load without restart, run: /py load screensaverAutoAway.py
# (If you don't want to put it in your ~/.xchat2, then specify the full path.)
#
# If running the '/py' command above results in a message 'py :Unknown command',
# then you do not have the Python plugin installed.
# Written by Wil Cooley <[email protected]>
# Began 26 Aug 2008
#
# $Id$
#todo idle sensor
import dbus
from dbus.mainloop.glib import DBusGMainLoop
try:
import xchat
except ImportError:
# Allow for external tests
pass
__author__ = 'Wil Cooley <wcooley at nakedape.cc>'
__module_name__ = 'screensaverAutoAway'
__module_version__ = '0.2'
__module_description__ = 'Sets user away when the GNOME screensaver is activated'
def screensaver_changed(state):
''' Called when screensaver stops or starts
state is either:
- True: Screensaver activated
- False: Screensaver deactivated
'''
if state:
set_away()
else:
set_back()
def set_away():
away_msg = '%s (Auto-away by %s, version %s)' % \
(xchat.get_prefs('away_reason'),
__module_name__ ,
__module_version__)
if xchat.get_info('away') is None:
xchat.command('away ' + away_msg)
def set_back():
if xchat.get_info('away') is not None:
xchat.command('back')
def setup_session():
DBusGMainLoop(set_as_default=True)
sesbus = dbus.SessionBus()
sesbus.add_signal_receiver(screensaver_changed,
'SessionIdleChanged', 'org.mate.ScreenSaver')
if __name__ == '__main__':
setup_session()
xchat.prnt('%s version %s by %s loaded' % \
(__module_name__, __module_version__, __author__) )
| gpl-2.0 | 1,878,460,759,486,318,300 | 27.383562 | 82 | 0.615347 | false |
Bajoo/client-pc | bajoo/filesync/task_builder.py | 1 | 5313 | # -*- coding: utf-8 -*-
from ..index.folder_node import FolderNode
from ..index.hints import DeletedHint, DestMoveHint, SourceMoveHint
from ..index.hint_builder import HintBuilder
from .added_local_files_task import AddedLocalFilesTask
from .added_remote_files_task import AddedRemoteFilesTask
from .folder_task import FolderTask
from .moved_local_files_task import MovedLocalFilesTask
from .removed_local_files_task import RemovedLocalFilesTask
from .removed_remote_files_task import RemovedRemoteFilesTask
class TaskBuilder(object):
"""Create sync task by acquiring node and release node when task is done.
A task is created from the node, depending of the node's type and its
state (new or existing node, type of hints).
When the task has been executed, it can release the reserved node(s).
A task can reserve several nodes, by example when there is a "Move" hint.
"""
@classmethod
def build_from_node(cls, local_container, node):
"""Create the best suited sync task for the target node.
The type of task will depends of the type of node and the hints set by
external events.
After this call, the node is not yet acquired. `acquire_from_task()`
should be called before executing the task.
Note:
- This method must be called with the IndexTree's lock acquired.
Args:
local_container (LocalContainer): container owning the node.
node (BaseNode): node to sync.
Returns:
Task: sync task, executable by the filesync service.
"""
container = local_container.container
node_path = node.get_full_path()
if isinstance(node, FolderNode):
task = FolderTask(local_container, node)
else:
if node.local_hint:
if isinstance(node.local_hint, DestMoveHint):
node = node.local_hint.source_node
node_path = node.get_full_path()
if isinstance(node.local_hint, SourceMoveHint):
dest_path = node.local_hint.dest_node.get_full_path()
task = MovedLocalFilesTask(container,
(node_path, dest_path,),
local_container)
elif isinstance(node.local_hint, DeletedHint):
task = RemovedLocalFilesTask(container, (node_path,),
local_container)
else: # ModifiedHint
task = AddedLocalFilesTask(container, (node_path,),
local_container)
elif node.remote_hint:
if isinstance(node.remote_hint, DestMoveHint):
node = node.remote_hint.source_node
node_path = node.get_full_path()
# if isinstance(node.remote_hint, SourceMoveHint):
# # TODO: no support for remove Move events.
# dest_path = node.remote_hint.dest_node.get_full_path()
if isinstance(node.remote_hint, DeletedHint):
task = RemovedRemoteFilesTask(container, (node_path,),
local_container)
else: # ModifiedHint
task = AddedRemoteFilesTask(container, (node_path,),
local_container)
else:
task = AddedLocalFilesTask(container, (node_path,),
local_container)
return task
@classmethod
def acquire_from_task(cls, node, task):
"""Acquire the node and all related nodes used by the task.
For most of the tasks, only the primary node is acquired. If there are
some "Move" hints, hint pairs can be split in (Deleted, Modified)
couple.
If the task is of type "MovedLocalFilesTask", both source and
destination nodes are acquired by the task.
Note:
- This method must be called with the IndexTree's lock acquired.
- After an acquisition, nodes's hints are reset to None. If they
are needed by the task, they should be copied before that.
Args:
node (BaseNode): primary target of the task.
task: sync task that will take care of the node(s).
"""
if isinstance(task, MovedLocalFilesTask):
HintBuilder.break_coupled_hints(node, HintBuilder.SCOPE_REMOTE)
if isinstance(node.local_hint, SourceMoveHint):
# acquire destination node
dest_node = node.local_hint.dest_node
dest_node.task = task
dest_node.remote_hint = None
dest_node.local_hint = None
else:
# acquire source node
source_node = node.local_hint.source_node
source_node.task = task
source_node.remote_hint = None
source_node.local_hint = None
else:
HintBuilder.break_coupled_hints(node)
# acquire target node
node.task = task
node.remote_hint = None
node.local_hint = None
| gpl-3.0 | -5,430,126,019,375,362,000 | 41.166667 | 78 | 0.576699 | false |
lord63/wangyi_music_top100 | crawler/database.py | 1 | 1097 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
crawler/database.py
~~~~~~~~~~~~~~~~~~~
provide some convenient ways to get data and communicate with
the redis server
"""
from __future__ import absolute_import
from datetime import datetime
from crawler import config
class Database(object):
def __init__(self):
self.redis = config.redis_server
def set_update_time(self):
self.redis.set('wangyi:latest_update',
datetime.strftime(datetime.now(), '%Y-%m-%d %H:%M:%S'))
@property
def songlists(self):
return self.redis.lrange('wangyi:songlists', 0, -1)
@property
def comments_ranklist(self):
return self.redis.lrange('wangyi:ranklist:comments', 0, -1)
@property
def palys_ranklist(self):
return self.redis.lrange('wangyi:ranklist:plays', 0, -1)
@property
def favourites_ranklist(self):
return self.redis.lrange('wangyi:ranklist:favourites', 0, -1)
@property
def shares_ranklist(self):
return self.redis.lrange('wangyi:ranklist:shares', 0, -1)
| mit | -4,058,596,468,989,847,000 | 23.377778 | 78 | 0.625342 | false |
maximz/cooperate-without-looking | src/cwl.py | 1 | 24981 | # -*- coding: utf-8 -*-
"""Module cwl.
Produces simulation calculation and figures for the Cooperate With/Without Looking project.
Usage:
python cwl.py {recalculate?}
Examples:
python cwl.py run using pre-calculated saved data
python cwl.py recalculate run with freshly calculated data
@author: Maxim Zaslavsky <[email protected]>
@author: Erez Yoeli <[email protected]>
"""
### GENERAL
# system imports
import sys, os
import numpy as np
import matplotlib
matplotlib.use("pdf") # save as PDFs
import matplotlib.pyplot as plt
from scipy.integrate import odeint
from collections import defaultdict
from random import sample as random_sample
from math import floor
import cPickle as pickle
# Choose whether to recalculate or to used saved data
Calculate = False
if __name__ == "__main__":
try:
if sys.argv[1] == 'recalculate':
Calculate = True
except: # Interactive mode
pass
output_dir = '../bin/'
print 'Welcome to the CW(O)L Simulations and Figures toolkit.'
print
#######################################################
#######################################################
# Game theory methods
def are_assumptions_valid(a, b, c1, c2, d, p, w):
#P1 and P2 prefer a cooperative interaction to no interaction
statement_1 = a > 0 and b > 0
#P1 gets short-term gains from defection
statement_2 = c1 > a and c2 > a
#P2 2 doesn't want to interact with 1 if he expects 1 to defect in either game.
statement_3 = b * p + d * (1 - p) < 0 and d * p + b * (1 - p) < 0
#wlog it is more tempting to defect in state 2.
statement_4 = c2 > c1
#all of this must hold
return statement_1 and statement_2 and statement_3 and statement_4
def get_game_population_1(a, b, c1, c2, d, p, w):
"""
Game for population 1 of CWL
"""
if not are_assumptions_valid(a, b, c1, c2, d, p, w):
raise ValueError("This parameters do not comply with assumptions")
A = np.empty(shape=(4, 3))
A[0, 0] = (a * p + a * (1.0 - p)) / (1.0 - w)
A[0, 1] = (a * p + a * (1.0 - p)) / (1.0 - w)
A[0, 2] = (a * p + a * (1.0 - p))
A[1, 0] = (a * p + a * (1.0 - p))
A[1, 1] = (a * p + a * (1.0 - p)) / (1 - w)
A[1, 2] = (a * p + a * (1.0 - p))
A[2, 0] = (a * p + c2 * (1.0 - p))
A[2, 1] = (a * p + c2 * (1.0 - p)) / (1 - p * w)
A[2, 2] = (a * p + c2 * (1.0 - p))
A[3, 0] = (c1 * p + c2 * (1.0 - p))
A[3, 1] = (c1 * p + c2 * (1.0 - p))
A[3, 2] = (c1 * p + c2 * (1.0 - p))
return A
def get_game_population_2(a, b, c1, c2, d, p, w):
"""
Game for population 2 of CWL
"""
if not are_assumptions_valid(a, b, c1, c2, d, p, w):
raise ValueError("This parameters do not comply with assumptions")
B = np.empty(shape=(4, 3))
B[0, 0] = (b * p + b * (1.0 - p)) / (1.0 - w)
B[0, 1] = (b * p + b * (1.0 - p)) / (1.0 - w)
B[0, 2] = (b * p + b * (1.0 - p))
B[1, 0] = (b * p + b * (1.0 - p))
B[1, 1] = (b * p + b * (1.0 - p)) / (1.0 - w)
B[1, 2] = (b * p + b * (1.0 - p))
B[2, 0] = (b * p + d * (1.0 - p))
B[2, 1] = (b * p + d * (1.0 - p)) / (1.0 - p * w)
B[2, 2] = (b * p + d * (1.0 - p))
B[3, 0] = (d * p + d * (1.0 - p))
B[3, 1] = (d * p + d * (1.0 - p))
B[3, 2] = (d * p + d * (1.0 - p))
return B.T
# replicator
def __replicator_equation_two_populations(x, t, game1, game2, number__of_strategies_population_1, number__of_strategies_population_2):
"""
This auxiliary function codes the replicator dynamics step. Typically it is only called from replicator_trajectory_two_populations()
Parameters
----------
x: ndarray initial state (concatenated from the two populations)
t: time
game1: ndarray, game for population 1
game2: ndarray, game for population 2
number__of_strategies_population_1: int
number__of_strategies_population_2: int
Returns:
out: ndarray next state (concatenated from the two populations)
"""
x_population_1 = x[0:number__of_strategies_population_1]
#the first piece of y corresponds to population 1
x_population_2 = x[number__of_strategies_population_1:number__of_strategies_population_1 + number__of_strategies_population_2] # the second piece of y corresponds to population 2
#First Ay
fitness_vector_1 = np.dot(game1, x_population_2)
# and Bx (see equation above)
fitness_vector_2 = np.dot(game2, x_population_1)
#Now xAy
average_fitness_1 = np.dot(x_population_1, fitness_vector_1)
#And yBx
average_fitness_2 = np.dot(x_population_2, fitness_vector_2)
#the next lines correspond to equations 10.5 and 10.6 of Hofbauer and Sigmund (page 116)
new_population_1 = x_population_1 * (fitness_vector_1 - average_fitness_1)
new_population_2 = x_population_2 * (fitness_vector_2 - average_fitness_2)
return np.array(new_population_1.tolist() + new_population_2.tolist())
def replicator_trajectory_two_populations(game_matrix_1, game_matrix_2, x_0, y_0, t_vector, **kwargs):
"""
Computes a replicator trajectory for two populations, given two games, starting points and time vector.
It uses scipy's odeint.
Parameters
----------
game_matrix_1: numpy matrix (for population 1)
game_matrix_2: numpy matrix (for population 2)
x_0: ndarray
y_0: ndarray
t_vector: time array
Returns
-------
out: list
Examples
--------
#TODO: Write examples
"""
#join initial populations to fit signature of replicator_equation
start = np.array(x_0.tolist() + y_0.tolist())
number__of_strategies_population_1 = len(x_0)
number__of_strategies_population_2 = len(y_0)
#solve
soln = odeint(__replicator_equation_two_populations, start, t_vector, args=(game_matrix_1, game_matrix_2, number__of_strategies_population_1, number__of_strategies_population_2), **kwargs)
return [soln[:, i] for i in xrange(number__of_strategies_population_1 + number__of_strategies_population_2)]
def get_random_point_inside_simplex(dimension):
"""
Returns a vector that sums up to one, where components have been uniformly chosen.
Parameters:
----------
dimension:int
"""
exponencial = np.random.exponential(size=dimension)
exponencial /= np.sum(exponencial, dtype=float)
return exponencial
def adjusted_solution(a, b, c1, c2, d, p, w, x_0, y_0, max_t, **kwargs):
"""
Returns a steady state, by ajusting dynamically the step size and total error.
"""
tolerance = 1e-4
added_factor_vector = [10.0, 20.0, 50.0, 100.0]
game_1 = get_game_population_1(a, b, c1, c2, d, p, w)
game_2 = get_game_population_2(a, b, c1, c2, d, p, w)
t = np.linspace(0.0, max_t, 2000)
if x_0 is None or y_0 is None:
(x_0, y_0) = (get_random_point_inside_simplex(4), get_random_point_inside_simplex(3))
for added_factor in added_factor_vector:
sol = replicator_trajectory_two_populations(added_factor + game_1, added_factor + game_2, x_0, y_0, t, atol=tolerance, **kwargs)
end_point = [sol[i][-1] for i in xrange(0, 7)]
if np.allclose(sum(end_point), 2.0, atol=tolerance):
return end_point
raise ValueError("Numerics: x = {}, y = {}, a = {}, b = {}, c1 = {}, c2 = {}, d = {}, p = {}, w = {}".format(x_0.tolist(), y_0.tolist(), a, b, c1, c2, d, p, w))
def determine_outcome(solution):
tolerance = 1e-3
if not np.allclose(np.sum(solution), 2.0, atol=tolerance):
raise ValueError("Probabilities don't add up: {} ".format(solution))
elif player1_CWOL(solution, atol=tolerance) and player2_sometimes_exits_if_looks_or_defects(solution, atol=tolerance):
return (1, solution)
elif player1_alwaysD(solution, atol=tolerance) and (player2_pure_strategy(solution, atol=tolerance) or player2_mixes(solution, atol=tolerance)):
return (2, solution)
elif player2_exitifdefect(solution, atol=tolerance) and (player1_CWOL(solution, atol=tolerance) or player1_CWL(solution, atol=tolerance) or player1_CWOL_or_CWL(solution, atol=tolerance)):
return (3, solution)
else:
return (4, solution)
def determine_random_outcome(a, b, c1, c2, d, p, w, max_t, **kwargs):
"""
Starting in a random point tries to determine the outcome, given parameters.
This is the main function to be called from montecarlo procedures
"""
x_0 = get_random_point_inside_simplex(4)
y_0 = get_random_point_inside_simplex(3)
solution = adjusted_solution(a, b, c1, c2, d, p, w, x_0, y_0, max_t)
return determine_outcome(solution)
def montecarlo(a, b, c1, c2, d, p, w, max_t=300, repetitions=5000):
"""
Takes samples for a given point in the space. Counting the occurrences
of different outcomes, and returns them in a dictionary with the
following indexes:
1 - Outcome 1
2 - Outcome 2
3 - Outcome 3
4 - No categorized
"""
ans = defaultdict(int)
sum_of_solution = np.zeros(7)
for i in xrange(0, repetitions):
try:
outcome, solution = determine_random_outcome(a, b, c1, c2, d, p, w, max_t)
ans[outcome] = ans[outcome]+1
sum_of_solution += solution
except ValueError, e:
print e
ans[5] = ans[5] + 1
avg_of_solution = sum_of_solution/repetitions
return (ans, sum_of_solution)
#--------- THEORY CHECKING FUNCTIONS ----------
def is_coop_wihtout_looking_an_equilibrium(a, b, c1, c2, d, p, w):
return c1*p+c2*(1.0 - p) < a / (1.0 - w)
def is_coop_looking_an_equilibrium(a, b, c1, c2, d, p, w):
return c2 < a / (1.0 - w)
def number_of_equlibria(a, b, c1, c2, d, p, w):
CWOL = is_coop_wihtout_looking_an_equilibrium(a, b, c1, c2, d, p, w)
CWL = is_coop_looking_an_equilibrium(a, b, c1, c2, d, p, w)
if CWOL and CWL:
return 3
elif CWOL or CWOL:
return 2
else:
return 1
#--- classifier functions
def player1_CWOL(solution, atol=1e-3):
player1_plays_desired_pure_strategy = np.allclose(solution[0], 1.0, atol)
return player1_plays_desired_pure_strategy
def player1_CWL(solution, atol=1e-3):
player1_plays_desired_pure_strategy = np.allclose(solution[1], 1.0, atol)
return player1_plays_desired_pure_strategy
def player1_Cin1(solution, atol=1e-3):
player1_plays_desired_pure_strategy = np.allclose(solution[2], 1.0, atol)
return player1_plays_desired_pure_strategy
def player1_alwaysD(solution, atol=1e-3):
player1_plays_desired_pure_strategy = np.allclose(solution[3], 1.0, atol)
return player1_plays_desired_pure_strategy
def player1_pure_strategy(solution, atol=1e-3):
return (player1_CWOL(solution, atol) or player1_CWL(solution, atol) or player1_Cin1(solution, atol) or player1_alwaysD(solution, atol))
def player1_CWOL_or_CWL(solution, atol=1e-3):
#solution[0:1] is now solution[0:2]
player1_mixes_CWL_CWOL = np.allclose(np.sum(solution[0:2]), 1.0, atol)
return player1_mixes_CWL_CWOL and not player1_pure_strategy(solution, atol)
def player1_mixes(solution, atol=1e-3):
#solution[0:3] is now solution[0:4]
player1_mixes = np.allclose(np.sum(solution[0:4]), 1.0, atol)
return player1_mixes and not player1_pure_strategy(solution, atol)
def player2_exitiflook(solution, atol=1e-3):
player2_plays_desired_pure_strategy = np.allclose(solution[4], 1.0, atol)
return player2_plays_desired_pure_strategy
def player2_exitifdefect(solution, atol=1e-3):
player2_plays_desired_pure_strategy = np.allclose(solution[5], 1.0, atol)
return player2_plays_desired_pure_strategy
def player2_alwaysexit(solution, atol=1e-3):
player2_plays_desired_pure_strategy = np.allclose(solution[6], 1.0, atol)
return player2_plays_desired_pure_strategy
def player2_pure_strategy(solution, atol=1e-3):
return (player2_exitifdefect(solution, atol=1e-3) or player2_exitiflook(solution, atol=atol) or player2_alwaysexit(solution, atol=atol))
def player2_mixes(solution, atol=1e-3):
#solution[4:6] is now changed to solution[4:7], please verify.
player2_mixes = np.allclose(np.sum(solution[4:7]), 1.0, atol)
return player2_mixes and not player2_pure_strategy(solution, atol=atol)
def player2_sometimes_exits_if_looks_or_defects(solution, atol=1e-3):
player2_sometimes_exits_if_looks = not np.allclose(solution[4], 0.0, atol)
player2_sometimes_exits_if_defects = not np.allclose(solution[5], 0.0, atol)
return player2_sometimes_exits_if_looks or player2_sometimes_exits_if_defects
# Additioanl plot beautifier functions:
def summarize_binary_list(lista):
"""
#determines edges of sequences of 1's in a binary list
"""
ans = []
x_0 = None
tamano = len(lista)
for i in xrange(tamano):
if lista[i] == 1 and x_0 is None:
x_0 = i
end_of_sequence = lista[i] == 0
end_of_array = i == (tamano-1) and lista[i] == 1
if (end_of_sequence or end_of_array) and x_0 is not None:
if end_of_sequence:
ans.append((x_0, i-1))
if end_of_array:
ans.append((x_0, i))
x_0 = None
return ans
#######################################################
#######################################################
### FIGURE 2 PREPARATION
def clear_past_figs():
plt.close()
plt.clf()
plt.cla()
plt.close()
#del f, fig_all
#gc.collect()
def export_graph(f_i, f_name):
#f_i.savefig(output_dir+f_name+'.png',dpi=300)
#f_i.savefig(output_dir+f_name+'.png',dpi=600)
f_i.savefig(output_dir+f_name+'.pdf', dpi=600) # This one looks the best
print f_name, 'exported as pdf at 600 dpi.' # 300dpi_png, 600dpi_png,
# Figure 2B and 2C calculations:
print 'Calculating or loading values for Figure 2B and Figure 2C'
p = 0.5 + 0.01
b = 1.0
c1 = 4.0
c2 = 12.0
d = -10.0
w = 7.0/8.0 + 0.02
repetitions = 10000
number_of_points = 50
if Calculate:
a_interval = np.linspace(0.0+0.1, 2.0, number_of_points, endpoint=False)
a_interval_tight = np.linspace(0.0+0.1, 2.0, number_of_points) # TODO: change to 300?
#lets plot the theory predictions first as a shade
calculated_equilibria=[number_of_equlibria(a, b, c1, c2, d, p, w) for a in a_interval_tight]
one_equilibrium_region = summarize_binary_list([ce == 1 for ce in calculated_equilibria])
two_equilibria_region = summarize_binary_list([ce == 2 for ce in calculated_equilibria])
three_equilibria_region = summarize_binary_list([ce == 3 for ce in calculated_equilibria])
#first the sampling
outcome_1 = []
outcome_2 = []
outcome_3 = []
outcome_4 = []
no_outcome = []
strategy_1 = []
strategy_2 = []
strategy_3 = []
strategy_4 = []
strategy_5 = []
strategy_6 = []
strategy_7 = []
for a in a_interval_tight: # TODO: should this be a_interval?
diccionario, avg_strategy_frequency = montecarlo(a, b, c1, c2, d, p, w, repetitions=repetitions)
outcome_1.append(diccionario[1])
outcome_2.append(diccionario[2])
outcome_3.append(diccionario[3])
outcome_4.append(diccionario[4])
no_outcome.append(diccionario[5])
strategy_1.append(avg_strategy_frequency[0])
strategy_2.append(avg_strategy_frequency[1])
strategy_3.append(avg_strategy_frequency[2])
strategy_4.append(avg_strategy_frequency[3])
strategy_5.append(avg_strategy_frequency[4])
strategy_6.append(avg_strategy_frequency[5])
strategy_7.append(avg_strategy_frequency[6])
stuff = [a_interval, a_interval_tight, one_equilibrium_region, two_equilibria_region, three_equilibria_region, outcome_1, outcome_2, outcome_3, outcome_4, no_outcome, strategy_1, strategy_2, strategy_3, strategy_4, strategy_5, strategy_6, strategy_7]
pickle.dump( stuff, open( output_dir+"Figure 2_B and C_strategy frequency.saved_data", "wb" ) )
else:
(a_interval, a_interval_tight, one_equilibrium_region, two_equilibria_region, three_equilibria_region, outcome_1, outcome_2, outcome_3, outcome_4, no_outcome, strategy_1, strategy_2, strategy_3, strategy_4, strategy_5, strategy_6, strategy_7) = pickle.load(open(output_dir+"Figure 2_B and C_strategy frequency.saved_data", "r"))
# Plotting:
clear_past_figs()
def process_ax(ax):
'''
Shades figure to correspond to equilibria regions.
'''
# hack to fill white space in the middle:
midpoint = (a_interval_tight[one_equilibrium_region[0][1]] + a_interval_tight[two_equilibria_region[0][0]])/2
midpoint1 = (a_interval_tight[two_equilibria_region[0][1]] + a_interval_tight[three_equilibria_region[0][0]])/2
for dupla in one_equilibrium_region:
#ax.axvspan(p_interval_tight[dupla[0]], p_interval_tight[dupla[1]], facecolor='red', alpha=0.2)
ax.axvspan(a_interval_tight[dupla[0]], midpoint, facecolor='white', alpha=1) # red, alpha=0.2
print 'one', dupla, a_interval_tight[dupla[0]], a_interval_tight[dupla[1]]
for dupla in two_equilibria_region:
#ax.axvspan(p_interval_tight[dupla[0]], p_interval_tight[dupla[1]], facecolor='blue', alpha=0.2)
ax.axvspan(midpoint, midpoint1, facecolor='0.50', alpha=0.2) # blue or .80
print 'two', dupla, a_interval_tight[dupla[0]], a_interval_tight[dupla[1]]
for dupla in three_equilibria_region:
ax.axvspan(midpoint1, a_interval_tight[dupla[1]], facecolor='0.10', alpha=0.2) # yellow or .20
print 'three', dupla, a_interval_tight[dupla[0]], a_interval_tight[dupla[1]]
avoid_end = -1 # remove last 1 point
#######################################################
#######################################################
### PLOT FIGURE 2(B): Frequency vs. a-value
print
print 'Plotting Figure 2B'
clear_past_figs()
f = plt.figure(figsize=(10,10))
process_ax(f.gca())
plt.plot(a_interval[:avoid_end], (np.array(outcome_1)/(float(repetitions)-np.array(no_outcome)))[:avoid_end], 'bo-', label='Cooperate without looking')
plt.plot(a_interval[:avoid_end], (np.array(outcome_2)/(float(repetitions)-np.array(no_outcome)))[:avoid_end], 'ro-', label='Always defect')
plt.plot(a_interval[:avoid_end], (np.array(outcome_3)/(float(repetitions)-np.array(no_outcome)))[:avoid_end], 'yo-', label='Cooperate with looking')
plt.plot(a_interval[:avoid_end], (np.array(outcome_4)/(float(repetitions)-np.array(no_outcome)))[:avoid_end], 'ko-', label='Other')
plt.grid()
plt.legend(loc='best')
plt.ylim((-0.01, 1.01))
plt.xlim((a_interval[0]-0.01, a_interval[-1]+0.01))
plt.xlabel('a')
plt.ylabel('Frequency')
plt.title('Frequency vs a')
export_graph(f, 'Figure_2B')
#######################################################
#######################################################
### PLOT FIGURE 2(C): Average frequency of strategies for players 1 and 2
print
print 'Plotting Figure 2C'
clear_past_figs()
fig_all, (ax1, ax2) = plt.subplots(2,1, sharex=False, sharey=False) # make 2x1 grid of subplots
fig_all.set_size_inches(10, 15)
#plt.subplots_adjust(wspace=0.30, hspace=0.15)
#prepare plots
for ax in (ax1, ax2):
ax.grid()
ax.legend(loc='best')
ax.set_ylim((-0.01, 1.01))
ax.set_xlim((a_interval[0]-0.01, a_interval[-1]+0.01))
ax.set_xlabel('a')
ax.set_ylabel('Frequency')
process_ax(ax)
plt.tight_layout()
#player1
ax1.plot(a_interval[:avoid_end], (np.array(strategy_1)/(float(repetitions)-np.array(no_outcome)))[:avoid_end], 'bo-', label='P1 CWOL')
ax1.plot(a_interval[:avoid_end], (np.array(strategy_2)/(float(repetitions)-np.array(no_outcome)))[:avoid_end], 'ro-', label='P1 CWL')
ax1.plot(a_interval[:avoid_end], (np.array(strategy_3)/(float(repetitions)-np.array(no_outcome)))[:avoid_end], 'yo-', label='P1 C in 1')
ax1.plot(a_interval[:avoid_end], (np.array(strategy_4)/(float(repetitions)-np.array(no_outcome)))[:avoid_end], 'ko-', label='P1 All D')
ax1.set_title('Average Frequency of Strategies - Player 1')
ax1.legend(loc='best')
#player2
ax2.plot(a_interval[:avoid_end], (np.array(strategy_5)/(float(repetitions)-np.array(no_outcome)))[:avoid_end], 'co-', label='P2 Exit if Look')
ax2.plot(a_interval[:avoid_end], (np.array(strategy_6)/(float(repetitions)-np.array(no_outcome)))[:avoid_end], 'mo-', label='P2 Exit if Defect')
ax2.plot(a_interval[:avoid_end], (np.array(strategy_7)/(float(repetitions)-np.array(no_outcome)))[:avoid_end], 'go-', label='P2 Always Exit')
ax2.set_title('Average Frequency of Strategies - Player 2')
ax2.legend(loc='best')
fig_all.tight_layout()
export_graph(fig_all, 'Figure_2C')
#######################################################
#######################################################
### PLOT FIGURE 2(A): Player 1 and 2 strategy replicator trajectories from single simulation run
print
print 'Calculating or loading values for Figure 2A'
# Decide which a-values to use and plot.
def get_a_value_from_interval(bounds):
for (bound_x, bound_y) in bounds:
i_chosen = int(floor((bound_x+bound_y)/2.0))
yield a_interval_tight[i_chosen]
a_selected = list(get_a_value_from_interval([one_equilibrium_region[0], two_equilibria_region[0], three_equilibria_region[0]]))
# This setup supports having multiple columns, i.e. one column for each a-value.
# The below is currently configured to hide all but the second column - however, we could easily disable this to return to all-column view, simply by commenting out the following line:
a_selected = a_selected[1:2]
print 'Using these a-values:', a_selected
# Randomly seed strategy frequencies:
if Calculate:
tolerance_current=1e-2 # previously, 1e-3. arbitrary designation.
x_0 = get_random_point_inside_simplex(4) # random frequency
y_0 = get_random_point_inside_simplex(3) # random frequency
t_vector = np.linspace(0.0, 30.0, 1000) # time values
parameters_saved = [x_0, y_0, t_vector, tolerance_current, b, c1, c2, d, p, w] # a_selected is not necessary
pickle.dump( parameters_saved, open( output_dir+"Figure 2_A_single simulation run of strategy replicator trajectories.saved_data", "wb" ) )
else: # load previous working version
(x_0, y_0, t_vector, tolerance_current, b, c1, c2, d, p, w) = pickle.load(open(output_dir+"Figure 2_A_single simulation run of strategy replicator trajectories.saved_data", "r"))
# Begin plot:
print
print 'Plotting Figure 2A'
clear_past_figs()
fig_all, ax_arr = plt.subplots(2,len(a_selected), sharex=False, sharey=False, figsize=(10,20)) # make 2 rows x 3 columns grid of subplots; (30, 20) size when 3x2
for i in range(len(a_selected)):
if len(a_selected) == 1: # Treat situation differently based on whether we are conmparing a-values or not.
(ax_p1, ax_p2) = (ax_arr[0], ax_arr[1])
else:
(ax_p1, ax_p2) = (ax_arr[0,i], ax_arr[1,i])
a_cur = a_selected[i]
solution = replicator_trajectory_two_populations(get_game_population_1(a_cur, b, c1, c2, d, p, w), get_game_population_2(a_cur, b, c1, c2, d, p, w), x_0, y_0, t_vector, atol=tolerance_current)
for ax in (ax_p1, ax_p2):
ax.set_ylim((-0.1, 1.1))
ax.set_xlim(0,10)
ax.set_ylabel('Frequency')
ax.set_xlabel('Time')
ax.grid(True)
ax_p1.plot(t_vector, solution[0], 'b-', label='P1 C wout looking', linewidth=2.0)
ax_p1.plot(t_vector, solution[1], 'g-', label='P1 Observe and C', linewidth=2.0)
ax_p1.plot(t_vector, solution[2], 'y-', label='P1 Observe and C only if 1 is chosen', linewidth=2.0)
ax_p1.plot(t_vector, solution[3], 'r-', label='P1 ALLD', linewidth=2.0)
ax_p2.plot(t_vector, solution[4], 'm--', label='P2 Continue iff P1 C wout looking', linewidth=2.0)
ax_p2.plot(t_vector, solution[5], 'y--', label='P2 Continue iff P1 C', linewidth=2.0)
ax_p2.plot(t_vector, solution[6], 'r--', label='P2 Exit', linewidth=2.0)
ax_p1.set_title('Player 1 Strategies') # 'Player 1. a = '+str(a_cur)+'.'
ax_p2.set_title('Player 2 Strategies') # 'Player 2. a = '+str(a_cur)+'.'
ax_p1.legend(loc='best')
ax_p2.legend(loc='best')
#fig_all.suptitle('Single simulation run, replicator trajectory; tolerance = '+str(tolerance_current)+'.', fontsize=24)
fig_all.tight_layout()
fig_all.subplots_adjust(top=0.85)
# fig_all.show()
export_graph(fig_all, 'Figure_2A')
#######################################################
#######################################################
print
print 'CW(O)L Simulation Calculations and Figures Complete.'
| mit | -9,027,010,238,727,414,000 | 38.818627 | 332 | 0.616148 | false |
walkr/cryex | cryex/coins/poloniex.py | 1 | 2638 | POLONIEX_REPAIRS = {
"1cr": "1CR",
"aby": "ABY",
"adn": "ADN",
"amp": "AMP",
"arch": "ARCH",
"bbr": "BBR",
"bcn": "BCN",
"bcy": "BCY",
"bela": "BELA",
"bitcny": "BITCNY",
"bits": "BITS",
"bitusd": "BITUSD",
"blk": "BLK",
"block": "BLOCK",
"btcd": "BTCD",
"btm": "BTM",
"bts": "BTS",
"burst": "BURST",
"c2": "C2",
"cga": "CGA",
"clam": "CLAM",
"cnmt": "CNMT",
"cure": "CURE",
"dash": "DASH",
"dgb": "DGB",
"diem": "DIEM",
"doge": "DOGE",
"emc2": "EMC2",
"eth": "ETH",
"exe": "EXE",
"exp": "EXP",
"fct": "FCT",
"fibre": "FIBRE",
"fldc": "FLDC",
"flo": "FLO",
"flt": "FLT",
"gap": "GAP",
"gemz": "GEMZ",
"geo": "GEO",
"gmc": "GMC",
"grc": "GRC",
"grs": "GRS",
"huc": "HUC",
"hyp": "HYP",
"hz": "HZ",
"index": "INDEX",
"ioc": "IOC",
"lqd": "LQD",
"ltbc": "LTBC",
"ltc": "LTC",
"maid": "MAID",
"mcn": "MCN",
"mil": "MIL",
"mint": "MINT",
"mmc": "MMC",
"mmnxt": "MMNXT",
"mrs": "MRS",
"myr": "MYR",
"naut": "NAUT",
"nav": "NAV",
"nbt": "NBT",
"neos": "NEOS",
"nmc": "NMC",
"nobl": "NOBL",
"note": "NOTE",
"noxt": "NOXT",
"nsr": "NSR",
"nxt": "NXT",
"omni": "OMNI",
"piggy": "PIGGY",
"pink": "PINK",
"pot": "POT",
"ppc": "PPC",
"pts": "PTS",
"qbk": "QBK",
"qora": "QORA",
"qtl": "QTL",
"rads": "RADS",
"rby": "RBY",
"rdd": "RDD",
"ric": "RIC",
"sc": "SC",
"sdc": "SDC",
"silk": "SILK",
"sjcx": "SJCX",
"str": "STR",
"swarm": "SWARM",
"sync": "SYNC",
"sys": "SYS",
"unity": "UNITY",
"via": "VIA",
"vrc": "VRC",
"vtc": "VTC",
"wdc": "WDC",
"xbc": "XBC",
"xc": "XC",
"xch": "XCH",
"xcn": "XCN",
"xcp": "XCP",
"xcr": "XCR",
"xdn": "XDN",
"xdp": "XDP",
"xem": "XEM",
"xmg": "XMG",
"xmr": "XMR",
"xpb": "XPB",
"xpm": "XPM",
"xrp": "XRP",
"xst": "XST",
"xvc": "XVC",
"yacc": "YACC",
}
def update():
new_pairs = {}
# Add *_BTC pair
for down, up in POLONIEX_REPAIRS.items():
new_key = '_'.join((down, 'btc'))
new_value = '_'.join(('BTC', up))
new_pairs[new_key] = new_value
# Add *_USD pair
for down in ['btc', 'eth', 'ltc', 'xmr', 'dash', 'xrp', 'nxt', 'str']:
up = down.upper()
new_key = '_'.join((down, 'usd'))
new_value = '_'.join(('USDT', up))
new_pairs[new_key] = new_value
POLONIEX_REPAIRS.update(new_pairs)
update()
| mit | 6,310,330,788,044,527,000 | 18.686567 | 74 | 0.392722 | false |
chrislit/abydos | tests/fingerprint/test_fingerprint_occurrence.py | 1 | 1890 | # Copyright 2018-2020 by Christopher C. Little.
# This file is part of Abydos.
#
# Abydos 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.
#
# Abydos 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 Abydos. If not, see <http://www.gnu.org/licenses/>.
"""abydos.tests.fingerprint.test_fingerprint_occurrence.
This module contains unit tests for abydos.fingerprint.Occurrence
"""
import unittest
from abydos.fingerprint import Occurrence
class OccurrenceFingerprintTestCases(unittest.TestCase):
"""Test Cisłak & Grabowski's occurrence fingerprint functions.
abydos.fingerprint.Occurrence
"""
fp = Occurrence()
def test_occurrence_fingerprint(self):
"""Test abydos.fingerprint.Occurrence."""
# Base case
self.assertEqual(self.fp.fingerprint(''), '0' * 16)
# https://arxiv.org/pdf/1711.08475.pdf
self.assertEqual(self.fp.fingerprint('instance'), '1110111000010000')
self.assertEqual(self.fp.fingerprint('inst'), '0100111000000000')
self.assertEqual(
Occurrence(15).fingerprint('instance'), '111011100001000'
)
self.assertEqual(
Occurrence(32).fingerprint('instance'),
'11101110000100000000000000000000',
)
self.assertEqual(
Occurrence(64).fingerprint('instance'),
'11101110000100000000000000000000' + '0' * 32,
)
if __name__ == '__main__':
unittest.main()
| gpl-3.0 | 6,633,291,817,443,212,000 | 31.568966 | 77 | 0.692959 | false |
Droriel/python_training | generator/contact.py | 1 | 7547 | # -*- coding: utf-8 -*-
import random
import string
from model.contact import PersonalData, PhoneNumbers, Emails, Www, AdditionalData, Notes, ContactBaseData, \
ContactAllData, BirthDate, AnniversaryDate
import jsonpickle
import os.path
import sys
import getopt
try:
opts, args=getopt.getopt(sys.argv[1:], 'n:f:', ['number of contacts', 'file'])
except getopt.GetoptError as err:
getopt.usage()
sys.exit(2)
n = 5
f = 'data/contacts.json'
for o, a in opts:
if o == '-n':
n = int(a)
elif o == '-f':
f = a
def random_string(maxlen):
symbols = string.ascii_letters + ' '*13 + '-'*3 + '_'*3
# + "'"*3
return ''.join([random.choice(symbols) for i in range(random.randrange(maxlen))])
def random_string_with_new_line(prefix, maxlen):
symbols = string.ascii_letters + string.digits + ' '*15 + '\n'*5 + '-'*3 + '_'*3
# + string.punctuation
return prefix + ''.join([random.choice(symbols) for i in range(random.randrange(maxlen))])
def random_email(maxlen):
symbols = string.ascii_letters + '-' * 3 + '_' * 3
return ''.join([random.choice(symbols) for i in range(random.randrange(maxlen+5))]) + '@' +\
''.join([random.choice(symbols) for i in range(random.randrange(maxlen))]) + '.' +\
''.join([random.choice(string.ascii_letters) for i in range(random.randrange(2,4))])
def random_phone_number(maxlen):
symbols = str(string.digits) * 4 + '('+ ')' + '+' + '-' + ' '
return ''.join([random.choice(symbols) for i in range(random.randrange(maxlen))])
def random_www(maxlen):
symbols = string.ascii_letters + '-'
return 'www.' + ''.join([random.choice(symbols) for i in range(random.randrange(maxlen))]) + '.'+\
''.join([random.choice(string.ascii_letters) for i in range(random.randrange(2,4))])
def random_day():
return random.randrange(1, 31)
def random_month():
return random.randrange(1, 12)
def random_year():
symbols = string.digits
return ''.join([random.choice(symbols) for i in range(4)])
testData = [ContactAllData(contactBaseData=ContactBaseData(firstname=random_string(10), lastname=random_string(18)),
personalData=PersonalData(middlename=random_string(10), nickname=random_string(10),
title=random_string(10), company=random_string(20),
address=random_string_with_new_line('Adres podstawowy: ', 30)),
phoneNumbers=PhoneNumbers(home=random_phone_number(12), mobile=random_phone_number(16),
work=random_phone_number(12), fax=random_phone_number(10)),
emails=Emails(email1=random_email(8), email2=random_email(5), email3=random_email(6)),
www=Www(www=random_www(30)),
birthDate=BirthDate(day=random_day(), month=random_month(), year=random_year()),
anniversaryDate=AnniversaryDate(day=random_day(), month=random_month(), year=random_year()),
additionalData=AdditionalData(address=random_string_with_new_line('Adres dodatkowy: ', 30) ,
phone=random_phone_number(12)),
notes=Notes(notes=random_string_with_new_line('n', 100)))
for i in range(n)]\
+ \
[ContactAllData(contactBaseData=ContactBaseData(firstname='', lastname=''),
personalData=PersonalData(middlename='', nickname='',
title='', company='',
address=''),
phoneNumbers=PhoneNumbers(home='', mobile='',
work='', fax=''),
emails=Emails(email1='', email2='', email3=''),
www=Www(www=''),
birthDate=BirthDate(day=-1, month=0, year=''),
anniversaryDate=AnniversaryDate(day=-1, month=0, year=''),
additionalData=AdditionalData(address='' ,
phone=''),
notes=Notes(notes=''))]\
+\
[ContactAllData(contactBaseData=ContactBaseData(firstname=random_string(10), lastname=random_string(18)),
personalData=PersonalData(middlename=random_string(10), nickname=random_string(10),
title=random_string(10), company=random_string(20),
address=''),
phoneNumbers=PhoneNumbers(home='', mobile='',
work='', fax=''),
emails=Emails(email1='', email2='', email3=''),
www=Www(www=''),
birthDate=BirthDate(day=31, month=12, year='1999'),
anniversaryDate=AnniversaryDate(day=1, month=1, year='2010'),
additionalData=AdditionalData(address='',
phone=''),
notes=Notes(notes=random_string_with_new_line('n', 100)))]\
+ \
[ContactAllData(contactBaseData=ContactBaseData(firstname=' a ', lastname=' b '),
personalData=PersonalData(middlename='', nickname='',
title='', company='',
address=''),
phoneNumbers=PhoneNumbers(home='', mobile='',
work='', fax=''),
emails=Emails(email1='', email2='', email3=''),
www=Www(www=''),
birthDate=BirthDate(day=-1, month=0, year=''),
anniversaryDate=AnniversaryDate(day=-1, month=0, year=''),
additionalData=AdditionalData(address='',
phone=''),
notes=Notes(notes=''))] \
+ \
[ContactAllData(contactBaseData=ContactBaseData(firstname='a b', lastname='c d'),
personalData=PersonalData(middlename='', nickname='',
title='', company='',
address=''),
phoneNumbers=PhoneNumbers(home='', mobile='',
work='', fax=''),
emails=Emails(email1='', email2='', email3=''),
www=Www(www=''),
birthDate=BirthDate(day=-1, month=0, year=''),
anniversaryDate=AnniversaryDate(day=-1, month=0, year=''),
additionalData=AdditionalData(address='',
phone=''),
notes=Notes(notes=''))]
file = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..' , f)
with open(file, 'w', encoding='utf8') as out:
jsonpickle.set_encoder_options('json', indent=2)
out.write(jsonpickle.encode(testData)) | apache-2.0 | -4,843,098,957,106,365,000 | 50.69863 | 119 | 0.481118 | false |
asoliveira/NumShip | source/Navio-back.py | 1 | 56391 | # -*- coding: utf-8 -*-
#
#This file is part of a program called NumShip
#Copyright (C) 2011,2012 Alex Sandro Oliveira
#NumShip 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 os
from Casco import *
from Leme import *
import scipy as sp
from scipy import linalg
from scipy import stats
from Prop import *
class inte(object):
"""
Classe que realisa a integração no tempo
:version:191010
:author: Alex
"""
def __init__(self):
"""
"""
pass
def rk4(self, function, x, t0, dt, par = None):
"""
Integrador runge-kutta
"""
k1 = function(x, t0, par)
k2 = function(x + 1./2*dt*k1, t0 + 1./2*dt, par)
k3 = function(x + 1./2*dt*k2, t0 + 1./2*dt, par)
k4 = function(x + dt*k3, t0 + dt, par)
xt = x + 1./6*(k1+ 2.*k2+ 2.*k3+ k4)*dt
return xt
def euler(self, f, x, t0, dt, par= None ):
"""
"""
return x + f(x, t0, par)*dt
class navio:
"""
Classe de navios
"""
tipo = 'Escolhido de acordo com self.Tipo'
data = '10-11-2010'
autor = 'Alex'
def __init__(self, DicionarioDerivadas, Nome = 'Teste', Tipo = 'TP'):
""""
Construtor do navio
__________________________
Variáveis de entrada:
Nome (string)-- Nome do Navio. Não possui relevância;
Tipo ('TP')-- Tipo de modelo numérico adotado para a construção do Leme
"""
self.nome = Nome
self.vel = sp.zeros((6, 1))
self.acel = sp.zeros((6, 1))
self.pos = sp.zeros((6, 1))
self.dic = DicionarioDerivadas
self.tipo = Tipo
self.integrador = inte()
self.uc = sp.array(self.dic['unom'])
if Tipo == 'TP':
self.leme = lemeTris(DicionarioDerivadas)
self.casco = cascoTris(DicionarioDerivadas)
self.prop = prop()
elif Tipo == 'MARAD':
self.leme = lemeMarAd(DicionarioDerivadas)
self.casco = cascoMarAd(DicionarioDerivadas)
self.prop = propMarAd(DicionarioDerivadas)
def MostraVel(self):
"""
Retorna a Velocidade da embarcação
"""
return self.vel
def MostraAcel(self):
"""
Retorna a aceleração da embarcação
"""
return self.acel
def MostraLeme(self):
"""
Retorna o leme em rad da embarcação
"""
return self.leme.MostraLeme()
def MostraLemeCom(self):
"""
Retorna o leme em rad da embarcação
"""
return self.leme.MostraLemeCom()
def MostraPos(self):
"""
Retorna a posição da embarcação
"""
return self.pos
def MostraRotCom(self):
"""
Retorna a rotação comandada
"""
return self.prop.MostraRotCom()
def MostraRot(self):
"""
Retorna a rotação
"""
return self.prop.MostraRot()
def MostraVelCom(self):
"""
Retorna a velocidade comandada
"""
return self.uc
def MudaVelCom(self, uc):
"""
Muda a velocidade comandada
"""
self.uc = uc.copy()
self.prop.MudaVelCom(uc)
def MudaLemeCom(self, AngLeme):
"""
Muda o leme comandado da embarcação
__________________________
Variáveis de entrada:
"""
temp = AngLeme.copy()
self.leme.MudaLemeCom(temp)
def MudaVel(self, Velocidade):
"""
Muda a velocidade da embarcação
__________________________
Variáveis de entrada:
Velocidade -- velocidade (m/s)
"""
temp = Velocidade.copy()
self.vel = temp
self.casco.MudaVel(temp)
self.leme.MudaVel(temp)
self.prop.MudaVel(temp)
def MudaPos(self, Posicao):
"""
Muda a posição da embarcação
__________________________
Variáveis de entrada:
Posição -- posição (m)
"""
temp = Posicao.copy()
self.pos = temp
self.casco.MudaPos(temp)
self.leme.MudaPos(temp)
self.prop.MudaPos(temp)
def MudaRotCom(self, Rot):
"""
Muda a rotação Comandada da embarcação
"""
self.prop.MudaRotCom(Rot)
def CalcFx(self):
"""
Calcula a força em Surge
"""
m = self.dic['m']*(self.dic['rho']*(self.dic['lpp']**3)/2)
u = self.MostraVel()[0]
v = self.MostraVel()[1]
p = self.MostraVel()[3]
r = self.MostraVel()[5]
xg = self.dic['xg']
zg = self.dic['zg']
cori = m*(v*r + xg*(r**2) - zg*p*r)
if self.tipo == 'MARAD':
saida = (self.casco.Fx() + self.prop.Fx() +
self.leme.Fx(self.MostraRot(),
self.MostraVelCom()/self.MostraVel()[0]) + cori)
elif self.tipo == 'TP':
saida = self.casco.Fx() + self.leme.Fx() + self.prop.Fx() + cori
return saida
def CalcFy(self):
"""
Calcula a força em Sway
"""
m = self.dic['m']*(self.dic['rho']*(self.dic['lpp']**3)/2)
u = self.MostraVel()[0]
v = self.MostraVel()[1]
p = self.MostraVel()[3]
r = self.MostraVel()[5]
xg = self.dic['xg']
zg = self.dic['zg']
cori = -m*u*r
if self.tipo == 'MARAD':
saida = (self.casco.Fy() + self.leme.Fy(self.MostraRot()) +
self.prop.Fy() + cori)
elif self.tipo == 'TP':
saida = self.casco.Fy() + self.leme.Fy() + self.prop.Fy() + cori
return saida
def CalcK(self):
"""
Calcula o momento de Roll
"""
m = self.dic['m']*(self.dic['rho']*(self.dic['lpp']**3)/2)
u = self.MostraVel()[0]
v = self.MostraVel()[1]
p = self.MostraVel()[3]
r = self.MostraVel()[5]
xg = self.dic['xg']
zg = self.dic['zg']
cori = m*zg*u*r
if self.tipo == 'MARAD':
saida = (self.casco.K() + self.leme.K(self.MostraRot()) +
self.prop.K() + cori)
elif self.tipo == 'TP':
saida = self.casco.K() + self.leme.K() + self.prop.K() + cori
return saida
def CalcN(self):
"""
Calcula o momento de Yaw
"""
m = self.dic['m']*(self.dic['rho']*(self.dic['lpp']**3)/2)
u = self.MostraVel()[0]
v = self.MostraVel()[1]
p = self.MostraVel()[3]
r = self.MostraVel()[5]
xg = self.dic['xg']
zg = self.dic['zg']
cori = -m*xg*u*r
if self.tipo == 'MARAD':
saida = (self.casco.N() + self.leme.N(self.MostraRot()) +
self.prop.N() + cori)
elif self.tipo == 'TP':
saida = self.casco.N() + self.leme.N() + self.prop.N() + cori
return saida
def VetF(self, p=None):
"""
Vetor de forças
_________________________
Variáveis de entrada:
p -- tupla
p[0] (integer)-- Graus de liberdade
p[1] (tupla)-- Com pesos
"""
if p == None:
GrausDeLib =4
peso = None
elif len(p)==1:
GrausDeLib =p[0]
peso = None
elif len(p)==2:
GrausDeLib =p[0]
peso = p[1]
if peso == None:
if GrausDeLib == 4:
saida = sp.array([self.CalcFx(), self.CalcFy(),
self.CalcK(), self.CalcN()])
elif GrausDeLib == 3:
saida = sp.array([self.CalcFx(), self.CalcFy(), self.CalcN()])
else:
lemearq = self.MostraLeme()
velarq = self.MostraVel()
uc = self.MostraVelCom()
####################
self.leme.MudaLemeDir(sp.array(0.))
self.MudaVelCom(velarq[0]) #condição eta=1
## ####################
## Aquilo que depende somente de u
##
## ####################
veltemp = sp.zeros((6, 1))
veltemp[0] = velarq[0]
self.MudaVel(veltemp)
fu = self.VetF((GrausDeLib, ))
####################
veltemp = sp.zeros((6, 1))
veltemp[0] = velarq[0]
veltemp[1] = velarq[1]
self.MudaVel(veltemp)
# leme = 0 e eta = 1
fbeta = self.VetF((GrausDeLib, )) - fu
it = 0
fbeta1 = fbeta.copy()
for arg in peso[0]:
fbeta[it] = arg* fbeta[it]
it +=1
####################
veltemp = sp.zeros((6, 1))
veltemp[5] = velarq[5]
veltemp[0] = velarq[0]
self.MudaVel(veltemp)
fr = self.VetF((GrausDeLib, )) - fu
fr1 = fr.copy()
it = 0
for arg in peso[1]:
fr[it] = arg* fr[it]
it +=1
####################
self.leme.MudaLemeDir(lemearq)
veltemp = sp.zeros((6, 1))
veltemp[0] = velarq[0]
self.MudaVel(veltemp)
fleme = self.VetF((GrausDeLib, )) - fu
fleme1 = fleme.copy()
it = 0
for arg in peso[2]:
fleme[it] = arg* fleme[it]
it +=1
####################
self.MudaVel(velarq)
self.MudaVelCom(uc)
fbetarl = self.VetF((GrausDeLib, )) - (fbeta1 + fr1 + fleme1)
it = 0
for arg in peso[3]:
fbetarl[it] = arg* fbetarl[it]
it +=1
del it
saida = fbeta + fr + fleme + fbetarl
return saida
def H (self, GrausDeLib=4):
"""
Matriz de massa menos matriz de massa adicional
_________________________
Variáveis de entrada:
GrausDeLib (integer)-- Graus de liberdade
"""
H = None
H = self.casco.M(GrausDeLib) - self.casco.Ma(GrausDeLib)
return sp.mat(H)
def MatRot(self, p=None):
"""
Retorna a matrix de rotação de do referêncial solidárial para o
inercial
"""
if p== None:
roll= self.MostraPos()[3]
pitch = self.MostraPos()[4]
yaw = self.MostraPos()[5]
else:
roll= p[0]
pitch = p[1]
yaw = p[2]
Rot = sp.array([[sp.cos(yaw)*sp.cos(pitch),
-sp.sin(yaw)*sp.cos(roll) + sp.cos(yaw)*sp.sin(pitch)*sp.sin(roll),
sp.sin(yaw)*sp.sin(roll) + sp.cos(yaw)*sp.cos(roll)*sp.sin(pitch) ],
[sp.sin(yaw)*sp.cos(pitch),
sp.cos(yaw)*sp.cos(roll) + sp.sin(roll)*sp.sin(pitch)*sp.sin(yaw),
-sp.cos(yaw)*sp.sin(roll) + sp.sin(yaw)*sp.cos(roll)*sp.sin(pitch) ],
[-sp.sin(pitch), sp.cos(pitch)*sp.sin(roll),
sp.cos(pitch)*sp.cos(roll)] ])
Rot.shape = (3, 3)
Rot= sp.matrix(Rot)
return Rot
def f2 (self, VetF, H):
"""
Calcula o valor de f(x) na equação
x' = f(x)
onde x são é o vetor de velocidades no sistema solidário
_________________________
Variáveis de entrada:
GrausDeLib (integer)-- Graus de liberdade
"""
GrausDeLib = len(VetF)
if GrausDeLib == 4:
a= sp.zeros((6, 6))
a[5, 5] = 1.
a[4, 4] = 1.
a[:4, :4]= H
b= sp.zeros((6, 1))
b [4, 0] = self.vel[3]
b [5, 0] = self.vel[5]*sp.cos(self.MostraPos()[3])
b[:4, :]= VetF
elif GrausDeLib == 3:
a= sp.zeros((4, 4))
a[3, 3] = 1.
a[:3, :3]= H
b= sp.zeros((4, 1))
b[:3, :]= VetF
b[3, 0] = self.MostraVel()[5]
saida = linalg.solve(a, b )
return saida
def f(self, velocidade=None, t=None, p=(4, )):
"""
O p é uma tupla com o valor dos graus de liberdade
"""
GrausDeLib = p[0]
if velocidade !=None:
velarq = self.MostraVel()
posarq = self.MostraPos()
veltemp = sp.zeros((6, 1))
postemp = sp.zeros((6, 1))
if GrausDeLib==3:
veltemp[:2] = velocidade[:2]
veltemp[5] = velocidade[2]
postemp[5] = velocidade[3]
elif GrausDeLib==4:
veltemp[:2] = velocidade[:2]
veltemp[3] = velocidade[2]
veltemp[5] = velocidade[3]
postemp[3] = velocidade[4]
postemp[5] = velocidade[5]
self.MudaVel(veltemp)
self.MudaPos(postemp)
if GrausDeLib == 4:
a= sp.zeros((6, 6))
a[5, 5] = 1.
a[4, 4] = 1.
a[:4, :4]= self.H(GrausDeLib)
b= sp.zeros((6, 1))
b [4, 0] = self.vel[3]
b [5, 0] = self.vel[5]*sp.cos(self.MostraPos()[3])
b[:4, :]= self.VetF(p)
elif GrausDeLib == 3:
a= sp.zeros((4, 4))
a[3, 3] = 1.
a[:3, :3]= self.H(GrausDeLib)
b= sp.zeros((4, 1))
b[:3, :]= self.VetF(p)
b[3, 0] = self.MostraVel()[5]
saida = linalg.solve(a, b)
if velocidade !=None:
self.MudaVel(velarq)
self.MudaPos(posarq)
return saida
def fvein(self, x, t, p):
"""
x = sp.array(u, v , w)
p = ( roll, pitch, yaw)
"""
return sp.array(self.MatRot(p[0])*p[1])
def simula (self, met='euler', t0=0., dt=0.5, t=100., GrausDeLib=4,
velocidade=None, tipo='ZigZag', leme=sp.array(20.),
proa=sp.array(20.), RotCom =sp.array(1), osa=sp.array(0.05),
ospath=sp.array(150), erro=sp.array(0.05),
errotf=sp.array(0.05), errotd=sp.array(0.05)):
"""
Simulador de manobras padrão
_________________________
Variáveis de entrada:
GrausDeLib (integer)-- Graus de liberdade;
met -- Método de integração. Default- Euler;
t0 -- Tempo inicial;
dt -- Passo no tempo;
t -- Tempo final
tipo - tipo de manobra simulada. Zig-Zag10/10 e Curva_de_Giro_port ou
Curva_de_Giro_starboard . Default -Zig-Zag
__________________________
Saída:
Tupla de sp.array
(veloHis, posHis, acelHis, fHis, veloInerHis, lemeHis)
Em cada elemento da tupla:
A primeira coluna é o passo de tempo e as demais são as variáveis
veloHis -- histórico de velocidades;
posHis -- histórico de posições
acelHis --- histórico de acelerações
fHis -- histórico de forças
veloInerHis -- histórico de velocidades no sistema inercial
lemeHis -- histórico do comando de leme
"""
#
# Tipo de Simulação a ser realizada:
#
self.MudaPos( sp.array([ [0.], [0.], [0.], [0.], [0.], [0.] ]))
self.MudaVel(sp.array([ [self.dic['unom']], [0.], [0.], [0.], [0.],
[0.] ]))
self.MudaRotCom(RotCom)
self.MudaVelCom(self.dic['unom'])
#Log é o parâmetro que indica quando a simulação armazenou os dados do
#relatório
if tipo == 'Curva_de_Giro_port':
self.MudaLemeCom(sp.array(leme*sp.pi/180))
log = False
elif tipo == 'Curva_de_Giro_starboard':
self.MudaLemeCom(sp.array(-leme*sp.pi/180))
log = False
elif tipo == 'ZigZag':
self.MudaLemeCom(sp.array(leme*sp.pi/180))
exe = 0
###############################
##
## Dados relacionados a curva de zizag
##
###############################
if (tipo == 'ZigZag' and (((exe%2 == 0) and self.MostraPos()[5] <=
-(proa*sp.pi/180) ) or (exe%2 != 0 and self.MostraPos()[5] >=
(proa*sp.pi/180) ))):
self.MudaLemeCom(self.MostraLeme()*(-1))
if exe!=0:
dic['reach'] = erro
dic['ospath'] = ospath
dic['osangle'] = abs(osa - dic['proa'])
dados.append(dic.copy())
exe += 1
dic['exeNummber'] = exe
dic['time'] = tp - sp.array(dt)
dic['path'] = self.MostraPos()[1]
dic['proa'] = self.MostraPos()[5]
if tipo=='ZigZag' and exe!=0:
if abs(self.MostraPos()[1]- dic['path'])>ospath:
ospath = abs(self.MostraPos()[1]- dic['path'])
if abs(self.MostraPos()[5])>abs(osa):
osa = self.MostraPos()[5]
if abs(self.MostraPos()[5] - PosIni[5]) < erro:
erro = abs(self.MostraPos()[5] - PosIni[5])
###############################
##
## Dados relacionados a curva de Giro
##
###############################
if ((tipo == 'Curva_de_Giro_port' or
tipo == 'Curva_de_Giro_starboard') and not log):
if (abs(abs(self.MostraPos()[5] - PosIni[5]) -
(sp.array(90)*sp.pi/180)) <= errotf):
errotf = (abs(abs(self.MostraPos()[5] - PosIni[5]) -
(sp.array(90)*sp.pi/180)))
dic['transfer'] = abs(self.MostraPos()[1] - PosIni[1])
dic['advance'] = abs(self.MostraPos()[0] - PosIni[0])
if abs(abs(self.MostraPos()[5] - PosIni[5]) - sp.pi) <= errotd:
errotd = abs(abs(self.MostraPos()[5] - PosIni[5]) - sp.pi)
dic['taticalDiameter'] = abs(self.MostraPos()[1] -
PosIni[1])
if abs(self.MostraPos()[5] - PosIni[5]) > sp.pi :
log = True
dados.append(dic)
Rot = self.MatRot()
#
# inc = Velocidades Lineares no Sistema Inecial
#
VelIn = Rot*sp.matrix(self.vel[0:3])
PosIne = self.MostraPos()[0:3]
##################################
#
# Guardando os parâmetros
#
##################################
# Velocidade Inercial
d= sp.hstack(VelIn)
veloInerHis[cont, 1:] = d #
veloInerHis[cont, 0] = tp #
# Histórico Leme
lemeHis[cont, 0] = tp
lemeHis[cont, 1] = self.MostraLeme()
# Histórico da posição
temp = sp.hstack(self.MostraPos())
posHis[cont, :] = sp.hstack((tp, temp))
# Histórico da Velocidade
temp = sp.hstack(self.MostraVel())
veloHis[cont, :] = sp.hstack((tp, temp))
# Histórico das Forças
temp =sp.hstack(sp.array(self.VetF(GrausDeLib)))
if GrausDeLib == 4:
fHis[cont, :] = sp.hstack((tp, temp))
elif GrausDeLib == 3:
fHis[cont, :3] = sp.hstack((tp, temp[:2]))
fHis[cont, 4] = temp[2]
# Histórico Propulsor
propHis[cont, :] = sp.hstack((tp, self.MostraRot()))
# Histórico das Acelerações
Acel = self.f(GrausDeLib)
if GrausDeLib == 4:
vetor = sp.zeros((6, 1))
vetor[:2] = Acel[:2]
vetor[3] = Acel[2]
vetor [5] = Acel[3]
elif GrausDeLib == 3:
vetor = sp.zeros((6, 1))
vetor[:2] = Acel[:2]
vetor [5] = Acel[2]
acelHis[cont, :] = sp.hstack((tp, sp.hstack(vetor)))
del temp
##############################
#
# Criação de vetor de graus de liberdade
#
##############################
if GrausDeLib == 4:
xIn = sp.zeros([6, 1])
xIn [0] = self.MostraVel()[0]
xIn [1] = self.MostraVel()[1]
xIn [2] = self.MostraVel()[3]
xIn [3] = self.MostraVel()[5]
xIn [4] = self.MostraPos()[3]
xIn [5] = self.MostraPos()[5]
elif GrausDeLib == 3:
xIn = sp.zeros([4, 1])
xIn [0] = self.MostraVel()[0]
xIn [1] = self.MostraVel()[1]
xIn [2] = self.MostraVel()[5]
xIn [3] = self.MostraPos()[5]
##################################
#
# Integração da Aceleração solidária
#
##################################
if met == 'euler':
xIn = self.integrador.euler(Acel, xIn, dt )
elif met =='rk4':
xIn = self.integrador.rk4(self.facel, dt, tp, xIn)
##################################
if GrausDeLib == 4:
x = sp.zeros((6, 1))
x[0] = xIn[0]
x[1] = xIn[1]
x[3] = xIn[2]
x[5] = xIn[3]
elif GrausDeLib==3:
x = sp.zeros((6, 1))
x[0] = xIn[0]
x[1] = xIn[1]
x[5] = xIn[2]
self.MudaVel(x)
del x
##################################
##
## Integração da velocidade inercial
##
###################################
posfutura = sp.zeros((6, 1))
posfutura[:3] = self.integrador.euler(VelIn, PosIne, dt)
##################################
if GrausDeLib== 4:
posfutura[3] = xIn[4]
posfutura[5] = xIn[5]
elif GrausDeLib== 3:
posfutura[5] = xIn[3]
self.MudaPos(posfutura)
cont += 1
del posfutura
self.prop.MudaRot(tp)
self.leme.MudaLeme(tp)
return (veloHis, posHis, acelHis, fHis, veloInerHis, lemeHis, propHis,
dados)
def getCurvaGiro(self, peso=None, met='euler', t0=0., dt=0.5, t=100.,
GrausDeLib=3, tipo='port', leme=sp.array(20.),
RotCom=None, VelCom= None, Vel=None, Eta='vel',
PosIne=sp.array([[0.], [0.], [0.], [0.], [0.], [0.] ]),
errotf=sp.array(0.05), errotd=sp.array(0.05),
errosr=sp.array(0.001), saida='txt'):
"""
"""
if RotCom == None:
RotCom = self.dic['rotnom']
if VelCom == None:
VelCom = self.dic['unom']
if Vel == None:
Vel = sp.array([ [self.dic['unom']], [0.], [0.], [0.], [0.], [0.]
])
self.MudaPos( PosIne)
self.MudaVel(Vel)
self.MudaRotCom(RotCom)
self.MudaVelCom(VelCom)
#Log é o parâmetro que indica quando a simulação armazenou os dados do
#relatório
if tipo == 'port':
self.MudaLemeCom(sp.array(leme*sp.pi/180))
log = False
log1 = False
elif tipo == 'starboard':
self.MudaLemeCom(sp.array(-leme*sp.pi/180))
log = False
log1 = False
#
# Criando espaço na memória para armazenar os parâmetros da curva
#
nlin = len(sp.arange(t0, t, dt)) #Número de linhas das colunas a serem
#criadas
if saida == 'mem':
lemeHis = sp.zeros((nlin, 2)) #historico do leme
veloHis = sp.zeros((nlin, 7)) #histórico da velocidade
veloInerHis = sp.zeros((nlin, 4))#histórico da velocidade no
#sistema inercial Verificar depois a necessidade
posHis = sp.zeros([nlin, 7]) #histórico da posição no sistema
#inercial
fHis = sp.zeros((nlin, 5)) #histórico de forças
acelHis = sp.zeros((nlin, 7)) #histórico de acelerações
propHis = sp.zeros((nlin, 2)) #histórico Máquina
EtaHis = sp.zeros((nlin, 2)) #histórico Eta
betaHis = sp.zeros((nlin, 2)) #histórico beta
elif saida == 'txt':
os.makedirs('./saida/CurvaGiro')
os.chdir('./saida/CurvaGiro')
lemeHis = open('leme.dat', 'w')#historico do leme
lemeHis.write('#Navio ' + self.nome + '\n' + '#Manobra de Curva
Giro\n#\n')
lemeHis.write('#Valor do leme em rad\n')
lemeHis.write('#temp'.center(5) + ' ' + 'leme'.rjust(8) + ' ' +
'\n')
veloHis = open('velo.dat', 'w') #histórico da velocidade
veloHis.write('#Navio ' + self.nome + '\n' + '#Manobra de Curva
Giro\n#\n')
veloHis.write('#Velocidade Sistema Solidário \n#\n')
veloHis.write('#temp'.center(5) + ' ' + 'u'.rjust(11) + ' ' +
'v'.rjust(11) + ' ' + 'w'.rjust(11) + ' ' + 'dot roll'.rjust(11) + ' ' + '
dot pitch'.rjust(11) + ' ' + 'dot yaw'.rjust(11) + ' ' + '\n')
veloInerHis = open('veloiner.dat', 'w')#histórico da velocidade no
#sistema inercial Verificar depois a necessidade
veloInerHis.write('#Navio ' + self.nome + '\n' + '#Manobra de
Curva Giro\n#\n')
veloInerHis.write('#Velocidade Inercial\n#\n')
veloInerHis.write('#temp'.center(5) + ' ' + 'u'.rjust(11) + ' ' +
'v'.rjust(11) + ' ' + 'r'.rjust(11) + '\n')
posHis = open('pos.dat', 'w')#histórico da posição no sistema
#inercial
posHis.write('#Navio ' + self.nome + '\n' + '#Manobra de Curva
Giro\n#\n')
posHis.write('#Posição e Orientação\n#\n')
posHis.write('#temp'.center(5) + ' ' + 'x'.rjust(11) + ' ' +
'y'.rjust(11) + ' ' + 'z'.rjust(11) + ' ' + 'roll'.rjust(11) + ' ' +
'pitch'.rjust(11) + ' ' + 'yaw'.rjust(11) + ' ' + '\n')
fHis = open('forcas.dat', 'w') #histórico de forças
fHis.write('#Navio ' + self.nome + '\n' + '#Manobra de Curva
Giro\n#\n')
fHis.write('#Forças e Momentos\n#\n')
fHis.write('#temp'.center(5) + ' ' + 'X'.rjust(11) + ' ' +
'Y'.rjust(11) + ' ' + 'K'.rjust(11) + ' ' + 'N'.rjust(11) + ' ' + '\n')
acelHis = open('acel.dat', 'w') #histórico de acelerações
acelHis.write('#Navio ' + self.nome + '\n' + '#Manobra de Curva
Giro\n#\n')
acelHis.write('#Aceleração\n#\n')
acelHis.write('#temp'.center(5) + ' ' + 'u'.rjust(11) + ' ' +
'v'.rjust(11) + ' ' + 'w'.rjust(11) + ' ' + 'ddotroll'.rjust(11) + ' ' + '
ddotpitch'.rjust(11) + ' ' + 'ddotyaw'.rjust(11) + ' ' + '\n')
propHis = open('propulsor.dat', 'w') #histórico Máquina
propHis.write('#Navio ' + self.nome + '\n' + '#Manobra de Curva
Giro\n#\n')
propHis.write('#Rotações do propulsor\n#\n')
propHis.write('#temp'.center(5) + ' ' + 'rot'.rjust(8) + '\n')
EtaHis = open('Eta.dat', 'w') #histórico Eta
EtaHis.write('#Navio ' + self.nome + '\n' + '#Manobra de Curva
Giro\n#\n')
EtaHis.write('#Eta \n#\n')
EtaHis.write('#temp'.center(5) + ' ' + 'rot'.rjust(8) + ' ' + '\n')
betaHis = open('beta.dat', 'w') #histórico Eta
betaHis.write('#Navio ' + self.nome + '\n' + '#Manobra de Curva
Giro\n#\n')
betaHis.write('#Beta \n#\n')
betaHis.write('#temp'.center(5) + ' ' + 'rot'.rjust(8) + ' ' +
'\n')
os.chdir('..')
os.chdir('..')
dados = []
dic = {}
PosIni = self.MostraPos().copy()
del nlin #não preciso mais
cont =0 #Contador
if peso == None:
par = (GrausDeLib, )
else:
par = (GrausDeLib, peso)
#
# Iteração
#
for tp in sp.arange(t0, t, dt):
if not log1:
if cont == 0:
V1 = sp.sqrt(self.MostraVel()[0]**2 +
self.MostraVel()[1]**2)
elif cont == 1:
V2 = sp.sqrt(self.MostraVel()[0]**2 +
self.MostraVel()[1]**2)
elif cont == 2:
V3 = sp.sqrt(self.MostraVel()[0]**2 +
self.MostraVel()[1]**2)
elif cont == 3:
V4 = sp.sqrt(self.MostraVel()[0]**2 +
self.MostraVel()[1]**2)
else:
V1 = V2
V2 = V3
V3 = V4
V4 = sp.sqrt(self.MostraVel()[0]**2 +
self.MostraVel()[1]**2)
if log:
if stats.tstd((V1, V2, V3, V4))<errosr:
dic['steadytr'] = (sp.sqrt(self.MostraVel()[0]**2 +
self.MostraVel()[1]**2) /
self.MostraVel()[5])
dados.append(dic.copy())
log1= True
if not log:
if (abs(abs(self.MostraPos()[5] - PosIni[5]) - (sp.pi/2))
<= errotf):
errotf = (abs(abs(self.MostraPos()[5] - PosIni[5]) -
(sp.pi/2)))
dic['transfer'] = abs(self.MostraPos()[1] - PosIni[1])
dic['advance'] = abs(self.MostraPos()[0] - PosIni[0])
if (abs(abs(self.MostraPos()[5] - PosIni[5]) - sp.pi) <=
errotd):
errotd = abs(abs(self.MostraPos()[5] - PosIni[5]) -
sp.pi)
dic['taticalDiameter'] = abs(self.MostraPos()[1] -
PosIni[1])
if abs(self.MostraPos()[5] - PosIni[5]) > sp.pi:
log = True
###################################
ft = self.VetF(par)
###################################
##
## inc = Velocidades Lineares no Sistema Inecial
##
###################################
MatRot = self.MatRot()
VelIn = sp.array(MatRot*self.MostraVel()[0:3])
PosIne = self.MostraPos()[0:3]
##################################
##
## Guardando os parâmetros
##
##################################
# Velocidade Inercial
if saida == 'txt':
veloInerHis.write('%.2f'.rjust(5)%(tp) + ' ')
for arg in VelIn:
veloInerHis.write('%.5e'.rjust(11)%(arg) + ' ')
veloInerHis.write('\n')
elif saida == 'mem':
d = sp.hstack(VelIn)
veloInerHis[cont, 1:] = d #
veloInerHis[cont, 0] = tp #
# Histórico Leme
if saida == 'txt':
lemeHis.write('%.2f'.rjust(5)%(tp) + ' ')
lemeHis.write('%.2f'.rjust(5)%(self.MostraLeme()) + '\n')
elif saida == 'mem':
lemeHis[cont, 0] = tp
lemeHis[cont, 1] = self.MostraLeme()
# Histórico da posição
if saida == 'txt':
posHis.write('%.2f'.rjust(5)%(tp) + ' ')
for arg in self.MostraPos():
posHis.write('%.5e'.rjust(11)%(arg) + ' ')
posHis.write('\n')
elif saida == 'mem':
temp = sp.hstack(self.MostraPos())
posHis[cont, :] = sp.hstack((tp, temp))
del temp
# Histórico da Velocidade
if saida == 'txt':
veloHis.write('%.2f'.rjust(5)%(tp) + ' ')
for arg in self.MostraVel():
veloHis.write('%.5e'.rjust(11)%(arg) + ' ')
veloHis.write('\n')
elif saida == 'mem':
temp = sp.hstack(self.MostraVel())
veloHis[cont, :] = sp.hstack((tp, temp))
del temp
# Histórico das Forças
if saida == 'txt':
temp = sp.zeros((4, 1))
if GrausDeLib == 4:
temp= ft
elif GrausDeLib == 3:
temp[:2] = ft[:2]
temp[3] = ft[2]
fHis.write('%.2f'.rjust(5)%(tp) + ' ')
for arg in temp:
fHis.write('%.5e'.rjust(11)%(arg) + ' ')
fHis.write('\n')
elif saida == 'mem':
temp = sp.hstack(sp.array(ft))
if GrausDeLib == 4:
fHis[cont, :] = sp.hstack((tp, temp))
elif GrausDeLib == 3:
fHis[cont, :3] = sp.hstack((tp, temp[:2]))
fHis[cont, 4] = temp[2]
# Histórico Propulsor
if saida == 'txt':
propHis.write('%.2f'.rjust(5)%(tp) + ' ')
propHis.write('%.2f'.rjust(5)%self.MostraRot() + '\n')
elif saida == 'mem':
propHis[cont, :] = sp.hstack((tp, self.MostraRot()))
# Histórico Eta
if saida == 'txt':
EtaHis.write('%.2f'.rjust(5)%(tp) + ' ')
if Eta == 'rot':
EtaHis.write('%.2f'.rjust(5) % (self.MostraRotCom() /
self.MostraRot()) + '\n')
elif Eta == 'vel':
EtaHis.write('%.2f'.rjust(5) %
(self.MostraVelCom() / self.MostraVel()[0]) +
'\n')
elif saida == 'mem':
if Eta== 'rot':
EtaHis[cont, :] = sp.hstack((tp, self.MostraRotCom() /
self.MostraRot()))
elif Eta == 'vel':
EtaHis[cont, :] = sp.hstack((tp,
self.MostraVelCom() /
self.MostraVel()[0]))
# Histórico Beta
if saida == 'txt':
betaHis.write('%.2f'.rjust(5)%(tp) + ' ')
betaHis.write('%.2f'.rjust(5)%(sp.arctan(-self.MostraVel()[1]
/ self.MostraVel()[0])) + '\n')
elif saida == 'mem':
betaHis[cont, :] = sp.hstack((tp,
sp.arctan(-self.MostraVel()[1] /
self.MostraVel()[0])))
# Histórico das Acelerações
Acel = self.f2(ft, self.H(GrausDeLib))
vetor = sp.zeros((6, 1))
if GrausDeLib == 4:
vetor[:2] = Acel[:2]
vetor[3] = Acel[2]
vetor [5] = Acel[3]
elif GrausDeLib == 3:
vetor[:2] = Acel[:2]
vetor [5] = Acel[2]
if saida == 'txt':
acelHis.write('%.2f'.rjust(5)%(tp) + ' ')
for arg in vetor:
acelHis.write('%.5e'.rjust(11)%(arg[0]) + ' ')
acelHis.write('\n')
elif saida == 'mem':
acelHis[cont, :] = sp.hstack((tp, sp.hstack(vetor)))
del temp
##############################
#
# Criação de vetor de graus de liberdade
#
##############################
if GrausDeLib == 4:
vt = sp.zeros([6, 1])
vt [0] = self.MostraVel()[0]
vt [1] = self.MostraVel()[1]
vt [2] = self.MostraVel()[3]
vt [3] = self.MostraVel()[5]
vt [4] = self.MostraPos()[3]
vt [5] = self.MostraPos()[5]
elif GrausDeLib == 3:
vt = sp.zeros([4, 1])
vt [0] = self.MostraVel()[0]
vt [1] = self.MostraVel()[1]
vt [2] = self.MostraVel()[5]
vt [3] = self.MostraPos()[5]
##################################
##
## Integração da Aceleração solidária
##
##################################
if met == 'euler':
vt = self.integrador.euler(self.f, vt, tp, dt ,par )
elif met =='rk4':
vt = self.integrador.rk4(self.f, vt, tp, dt, par)
##################################
if GrausDeLib == 4:
v = sp.zeros((6, 1))
v[0] = vt[0]
v[1] = vt[1]
v[3] = vt[2]
v[5] = vt[3]
elif GrausDeLib == 3:
v = sp.zeros((6, 1))
v[0] = vt[0]
v[1] = vt[1]
v[5] = vt[2]
self.MudaVel(v)
del v
##################################
##
## Integração da velocidade inercial
##
###################################
x = sp.zeros((6, 1))
if met == 'euler':
x[:3] = self.integrador.euler(self.fvein ,
self.MostraPos()[:3], tp, dt ,
(self.MostraPos()[3:] ,
self.MostraVel()[:3]))
elif met == 'rk4':
x[:3] = self.integrador.rk4(self.fvein, self.MostraPos()[:3],
tp, dt, (self.MostraPos()[3:],
self.MostraVel()[:3]))
##################################
if GrausDeLib == 4:
x[3] = vt[4]
x[5] = vt[5]
elif GrausDeLib == 3:
x[5] = vt[3]
self.MudaPos(x)
del x
cont += 1
self.prop.MudaRot(tp)
self.leme.MudaLeme(tp)
if saida == 'txt':
arq = [veloHis, posHis, acelHis, fHis, veloInerHis, lemeHis,
propHis, EtaHis]
for arg in arq:
arg.close()
return dados
elif saida == 'mem':
return (veloHis, posHis, acelHis, fHis, veloInerHis, lemeHis,
propHis, EtaHis, dados, betaHis)
def getCurvaZigZag(self, peso=None, met='euler', t0=0., dt=0.5, t=100.,
GrausDeLib=3, tipo='port', lemesp.array(20.),
RotCom=None, VelComNone, VelNone, proa=
sp.array([20.]), Eta='vel', PosInesp.array([[0.], [0.],
[0.], [0.], [0.], [0.]]), osasp.array(0.0),
ospathsp.array(0.0), erro=sp.array(0.005), saida'txt'):
"""
Simulador de manobras padrão
_________________________
Variáveis de entrada:
GrausDeLib (integer)-- Graus de liberdade;
met -- Método de integração. Default- Euler;
t0 -- Tempo inicial;
dt -- Passo no tempo;
t -- Tempo final
tipo - tipo de manobra simulada. Zig-Zag10/10 e Curva_de_Giro_port ou
Curva_de_Giro_starboard . Default -Zig-Zag
__________________________
Saída:
Tupla de sp.array
(veloHis, posHis, acelHis, fHis, veloInerHis, lemeHis)
Em cada elemento da tupla:
A primeira coluna é o passo de tempo e as demais são as variáveis
veloHis -- histórico de velocidades;
posHis -- histórico de posições
acelHis --- histórico de acelerações
fHis -- histórico de forças
veloInerHis -- histórico de velocidades no sistema inercial
lemeHis -- histórico do comando de leme
"""
if RotCom == None:
RotCom = self.dic['rotnom']
if VelCom == None:
VelCom = self.dic['unom']
if Vel == None:
Vel = sp.array([[self.dic['unom']], [0.], [0.], [0.], [0.], [0.]
])
self.MudaPos( PosIne)
self.MudaVel(Vel)
self.MudaRotCom(RotCom)
self.MudaVelCom(VelCom)
if tipo == 'port':
self.MudaLemeCom(sp.array(leme*sp.pi/180))
exe=0
elif tipo == 'starboard':
self.MudaLemeCom(sp.array(-leme*sp.pi/180))
exe=1
#
# Criando espaço na memória para armazenar os parâmetros da curva
#
#Número de linhas das colunas a seremcriadas
nlin = len(sp.arange(t0, t, dt))
if saida == 'mem':
lemeHis = sp.zeros((nlin, 2)) #historico do leme
veloHis = sp.zeros((nlin, 7)) #histórico da velocidade
veloInerHis = sp.zeros((nlin, 4))#histórico da velocidade no
#sistema inercial Verificar depois a necessidade
posHis = sp.zeros([nlin, 7]) #histórico da posição no sistema
#inercial
fHis = sp.zeros((nlin, 5)) #histórico de forças
acelHis = sp.zeros((nlin, 7)) #histórico de acelerações
propHis = sp.zeros((nlin, 2)) #histórico Máquina
EtaHis = sp.zeros((nlin, 2)) #histórico Eta
elif saida == 'txt':
os.makedirs('./saida/ZigZag')
os.chdir('./saida/ZigZag')
lemeHis = open('leme.dat', 'w')#historico do leme
lemeHis.write('#Navio ' + self.nome + '\n' + '#Manobra de Curva
Zig-Zag\n#\n')
lemeHis.write('#Valor do leme em rad\n')
lemeHis.write('#temp'.center(5) + ' ' + 'leme'.rjust(8) + ' ' +
'\n')
veloHis = open('velo.dat', 'w') #histórico da velocidade
veloHis.write('#Navio ' + self.nome + '\n' + '#Manobra de Curva
Zig-Zag\n#\n')
veloHis.write('#Velocidade Sistema Solidário \n#\n')
veloHis.write('#temp'.center(5) + ' ' + 'u'.rjust(11) + ' ' +
'v'.rjust(11) + ' ' + 'w'.rjust(11) + ' ' + 'dot
roll'.rjust(11) + ' ' + ' dot pitch'.rjust(11) + '
' + 'dot yaw'.rjust(11) + ' ' + '\n')
veloInerHis = open('veloiner.dat', 'w')#histórico da velocidade no
#sistema inercial Verificar depois a necessidade
veloInerHis.write('#Navio ' + self.nome + '\n' + '#Manobra de
Curva Zig-Zag\n#\n')
veloInerHis.write('#Velocidade Inercial\n#\n')
veloInerHis.write('#temp'.center(5) + ' ' + 'u'.rjust(11) + ' ' +
'v'.rjust(11) + ' ' + 'r'.rjust(11) + '\n')
posHis = open('pos.dat', 'w')#histórico da posição no sistema
#inercial
posHis.write('#Navio ' + self.nome + '\n' + '#Manobra de Curva
Zig-Zag\n#\n')
posHis.write('#Posição e Orientação\n#\n')
posHis.write('#temp'.center(5) + ' ' + 'x'.rjust(11) + ' ' +
'y'.rjust(11) + ' ' + 'z'.rjust(11) + ' ' +
'roll'.rjust(11) + ' ' + 'pitch'.rjust(11) + ' ' +
'yaw'.rjust(11) + ' ' + '\n')
fHis = open('forcas.dat', 'w') #histórico de forças
fHis.write('#Navio ' + self.nome + '\n' + '#Manobra de Curva
Zig-Zag\n#\n')
fHis.write('#Forças e Momentos\n#\n')
fHis.write('#temp'.center(5) + ' ' + 'X'.rjust(11) + ' ' +
'Y'.rjust(11) + ' ' + 'K'.rjust(11) + ' ' +
'N'.rjust(11) + ' ' + '\n')
acelHis = open('acel.dat', 'w') #histórico de acelerações
acelHis.write('#Navio ' + self.nome + '\n' + '#Manobra de Curva
Zig-Zag\n#\n')
acelHis.write('#Aceleração\n#\n')
acelHis.write('#temp'.center(5) + ' ' + 'u'.rjust(11) + ' ' +
'v'.rjust(11) + ' ' + 'w'.rjust(11) + ' ' +
'ddotroll'.rjust(11) + ' ' + ' ddotpitch'.rjust(11)
+ ' ' + 'ddotyaw'.rjust(11) + ' ' + '\n')
propHis = open('propulsor.dat', 'w') #histórico Máquina
propHis.write('#Navio ' + self.nome + '\n' + '#Manobra de Curva
Zig-Zag\n#\n')
propHis.write('#Rotações do propulsor\n#\n')
propHis.write('#temp'.center(5) + ' ' + 'rot'.rjust(8) + '\n')
EtaHis = open('Eta.dat', 'w') #histórico Eta
EtaHis.write('#Navio ' + self.nome + '\n' + '#Manobra de Curva
Zig-Zag\n#\n')
EtaHis.write('#Eta \n#\n')
EtaHis.write('#temp'.center(5) + ' ' + 'rot'.rjust(8) + ' ' + '\n')
os.chdir('..')
os.chdir('..')
dados = []
dic = {}
PosIni = self.MostraPos().copy()
del nlin #não preciso mais
cont =0 #Contador
if peso == None:
par = (GrausDeLib, )
else:
par = (GrausDeLib, peso)
#
# Iteração
#
for tp in sp.arange(t0, t, dt):
###############################
##
## Verificando o momento em que será realizada a mudança do leme
##
###############################
if (((exe%2 == 0) and self.MostraPos()[5] <=
-(proa * sp.pi / 180)) or (exe%2 != 0 and
self.MostraPos()[5] >= (proa * sp.pi / 180))):
self.MudaLemeCom(self.MostraLeme() * (-1))
if ((exe != 0 and tipo == 'port') or (exe != 1
and tipo == 'starboard')):
dic['reach'] = erro
dic['ospath'] = ospath
dic['osangle'] = osa
dados.append(dic.copy())
osa = sp.array(0.0)
ospath = sp.array(0)
erro = sp.array(0.05)
logospath = False
logosa = False
exe += 1
if tipo =='port':
dic['exeNummber'] = exe
elif tipo=='starboard':
dic['exeNummber'] = exe - 1
dic['time'] = tp - sp.array(dt)
dic['path'] = self.MostraPos()[1]
dic['proa'] = self.MostraPos()[5]
###############################
##
## Atualizando os parâmetros
##
###############################
if ((exe!=0 and tipo == 'port') or (exe!=1 and tipo ==
'starboard')):
if ((logospath == False) and
(abs(self.MostraPos()[1] - dic['path']) >= ospath)):
#(sp.sign(self.MostraPos()[1])== sp.sign(dic['path'])) and
ospath = abs(self.MostraPos()[1] - dic['path'])
else:
logospath = True
if ((logosa == False) and (abs(self.MostraPos()[5] -
dic['proa']) >= osa)): #(sp.sign(self.MostraPos()[5])==
#sp.sign(dic['proa'])) and
osa = abs(self.MostraPos()[5] - dic['proa'])
else:
logosa = True
if abs(abs(self.MostraPos()[5]) - abs(PosIni[5])) < erro:
erro = abs(self.MostraPos()[5] - PosIni[5])
#
# inc = Velocidades Lineares no Sistema Inecial
#
MatRot = self.MatRot()
VelIn = MatRot * sp.matrix(self.vel[0:3])
PosIne = self.MostraPos()[0:3]
###################################
#################################
##
## Cálculo das forças de Maneira Modular
##
###################################
ft = self.VetF(par)
##################################
##################################
##
## Guardando os parâmetros
##
##################################
# Velocidade Inercial
if saida == 'txt':
veloInerHis.write('%.2f'.rjust(5)%(tp) + ' ')
for arg in VelIn:
veloInerHis.write('%.5e'.rjust(11)%(arg) + ' ')
veloInerHis.write('\n')
elif saida == 'mem':
d = sp.hstack(VelIn)
veloInerHis[cont, 1:] = d #
veloInerHis[cont, 0] = tp #
# Histórico Leme
if saida == 'txt':
lemeHis.write('%.2f'.rjust(5)%(tp) + ' ')
lemeHis.write('%.2f'.rjust(5)%(self.MostraLeme()) + '\n')
elif saida == 'mem':
lemeHis[cont, 0] = tp
lemeHis[cont, 1] = self.MostraLeme()
# Histórico da posição
if saida == 'txt':
posHis.write('%.2f'.rjust(5)%(tp) + ' ')
for arg in self.MostraPos():
posHis.write('%.5e'.rjust(11)%(arg) + ' ')
posHis.write('\n')
elif saida == 'mem':
temp = sp.hstack(self.MostraPos())
posHis[cont, :] = sp.hstack((tp, temp))
del temp
# Histórico da Velocidade
if saida == 'txt':
veloHis.write('%.2f'.rjust(5)%(tp) + ' ')
for arg in self.MostraVel():
veloHis.write('%.5e'.rjust(11)%(arg) + ' ')
veloHis.write('\n')
elif saida == 'mem':
temp = sp.hstack(self.MostraVel())
veloHis[cont, :] = sp.hstack((tp, temp))
del temp
# Histórico das Forças
if saida == 'txt':
temp = sp.zeros((4, 1))
if GrausDeLib == 4:
temp = ft
elif GrausDeLib == 3:
temp[:2] = ft[:2]
temp[3] = ft[2]
fHis.write('%.2f'.rjust(5)%(tp) + ' ')
for arg in temp:
fHis.write('%.5e'.rjust(11)%(arg) + ' ')
fHis.write('\n')
elif saida == 'mem':
temp = sp.hstack(sp.array(ft))
if GrausDeLib == 4:
fHis[cont, :] = sp.hstack((tp, temp))
elif GrausDeLib == 3:
fHis[cont, :3] = sp.hstack((tp, temp[:2]))
fHis[cont, 4] = temp[2]
# Histórico Propulsor
if saida == 'txt':
propHis.write('%.2f'.rjust(5)%(tp) + ' ')
propHis.write('%.2f'.rjust(5)%self.MostraRot() + '\n')
elif saida == 'mem':
propHis[cont, :] = sp.hstack((tp, self.MostraRot()))
# Histórico Eta
if saida == 'txt':
EtaHis.write('%.2f'.rjust(5)%(tp) + ' ')
if Eta == 'rot':
EtaHis.write('%.2f'.rjust(5) % (self.MostraRotCom() /
self.MostraRot()) + '\n')
elif Eta == 'vel':
EtaHis.write('%.2f'.rjust(5) % (self.MostraVelCom() /
self.MostraVel()[0]) + '\n')
elif saida == 'mem':
if Eta== 'rot':
EtaHis[cont, :] = sp.hstack((tp, self.MostraRotCom() /
self.MostraRot()))
elif Eta == 'vel':
EtaHis[cont, :] = sp.hstack((tp, self.MostraVelCom() /
self.MostraVel()[0]))
# Histórico das Acelerações
Acel = self.f2(ft, self.H(GrausDeLib))
vetor = sp.zeros((6, 1))
if GrausDeLib == 4:
vetor[:2] = Acel[:2]
vetor[3] = Acel[2]
vetor [5] = Acel[3]
elif GrausDeLib == 3:
vetor[:2] = Acel[:2]
vetor [5] = Acel[2]
if saida == 'txt':
acelHis.write('%.2f'.rjust(5)%(tp) + ' ')
for arg in vetor:
acelHis.write('%.5e'.rjust(11)%(arg[0]) + ' ')
acelHis.write('\n')
elif saida == 'mem':
acelHis[cont, :] = sp.hstack((tp, sp.hstack(vetor)))
del vetor
##############################
##
## Criação de vetor de graus de liberdade
##
##############################
if GrausDeLib == 4:
vt = sp.zeros([6, 1])
vt [0] = self.MostraVel()[0]
vt [1] = self.MostraVel()[1]
vt [2] = self.MostraVel()[3]
vt [3] = self.MostraVel()[5]
vt [4] = self.MostraPos()[3]
vt [5] = self.MostraPos()[5]
elif GrausDeLib == 3:
vt = sp.zeros([4, 1])
vt [0] = self.MostraVel()[0]
vt [1] = self.MostraVel()[1]
vt [2] = self.MostraVel()[5]
vt [3] = self.MostraPos()[5]
##################################
##
## Integração da Aceleração solidária
##
##################################
if met == 'euler':
vt = self.integrador.euler(self.f, vt, tp, dt ,par )
elif met =='rk4':
vt = self.integrador.rk4(self.f, vt, tp, dt, par)
##################################
if GrausDeLib == 4:
v = sp.zeros((6, 1))
v[0] = vt[0]
v[1] = vt[1]
v[3] = vt[2]
v[5] = vt[3]
elif GrausDeLib ==3:
v = sp.zeros((6, 1))
v[0] = vt[0]
v[1] = vt[1]
v[5] = vt[2]
self.MudaVel(v)
del v
##################################
##
## Integração da velocidade inercial
##
###################################
x = sp.zeros((6, 1))
if met == 'euler':
x[:3] = self.integrador.euler(self.fvein, self.MostraPos()[:3],
tp, dt, (self.MostraPos()[3:],
self.MostraVel()[:3]))
elif met == 'rk4':
x[:3] = self.integrador.rk4(self.fvein, self.MostraPos()[:3],
tp, dt, (self.MostraPos()[3:],
self.MostraVel()[:3]))
##################################
if GrausDeLib == 4:
x[3] = vt[4]
x[5] = vt[5]
elif GrausDeLib == 3:
x[5] = vt[3]
self.MudaPos(x)
cont += 1
del x
self.prop.MudaRot(tp)
self.leme.MudaLeme(tp)
if saida == 'txt':
arq = [veloHis, posHis, acelHis, fHis, veloInerHis, lemeHis,
propHis, EtaHis]
for arg in arq:
arg.close()
return dados
elif saida == 'mem':
return (veloHis, posHis, acelHis, fHis, veloInerHis, lemeHis,
propHis, EtaHis, dados)
def simulaTestb(self, p, intervalo=sp.array(5.), V= None ):
"""
Retorna uma matrix com o valor das forças variando de acordo com que
varia a velocidade
u= Vcos(beta) v = Vsen(beta) com beta variando de 0 a 180 graus em um
intervalo = intervalo
"""
if V == None:
V = self.dic['unom']
Velocidade = sp.zeros((6, 1))
saida = sp.zeros([len( sp.arange(0., sp.pi, intervalo * sp.pi / 180)),
5])
contlinha = 0
for beta in sp.arange(0., sp.pi, intervalo * sp.pi / 180):
Velocidade[0] = sp.array(V) * sp.cos(beta)
Velocidade[1] = -sp.array(V) * sp.sin(beta)
self.MudaVelCom(Velocidade[0]) #condição que força \eta=1
self.MudaVel(Velocidade)
v = sp.sqrt(Velocidade[0] ** 2 + Velocidade[1] ** 2)
rho = self.dic['rho']
lpp = self.dic['lpp']
vetF = self.VetF((4, p))
# vetF = sp.hstack(vetF)
saida[contlinha, :] = sp.hstack([beta, vetF[0] * (2 / (rho * (lpp *
(v ** 2)))), vetF[1] * (2 / (rho *
(lpp* (v ** 2)))), vetF[2] *
(2 / (rho * ((lpp * v) ** 2))),
vetF[3] * (2 / (rho * ((lpp * v) **
2)))])
contlinha += 1
return saida
| gpl-3.0 | -2,103,145,341,740,217,300 | 33.131995 | 79 | 0.426835 | false |
zombiezen/pymage | pymage/config.py | 1 | 21300 | #!/usr/bin/env python
#
# config.py
# pymage
#
# Copyright (C) 2006-2007 Ross Light
#
# This file is part of pymage.
#
# pymage is free software; you can redistribute it and/or modify it under the
# terms of the GNU Lesser General Public License as published by the Free
# Software Foundation; either version 3 of the License, or (at your option)
# any later version.
#
# pymage 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 Lesser General Public License for
# more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this library. If not, see <http://www.gnu.org/licenses/>.
#
"""
Provide configuration for your game.
The typical use of this module is to use the `setup` function and give set up
parameters. From there, the module sets up the correct parts of the pymage
library.
This module is not strictly necessary, but pymage's reasoning is as follows:
Resources for the game should be loaded on an location-independent basis.
This provides abstraction and the ability for arbitrary file structure.
However, these files eventually need to be located, so the developer should
create a file (separate from the main code) that locates everything. From
there, there may be a legitimate reason for the user to want to customize the
file locations (perhaps he/she wants the game resources to be on a separate hard
drive). Therefore, a separate file is used to override the behavior of any
given installation of the game. But since the user never touches the
developer's default game setup, any corrupt preferences can be corrected by
deleting the user configuration files.
Here is a sample gamesite.xml file::
<?xml version="1.0"?>
<!-- name is not necessary, but reserved for future use. -->
<game-site name="Sample Game">
<!-- Prepare an image in the ImageManager.
The id attribute is used as the tag.
The path element is required to find the file.
The section and option elements specify how the path can be
overriden in configuration files. -->
<image id="SampleImage">
<section>sprites</section>
<option>sample</option>
<path>img/sample.png</path>
</image>
<!-- Prepare a sound in the SoundManager.
The id attribute is used as the tag.
The path element is required to find the file.
The section and option elements specify how the path can be
overriden in configuration files. -->
<sound id="SampleSound">
<section>sounds</section>
<option>sample</option>
<path>sfx/sample.wav</path>
</sound>
<!-- Prepare a playlist in the MusicManager.
The id attribute is used as the tag.
The path element(s) are required to find the music file(s).
The section and option elements specify how the playlist can be
overriden in configuration files. -->
<music id="song1">
<path>music/song1.wav</path>
</music>
<playlist id="SamplePlaylist">
<section>playlists</section>
<option>sample</option>
<music ref="song1"/>
<path>music/song2.wav</path> <!-- Old way, still works -->
</playlist>
<!-- Prepare a cache group. -->
<group id="SampleGroup">
<section>groups</section>
<option>sample</option>
<image ref="SampleImage"/>
<sound ref="SampleSound"/>
</group>
<!-- Specify additional configuration files. -->
<config-file>userconfig.ini</config-file>
</game-site>
"""
from ConfigParser import ConfigParser
import os
from textwrap import dedent
import warnings
from xml.dom import minidom
from pymage import resman
from pymage import sound
from pymage import states
from pymage import vfs
__author__ = 'Ross Light'
__date__ = 'August 10, 2006'
__all__ = ['GameSiteWarning',
'load',
'save',
'getOption',
'setOption',
'registerType',
'unregisterType',
'setup',]
__docformat__ = 'reStructuredText'
# Globals
_gsPrims = {'resource': resman.Resource,
'image': resman.ImageResource,
'sound': resman.SoundResource,
'music': resman.MusicResource,}
class GameSiteWarning(UserWarning):
"""Warning emitted when odd game site constructs are used."""
pass
## CONFIG PARSER ##
class CaseConfigParser(ConfigParser):
"""A ``ConfigParser`` that is case-sensitive."""
def optionxform(self, optstr):
"""Return the string in the same case."""
return optstr
def load(*args, **kw):
"""
Load a series of configuration files.
Any keyword values are used as variables.
:Keywords:
convert : bool
Whether the function should interpret the values as what they seem
to be (e.g. ``float``, ``int``). The default is ``True``.
:Returns: Loaded configuration
:ReturnType: dict
"""
# Retrieve convert keyword
convertValues = kw.get('convert', True)
try:
del kw['convert']
except KeyError:
pass
# Parse the files
parser = CaseConfigParser(kw)
for configFile in args:
close = False
if isinstance(configFile, (basestring, vfs.Path)):
# Open strings as paths
game = states.Game.getGame()
if game is None:
# Use physical filesystem
configFile = os.path.normpath(os.path.expanduser(configFile))
if os.path.exists(configFile):
configFile = open(configFile)
else:
continue
else:
# Use virtual filesystem
if game.filesystem.exists(configFile):
configFile = game.filesystem.open(configFile)
else:
continue
close = True
parser.readfp(configFile)
if close:
configFile.close()
# Assemble dictionary
configDict = {}
for section in parser.sections():
sectionDict = {}
for option in parser.options(section):
value = parser.get(section, option)
if convertValues: # Interpret values
value = _getValue(value)
sectionDict[option] = value
configDict[section] = sectionDict
return configDict
def save(config, config_file):
"""
Saves a configuration dictionary to a file.
:Parameters:
config : dict
Configuration dictionary
config_file : string or file
File to write configuration to
"""
# Create configuration writer
parser = CaseConfigParser()
for section, values in config.iteritems():
parser.add_section(section)
for option, value in values.iteritems():
parser.set(section, option, value)
# Determine file to write
close = False
if isinstance(config_file, (basestring, vfs.Path)):
game = states.Game.getGame()
if game is not None:
config_file = game.filesystem.open(site)
else:
if isinstance(config_file, vfs.Path):
config_file = str(config_file)
path = os.path.normpath(os.path.expanduser(config_file))
config_file = open(path, 'w')
close = True
# Write file and close
parser.write(config_file)
if close:
config_file.close()
def _getValue(value_string):
"""
Retrieves a value from a ``ConfigParser`` string.
:Parameters:
value_string : string
Option string to convert
:Returns: The string's value, converted into an int, bool, float, or string
"""
boolLiterals = {'false': False,
'no': False,
'off': False,
'true': True,
'yes': True,
'on': True,}
if value_string.isdigit():
# Integer
return int(value_string)
elif value_string.lower() in boolLiterals:
# Boolean
return boolLiterals[value_string.lower()]
elif _isFloat(value_string):
# Float
return float(value_string)
else:
# String
return str(value_string)
def _isFloat(value_string):
"""
Returns whether the string is a ``float``.
The format for a float is::
int[.[fraction]]
:Parameters:
value_string : string
String to test for floatiness
:ReturnType: bool
"""
if value_string.isdigit():
# int
return True
elif value_string.count('.') == 1:
# has a decimal point
value_string = value_string.replace('.', '')
if value_string.isdigit():
# int[.[fraction]]
return True
else:
return False
else:
return False
def getOption(config, section, option, default=None):
"""
Retrieves an option from the configuration dictionary.
:Parameters:
config : dict
Configuration dictionary to read from
section : string
Configuration section
option : string
Option name
default
Default value to return if option is not found
:Returns: The requested option's value
"""
try:
section = config[section]
except KeyError:
return default
else:
return section.get(option, default)
def setOption(config, section, option, value):
"""
Changes an option in the configuration dictionary.
:Parameters:
config : dict
Configuration dictionary to modify
section : string
Configuration section
option : string
Option name
value
Value to change the option to
"""
section = config.setdefault(section, {})
section[option] = value
## GAME SITE ##
def registerType(tag, factory):
"""
Register a custom game site resource type.
:Parameters:
tag : string
Name of the XML element
factory
Callable that takes one positional argument: the path to the
resource. Any additional attributes found on the XML element are
passed as keyword arguments. The value of this parameter is
typically the constructor of a `pymage.resman.Resource` subclass.
"""
_gsPrims[tag] = factory
def unregisterType(tag):
"""
Unregister a custom game site resource type.
:Parameters:
tag : string
Name of the XML element
"""
del _gsPrims[tag]
def setup(site='gamesite.xml', *config_files, **kw):
"""
Sets up a game from the specified parameters.
The additional arguments are program default configuration files. These
are parsed before any inside the game site file (therefore giving the site
configuration files higher precedence).
:Parameters:
site : string or file
Game site file
:Keywords:
configSound : bool
Whether the sound manager volume should be configured automatically
configMusic : bool
Whether the music manager volume should be configured automatically
:Returns: The game's configuration
:ReturnType: dict
"""
# Get keyword arguments
configSound = kw.pop('configSound', True)
configMusic = kw.pop('configMusic', True)
if kw:
raise TypeError("Invalid keyword argument")
# See if we can use the game's filesystem
if isinstance(site, (basestring, vfs.Path)):
game = states.Game.getGame()
if game is not None:
site = game.filesystem.open(site)
elif isinstance(site, vfs.Path):
site = str(site)
# Parse game site file
doc = minidom.parse(site)
config = _getSiteConfig(doc, config_files)
# Load configuration
if configSound:
_processSoundOptions(config)
if configMusic:
_processMusicOptions(config)
# Process resources
_processGameSite(doc, config)
# Return configuration dictionary
return config
def _getSiteConfig(doc, config_files):
"""
Obtains full configuration.
The configuration files passed in are put first in the list, so the ones
specified in the game site file take precedence.
:Parameters:
doc : DOM document
Game site DOM tree
config_files : list of strings or files
Configuration files to load
:Returns: The loaded configuration dictionary
:ReturnType: dict
"""
siteConfigs = []
for child in doc.documentElement.childNodes:
if (child.nodeType == minidom.Node.ELEMENT_NODE and
child.tagName == 'config-file'):
siteConfigs.append(_getText(child))
config_files = list(config_files) + list(siteConfigs)
return load(*config_files)
def _processSoundOptions(config):
"""
Configure the sound manager with the default configuration keys.
:Parameters:
config : dict
The configuration dictionary
"""
sound.sound.shouldPlay = bool(getOption(config, 'sound', 'play', True))
sound.sound.volume = float(getOption(config, 'sound', 'volume', 1.0))
def _processMusicOptions(config):
"""
Configure the music manager with the default configuration keys.
:Parameters:
config : dict
The configuration dictionary
"""
sound.music.shouldPlay = bool(getOption(config, 'music', 'play', True))
sound.music.volume = bool(getOption(config, 'music', 'volume', 0.5))
sound.music.loop = bool(getOption(config, 'music', 'loop', True))
def _processGameSite(doc, config):
"""
Run through game site file and add resources to manager.
:Parameters:
doc : DOM document
Game site DOM tree
config : dict
Configuration dictionary
"""
handlers = {'playlist': _handlePlaylist,
'group': _handleGroup,}
handlers.update(dict.fromkeys(_gsPrims, _handlePrimitive))
for child in doc.documentElement.childNodes:
if (child.nodeType == minidom.Node.ELEMENT_NODE and
child.tagName in handlers):
# Call handler
handler = handlers[child.tagName]
handler(child, config)
def _handlePrimitive(elem, config):
"""
Handle a basic resource (i.e. images, sound effects, and custom resources).
:Parameters:
elem : DOM node
Element to handle
config : dict
Configuration dictionary
:Returns: Resource's key
:ReturnType: string
"""
attr = _attributes(elem, include_ns=False, ascii=True)
pathChild = _childNamed(elem, 'path')
if pathChild is None:
warnings.warn("Primitive without a path", GameSiteWarning)
return
# Get ID
try:
key = attr.pop('id')
except KeyError:
pathChild = _childNamed(elem, 'path')
if pathChild:
key = _getText(pathChild)
else:
warnings.warn("Primitive without a key", GameSiteWarning)
return
# Get resource information
resType = _gsPrims[elem.tagName]
section = _getText(_childNamed(elem, 'section'))
option = _getText(_childNamed(elem, 'option'))
path = _getText(pathChild)
# Create resource
if section is not None and option is not None:
path = getOption(config, section, option, path)
resman.resman.addResource(key, resType(path, **attr))
# Return key
return key
def _handlePlaylist(elem, config):
"""
Handle a playlist element.
:Parameters:
elem : DOM node
Element to handle
config : dict
Configuration dictionary
:Returns: Playlist's key
:ReturnType: string
"""
key = elem.getAttribute('id')
section = _getText(_childNamed(elem, 'section'))
option = _getText(_childNamed(elem, 'option'))
playlistKeys = []
# Get playlist keys
for sub in elem.childNodes:
if sub.nodeType == minidom.Node.ELEMENT_NODE:
if sub.tagName == 'path':
# Old-school path approach
warnings.warn("%s using old path-based playlist" % (key),
GameSiteWarning)
if sub.hasAttribute('id'):
musicKey = sub.getAttribute('id')
musicPath = _getText(sub)
else:
musicKey = musicPath = _getText(sub)
resman.addResource(musicKey, resman.MusicResource(musicPath))
playlistKeys.append(musicKey)
elif sub.tagName == 'music':
# New-school music reference/declaration approach
if sub.hasAttribute('ref'):
musicKey = sub.getAttribute('ref')
else:
musicKey = _handlePrimitive(sub, config)
playlistKeys.append(musicKey)
# Create playlist
if section is not None and option is not None:
configKeys = getOption(config, section, option)
if configKeys is not None:
playlistKeys = configKeys.split(',')
sound.music.addPlaylist(key, playlistKeys)
# Return key
return key
def _handleGroup(elem, config):
"""
Handle a group element (a cache group).
:Parameters:
elem : DOM node
Element to handle
config : dict
Configuration dictionary
:Returns: Cache group's key
:ReturnType: string
"""
key = elem.getAttribute('id')
section = _getText(_childNamed(elem, 'section'))
option = _getText(_childNamed(elem, 'option'))
groupKeys = set()
# Get group keys
for sub in elem.childNodes:
if (sub.nodeType == minidom.Node.ELEMENT_NODE and
sub.tagName in _gsPrims):
if sub.hasAttribute('ref'):
resourceKey = sub.getAttribute('ref')
else:
resourceKey = _handlePrimitive(sub, config)
groupKeys.add(resourceKey)
# Create group
if section is not None and option is not None:
configKeys = getOption(config, section, option)
if configKeys is not None:
groupKeys = configKeys.split(',')
resman.resman.addCacheGroup(key, groupKeys)
# Return key
return key
def _getText(elem, post=True):
"""
Retrieve text from a DOM node, stripping indents, if asked.
This function does honor the ``xml:space`` attribute, and if
``xml:space="preserve"`` is specified, it takes precendence over the
``post`` argument.
:Parameters:
elem : DOM node
The element to get text from
:Keywords:
post : bool
Whether to strip indents
:Returns: The element's text
:ReturnType: string
"""
xmlNS = 'http://www.w3.org/XML/1998/namespace'
if elem is None:
return None
text = ''
for child in elem.childNodes:
if child.nodeType == minidom.Node.TEXT_NODE:
text += child.wholeText
preserve = (elem.hasAttributeNS(xmlNS, 'space') and
elem.getAttributeNS(xmlNS, 'space') == 'preserve')
if post and not preserve:
text = dedent(text)
if text.startswith('\n'):
text = text[1:]
if text.endswith('\n'):
text = text[:-1]
return text
def _childNamed(elem, name):
"""
Returns the first child with the given name.
:Parameters:
elem : DOM node
The element to search in
name : string
The name to search for
:Returns: The named child, or ``None`` if not found
:ReturnType: DOM node
"""
for child in elem.childNodes:
if (child.nodeType == minidom.Node.ELEMENT_NODE and
child.tagName == name):
return child
else:
return None
def _attributes(elem, include_ns=True, ascii=False):
"""
Retrieves the attributes of a DOM node as a dictionary.
If ``include_ns`` is ``True``, then . If ``ascii`` is ``True``, then
:Parameters:
elem : DOM node
The element to extract attributes from
:Keywords:
include_ns : bool
Whether attributes with a namespace will be discarded
ascii : bool
Whether the attribute names are converted to ASCII. If an attribute
name cannot be converted, the entire attribute is discarded.
"""
nodemap = elem.attributes
attrDict = {}
for index in xrange(nodemap.length):
attr = nodemap.item(index)
if not include_ns and attr.prefix:
continue
name = attr.localName
if ascii:
try:
name = str(name)
except UnicodeError:
continue
attrDict[name] = attr.value
return attrDict
| gpl-3.0 | -6,821,084,749,787,888,000 | 31.223903 | 80 | 0.601596 | false |
ASMlover/study | cplusplus/wren_cc/test/bench_fib.py | 1 | 1588 | #!/usr/bin/env python
# -*- coding: UTF-8 -*-
#
# Copyright (c) 2019 ASMlover. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list ofconditions and the following disclaimer.
#
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materialsprovided with the
# distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
import time
def fib(n):
if n < 2:
return n
return fib(n - 1) + fib(n - 2)
start = time.clock()
for i in range(5):
print(fib(20))
print("use: " + str(time.clock() - start))
| bsd-2-clause | -9,005,991,868,441,173,000 | 37.731707 | 70 | 0.742443 | false |
CCS-Lab/hBayesDM | Python/hbayesdm/models/_dd_hyperbolic_single.py | 1 | 9923 | from typing import Sequence, Union, Any
from collections import OrderedDict
from numpy import Inf, exp
import pandas as pd
from hbayesdm.base import TaskModel
from hbayesdm.preprocess_funcs import dd_single_preprocess_func
__all__ = ['dd_hyperbolic_single']
class DdHyperbolicSingle(TaskModel):
def __init__(self, **kwargs):
super().__init__(
task_name='dd',
model_name='hyperbolic',
model_type='single',
data_columns=(
'subjID',
'delay_later',
'amount_later',
'delay_sooner',
'amount_sooner',
'choice',
),
parameters=OrderedDict([
('k', (0, 0.1, 1)),
('beta', (0, 1, 5)),
]),
regressors=OrderedDict([
]),
postpreds=['y_pred'],
parameters_desc=OrderedDict([
('k', 'discounting rate'),
('beta', 'inverse temperature'),
]),
additional_args_desc=OrderedDict([
]),
**kwargs,
)
_preprocess_func = dd_single_preprocess_func
def dd_hyperbolic_single(
data: Union[pd.DataFrame, str, None] = None,
niter: int = 4000,
nwarmup: int = 1000,
nchain: int = 4,
ncore: int = 1,
nthin: int = 1,
inits: Union[str, Sequence[float]] = 'vb',
ind_pars: str = 'mean',
model_regressor: bool = False,
vb: bool = False,
inc_postpred: bool = False,
adapt_delta: float = 0.95,
stepsize: float = 1,
max_treedepth: int = 10,
**additional_args: Any) -> TaskModel:
"""Delay Discounting Task - Hyperbolic Model
Individual Bayesian Modeling of the Delay Discounting Task
using Hyperbolic Model [Mazur1987]_ with the following parameters:
"k" (discounting rate), "beta" (inverse temperature).
.. [Mazur1987] Mazur, J. E. (1987). An adjustment procedure for studying delayed reinforcement.
User data should contain the behavioral data-set of all subjects of interest for
the current analysis. When loading from a file, the datafile should be a
**tab-delimited** text file, whose rows represent trial-by-trial observations
and columns represent variables.
For the Delay Discounting Task, there should be 6 columns of data
with the labels "subjID", "delay_later", "amount_later", "delay_sooner", "amount_sooner", "choice". It is not necessary for the columns to be
in this particular order; however, it is necessary that they be labeled
correctly and contain the information below:
- "subjID": A unique identifier for each subject in the data-set.
- "delay_later": An integer representing the delayed days for the later option (e.g. 1, 6, 28).
- "amount_later": A floating point number representing the amount for the later option (e.g. 10.5, 13.4, 30.9).
- "delay_sooner": An integer representing the delayed days for the sooner option (e.g. 0).
- "amount_sooner": A floating point number representing the amount for the sooner option (e.g. 10).
- "choice": If amount_later was selected, choice == 1; else if amount_sooner was selected, choice == 0.
.. note::
User data may contain other columns of data (e.g. ``ReactionTime``,
``trial_number``, etc.), but only the data within the column names listed
above will be used during the modeling. As long as the necessary columns
mentioned above are present and labeled correctly, there is no need to
remove other miscellaneous data columns.
.. note::
``adapt_delta``, ``stepsize``, and ``max_treedepth`` are advanced options that
give the user more control over Stan's MCMC sampler. It is recommended that
only advanced users change the default values, as alterations can profoundly
change the sampler's behavior. See [Hoffman2014]_ for more information on the
sampler control parameters. One can also refer to 'Section 34.2. HMC Algorithm
Parameters' of the `Stan User's Guide and Reference Manual`__.
.. [Hoffman2014]
Hoffman, M. D., & Gelman, A. (2014).
The No-U-Turn sampler: adaptively setting path lengths in Hamiltonian Monte Carlo.
Journal of Machine Learning Research, 15(1), 1593-1623.
__ https://mc-stan.org/users/documentation/
Parameters
----------
data
Data to be modeled. It should be given as a Pandas DataFrame object,
a filepath for a data file, or ``"example"`` for example data.
Data columns should be labeled as: "subjID", "delay_later", "amount_later", "delay_sooner", "amount_sooner", "choice".
niter
Number of iterations, including warm-up. Defaults to 4000.
nwarmup
Number of iterations used for warm-up only. Defaults to 1000.
``nwarmup`` is a numerical value that specifies how many MCMC samples
should not be stored upon the beginning of each chain. For those
familiar with Bayesian methods, this is equivalent to burn-in samples.
Due to the nature of the MCMC algorithm, initial values (i.e., where the
sampling chains begin) can have a heavy influence on the generated
posterior distributions. The ``nwarmup`` argument can be set to a
higher number in order to curb the effects that initial values have on
the resulting posteriors.
nchain
Number of Markov chains to run. Defaults to 4.
``nchain`` is a numerical value that specifies how many chains (i.e.,
independent sampling sequences) should be used to draw samples from
the posterior distribution. Since the posteriors are generated from a
sampling process, it is good practice to run multiple chains to ensure
that a reasonably representative posterior is attained. When the
sampling is complete, it is possible to check the multiple chains for
convergence by running the following line of code:
.. code:: python
output.plot(type='trace')
ncore
Number of CPUs to be used for running. Defaults to 1.
nthin
Every ``nthin``-th sample will be used to generate the posterior
distribution. Defaults to 1. A higher number can be used when
auto-correlation within the MCMC sampling is high.
``nthin`` is a numerical value that specifies the "skipping" behavior
of the MCMC sampler. That is, only every ``nthin``-th sample is used to
generate posterior distributions. By default, ``nthin`` is equal to 1,
meaning that every sample is used to generate the posterior.
inits
String or list specifying how the initial values should be generated.
Options are ``'fixed'`` or ``'random'``, or your own initial values.
ind_pars
String specifying how to summarize the individual parameters.
Current options are: ``'mean'``, ``'median'``, or ``'mode'``.
model_regressor
Whether to export model-based regressors. Currently not available for this model.
vb
Whether to use variational inference to approximately draw from a
posterior distribution. Defaults to ``False``.
inc_postpred
Include trial-level posterior predictive simulations in
model output (may greatly increase file size). Defaults to ``False``.
adapt_delta
Floating point value representing the target acceptance probability of a new
sample in the MCMC chain. Must be between 0 and 1. See note below.
stepsize
Integer value specifying the size of each leapfrog step that the MCMC sampler
can take on each new iteration. See note below.
max_treedepth
Integer value specifying how many leapfrog steps the MCMC sampler can take
on each new iteration. See note below.
**additional_args
Not used for this model.
Returns
-------
model_data
An ``hbayesdm.TaskModel`` instance with the following components:
- ``model``: String value that is the name of the model ('dd_hyperbolic_single').
- ``all_ind_pars``: Pandas DataFrame containing the summarized parameter values
(as specified by ``ind_pars``) for each subject.
- ``par_vals``: OrderedDict holding the posterior samples over different parameters.
- ``fit``: A PyStan StanFit object that contains the fitted Stan model.
- ``raw_data``: Pandas DataFrame containing the raw data used to fit the model,
as specified by the user.
Examples
--------
.. code:: python
from hbayesdm import rhat, print_fit
from hbayesdm.models import dd_hyperbolic_single
# Run the model and store results in "output"
output = dd_hyperbolic_single(data='example', niter=2000, nwarmup=1000, nchain=4, ncore=4)
# Visually check convergence of the sampling chains (should look like "hairy caterpillars")
output.plot(type='trace')
# Plot posterior distributions of the hyper-parameters (distributions should be unimodal)
output.plot()
# Check Rhat values (all Rhat values should be less than or equal to 1.1)
rhat(output, less=1.1)
# Show the LOOIC and WAIC model fit estimates
print_fit(output)
"""
return DdHyperbolicSingle(
data=data,
niter=niter,
nwarmup=nwarmup,
nchain=nchain,
ncore=ncore,
nthin=nthin,
inits=inits,
ind_pars=ind_pars,
model_regressor=model_regressor,
vb=vb,
inc_postpred=inc_postpred,
adapt_delta=adapt_delta,
stepsize=stepsize,
max_treedepth=max_treedepth,
**additional_args)
| gpl-3.0 | 7,724,618,514,999,984,000 | 40.518828 | 145 | 0.640331 | false |
kashev/pysc | util/anagram_dict_builder.py | 1 | 1580 | #!/usr/bin/env python3
# pysc
# Kashev Dalmia | @kashev | [email protected]
# anagram_dict_builder.py
""" A script which builds an anagram dictionary from a dictionary. """
# Credit: Jeff Knupp
# https://github.com/jeffknupp/presser/blob/master/make_anagrams.py
import collections
import os
import string
def build_anagram_dict(infile, outfile):
with open(infile, 'r') as file_handle:
words = collections.defaultdict(list)
letters = set(string.ascii_lowercase + '\n')
for word in file_handle:
# Check to see if the word contains only letters in the set
# (no apostraphies, only an issue if using a poor dictionary)
# and that the word is of a reasonable length
if len(set(word) - letters) == 0 and len(word) < 20 or True:
word = word.strip()
letter_key = ''.join(sorted(word))
words[letter_key].append(word)
anagram_dictionary = [' '.join([key] + value)
for key, value in words.items()]
anagram_dictionary.sort()
with open(outfile, 'w') as file_handle:
file_handle.write('\n'.join(anagram_dictionary))
def main():
""" main function. """
# Change to script directory.
abspath = os.path.abspath(__file__)
dname = os.path.dirname(abspath)
os.chdir(dname)
for sd in ["sowpods", "twl", "wwf"]:
infile = '../dict/{}.txt'.format(sd)
outfile = '../dict/{}_anagram.txt'.format(sd)
build_anagram_dict(infile, outfile)
if __name__ == '__main__':
main()
| mit | 3,450,408,199,887,984,000 | 31.244898 | 73 | 0.605063 | false |
dbenoit17/ansible_agnostic_deployer | ansible/inventory/ravello.py | 1 | 7162 | #!/usr/bin/python
'''
Ravello external inventory script
==================================================
Generates inventory that Ansible can understand by making an API request to Ravello.
Modeled after https://raw.githubusercontent.com/jameslabocki/ansible_api/master/python/ansible_tower_cloudforms_inventory.py
Required: Ravello Python SDK https://github.com/ravello/python-sdk
Useful: https://www.ravellosystems.com/ravello-api-doc/
Notes: In my testing, with >200 applications and ~1,000 virtual machines this took 30 seconds to execute.
If the get_applications call in the Ravello Python SDK supported dumping design information this could be dramatically reduced.
jlabocki <at> redhat.com or @jameslabocki on twitter
'''
import os
import re
import argparse
import ConfigParser
import requests
import json
from argparse import ArgumentParser
import base64
import getpass
import logging
import logging.handlers
from ravello_sdk import *
def get_credentials():
with open(os.path.expanduser("~/.ravello_login"),"r") as pf:
username = pf.readline().strip()
encrypted_password = pf.readline().strip()
password = base64.b64decode(encrypted_password).decode()
return username,password
def get_user_credentials(username):
password = None
if username:
password = getpass.getpass('Enter a Password: ')
else:
#read user credentials from .ravello_login file in user HOMEDIR
username,password = get_credentials()
if not username or not password:
log.error('User credentials are not set')
print('Error: User credentials are not set')
return None,None
return username,password
def connect(username, password):
client = RavelloClient()
try:
client.login(username, password)
except Exception as e:
print('Error: Invalid user credentials, username {0}'.format(username))
return None
return client
def get_app_id(app_name,client):
app_id=0
for app in client.get_applications():
if app['name'].lower() == app_name.lower():
app_id = app['id']
break
return app_id
class RavelloInventory(object):
def _empty_inventory(self):
return {"_meta" : {"hostvars" : {}}}
def __init__(self):
''' Main execution path '''
# Inventory grouped by instance IDs, tags, security groups, regions,
# and availability zones
self.inventory = self._empty_inventory()
# Index of hostname (address) to instance ID
self.index = {}
# Read CLI arguments
self.read_settings()
self.parse_cli_args()
# If --apps is set then run get_apps_all
#if self.args.apps is True:
# self.get_apps_all()
# If --list is set then run get_app with ID of application
if self.args.list is not None:
self.get_app()
def parse_cli_args(self):
''' Command line argument processing '''
parser = argparse.ArgumentParser(description='Produce an Ansible Inventory file based on Ravello')
parser.add_argument('--apps', action='store_false',
help='List all app names (default: False)')
parser.add_argument('--list', action='store', default=False,
help='Get the group(s) and hostname(s) from a specific application by specifying the app name')
self.args = parser.parse_args()
def read_settings(self):
''' Reads the settings from the ravello.ini file '''
config = ConfigParser.SafeConfigParser()
config_paths = [
os.path.join(os.path.dirname(os.path.realpath(__file__)), 'ravello.ini'),
"/etc/ansible/ravello.ini",
]
env_value = os.environ.get('RAVELLO_INI_PATH')
if env_value is not None:
config_paths.append(os.path.expanduser(os.path.expandvars(env_value)))
config.read(config_paths)
# Get Auth from INI
INI=True
if config.has_option('ravello', 'username'):
self.ravello_username = config.get('ravello', 'username')
else:
self.ravello_username = "none"
INI=False
if config.has_option('ravello', 'password'):
self.ravello_password = config.get('ravello', 'password')
else:
self.ravello_password = "none"
INI=False
if INI is False:
self.ravello_username, self.ravello_password = get_user_credentials(None)
if not self.ravello_username or not self.ravello_password:
print("ERROR: Could not get Ravello credentials from INI file or .ravello_login (SDK Auth)")
exit(1)
def get_apps_all(self):
#Connect to Ravello
client = connect(self.ravello_username, self.ravello_password)
if not client:
exit (1)
apps = client.get_applications()
names = []
for app in apps:
#Only get the published apps
if app['published']:
myname = (json.dumps(app['name']))
names.append(myname)
for name in names:
print name
def get_app(self):
#Connect to Ravello
myappname = self.args.list
client = connect(self.ravello_username, self.ravello_password)
if not client:
exit (1)
apps = client.get_applications()
myappid = ""
for app in apps:
#Only get the published apps
if app['published']:
if str(app['name']) == myappname:
myappid = app['id']
#First, define empty lists for the the tags, groups, subgroups for tags/vms, and the formatted list for tower.
groups = {}
groups['_meta'] = {}
groups['_meta']['hostvars'] = {}
app = client.get_application(myappid, aspect="deployment")
if app['deployment']:
appname = app['name']
vmsFlag = True if "vms" in app["deployment"] else False
if vmsFlag == True:
vms = app['deployment']['vms']
for vm in vms:
#if 'externalFqdn' in vm:
# hostname = vm['externalFqdn']
#else:
hostnames = vm['hostnames']
hostname = hostnames[0]
desc = vm['description']
for line in desc.splitlines():
if re.match("^tag:", line):
t = line.split(':')
tag = t[1]
if tag in groups.keys():
groups[tag]['hosts'].append(hostname)
else:
groups[tag] = {}
groups[tag]['hosts'] = {}
groups[tag]['hosts'] = [hostname]
if 'externalFqdn' in vm:
groups['_meta']['hostvars'][hostname] = { 'externalFqdn': vm['externalFqdn'] }
if tag == 'bastion' and 'externalFqdn' in vm:
groups['_meta']['hostvars'][hostname].update({ 'bastion': True })
print json.dumps(groups, indent=5)
#Run the script
RavelloInventory()
| gpl-3.0 | 1,995,015,316,470,555,400 | 32.004608 | 134 | 0.586289 | false |
guillaume-havard/testdjango | sitetest/stats/middleware.py | 1 | 1123 | from django.db.models import F
from stats.models import Page
class StatsMiddleware(object):
def process_view(self, request, view_func, view_args, view_kwargs):
""" Incrémente le nombre de page vues à chaque appel de vues """
try:
# Le compteur lié à la page est récupéré et incrémenté
p = Page.objects.get(url=request.path)
p.nb_visites = F('nb_visites') + 1
p.save()
except Page.DoesNotExist:
# Un nouveau compteur à 1 par défaut est créé
Page(url=request.path).save()
def process_response(self, request, response):
""" Affiche le nombre de fois que la page a été vue """
if response.status_code == 200:
p = Page.objects.get(url=request.path)
response.content += bytes(
"Cette page a été vue {0} fois.".format(p.nb_visites), "utf8")
return response
# Ici l'objet F permet de faire des requette directement en base de donnée (plus rapide)
# Attention normalement nous ne modifions pas le contenue de la réponse via un missleware !! | mit | -3,092,915,929,755,777,500 | 39.925926 | 92 | 0.631341 | false |
pythonistas-tw/academy | web-api/maomao/web_test.py | 1 | 3005 | import os
import web
import unittest
import tempfile
from lxml import etree
case = [
"/count?op={}&value1=1&value2=1", "/count?op={}&value1=52&value2=7",
"/count?op={}&value1=100.5&value2=33.1", "/count?op={}",
"/count?op={}&value1=1", "/count?op={}&value2=10",
"/count?op={}&value1=&value2=10", "/count?op={}&value1=kk&value2=1",
"/count?op={}&value1=9&value2=ss1", "/count?op={}&value1=9p&value2=121"
]
sum_answer = ["The Answer of 1 + 1 is 2.0", "The Answer of 52 + 7 is 59.0", "The Answer of 100.5 + 33.1 is 133.6"]
sum_answer += ["Missing values"]*4
sum_answer += ["Invalid values"]*3
minus_answer = ["The Answer of 1 - 1 is 0.0", "The Answer of 52 - 7 is 45.0", "The Answer of 100.5 - 33.1 is 67.4"]
minus_answer += ["Missing values"]*4
minus_answer += ["Invalid values"]*3
multiply_answer = ["The Answer of 1 * 1 is 1.0", "The Answer of 52 * 7 is 364.0", "The Answer of 100.5 * 33.1 is 3326.55"]
multiply_answer += ["Missing values"]*4
multiply_answer += ["Invalid values"]*3
divide_answer = ["The Answer of 1 / 1 is 1.0", "The Answer of 52 / 7 is 7.428571428571429", "The Answer of 100.5 / 33.1 is 3.036253776435045"]
divide_answer += ["Missing values"]*4
divide_answer += ["Invalid values"]*3
class FlaskrTestCase(unittest.TestCase):
def setUp(self):
web.app.config['TESTING'] = True
self.app = web.app.test_client()
def test_sum(self):
num = 0
for c in case:
rv = self.app.get(c.format("sum"))
page = etree.HTML(rv.data)
for i in page.xpath(u"//em"):
assert i.text == sum_answer[num], "The Response of {} isn't correct.".format(c.format("sum"))
num += 1
def test_minus(self):
num = 0
for c in case:
rv = self.app.get(c.format("minus"))
page = etree.HTML(rv.data)
for i in page.xpath(u"//em"):
assert i.text == minus_answer[num], "The Response of {} isn't correct.".format(c.format("minus"))
num += 1
def test_multiply(self):
num = 0
for c in case:
rv = self.app.get(c.format("multiply"))
page = etree.HTML(rv.data)
for i in page.xpath(u"//em"):
assert i.text == multiply_answer[num], "The Response of {} isn't correct.".format(c.format("multiply"))
num += 1
def test_divide(self):
num = 0
for c in case:
rv = self.app.get(c.format("divide"))
page = etree.HTML(rv.data)
for i in page.xpath(u"//em"):
assert i.text == divide_answer[num], "The Response of {} isn't correct.".format(c.format("divide"))
num += 1
rv = self.app.get("/count?op=divide&value1=22&value2=0")
page = etree.HTML(rv.data)
for i in page.xpath(u"//em"):
assert i.text == "Zero Division Error", "The Response of {} isn't correct.".format("/count?op=divide&value1=22&value2=0")
if __name__ == '__main__':
unittest.main() | gpl-2.0 | 7,145,401,281,587,108,000 | 37.050633 | 142 | 0.570383 | false |
priyom/priyomdb | Schema/Patches/patch_3.py | 1 | 1691 | """
File name: patch_3.py
This file is part of: priyomdb
LICENSE
The contents of this file are subject to the Mozilla Public License
Version 1.1 (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.mozilla.org/MPL/
Software distributed under the License is distributed on an "AS IS"
basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
License for the specific language governing rights and limitations under
the License.
Alternatively, the contents of this file may be used under the terms of
the GNU General Public license (the "GPL License"), in which case the
provisions of GPL License are applicable instead of those above.
FEEDBACK & QUESTIONS
For feedback and questions about priyomdb please e-mail one of the
authors:
Jonas Wielicki <[email protected]>
"""
def apply(store):
statements = [
"""CREATE TABLE `eventClass` (
`ID` INT NOT NULL AUTO_INCREMENT,
`Title` VARCHAR(255) NOT NULL COMMENT 'title of the event class',
PRIMARY KEY (`ID`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8""",
"""CREATE TABLE `events` (
`ID` INT NOT NULL AUTO_INCREMENT,
`Created` BIGINT NOT NULL COMMENT 'creation date of row',
`Modified` BIGINT NOT NULL COMMENT 'last modification date of row',
`StationID` INT NOT NULL COMMENT 'station to which the ID is associated',
`EventClassID` INT DEFAULT NULL COMMENT 'event class, NULL for raw event',
`Description` TEXT NOT NULL COMMENT 'descriptive text of the event',
PRIMARY KEY (`ID`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8"""
]
for statement in statements:
store.execute(statement)
| gpl-3.0 | -6,247,857,135,208,938,000 | 34.978723 | 78 | 0.735068 | false |
pedrohml/smartbot | smartbot/joke_behaviour.py | 1 | 2199 | # coding: utf-8
from smartbot import Behaviour
from smartbot import Utils
from smartbot import ExternalAPI
import re
import os
import random
class JokeBehaviour(Behaviour):
def __init__(self, bot):
super(JokeBehaviour, self).__init__(bot)
self.language = self.bot.config.get('main', 'language') if self.bot.config.has_option('main', 'language') else 'en-US'
def addHandlers(self):
self.bot.addCommandHandler('joke', self.jokeSearch)
self.bot.addCommandHandler('jalk', self.jalkSearch)
def removeHandlers(self):
self.bot.removeCommandHandler('joke', self.jokeSearch)
self.bot.removeCommandHandler('jalk', self.jalkSearch)
def jokeSearch(self, telegramBot, update):
p = re.compile('([^ ]*) (.*)')
query = (p.match(update.message.text).groups()[1] or '').strip()
self.logDebug(u'Joke search (chat_id: %s, query: %s)' % (update.message.chat_id, query or 'None'))
jokes = ExternalAPI.searchJoke(query)
if jokes:
self.bot.sendMessage(chat_id=update.message.chat_id, text=random.choice(jokes))
def jalkSearch(self, telegramBot, update):
p = re.compile('([^ ]*) (.*)')
query = (p.match(update.message.text).groups()[1] or '').strip()
self.logDebug(u'Jalk search (chat_id: %s, query: %s)' % (update.message.chat_id, query or 'None'))
jokes = ExternalAPI.searchJoke(query)
if jokes:
jokes = filter(lambda c: len(re.split('\W+', c, re.MULTILINE)) < 200, jokes)
jokes = sorted(jokes, lambda x, y: len(x) - len(y))
if jokes:
joke = jokes[0]
audioFile = ExternalAPI.textToSpeech(joke, language=self.language, encode='mp3')
if os.path.exists(audioFile) and os.path.getsize(audioFile) > 0:
self.bot.sendAudio(chat_id=update.message.chat_id, audio=audioFile, performer=self.bot.getInfo().username)
else:
self.bot.sendMessage(chat_id=update.message.chat_id, text=u'Não consigo contar')
else:
self.bot.sendMessage(chat_id=update.message.chat_id, text=u'Não encontrei piada curta')
| mit | 4,034,820,672,840,083,500 | 44.770833 | 126 | 0.622667 | false |
nop33/indico-plugins | importer/indico_importer/controllers.py | 1 | 4381 | # This file is part of Indico.
# Copyright (C) 2002 - 2017 European Organization for Nuclear Research (CERN).
#
# Indico 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.
#
# Indico 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 Indico; if not, see <http://www.gnu.org/licenses/>.
from __future__ import unicode_literals
from datetime import datetime
from dateutil.relativedelta import relativedelta
from flask import jsonify, request
from flask_pluginengine import current_plugin
from pytz import timezone, utc
from werkzeug.exceptions import NotFound
from indico.core.db import db
from indico.modules.events.timetable.controllers import RHManageTimetableBase
from indico.modules.events.timetable.models.entries import TimetableEntry, TimetableEntryType
from indico.legacy.webinterface.rh.base import RHProtected
class RHGetImporters(RHProtected):
def _process(self):
importers = {k: importer.name for k, (importer, _) in current_plugin.importer_engines.iteritems()}
return jsonify(importers)
class RHImportData(RHProtected):
def _process(self):
size = request.args.get('size', 10)
query = request.args.get('query')
importer, plugin = current_plugin.importer_engines.get(request.view_args['importer_name'])
with plugin.plugin_context():
data = {'records': importer.import_data(query, size)}
return jsonify(data)
class RHEndTimeBase(RHManageTimetableBase):
"""Base class for the importer operations"""
normalize_url_spec = {
'locators': {
lambda self: self.event_new
},
'preserved_args': {
'importer_name'
}
}
@staticmethod
def _find_latest_end_dt(entries):
latest_dt = None
for entry in entries:
if latest_dt is None or entry.end_dt > latest_dt:
latest_dt = entry.end_dt
return latest_dt
def _format_date(self, date):
return date.astimezone(timezone(self.event_new.timezone)).strftime('%H:%M')
class RHDayEndTime(RHEndTimeBase):
"""Get the end_dt of the latest timetable entry or the event start_dt if no entry exist on that date"""
def _checkParams(self, params):
RHEndTimeBase._checkParams(self, params)
self.date = self.event_new.tzinfo.localize(datetime.strptime(request.args['selectedDay'], '%Y/%m/%d')).date()
def _process(self):
event_start_date = db.cast(TimetableEntry.start_dt.astimezone(self.event_new.tzinfo), db.Date)
entries = self.event_new.timetable_entries.filter(event_start_date == self.date)
latest_end_dt = self._find_latest_end_dt(entries)
if latest_end_dt is None:
event_start = self.event_new.start_dt
latest_end_dt = utc.localize(datetime.combine(self.date, event_start.time()))
return self._format_date(latest_end_dt)
class RHBlockEndTime(RHEndTimeBase):
"""Return the end_dt of the latest timetable entry inside the block or the block start_dt if it is empty"""
normalize_url_spec = {
'locators': {
lambda self: self.timetable_entry
},
'preserved_args': {
'importer_name'
}
}
def _checkParams(self, params):
RHEndTimeBase._checkParams(self, params)
self.date = timezone(self.event_new.timezone).localize(datetime.strptime(request.args['selectedDay'],
'%Y/%m/%d'))
self.timetable_entry = self.event_new.timetable_entries.filter_by(
type=TimetableEntryType.SESSION_BLOCK, id=request.view_args['entry_id']).first_or_404()
def _process(self):
entries = self.timetable_entry.children
latest_end_dt = self._find_latest_end_dt(entries)
if latest_end_dt is None:
latest_end_dt = self.timetable_entry.start_dt
return self._format_date(latest_end_dt)
| gpl-3.0 | -1,073,251,264,224,585,700 | 37.769912 | 117 | 0.671764 | false |
mhubig/intelhex | scripts/hex2dump.py | 1 | 3960 | #!/usr/bin/python
# Copyright (c) 2008,2010,2011,2012,2013 Alexander Belchenko
# All rights reserved.
#
# Redistribution and use in source and binary forms,
# with or without modification, are permitted provided
# that the following conditions are met:
#
# * Redistributions of source code must retain
# the above copyright notice, this list of conditions
# and the following disclaimer.
# * Redistributions in binary form must reproduce
# the above copyright notice, this list of conditions
# and the following disclaimer in the documentation
# and/or other materials provided with the distribution.
# * Neither the name of the author nor the names
# of its contributors may be used to endorse
# or promote products derived from this software
# without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
# BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
# AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
# IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
# OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
# OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""Show content of hex file as hexdump."""
VERSION = '1.5.1'
USAGE = '''hex2dump: show content of hex file as hexdump.
Usage:
python hex2dump.py [options] HEXFILE
Options:
-h, --help this help message.
-v, --version version info.
-r, --range=START:END specify address range for dumping
(ascii hex value).
Range can be in form 'START:' or ':END'.
Arguments:
HEXFILE name of hex file for processing (use '-' to read
from stdin)
'''
import sys
def hex2dump(hexfile, start=None, end=None):
import intelhex
if hexfile == '-':
hexfile = sys.stdin
try:
ih = intelhex.IntelHex(hexfile)
except (IOError, intelhex.IntelHexError), e:
sys.stderr.write('Error reading file: %s\n' % e)
return 1
if not (start is None and end is None):
ih = ih[slice(start,end)]
ih.dump()
return 0
def main(argv=None):
import getopt
if argv is None:
argv = sys.argv[1:]
start = None
end = None
try:
opts, args = getopt.getopt(sys.argv[1:], "hvp:r:",
["help", "version", "range="])
for o, a in opts:
if o in ("-h", "--help"):
print(USAGE)
return 0
elif o in ("-v", "--version"):
print(VERSION)
return 0
elif o in ("-r", "--range"):
try:
l = a.split(":")
if l[0] != '':
start = int(l[0], 16)
if l[1] != '':
end = int(l[1], 16)
except:
raise getopt.GetoptError('Bad range value(s)')
if not args:
raise getopt.GetoptError('Hex file is not specified')
if len(args) > 1:
raise getopt.GetoptError('Too many arguments')
except getopt.GetoptError, msg:
txt = 'ERROR: '+str(msg) # that's required to get not-so-dumb result from 2to3 tool
print(txt)
print(USAGE)
return 2
try:
return hex2dump(args[0], start, end)
except IOError, e:
import errno
if e.errno not in (0, errno.EPIPE):
raise
if __name__ == '__main__':
import sys
sys.exit(main())
| bsd-3-clause | -4,853,036,239,676,083,000 | 31.727273 | 92 | 0.603283 | false |
oliver-sanders/cylc | cylc/flow/network/schema.py | 1 | 52672 | # THIS FILE IS PART OF THE CYLC SUITE ENGINE.
# Copyright (C) 2008-2019 NIWA & British Crown (Met Office) & Contributors.
#
# 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/>.
"""GraphQL API schema via Graphene implementation."""
import asyncio
from functools import partial
import logging
from textwrap import dedent
from typing import Callable, AsyncGenerator, Any
from graphene import (
Boolean, Field, Float, ID, InputObjectType, Int,
List, Mutation, ObjectType, Schema, String, Union, Enum
)
from graphene.types.generic import GenericScalar
from graphene.utils.str_converters import to_snake_case
from cylc.flow.task_state import (
TASK_STATUSES_ORDERED,
TASK_STATUS_DESC,
# TASK_STATUS_RUNAHEAD,
TASK_STATUS_WAITING,
TASK_STATUS_QUEUED,
TASK_STATUS_EXPIRED,
TASK_STATUS_READY,
TASK_STATUS_SUBMIT_FAILED,
TASK_STATUS_SUBMIT_RETRYING,
TASK_STATUS_SUBMITTED,
TASK_STATUS_RETRYING,
TASK_STATUS_RUNNING,
TASK_STATUS_FAILED,
TASK_STATUS_SUCCEEDED
)
from cylc.flow.data_store_mgr import (
ID_DELIM, FAMILIES, FAMILY_PROXIES,
JOBS, TASKS, TASK_PROXIES
)
from cylc.flow.suite_status import StopMode
def sstrip(text):
"""Simple function to dedent and strip text.
Examples:
>>> print(sstrip('''
... foo
... bar
... baz
... '''))
foo
bar
baz
"""
return dedent(text).strip()
PROXY_NODES = 'proxy_nodes'
NODE_MAP = {
'Task': TASKS,
'TaskProxy': TASK_PROXIES,
'Family': FAMILIES,
'FamilyProxy': FAMILY_PROXIES,
'Job': JOBS,
'Node': PROXY_NODES,
}
CYCLING_TYPES = [
'family_proxies',
'family_proxy',
'jobs',
'job',
'task_proxies',
'task_proxy',
]
PROXY_TYPES = [
'family_proxies',
'family_proxy',
'task_proxies',
'task_proxy',
]
DEF_TYPES = [
'families',
'family',
'tasks',
'task',
]
def parse_workflow_id(item):
"""Split workflow id argument to individual workflow attributes.
Args:
item (owner|workflow:status):
It's possible to traverse workflows,
defaults to UI Server owner, and ``*`` glob for workflow.
Returns:
A tuple of id components in respective order. For example:
(owner, name, status)
"""
owner, workflow, status = (None, None, None)
if ':' in item:
head, status = item.rsplit(':', 1)
else:
head, status = (item, None)
if head.count(ID_DELIM):
owner, workflow = head.split(ID_DELIM, 1)
else:
# more common to filter on workflow (with owner constant)
workflow = head
return (owner, workflow, status)
def parse_node_id(item, node_type=None):
"""Parse definition, job, or proxy id argument returning components.
Args:
item (str): A string representing a node ID. Jobs fill out
cycle|name|num first, cycle is irrelevant to Def
owner|workflow is always last.
For example:
name
cycle|na*
workflow|cycle|name
owner|workflow|cycle|name|submit_num:state
cycle|*|submit_num
node_type (str):
the type of the node to be parsed.
Returns:
A tuple of string id components in respective order. For example:
(owner, workflow, cycle, name, submit_num, state)
None type is set for missing components.
"""
if ':' in item:
head, state = item.rsplit(':', 1)
else:
head, state = (item, None)
if ID_DELIM in head:
dil_count = head.count(ID_DELIM)
parts = head.split(ID_DELIM, dil_count)
else:
return (None, None, None, head, None, state)
if node_type in DEF_TYPES:
owner, workflow, name = [None] * (2 - dil_count) + parts
parts = [owner, workflow, None, name, None]
elif node_type in PROXY_TYPES:
parts = [None] * (3 - dil_count) + parts + [None]
elif dil_count < 4:
if dil_count < 3:
parts = [None, None] + parts + [None] * (2 - dil_count)
else:
parts = [None] * (4 - dil_count) + parts
parts += [state]
return tuple(parts)
# ** Query Related **#
# Field args (i.e. for queries etc):
class SortArgs(InputObjectType):
keys = List(String, default_value=['id'])
reverse = Boolean(default_value=False)
jobs_args = dict(
ids=List(ID, default_value=[]),
exids=List(ID, default_value=[]),
states=List(String, default_value=[]),
exstates=List(String, default_value=[]),
sort=SortArgs(default_value=None),
)
all_jobs_args = dict(
workflows=List(ID, default_value=[]),
exworkflows=List(ID, default_value=[]),
ids=List(ID, default_value=[]),
exids=List(ID, default_value=[]),
states=List(String, default_value=[]),
exstates=List(String, default_value=[]),
sort=SortArgs(default_value=None),
)
def_args = dict(
ids=List(ID, default_value=[]),
exids=List(ID, default_value=[]),
mindepth=Int(default_value=-1),
maxdepth=Int(default_value=-1),
sort=SortArgs(default_value=None),
)
all_def_args = dict(
workflows=List(ID, default_value=[]),
exworkflows=List(ID, default_value=[]),
ids=List(ID, default_value=[]),
exids=List(ID, default_value=[]),
mindepth=Int(default_value=-1),
maxdepth=Int(default_value=-1),
sort=SortArgs(default_value=None),
)
proxy_args = dict(
ghosts=Boolean(default_value=False),
ids=List(ID, default_value=[]),
exids=List(ID, default_value=[]),
states=List(String, default_value=[]),
exstates=List(String, default_value=[]),
is_held=Boolean(),
mindepth=Int(default_value=-1),
maxdepth=Int(default_value=-1),
sort=SortArgs(default_value=None),
)
all_proxy_args = dict(
ghosts=Boolean(default_value=False),
workflows=List(ID, default_value=[]),
exworkflows=List(ID, default_value=[]),
ids=List(ID, default_value=[]),
exids=List(ID, default_value=[]),
states=List(String, default_value=[]),
exstates=List(String, default_value=[]),
is_held=Boolean(),
mindepth=Int(default_value=-1),
maxdepth=Int(default_value=-1),
sort=SortArgs(default_value=None),
)
edge_args = dict(
ids=List(ID, default_value=[]),
exids=List(ID, default_value=[]),
states=List(String, default_value=[]),
exstates=List(String, default_value=[]),
mindepth=Int(default_value=-1),
maxdepth=Int(default_value=-1),
sort=SortArgs(default_value=None),
)
all_edge_args = dict(
workflows=List(ID, default_value=[]),
exworkflows=List(ID, default_value=[]),
sort=SortArgs(default_value=None),
)
nodes_edges_args = dict(
ghosts=Boolean(default_value=False),
ids=List(ID, default_value=[]),
exids=List(ID, default_value=[]),
states=List(String, default_value=[]),
exstates=List(String, default_value=[]),
is_held=Boolean(),
distance=Int(default_value=1),
mindepth=Int(default_value=-1),
maxdepth=Int(default_value=-1),
sort=SortArgs(default_value=None),
)
nodes_edges_args_all = dict(
ghosts=Boolean(default_value=False),
workflows=List(ID, default_value=[]),
exworkflows=List(ID, default_value=[]),
ids=List(ID, default_value=[]),
exids=List(ID, default_value=[]),
states=List(String, default_value=[]),
exstates=List(String, default_value=[]),
is_held=Boolean(),
distance=Int(default_value=1),
mindepth=Int(default_value=-1),
maxdepth=Int(default_value=-1),
sort=SortArgs(default_value=None),
)
# Resolvers are used to collate data needed for query resolution.
# Treated as implicit static methods;
# https://docs.graphene-python.org/en/latest/types
# /objecttypes/#implicit-staticmethod
# they can exist inside or outside the query object types.
#
# Here we define them outside the queries so they can be used with
# multiple resolution calls, both at root query or object field level.
#
# The first argument has a naming convention;
# https://docs.graphene-python.org/en/latest/types
# /objecttypes/#naming-convention
# with name 'root' used here, it provides context to the resolvers.
# Resolvers:
async def get_workflows(root, info, **args):
args['workflows'] = [parse_workflow_id(w_id) for w_id in args['ids']]
args['exworkflows'] = [parse_workflow_id(w_id) for w_id in args['exids']]
resolvers = info.context.get('resolvers')
return await resolvers.get_workflows(args)
async def get_nodes_all(root, info, **args):
"""Resolver for returning job, task, family nodes"""
field_name = to_snake_case(info.field_name)
field_ids = getattr(root, field_name, None)
if hasattr(args, 'id'):
args['ids'] = [args.get('id')]
if field_ids:
args['ids'] = field_ids
elif field_ids == []:
return []
try:
obj_type = str(info.return_type.of_type).replace('!', '')
except AttributeError:
obj_type = str(info.return_type)
node_type = NODE_MAP[obj_type]
args['ids'] = [parse_node_id(n_id, node_type) for n_id in args['ids']]
args['exids'] = [parse_node_id(n_id, node_type) for n_id in args['exids']]
args['workflows'] = [
parse_workflow_id(w_id) for w_id in args['workflows']]
args['exworkflows'] = [
parse_workflow_id(w_id) for w_id in args['exworkflows']]
resolvers = info.context.get('resolvers')
return await resolvers.get_nodes_all(node_type, args)
async def get_nodes_by_ids(root, info, **args):
"""Resolver for returning job, task, family node"""
field_name = to_snake_case(info.field_name)
field_ids = getattr(root, field_name, None)
if hasattr(args, 'id'):
args['ids'] = [args.get('id')]
if field_ids:
if isinstance(field_ids, str):
field_ids = [field_ids]
args['native_ids'] = field_ids
elif field_ids == []:
return []
try:
obj_type = str(info.return_type.of_type).replace('!', '')
except AttributeError:
obj_type = str(info.return_type)
node_type = NODE_MAP[obj_type]
args['ids'] = [parse_node_id(n_id, node_type) for n_id in args['ids']]
args['exids'] = [parse_node_id(n_id, node_type) for n_id in args['exids']]
resolvers = info.context.get('resolvers')
return await resolvers.get_nodes_by_ids(node_type, args)
async def get_node_by_id(root, info, **args):
"""Resolver for returning job, task, family node"""
field_name = to_snake_case(info.field_name)
if field_name == 'source_node':
field_id = getattr(root, 'source', None)
elif field_name == 'target_node':
field_id = getattr(root, 'target', None)
else:
field_id = getattr(root, field_name, None)
if field_id:
args['id'] = field_id
if args.get('id', None) is None:
return None
try:
obj_type = str(info.return_type.of_type).replace('!', '')
except AttributeError:
obj_type = str(info.return_type)
resolvers = info.context.get('resolvers')
return await resolvers.get_node_by_id(NODE_MAP[obj_type], args)
async def get_edges_all(root, info, **args):
args['workflows'] = [
parse_workflow_id(w_id) for w_id in args['workflows']]
args['exworkflows'] = [
parse_workflow_id(w_id) for w_id in args['exworkflows']]
resolvers = info.context.get('resolvers')
return await resolvers.get_edges_all(args)
async def get_edges_by_ids(root, info, **args):
field_name = to_snake_case(info.field_name)
field_ids = getattr(root, field_name, None)
if field_ids:
args['native_ids'] = list(field_ids)
elif field_ids == []:
return []
resolvers = info.context.get('resolvers')
return await resolvers.get_edges_by_ids(args)
async def get_nodes_edges(root, info, **args):
"""Resolver for returning job, task, family nodes"""
node_type = NODE_MAP['TaskProxy']
workflow = getattr(root, 'id', None)
if workflow:
args['workflows'] = [parse_workflow_id(workflow)]
args['exworkflows'] = []
else:
args['workflows'] = [
parse_workflow_id(w_id) for w_id in args['workflows']]
args['exworkflows'] = [
parse_workflow_id(w_id) for w_id in args['exworkflows']]
args['ids'] = [parse_node_id(n_id, node_type) for n_id in args['ids']]
args['exids'] = [parse_node_id(n_id, node_type) for n_id in args['exids']]
resolvers = info.context.get('resolvers')
root_nodes = await resolvers.get_nodes_all(node_type, args)
return await resolvers.get_nodes_edges(root_nodes, args)
def resolve_state_totals(root, info, **args):
state_totals = {state: 0 for state in TASK_STATUSES_ORDERED}
# Update with converted protobuf map container
state_totals.update(
dict(getattr(root, to_snake_case(info.field_name), {})))
return state_totals
# Types:
class DefMeta(ObjectType):
class Meta:
description = """
Meta data fields,
including custom fields in a generic user-defined dump"""
title = String(default_value=None)
description = String(default_value=None)
URL = String(default_value=None)
user_defined = List(String, default_value=[])
class TimeZone(ObjectType):
class Meta:
description = """Time zone info."""
hours = Int()
minutes = Int()
string_basic = String()
string_extended = String()
class Workflow(ObjectType):
class Meta:
description = """Global workflow info."""
id = ID(required=True)
name = String()
status = String()
status_msg = String()
host = String()
port = Int()
owner = String()
tasks = List(
lambda: Task,
description="""Task definitions.""",
args=def_args,
resolver=get_nodes_by_ids)
families = List(
lambda: Family,
description="""Family definitions.""",
args=def_args,
resolver=get_nodes_by_ids)
task_proxies = List(
lambda: TaskProxy,
description="""Task cycle instances.""",
args=proxy_args,
resolver=get_nodes_by_ids)
family_proxies = List(
lambda: FamilyProxy,
description="""Family cycle instances.""",
args=proxy_args,
resolver=get_nodes_by_ids)
edges = Field(
lambda: Edges,
args=edge_args,
description="""Graph edges""")
nodes_edges = Field(
lambda: NodesEdges,
args=nodes_edges_args,
resolver=get_nodes_edges)
api_version = Int()
cylc_version = String()
last_updated = Float()
meta = Field(DefMeta)
newest_runahead_cycle_point = String()
newest_cycle_point = String()
oldest_cycle_point = String()
reloaded = Boolean()
run_mode = String()
is_held_total = Int()
state_totals = GenericScalar(resolver=resolve_state_totals)
workflow_log_dir = String()
time_zone_info = Field(TimeZone)
tree_depth = Int()
ns_defn_order = List(String)
job_log_names = List(String)
states = List(String)
class Job(ObjectType):
class Meta:
description = """Jobs."""
id = ID(required=True)
submit_num = Int()
state = String()
# name and cycle_point for filtering/sorting
name = String(required=True)
cycle_point = String(required=True)
task_proxy = Field(
lambda: TaskProxy,
description="""Associated Task Proxy""",
required=True,
resolver=get_node_by_id)
submitted_time = String()
started_time = String()
finished_time = String()
batch_sys_job_id = ID()
batch_sys_name = String()
env_script = String()
err_script = String()
exit_script = String()
execution_time_limit = Float()
host = String()
init_script = String()
job_log_dir = String()
owner = String()
post_script = String()
pre_script = String()
script = String()
work_sub_dir = String()
batch_sys_conf = List(String)
environment = List(String)
directives = List(String)
param_env_tmpl = List(String)
param_var = List(String)
extra_logs = List(String)
messages = List(String)
class Task(ObjectType):
class Meta:
description = """Task definition, static fields"""
id = ID(required=True)
name = String(required=True)
meta = Field(DefMeta)
mean_elapsed_time = Float()
depth = Int()
proxies = List(
lambda: TaskProxy,
description="""Associated cycle point proxies""",
args=proxy_args,
resolver=get_nodes_by_ids)
namespace = List(String, required=True)
class PollTask(ObjectType):
class Meta:
description = """Polling task edge"""
local_proxy = ID(required=True)
workflow = String()
remote_proxy = ID(required=True)
req_state = String()
graph_string = String()
class Condition(ObjectType):
class Meta:
description = """Prerequisite conditions."""
task_proxy = Field(
lambda: TaskProxy,
description="""Associated Task Proxy""",
resolver=get_node_by_id)
expr_alias = String()
req_state = String()
satisfied = Boolean()
message = String()
class Prerequisite(ObjectType):
class Meta:
description = """Task prerequisite."""
expression = String()
conditions = List(
Condition,
description="""Condition monomers of a task prerequisites.""")
cycle_points = List(String)
satisfied = Boolean()
class TaskProxy(ObjectType):
class Meta:
description = """Task cycle instance."""
id = ID(required=True)
task = Field(
Task,
description="""Task definition""",
required=True,
resolver=get_node_by_id)
state = String()
cycle_point = String()
is_held = Boolean()
spawned = Boolean()
depth = Int()
job_submits = Int()
latest_message = String()
outputs = List(String, default_value=[])
broadcasts = List(String, default_value=[])
# name & namespace for filtering/sorting
name = String(required=True)
namespace = List(String, required=True)
prerequisites = List(Prerequisite)
jobs = List(
Job,
description="""Task jobs.""",
args=jobs_args,
resolver=get_nodes_by_ids)
parents = List(
lambda: FamilyProxy,
description="""Task parents.""",
args=proxy_args,
resolver=get_nodes_by_ids)
first_parent = Field(
lambda: FamilyProxy,
description="""Task first parent.""",
args=proxy_args,
resolver=get_node_by_id)
ancestors = List(
lambda: FamilyProxy,
description="""First parent ancestors.""",
args=proxy_args,
resolver=get_nodes_by_ids)
class Family(ObjectType):
class Meta:
description = """Task definition, static fields"""
id = ID(required=True)
name = String(required=True)
meta = Field(DefMeta)
depth = Int()
proxies = List(
lambda: FamilyProxy,
description="""Associated cycle point proxies""",
args=proxy_args,
resolver=get_nodes_by_ids)
parents = List(
lambda: Family,
description="""Family definition parent.""",
args=def_args,
resolver=get_nodes_by_ids)
child_tasks = List(
Task,
description="""Descendant definition tasks.""",
args=def_args,
resolver=get_nodes_by_ids)
child_families = List(
lambda: Family,
description="""Descendant desc families.""",
args=def_args,
resolver=get_nodes_by_ids)
class FamilyProxy(ObjectType):
class Meta:
description = """Family composite."""
id = ID(required=True)
cycle_point = String()
# name & namespace for filtering/sorting
name = String(required=True)
family = Field(
Family,
description="""Family definition""",
required=True,
resolver=get_node_by_id)
state = String()
is_held = Boolean()
depth = Int()
parents = List(
lambda: FamilyProxy,
description="""Family parent proxies.""",
args=proxy_args,
resolver=get_nodes_by_ids)
child_tasks = List(
TaskProxy,
description="""Descendant task proxies.""",
args=proxy_args,
resolver=get_nodes_by_ids)
child_families = List(
lambda: FamilyProxy,
description="""Descendant family proxies.""",
args=proxy_args,
resolver=get_nodes_by_ids)
first_parent = Field(
lambda: FamilyProxy,
description="""Task first parent.""",
args=proxy_args,
resolver=get_node_by_id)
ancestors = List(
lambda: FamilyProxy,
description="""First parent ancestors.""",
args=proxy_args,
resolver=get_nodes_by_ids)
class Node(Union):
class Meta:
types = (TaskProxy, FamilyProxy)
@classmethod
def resolve_type(cls, instance, info):
if hasattr(instance, 'task'):
return TaskProxy
return FamilyProxy
class Edge(ObjectType):
class Meta:
description = """Dependency edge task/family proxies"""
id = ID(required=True)
source = ID()
source_node = Field(
Node,
resolver=get_node_by_id)
target = ID()
target_node = Field(
Node,
resolver=get_node_by_id)
suicide = Boolean()
cond = Boolean()
class Edges(ObjectType):
class Meta:
description = """Dependency edge"""
edges = List(
Edge,
required=True,
args=edge_args,
resolver=get_edges_by_ids)
workflow_polling_tasks = List(PollTask)
leaves = List(String)
feet = List(String)
class NodesEdges(ObjectType):
class Meta:
description = """Related Nodes & Edges."""
nodes = List(
TaskProxy,
description="""Task nodes from and including root.""")
edges = List(
Edge,
description="""Edges associated with the nodes.""")
# Query declaration
class Queries(ObjectType):
class Meta:
description = """Multi-Workflow root level queries."""
workflows = List(
Workflow,
description=Workflow._meta.description,
ids=List(ID, default_value=[]),
exids=List(ID, default_value=[]),
resolver=get_workflows)
job = Field(
Job,
description=Job._meta.description,
id=ID(required=True),
resolver=get_node_by_id)
jobs = List(
Job,
description=Job._meta.description,
args=all_jobs_args,
resolver=get_nodes_all)
task = Field(
Task,
description=Task._meta.description,
id=ID(required=True),
resolver=get_node_by_id)
tasks = List(
Task,
description=Task._meta.description,
args=all_def_args,
resolver=get_nodes_all)
task_proxy = Field(
TaskProxy,
description=TaskProxy._meta.description,
id=ID(required=True),
resolver=get_node_by_id)
task_proxies = List(
TaskProxy,
description=TaskProxy._meta.description,
args=all_proxy_args,
resolver=get_nodes_all)
family = Field(
Family,
description=Family._meta.description,
id=ID(required=True),
resolver=get_node_by_id)
families = List(
Family,
description=Family._meta.description,
args=all_def_args,
resolver=get_nodes_all)
family_proxy = Field(
FamilyProxy,
description=FamilyProxy._meta.description,
id=ID(required=True),
resolver=get_node_by_id)
family_proxies = List(
FamilyProxy,
description=FamilyProxy._meta.description,
args=all_proxy_args,
resolver=get_nodes_all)
edges = List(
Edge,
description=Edge._meta.description,
args=all_edge_args,
resolver=get_edges_all)
nodes_edges = Field(
NodesEdges,
description=NodesEdges._meta.description,
args=nodes_edges_args_all,
resolver=get_nodes_edges)
# ** Mutation Related ** #
# Generic containers
class GenericResponse(ObjectType):
class Meta:
description = """Container for command queued response"""
result = GenericScalar()
# Mutators are used to call the internals of the parent program in the
# resolution of mutation requests (or can make external calls themselves).
# Like query resolvers (read above), they are treated as implicit
# static methods, with object context pass in as the first argument.
# Mutators:
async def mutator(root, info, command=None, workflows=None,
exworkflows=None, **args):
"""Call the resolver method that act on the workflow service
via the internal command queue."""
if workflows is None:
workflows = []
if exworkflows is None:
exworkflows = []
w_args = {}
w_args['workflows'] = [parse_workflow_id(w_id) for w_id in workflows]
w_args['exworkflows'] = [parse_workflow_id(w_id) for w_id in exworkflows]
if args.get('args', False):
args.update(args.get('args', {}))
args.pop('args')
resolvers = info.context.get('resolvers')
res = await resolvers.mutator(info, command, w_args, args)
return GenericResponse(result=res)
async def nodes_mutator(root, info, command, ids, workflows=None,
exworkflows=None, **args):
"""Call the resolver method, dealing with multiple node id arguments,
which acts on the workflow service via the internal command queue."""
if command == 'put_messages':
node_type = 'jobs'
else:
node_type = 'task_proxy'
ids = [parse_node_id(n_id, node_type) for n_id in ids]
# if the workflows arg is empty extract from proxy args
if workflows is None:
workflows = set()
for owner, workflow, _, _, _, _ in ids:
if owner and workflow:
workflows.add(f'{owner}{ID_DELIM}{workflow}')
elif workflow:
workflows.add(workflow)
if not workflows:
return GenericResponse(result="Error: No given Workflow(s)")
if exworkflows is None:
exworkflows = []
w_args = {}
w_args['workflows'] = [parse_workflow_id(w_id) for w_id in workflows]
w_args['exworkflows'] = [parse_workflow_id(w_id) for w_id in exworkflows]
if args.get('args', False):
args.update(args.get('args', {}))
args.pop('args')
resolvers = info.context.get('resolvers')
res = await resolvers.nodes_mutator(info, command, ids, w_args, args)
return GenericResponse(result=res)
# Input types:
class WorkflowID(String):
"""A registered workflow."""
class CyclePoint(String):
"""An integer or date-time cyclepoint."""
class CyclePointGlob(String):
"""A glob for integer or date-time cyclepoints.
The wildcard character (`*`) can be used to perform globbing.
For example `2000*` might match `2000-01-01T00:00Z`.
"""
class RuntimeConfiguration(String):
"""A configuration item for a task or family e.g. `script`."""
class BroadcastSetting(InputObjectType):
"""A task/family runtime setting as a key, value pair."""
key = RuntimeConfiguration(
description=sstrip('''
The cylc namespace for the setting to modify.
e.g. `[environment]variable_name`.
'''),
required=True
)
value = String(
description='The value of the modification',
required=True
)
class BroadcastMode(Enum):
Set = 'put_broadcast'
Clear = 'clear_broadcast'
@property
def description(self):
if self == BroadcastMode.Set:
return 'Create a new broadcast.'
if self == BroadcastMode.Clear:
return 'Revoke an existing broadcast.'
return ''
class TaskStatus(Enum):
"""The status of a task in a workflow."""
# NOTE: this is an enumeration purely for the GraphQL schema
# TODO: the task statuses should be formally declared in a Python
# enumeration rendering this class unnecessary
# NOTE: runahead purposefully omitted to hide users from the task pool
# Runahead = TASK_STATUS_RUNAHEAD
Waiting = TASK_STATUS_WAITING
Queued = TASK_STATUS_QUEUED
Expired = TASK_STATUS_EXPIRED
Ready = TASK_STATUS_READY
SubmitFailed = TASK_STATUS_SUBMIT_FAILED
SubmitRetrying = TASK_STATUS_SUBMIT_RETRYING
Submitted = TASK_STATUS_SUBMITTED
Retrying = TASK_STATUS_RETRYING
Running = TASK_STATUS_RUNNING
Failed = TASK_STATUS_FAILED
Succeeded = TASK_STATUS_SUCCEEDED
@property
def description(self):
return TASK_STATUS_DESC.get(self.value, '')
class TaskState(InputObjectType):
"""The state of a task, a combination of status and other fields."""
status = TaskStatus()
is_held = Boolean(description=sstrip('''
If a task is held no new job submissions will be made
'''))
class TaskName(String):
"""The name a task.
* Must be a task not a family.
* Does not include the cycle point.
* Any parameters must be expanded (e.g. can't be `foo<bar>`).
"""
class NamespaceName(String):
"""The name of a task or family."""
class NamespaceIDGlob(String):
"""A glob search for an active task or family.
Can use the wildcard character (`*`), e.g `foo*` might match `foot`.
"""
class TaskID(String):
"""The name of an active task."""
class JobID(String):
"""A job submission from an active task."""
class TimePoint(String):
"""A date-time in the ISO8601 format."""
LogLevels = Enum(
'LogLevels',
list(logging._nameToLevel.items()),
description=lambda x: f'Python logging level: {x.name} = {x.value}.'
if x else ''
)
class SuiteStopMode(Enum):
"""The mode used to stop a running workflow."""
# Note: contains only the REQUEST_* values from StopMode
Clean = StopMode.REQUEST_CLEAN
Now = StopMode.REQUEST_NOW
NowNow = StopMode.REQUEST_NOW_NOW
@property
def description(self):
return StopMode(self.value).describe()
# Mutations:
# TODO: re-instate:
# - get-broadcast (can just use GraphQL query BUT needs CLI access too)
# - expire-broadcast
class Broadcast(Mutation):
class Meta:
description = sstrip('''
Override or add new [runtime] config in targeted namespaces in
a running suite.
Uses for broadcast include making temporary changes to task
behaviour, and task-to-downstream-task communication via
environment variables.
A broadcast can target any [runtime] namespace for all cycles or
for a specific cycle. If a task is affected by specific-cycle and
all-cycle broadcasts at once, the specific takes precedence. If
a task is affected by broadcasts to multiple ancestor
namespaces, the result is determined by normal [runtime]
inheritance. In other words, it follows this order:
`all:root -> all:FAM -> all:task -> tag:root -> tag:FAM ->
tag:task`
Broadcasts persist, even across suite restarts, until they expire
when their target cycle point is older than the oldest current in
the suite, or until they are explicitly cancelled with this
command. All-cycle broadcasts do not expire.
For each task the final effect of all broadcasts to all namespaces
is computed on the fly just prior to job submission. The
`--cancel` and `--clear` options simply cancel (remove) active
broadcasts, they do not act directly on the final task-level
result. Consequently, for example, you cannot broadcast to "all
cycles except Tn" with an all-cycle broadcast followed by a cancel
to Tn (there is no direct broadcast to Tn to cancel); and you
cannot broadcast to "all members of FAMILY except member_n" with a
general broadcast to FAMILY followed by a cancel to member_n (there
is no direct broadcast to member_n to cancel).
''')
resolver = partial(mutator, command='broadcast')
class Arguments:
workflows = List(WorkflowID, required=True)
mode = BroadcastMode(
default_value=1,
required=True
)
cycle_points = List(
CyclePoint,
description=sstrip('''
List of cycle points to target or `*` to cancel all all-cycle
broadcasts without canceling all specific-cycle broadcasts.
'''),
default_value=['*'])
tasks = List(
NamespaceName,
description='Target namespaces.',
default_value=['root']
)
settings = List(
BroadcastSetting,
description='Target settings.'
)
# TODO: work out how to implement this feature, it needs to be
# handled client-side which makes it slightly awkward in
# api-on-the-fly land
# files = List(
# String,
# description=sstrip('''
# File with config to broadcast. Can be used multiple times
# ''')
# )
result = GenericScalar()
class Hold(Mutation):
class Meta:
description = sstrip('''
Hold a workflow or tasks within it.
''')
resolver = partial(mutator, command='hold')
class Arguments:
workflows = List(WorkflowID, required=True)
tasks = List(
NamespaceIDGlob,
description='Hold the specified tasks rather than the workflow.'
)
time = TimePoint(description=sstrip('''
Get the workflow to hold after the specified wallclock time
has passed.
'''))
result = GenericScalar()
class Nudge(Mutation):
class Meta:
description = sstrip('''
Cause the Cylc task processing loop to be invoked on a running
suite.
This happens automatically when the state of any task changes
such that task processing (dependency negotiation etc.)
is required, or if a clock-trigger task is ready to run.
''')
resolver = partial(mutator, command='nudge')
class Arguments:
workflows = List(WorkflowID, required=True)
result = GenericScalar()
class Ping(Mutation):
class Meta:
description = sstrip('''
Send a test message to a running suite.
''')
resolver = partial(mutator, command='ping_suite')
class Arguments:
workflows = List(WorkflowID, required=True)
result = GenericScalar()
class Message(Mutation):
class Meta:
description = sstrip('''
Record task job messages.
Send task job messages to:
- The job stdout/stderr.
- The job status file, if there is one.
- The suite server program, if communication is possible.
Task jobs use this to record and report status such
as success and failure. Applications run by task jobs can use
this command to report messages and to report registered task
outputs.
''')
resolver = partial(nodes_mutator, command='put_messages')
class Arguments:
workflows = List(WorkflowID, required=True)
task_job = String(required=True)
event_time = String(default_value=None)
messages = List(
List(String),
description="""List in the form `[[severity, message], ...]`.""",
default_value=None
)
result = GenericScalar()
class Release(Mutation):
class Meta:
description = sstrip('''
Release a held workflow or tasks within it.
See also the opposite command `hold`.
''')
resolver = partial(mutator, command='release')
class Arguments:
workflows = List(WorkflowID, required=True)
tasks = List(
NamespaceIDGlob,
description=sstrip('''
Release matching tasks rather than the workflow as whole.
''')
)
result = GenericScalar()
class Reload(Mutation):
class Meta:
description = sstrip('''
Tell a suite to reload its definition at run time.
All settings including task definitions, with the
exception of suite log configuration, can be changed on reload.
Note that defined tasks can be be added to or removed from a
running suite using "insert" and "remove" without reloading. This
command also allows addition and removal of actual task
definitions, and therefore insertion of tasks that were not defined
at all when the suite started (you will still need to manually
insert a particular instance of a newly defined task). Live task
proxies that are orphaned by a reload (i.e. their task definitions
have been removed) will be removed from the task pool if they have
not started running yet. Changes to task definitions take effect
immediately, unless a task is already running at reload time.
If the suite was started with Jinja2 template variables
set on the command line (cylc run --set FOO=bar REG) the same
template settings apply to the reload (only changes to the suite.rc
file itself are reloaded).
If the modified suite definition does not parse,
failure to reload will be reported but no harm will be done to the
running suite.
''')
resolver = partial(mutator, command='reload_suite')
class Arguments:
workflows = List(WorkflowID, required=True)
result = GenericScalar()
class SetVerbosity(Mutation):
class Meta:
description = sstrip('''
Change the logging severity level of a running suite.
Only messages at or above the chosen severity level will be logged;
for example, if you choose `WARNING`, only warnings and critical
messages will be logged.
''')
resolver = partial(mutator, command='set_verbosity')
class Arguments:
workflows = List(WorkflowID, required=True)
level = LogLevels(required=True)
result = GenericScalar()
class Stop(Mutation):
class Meta:
description = sstrip(f'''
Tell a suite server program to shut down.
By default suites wait for all submitted and running tasks to
complete before shutting down. You can change this behaviour
with the "mode" option.
''')
resolver = partial(mutator, command='stop_workflow')
class Arguments:
workflows = List(WorkflowID, required=True)
mode = SuiteStopMode(
# TODO default
)
cycle_point = CyclePoint(
description='Stop after the suite reaches this cycle.'
)
clock_time = TimePoint(
description='Stop after wall-clock time passes this point.'
)
task = TaskID(
description='Stop after this task succeeds.'
)
result = GenericScalar()
class Checkpoint(Mutation):
class Meta:
description = 'Tell the suite to checkpoint its current state.'
resolver = partial(mutator, command='take_checkpoints')
class Arguments:
workflows = List(WorkflowID, required=True)
name = String(
description='The checkpoint name.',
required=True
)
result = GenericScalar()
class ExtTrigger(Mutation):
class Meta:
description = sstrip('''
Report an external event message to a suite server program.
It is expected that a task in the suite has registered the same
message as an external trigger - a special prerequisite to be
satisfied by an external system, via this command, rather than by
triggering off other tasks.
The ID argument should uniquely distinguish one external trigger
event from the next. When a task's external trigger is satisfied by
an incoming message, the message ID is broadcast to all downstream
tasks in the cycle point as `$CYLC_EXT_TRIGGER_ID` so that they can
use it - e.g. to identify a new data file that the external
triggering system is responding to.
Use the retry options in case the target suite is down or out of
contact.
Note: To manually trigger a task use "Trigger" not
"ExtTrigger".
''')
resolver = partial(mutator, command='put_ext_trigger')
class Arguments:
workflows = List(WorkflowID, required=True)
message = String(
description='External trigger message.',
required=True
)
id = String(
description='Unique trigger ID.',
required=True
)
result = GenericScalar()
class TaskMutation:
class Arguments:
workflows = List(
WorkflowID,
required=True
)
tasks = List(
NamespaceIDGlob,
required=True
)
result = GenericScalar()
class DryRun(Mutation, TaskMutation):
class Meta:
description = sstrip('''
[For internal use] Prepare the job file for a task.
''')
resolver = partial(mutator, command='dry_run_tasks')
class Arguments(TaskMutation.Arguments):
check_syntax = Boolean(
description='Check shell syntax.',
default_value=True
)
class Insert(Mutation, TaskMutation):
class Meta:
description = sstrip('''
Insert new task proxies into the task pool of a running workflow.
For example to enable re-triggering earlier tasks already removed
from the pool.
Note: inserted cycling tasks cycle on as normal, even if another
instance of the same task exists at a later cycle (instances of the
same task at different cycles can coexist, but a newly spawned task
will not be added to the pool if it catches up to another task with
the same ID).
See also "Submit", for running tasks without the scheduler.
''')
resolver = partial(mutator, command='insert_tasks')
class Arguments(TaskMutation.Arguments):
check_point = Boolean(
description=sstrip('''
Check that the provided cycle point is on one of the task's
recurrences as defined in the suite configuration before
inserting.
'''),
default_value=True
)
stop_point = CyclePoint(
description='hold/stop cycle point for inserted task.'
)
class Kill(Mutation, TaskMutation):
# TODO: This should be a job mutation?
class Meta:
description = sstrip('''
Kill jobs of active tasks and update their statuses accordingly.
''')
resolver = partial(mutator, command='kill_tasks')
class Poll(Mutation, TaskMutation):
class Meta:
description = sstrip('''
Poll (query) task jobs to verify and update their statuses.
''')
resolver = partial(mutator, command='poll_tasks')
class Arguments(TaskMutation.Arguments):
poll_succeeded = Boolean(
description='Allow polling of succeeded tasks.',
default_value=False
)
class Remove(Mutation, TaskMutation):
class Meta:
description = sstrip('''
Remove one or more task instances from a running workflow.
Tasks will be forced to spawn successors before removal if they
have not done so already, unless you change the `spawn` option.
''')
resolver = partial(mutator, command='remove_tasks')
class Arguments(TaskMutation.Arguments):
spawn = Boolean(
description='Spawn successors before removal.',
default_value=True
)
class Reset(Mutation, TaskMutation):
class Meta:
description = sstrip(f'''
Force task instances to a specified state.
Outputs are automatically updated to reflect the new task state,
except for custom message outputs which can be manipulated directly
with `outputs`.
Prerequisites reflect the state of other tasks; they are not
changed except to unset them on resetting state to
`{TASK_STATUS_WAITING}` or earlier.
Note: To hold and release tasks use "Hold" and "Release", not this
command.
''')
resolver = partial(mutator, command='reset_task_states')
class Arguments(TaskMutation.Arguments):
state = TaskStatus(
description='Reset the task status to this.'
)
outputs = List(
String,
description=sstrip('''
Find task output by message string or trigger string, set
complete or incomplete with `!OUTPUT`, `*` to set all
complete, `!*` to set all incomplete.
''')
)
class Spawn(Mutation, TaskMutation):
class Meta:
description = sstrip(f'''
Force task proxies to spawn successors at their own next cycle
point.
Tasks normally spawn on reaching the {TASK_STATUS_SUBMITTED}
status. Spawning them early allows running successive instances of
the same task out of order. See also the `spawn to max active
cycle points` workflow configuration.
Note this command does not operate on tasks at any arbitrary point
in the abstract workflow graph - tasks not already in the pool must
be inserted first with "Insert".
''')
resolver = partial(mutator, command='spawn_tasks')
class Trigger(Mutation, TaskMutation):
class Meta:
description = sstrip('''
Manually trigger tasks.
TODO: re-implement edit funtionality!
For single tasks you can use `edit` to edit the generated job
script before it submits, to apply one-off changes. A diff between
the original and edited job script will be saved to the task job
log directory.
Warning: waiting tasks that are queue-limited will be queued if
triggered, to submit as normal when released by the queue; queued
tasks will submit immediately if triggered, even if that violates
the queue limit (so you may need to trigger a queue-limited task
twice to get it to submit immediately).
Note: tasks not already in the pool must be inserted first with
"Insert" in order to be matched.
''')
resolver = partial(mutator, command='trigger_tasks')
class Arguments(TaskMutation.Arguments):
# back_out = Boolean()
# TODO: remove or re-implement?
pass
# Mutation declarations
class Mutations(ObjectType):
# workflow actions
broadcast = Broadcast.Field(description=Message._meta.description)
ext_trigger = ExtTrigger.Field(
description=ExtTrigger._meta.description)
hold = Hold.Field(description=Hold._meta.description)
nudge = Nudge.Field(description=Nudge._meta.description)
message = Message.Field(description=Message._meta.description)
ping = Ping.Field(description=Ping._meta.description)
release = Release.Field(description=Release._meta.description)
reload = Reload.Field(description=Reload._meta.description)
set_verbosity = SetVerbosity.Field(
description=SetVerbosity._meta.description)
stop = Stop.Field(description=Stop._meta.description)
checkpoint = Checkpoint.Field(
description=Checkpoint._meta.description)
# task actions
dry_run = DryRun.Field(description=DryRun._meta.description)
insert = Insert.Field(description=Insert._meta.description)
kill = Kill.Field(description=Kill._meta.description)
poll = Poll.Field(description=Poll._meta.description)
remove = Remove.Field(description=Remove._meta.description)
reset = Reset.Field(description=Reset._meta.description)
spawn = Spawn.Field(description=Spawn._meta.description)
trigger = Trigger.Field(description=Trigger._meta.description)
# job actions
# TODO
# ** Subscription Related ** #
def to_subscription(func: Callable, sleep_seconds: float = 5.) -> Callable:
"""Wraps a function in a while-true-sleep, transforming
the function into an async-generator, used by the
websockets/subscriptions.
Args:
func (Callable): a callable.
sleep_seconds (float): asyncio sleep interval in seconds.
Returns:
Callable: a callable async-generator wrapping the original callable.
"""
async def gen(*args: Any, **kwargs: Any) -> AsyncGenerator[Any, None]:
"""
Args:
*args: Variable length argument list, varies as per schema.
**kwargs: Arbitrary keyword arguments, varies as per schema.
Returns:
AsyncGenerator[Any, None]: an async generator that will
yield values from resolvers.
"""
while True:
yield await func(*args, **kwargs)
await asyncio.sleep(sleep_seconds)
return gen
class Subscriptions(ObjectType):
"""Defines the subscriptions available in the schema."""
class Meta:
description = """Multi-Workflow root level subscriptions."""
workflows = List(
Workflow,
description=Workflow._meta.description,
ids=List(ID, default_value=[]),
exids=List(ID, default_value=[]),
resolver=to_subscription(get_workflows))
job = Field(
Job,
description=Job._meta.description,
id=ID(required=True),
resolver=to_subscription(get_node_by_id))
jobs = List(
Job,
description=Job._meta.description,
args=all_jobs_args,
resolver=to_subscription(get_nodes_all))
task = Field(
Task,
description=Task._meta.description,
id=ID(required=True),
resolver=to_subscription(get_node_by_id))
tasks = List(
Task,
description=Task._meta.description,
args=all_def_args,
resolver=to_subscription(get_nodes_all))
task_proxy = Field(
TaskProxy,
description=TaskProxy._meta.description,
id=ID(required=True),
resolver=to_subscription(get_node_by_id))
task_proxies = List(
TaskProxy,
description=TaskProxy._meta.description,
args=all_proxy_args,
resolver=to_subscription(get_nodes_all))
family = Field(
Family,
description=Family._meta.description,
id=ID(required=True),
resolver=to_subscription(get_node_by_id))
families = List(
Family,
description=Family._meta.description,
args=all_def_args,
resolver=to_subscription(get_nodes_all))
family_proxy = Field(
FamilyProxy,
description=FamilyProxy._meta.description,
id=ID(required=True),
resolver=to_subscription(get_node_by_id))
family_proxies = List(
FamilyProxy,
description=FamilyProxy._meta.description,
args=all_proxy_args,
resolver=to_subscription(get_nodes_all))
edges = List(
Edge,
description=Edge._meta.description,
args=all_edge_args,
resolver=to_subscription(get_edges_all))
nodes_edges = Field(
NodesEdges,
description=NodesEdges._meta.description,
args=nodes_edges_args_all,
resolver=to_subscription(get_nodes_edges))
schema = Schema(query=Queries, subscription=Subscriptions, mutation=Mutations)
| gpl-3.0 | 7,159,439,198,366,642,000 | 30.371054 | 79 | 0.621867 | false |
yuanming-hu/taichi | examples/mgpcg_advanced.py | 1 | 9080 | import math
import time
import numpy as np
import taichi as ti
@ti.data_oriented
class MGPCG:
'''
Grid-based MGPCG solver for the possion equation.
See `examples/stable_fluid.py <https://github.com/taichi-dev/taichi/blob/master/examples/stable_fluid.py>`_ for a usage example.
.. note::
This solver only runs on CPU and CUDA backends since it requires the
``pointer`` SNode.
'''
def __init__(self, dim=2, N=512, n_mg_levels=6, real=float):
'''
:parameter dim: Dimensionality of the fields.
:parameter N: Grid resolution.
:parameter n_mg_levels: Number of multigrid levels.
'''
# grid parameters
self.use_multigrid = True
self.N = N
self.n_mg_levels = n_mg_levels
self.pre_and_post_smoothing = 2
self.bottom_smoothing = 50
self.dim = dim
self.real = real
self.N_ext = self.N // 2 # number of ext cells set so that that total grid size is still power of 2
self.N_tot = 2 * self.N
# setup sparse simulation data arrays
self.r = [ti.field(dtype=self.real)
for _ in range(self.n_mg_levels)] # residual
self.z = [ti.field(dtype=self.real)
for _ in range(self.n_mg_levels)] # M^-1 self.r
self.x = ti.field(dtype=self.real) # solution
self.p = ti.field(dtype=self.real) # conjugate gradient
self.Ap = ti.field(dtype=self.real) # matrix-vector product
self.alpha = ti.field(dtype=self.real) # step size
self.beta = ti.field(dtype=self.real) # step size
self.sum = ti.field(dtype=self.real) # storage for reductions
indices = ti.ijk if self.dim == 3 else ti.ij
self.grid = ti.root.pointer(indices, [self.N_tot // 4]).dense(
indices, 4).place(self.x, self.p, self.Ap)
for l in range(self.n_mg_levels):
self.grid = ti.root.pointer(indices,
[self.N_tot // (4 * 2**l)]).dense(
indices,
4).place(self.r[l], self.z[l])
ti.root.place(self.alpha, self.beta, self.sum)
@ti.func
def init_r(self, I, r_I):
I = I + self.N_ext
self.r[0][I] = r_I
self.z[0][I] = 0
self.Ap[I] = 0
self.p[I] = 0
self.x[I] = 0
@ti.kernel
def init(self, r: ti.template(), k: ti.template()):
'''
Set up the solver for $\nabla^2 x = k r$, a scaled Poisson problem.
:parameter k: (scalar) A scaling factor of the right-hand side.
:parameter r: (ti.field) Unscaled right-hand side.
'''
for I in ti.grouped(ti.ndrange(*[self.N] * self.dim)):
self.init_r(I, r[I] * k)
@ti.func
def get_x(self, I):
I = I + self.N_ext
return self.x[I]
@ti.kernel
def get_result(self, x: ti.template()):
'''
Get the solution field.
:parameter x: (ti.field) The field to store the solution
'''
for I in ti.grouped(ti.ndrange(*[self.N] * self.dim)):
x[I] = self.get_x(I)
@ti.func
def neighbor_sum(self, x, I):
ret = ti.cast(0.0, self.real)
for i in ti.static(range(self.dim)):
offset = ti.Vector.unit(self.dim, i)
ret += x[I + offset] + x[I - offset]
return ret
@ti.kernel
def compute_Ap(self):
for I in ti.grouped(self.Ap):
self.Ap[I] = 2 * self.dim * self.p[I] - self.neighbor_sum(
self.p, I)
@ti.kernel
def reduce(self, p: ti.template(), q: ti.template()):
self.sum[None] = 0
for I in ti.grouped(p):
self.sum[None] += p[I] * q[I]
@ti.kernel
def update_x(self):
for I in ti.grouped(self.p):
self.x[I] += self.alpha[None] * self.p[I]
@ti.kernel
def update_r(self):
for I in ti.grouped(self.p):
self.r[0][I] -= self.alpha[None] * self.Ap[I]
@ti.kernel
def update_p(self):
for I in ti.grouped(self.p):
self.p[I] = self.z[0][I] + self.beta[None] * self.p[I]
@ti.kernel
def restrict(self, l: ti.template()):
for I in ti.grouped(self.r[l]):
res = self.r[l][I] - (2 * self.dim * self.z[l][I] -
self.neighbor_sum(self.z[l], I))
self.r[l + 1][I // 2] += res * 0.5
@ti.kernel
def prolongate(self, l: ti.template()):
for I in ti.grouped(self.z[l]):
self.z[l][I] = self.z[l + 1][I // 2]
@ti.kernel
def smooth(self, l: ti.template(), phase: ti.template()):
# phase = red/black Gauss-Seidel phase
for I in ti.grouped(self.r[l]):
if (I.sum()) & 1 == phase:
self.z[l][I] = (self.r[l][I] + self.neighbor_sum(
self.z[l], I)) / (2 * self.dim)
def apply_preconditioner(self):
self.z[0].fill(0)
for l in range(self.n_mg_levels - 1):
for i in range(self.pre_and_post_smoothing << l):
self.smooth(l, 0)
self.smooth(l, 1)
self.z[l + 1].fill(0)
self.r[l + 1].fill(0)
self.restrict(l)
for i in range(self.bottom_smoothing):
self.smooth(self.n_mg_levels - 1, 0)
self.smooth(self.n_mg_levels - 1, 1)
for l in reversed(range(self.n_mg_levels - 1)):
self.prolongate(l)
for i in range(self.pre_and_post_smoothing << l):
self.smooth(l, 1)
self.smooth(l, 0)
def solve(self,
max_iters=-1,
eps=1e-12,
abs_tol=1e-12,
rel_tol=1e-12,
verbose=False):
'''
Solve a Poisson problem.
:parameter max_iters: Specify the maximal iterations. -1 for no limit.
:parameter eps: Specify a non-zero value to prevent ZeroDivisionError.
:parameter abs_tol: Specify the absolute tolerance of loss.
:parameter rel_tol: Specify the tolerance of loss relative to initial loss.
'''
self.reduce(self.r[0], self.r[0])
initial_rTr = self.sum[None]
tol = max(abs_tol, initial_rTr * rel_tol)
# self.r = b - Ax = b since self.x = 0
# self.p = self.r = self.r + 0 self.p
if self.use_multigrid:
self.apply_preconditioner()
else:
self.z[0].copy_from(self.r[0])
self.update_p()
self.reduce(self.z[0], self.r[0])
old_zTr = self.sum[None]
# Conjugate gradients
iter = 0
while max_iters == -1 or iter < max_iters:
# self.alpha = rTr / pTAp
self.compute_Ap()
self.reduce(self.p, self.Ap)
pAp = self.sum[None]
self.alpha[None] = old_zTr / (pAp + eps)
# self.x = self.x + self.alpha self.p
self.update_x()
# self.r = self.r - self.alpha self.Ap
self.update_r()
# check for convergence
self.reduce(self.r[0], self.r[0])
rTr = self.sum[None]
if verbose:
print(f'iter {iter}, |residual|_2={math.sqrt(rTr)}')
if rTr < tol:
break
# self.z = M^-1 self.r
if self.use_multigrid:
self.apply_preconditioner()
else:
self.z[0].copy_from(self.r[0])
# self.beta = new_rTr / old_rTr
self.reduce(self.z[0], self.r[0])
new_zTr = self.sum[None]
self.beta[None] = new_zTr / (old_zTr + eps)
# self.p = self.z + self.beta self.p
self.update_p()
old_zTr = new_zTr
iter += 1
class MGPCG_Example(MGPCG):
def __init__(self):
super().__init__(dim=3, N=128, n_mg_levels=4)
self.N_gui = 512 # gui resolution
self.pixels = ti.field(dtype=float,
shape=(self.N_gui, self.N_gui)) # image buffer
@ti.kernel
def init(self):
for I in ti.grouped(ti.ndrange(*[self.N] * self.dim)):
r_I = 5.0
for k in ti.static(range(self.dim)):
r_I *= ti.cos(5 * np.pi * I[k] / self.N)
self.init_r(I, r_I)
@ti.kernel
def paint(self):
if ti.static(self.dim == 3):
kk = self.N_tot * 3 // 8
for i, j in self.pixels:
ii = int(i * self.N / self.N_gui) + self.N_ext
jj = int(j * self.N / self.N_gui) + self.N_ext
self.pixels[i, j] = self.x[ii, jj, kk] / self.N_tot
def run(self, verbose=False):
self.init()
self.solve(max_iters=400, verbose=verbose)
self.paint()
ti.imshow(self.pixels)
ti.kernel_profiler_print()
if __name__ == '__main__':
ti.init(kernel_profiler=True)
solver = MGPCG_Example()
t = time.time()
solver.run(verbose=True)
print(f'Solver time: {time.time() - t:.3f} s')
| mit | 2,937,493,401,941,731,300 | 30.527778 | 128 | 0.508921 | false |
Brunel-Visualization/Brunel | python/brunel/brunel_util.py | 1 | 1472 | # Copyright (c) 2015 IBM Corporation and others.
#
# 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 the JVM cannot be located automatically, use this variable to get it from an environment variable. It should be the fully qualified
# path to the JVM. Typically jvm.dll on Windows or libjvm.so on Unix
import os
JVM_PATH = ""
D3_LOC = "https://cdnjs.cloudflare.com/ajax/libs/d3/4.13.0/d3.min"
TOPO_JSON_LOC = "https://cdnjs.cloudflare.com/ajax/libs/topojson/1.6.20/topojson.min"
JS_LOC = "/nbextensions/brunel_ext"
BRUNEL_CONFIG = os.getenv("BRUNEL_CONFIG", "")
opts = BRUNEL_CONFIG.strip().split(";")
for opt in opts:
keyval = opt.strip().split("=");
if keyval[0].strip().lower() == "jvm":
JVM_PATH = keyval[1]
elif keyval[0].strip().lower() == "locd3":
D3_LOC = keyval[1]
elif keyval[0].strip().lower() == "locjavascript":
JS_LOC = keyval[1]
elif keyval[0].strip().lower() == "loctopojson":
TOPO_JSON_LOC = keyval[1]
| apache-2.0 | 7,878,519,849,403,592,000 | 39.888889 | 137 | 0.69769 | false |
scenarios/tensorflow | tensorflow/contrib/distributions/python/ops/bijector.py | 2 | 92884 | # Copyright 2016 The TensorFlow Authors. 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.
# ==============================================================================
r"""Bijector Ops.
An API for invertible, differentiable transformations of random variables.
## Background
Differentiable, bijective transformations of continuous random variables alter
the calculations made in the cumulative/probability distribution functions and
sample function. This module provides a standard interface for making these
manipulations.
For more details and examples, see the `Bijector` docstring.
To apply a `Bijector`, use `distributions.TransformedDistribution`.
## Bijectors
@@Affine
@@AffineLinearOperator
@@Bijector
@@Chain
@@CholeskyOuterProduct
@@Exp
@@Identity
@@Inline
@@Invert
@@SigmoidCentered
@@SoftmaxCentered
@@Softplus
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import abc
import collections
import contextlib
import itertools
import math
import re
import numpy as np
import six
from tensorflow.contrib import framework as contrib_framework
from tensorflow.contrib.distributions.python.ops import distribution_util
from tensorflow.contrib.distributions.python.ops import operator_pd_cholesky
from tensorflow.contrib.distributions.python.ops import operator_pd_diag
from tensorflow.contrib.distributions.python.ops import operator_pd_identity
from tensorflow.contrib.distributions.python.ops import operator_pd_vdvt_update
from tensorflow.contrib.distributions.python.ops.shape import _DistributionShape
from tensorflow.contrib.linalg.python.ops import linear_operator
from tensorflow.python.framework import constant_op
from tensorflow.python.framework import dtypes
from tensorflow.python.framework import ops
from tensorflow.python.framework import tensor_shape
from tensorflow.python.framework import tensor_util
from tensorflow.python.ops import array_ops
from tensorflow.python.ops import check_ops
from tensorflow.python.ops import control_flow_ops
from tensorflow.python.ops import linalg_ops
from tensorflow.python.ops import math_ops
from tensorflow.python.ops import nn_ops
__all__ = [
"Affine",
"AffineLinearOperator",
"Bijector",
"Chain",
"CholeskyOuterProduct",
"Exp",
"Identity",
"Inline",
"Invert",
"PowerTransform",
"SigmoidCentered",
"SoftmaxCentered",
"Softplus",
]
def _as_tensor(x, name):
"""Convenience to convert to `Tensor` or leave as `None`."""
return None if x is None else ops.convert_to_tensor(x, name=name)
class _Mapping(collections.namedtuple("_Mapping",
["x", "y", "ildj", "condition_kwargs"])):
"""Helper class to make it easier to manage caching in `Bijector`."""
def __new__(cls, x=None, y=None, ildj=None, condition_kwargs=None):
"""Custom __new__ so namedtuple items have defaults.
Args:
x: `Tensor`. Forward.
y: `Tensor`. Inverse.
ildj: `Tensor`. Inverse log det Jacobian.
condition_kwargs: Python dictionary. Extra args supplied to
forward/inverse/etc functions.
Returns:
mapping: New instance of _Mapping.
"""
return super(_Mapping, cls).__new__(cls, x, y, ildj, condition_kwargs)
@property
def x_key(self):
"""Returns key used for caching Y=g(X)."""
return (self.x,) + self._deep_tuple(tuple(sorted(
self.condition_kwargs.items())))
@property
def y_key(self):
"""Returns key used for caching X=g^{-1}(Y)."""
return (self.y,) + self._deep_tuple(tuple(sorted(
self.condition_kwargs.items())))
def merge(self, x=None, y=None, ildj=None,
condition_kwargs=None, mapping=None):
"""Returns new _Mapping with args merged with self.
Args:
x: `Tensor`. Forward.
y: `Tensor`. Inverse.
ildj: `Tensor`. Inverse log det Jacobian.
condition_kwargs: Python dictionary. Extra args supplied to
forward/inverse/etc functions.
mapping: Instance of _Mapping to merge. Can only be specified if no other
arg is specified.
Returns:
mapping: New instance of `_Mapping` which has inputs merged with self.
Raises:
ValueError: if mapping and any other arg is not `None`.
"""
if mapping is None:
mapping = _Mapping(x=x, y=y, ildj=ildj,
condition_kwargs=condition_kwargs)
elif not all(arg is None for arg in [x, y, ildj, condition_kwargs]):
raise ValueError("Cannot specify mapping and individual args.")
return _Mapping(
x=self._merge(self.x, mapping.x),
y=self._merge(self.y, mapping.y),
ildj=self._merge(self.ildj, mapping.ildj),
condition_kwargs=self._merge(self.condition_kwargs,
mapping.condition_kwargs))
def _merge(self, old, new):
"""Helper to merge which handles merging one value."""
if old is None:
return new
elif new is not None and old != new:
raise ValueError("Incompatible values: %s != %s" % (old, new))
return old
def _deep_tuple(self, x):
"""Converts lists of lists to tuples of tuples."""
return (tuple(map(self._deep_tuple, x))
if isinstance(x, (list, tuple)) else x)
@six.add_metaclass(abc.ABCMeta)
class Bijector(object):
"""Interface for transforming a `Distribution` sample.
A `Bijector` implements a
[diffeomorphism](https://en.wikipedia.org/wiki/Diffeomorphism), i.e., a
bijective, differentiable function. A `Bijector` is used by
`TransformedDistribution` but can be generally used for transforming a
`Distribution` generated `Tensor`. A `Bijector` is characterized by three
operations:
1. Forward Evaluation
Useful for turning one random outcome into another random outcome from a
different distribution.
2. Inverse Evaluation
Useful for "reversing" a transformation to compute one probability in
terms of another.
3. (log o det o Jacobian o inverse)(x)
"The log of the determinant of the matrix of all first-order partial
derivatives of the inverse function."
Useful for inverting a transformation to compute one probability in terms
of another. Geometrically, the det(Jacobian) is the volume of the
transformation and is used to scale the probability.
By convention, transformations of random variables are named in terms of the
forward transformation. The forward transformation creates samples, the
inverse is useful for computing probabilities.
Example Use:
- Basic properties:
```python
x = ... # A tensor.
# Evaluate forward transformation.
fwd_x = my_bijector.forward(x)
x == my_bijector.inverse(fwd_x)
x != my_bijector.forward(fwd_x) # Not equal because g(x) != g(g(x)).
```
- Computing a log-likelihood:
```python
def transformed_log_pdf(bijector, log_pdf, x):
return (bijector.inverse_log_det_jacobian(x) +
log_pdf(bijector.inverse(x)))
```
- Transforming a random outcome:
```python
def transformed_sample(bijector, x):
return bijector.forward(x)
```
Example transformations:
- "Exponential"
```
Y = g(X) = exp(X)
X ~ Normal(0, 1) # Univariate.
```
Implies:
```
g^{-1}(Y) = log(Y)
|Jacobian(g^{-1})(y)| = 1 / y
Y ~ LogNormal(0, 1), i.e.,
prob(Y=y) = |Jacobian(g^{-1})(y)| * prob(X=g^{-1}(y))
= (1 / y) Normal(log(y); 0, 1)
```
Here is an example of how one might implement the `Exp` bijector:
```
class Exp(Bijector):
def __init__(self, event_ndims=0, validate_args=False, name="exp"):
super(Exp, self).__init__(batch_ndims=0, event_ndims=event_ndims,
validate_args=validate_args, name=name)
def _forward(self, x):
return math_ops.exp(x)
def _inverse_and_inverse_log_det_jacobian(self, y):
x = math_ops.log(y)
return x, -self._forward_log_det_jacobian(x)
def _forward_log_det_jacobian(self, x):
if self.shaper is None:
raise ValueError("Jacobian requires known event_ndims.")
_, _, event_dims = self.shaper.get_dims(x)
return math_ops.reduce_sum(x, reduction_indices=event_dims)
```
- "Affine"
```
Y = g(X) = sqrtSigma * X + mu
X ~ MultivariateNormal(0, I_d)
```
Implies:
```
g^{-1}(Y) = inv(sqrtSigma) * (Y - mu)
|Jacobian(g^{-1})(y)| = det(inv(sqrtSigma))
Y ~ MultivariateNormal(mu, sqrtSigma) , i.e.,
prob(Y=y) = |Jacobian(g^{-1})(y)| * prob(X=g^{-1}(y))
= det(sqrtSigma)^(-d) *
MultivariateNormal(inv(sqrtSigma) * (y - mu); 0, I_d)
```
Example of why a `Bijector` needs to understand sample, batch, event
partitioning:
- Consider the `Exp` `Bijector` applied to a `Tensor` which has sample, batch,
and event (S, B, E) shape semantics. Suppose
the `Tensor`'s partitioned-shape is `(S=[4], B=[2], E=[3, 3])`.
For `Exp`, the shape of the `Tensor` returned by `forward` and `inverse` is
unchanged, i.e., `[4, 2, 3, 3]`. However the shape returned by
`inverse_log_det_jacobian` is `[4, 2]` because the Jacobian is a reduction
over the event dimensions.
Subclass Requirements:
- Typically subclasses implement `_forward` and one or both of:
- `_inverse`, `_inverse_log_det_jacobian`,
- `_inverse_and_inverse_log_det_jacobian`.
- If the `Bijector`'s use is limited to `TransformedDistribution` (or friends
like `QuantizedDistribution`) then depending on your use, you may not need
to implement all of `_forward` and `_inverse` functions. Examples:
1. Sampling (e.g., `sample`) only requires `_forward`.
2. Probability functions (e.g., `prob`, `cdf`, `survival`) only require
`_inverse` (and related).
3. Only calling probability functions on the output of `sample` means
`_inverse` can be implemented as a cache lookup.
See `Example Use` [above] which shows how these functions are used to
transform a distribution. (Note: `_forward` could theoretically be
implemented as a cache lookup but this would require controlling the
underlying sample generation mechanism.)
- If computation can be shared among `_inverse` and
`_inverse_log_det_jacobian` it is preferable to implement
`_inverse_and_inverse_log_det_jacobian`. This usually reduces
graph-construction overhead because a `Distribution`'s implementation of
`log_prob` will need to evaluate both the inverse Jacobian as well as the
inverse function.
- If an additional use case needs just `inverse` or just
`inverse_log_det_jacobian` then he or she may also wish to implement these
functions to avoid computing the `inverse_log_det_jacobian` or the
`inverse`, respectively.
- Subclasses should implement `_get_forward_event_shape`,
`_forward_event_shape` (and `inverse` counterparts) if the transformation is
shape-changing. By default the event-shape is assumed unchanged from input.
Tips for implementing `_inverse` and `_inverse_log_det_jacobian`:
- As case 3 [above] indicates, under some circumstances the inverse function
can be implemented as a cache lookup.
- The inverse `log o det o Jacobian` can be implemented as the negative of the
forward `log o det o Jacobian`. This is useful if the `inverse` is
implemented as a cache or the inverse Jacobian is computationally more
expensive (e.g., `CholeskyOuterProduct` `Bijector`). The following
demonstrates the suggested implementation.
```python
def _inverse_and_log_det_jacobian(self, y):
x = # ... implement inverse, possibly via cache.
return x, -self._forward_log_det_jac(x) # Note negation.
```
By overriding the `_inverse_and_log_det_jacobian` function we have access to
the inverse in one call.
The correctness of this approach can be seen from the following claim.
- Claim:
Assume `Y=g(X)` is a bijection whose derivative exists and is nonzero
for its domain, i.e., `d/dX g(X)!=0`. Then:
```none
(log o det o jacobian o g^{-1})(Y) = -(log o det o jacobian o g)(X)
```
- Proof:
From the bijective, nonzero differentiability of `g`, the
[inverse function theorem](
https://en.wikipedia.org/wiki/Inverse_function_theorem)
implies `g^{-1}` is differentiable in the image of `g`.
Applying the chain rule to `y = g(x) = g(g^{-1}(y))` yields
`I = g'(g^{-1}(y))*g^{-1}'(y)`.
The same theorem also implies `g{-1}'` is non-singular therefore:
`inv[ g'(g^{-1}(y)) ] = g^{-1}'(y)`.
The claim follows from [properties of determinant](
https://en.wikipedia.org/wiki/Determinant#Multiplicativity_and_matrix_groups).
- If possible, prefer a direct implementation of the inverse Jacobian. This
should have superior numerical stability and will often share subgraphs with
the `_inverse` implementation.
"""
@abc.abstractmethod
def __init__(self,
batch_ndims=None,
event_ndims=None,
graph_parents=None,
is_constant_jacobian=False,
validate_args=False,
dtype=None,
name=None):
"""Constructs Bijector.
A `Bijector` transforms random variables into new random variables.
Examples:
```python
# Create the Y = g(X) = X transform which operates on 4-Tensors of vectors.
identity = Identity(batch_ndims=4, event_ndims=1)
# Create the Y = g(X) = exp(X) transform which operates on matrices.
exp = Exp(batch_ndims=0, event_ndims=2)
```
See `Bijector` subclass docstring for more details and specific examples.
Args:
batch_ndims: number of dimensions associated with batch coordinates.
event_ndims: number of dimensions associated with event coordinates.
graph_parents: Python list of graph prerequisites of this `Bijector`.
is_constant_jacobian: `Boolean` indicating that the Jacobian is not a
function of the input.
validate_args: `Boolean`, default `False`. Whether to validate input with
asserts. If `validate_args` is `False`, and the inputs are invalid,
correct behavior is not guaranteed.
dtype: `tf.dtype` supported by this `Bijector`. `None` means dtype is not
enforced.
name: The name to give Ops created by the initializer.
"""
if batch_ndims is None or event_ndims is None:
self._shaper = None # Apparently subclass will create.
else:
self._shaper = _DistributionShape(
batch_ndims=batch_ndims,
event_ndims=event_ndims,
validate_args=validate_args)
self._graph_parents = graph_parents or []
self._is_constant_jacobian = is_constant_jacobian
self._validate_args = validate_args
self._dtype = dtype
self._from_y = {}
self._from_x = {}
# Using abbreviation ildj for "inverse log det Jacobian."
# This variable is not `None` iff is_constant_jacobian is `True`.
self._constant_ildj = None
if name:
self._name = name
else:
# We want the default convention to be snake_case rather than CamelCase
# since `Chain` uses bijector.name as the condition_kwargs dictionary key.
def camel_to_snake(name):
s1 = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", name)
return re.sub("([a-z0-9])([A-Z])", r"\1_\2", s1).lower()
self._name = camel_to_snake(type(self).__name__)
@property
def shaper(self):
"""Returns shape object used to manage shape constraints."""
return self._shaper
@property
def graph_parents(self):
"""Returns this `Bijector`'s graph_parents as a Python list."""
return self._graph_parents
@property
def is_constant_jacobian(self):
"""Returns true iff the Jacobian is not a function of x.
Note: Jacobian is either constant for both forward and inverse or neither.
Returns:
`Boolean`.
"""
return self._is_constant_jacobian
@property
def validate_args(self):
"""Returns True if Tensor arguments will be validated."""
return self._validate_args
@property
def dtype(self):
"""dtype of `Tensor`s transformable by this distribution."""
return self._dtype
@property
def name(self):
"""Returns the string name of this `Bijector`."""
return self._name
def _forward_event_shape(self, input_shape):
"""Subclass implementation for `forward_event_shape` public function."""
return input_shape
def forward_event_shape(self, input_shape, name="forward_event_shape"):
"""Shape of a single sample from a single batch as an `int32` 1D `Tensor`.
Args:
input_shape: `Tensor`, `int32` vector indicating event-portion shape
passed into `forward` function.
name: name to give to the op
Returns:
forward_event_shape: `Tensor`, `int32` vector indicating event-portion
shape after applying `forward`.
"""
with self._name_scope(name, [input_shape]):
input_shape = ops.convert_to_tensor(input_shape, dtype=dtypes.int32,
name="input_shape")
return self._forward_event_shape(input_shape)
def _get_forward_event_shape(self, input_shape):
"""Subclass implementation for `get_forward_event_shape` public function."""
return input_shape
def get_forward_event_shape(self, input_shape):
"""Shape of a single sample from a single batch as a `TensorShape`.
Same meaning as `forward_event_shape`. May be only partially defined.
Args:
input_shape: `TensorShape` indicating event-portion shape passed into
`forward` function.
Returns:
forward_event_shape: `TensorShape` indicating event-portion shape after
applying `forward`. Possibly unknown.
"""
return self._get_forward_event_shape(tensor_shape.TensorShape(input_shape))
def _inverse_event_shape(self, output_shape):
"""Subclass implementation for `inverse_event_shape` public function."""
return output_shape
def inverse_event_shape(self, output_shape, name="inverse_event_shape"):
"""Shape of a single sample from a single batch as an `int32` 1D `Tensor`.
Args:
output_shape: `Tensor`, `int32` vector indicating event-portion shape
passed into `inverse` function.
name: name to give to the op
Returns:
inverse_event_shape: `Tensor`, `int32` vector indicating event-portion
shape after applying `inverse`.
"""
with self._name_scope(name, [output_shape]):
output_shape = ops.convert_to_tensor(output_shape, dtype=dtypes.int32,
name="output_shape")
return self._inverse_event_shape(output_shape)
def _get_inverse_event_shape(self, output_shape):
"""Subclass implementation for `get_inverse_event_shape` public function."""
return self._get_inverse_event_shape(tensor_shape.TensorShape(output_shape))
def get_inverse_event_shape(self, output_shape):
"""Shape of a single sample from a single batch as a `TensorShape`.
Same meaning as `inverse_event_shape`. May be only partially defined.
Args:
output_shape: `TensorShape` indicating event-portion shape passed into
`inverse` function.
Returns:
inverse_event_shape: `TensorShape` indicating event-portion shape after
applying `inverse`. Possibly unknown.
"""
return self._get_inverse_event_shape(output_shape)
def _forward(self, x):
"""Subclass implementation for `forward` public function."""
raise NotImplementedError("forward not implemented.")
def forward(self, x, name="forward", **condition_kwargs):
"""Returns the forward `Bijector` evaluation, i.e., X = g(Y).
Args:
x: `Tensor`. The input to the "forward" evaluation.
name: The name to give this op.
**condition_kwargs: Named arguments forwarded to subclass implementation.
Returns:
`Tensor`.
Raises:
TypeError: if `self.dtype` is specified and `x.dtype` is not
`self.dtype`.
NotImplementedError: if `_forward` is not implemented.
"""
with self._name_scope(name, [x]):
x = ops.convert_to_tensor(x, name="x")
self._maybe_assert_dtype(x)
mapping = self._lookup(x=x, condition_kwargs=condition_kwargs)
if mapping.y is not None:
return mapping.y
mapping = mapping.merge(y=self._forward(x, **condition_kwargs))
self._cache(mapping)
return mapping.y
def _inverse(self, y):
"""Subclass implementation for `inverse` public function."""
raise NotImplementedError("inverse not implemented")
def inverse(self, y, name="inverse", **condition_kwargs):
"""Returns the inverse `Bijector` evaluation, i.e., X = g^{-1}(Y).
Args:
y: `Tensor`. The input to the "inverse" evaluation.
name: The name to give this op.
**condition_kwargs: Named arguments forwarded to subclass implementation.
Returns:
`Tensor`.
Raises:
TypeError: if `self.dtype` is specified and `y.dtype` is not
`self.dtype`.
NotImplementedError: if neither `_inverse` nor
`_inverse_and_inverse_log_det_jacobian` are implemented.
"""
with self._name_scope(name, [y]):
y = ops.convert_to_tensor(y, name="y")
self._maybe_assert_dtype(y)
mapping = self._lookup(y=y, condition_kwargs=condition_kwargs)
if mapping.x is not None:
return mapping.x
ildj = None
try:
x = self._inverse(y, **condition_kwargs)
except NotImplementedError as original_error:
# Since _inverse was not implemented, try to see if it's implemented
# by the _inverse_and_inverse_log_det_jacobian member.
try:
x, ildj = self._inverse_and_inverse_log_det_jacobian(
y, **condition_kwargs)
except NotImplementedError:
raise original_error
if self._constant_ildj is not None:
ildj = self._constant_ildj # Use the "global" result.
elif self.is_constant_jacobian:
self._constant_ildj = ildj
x = x if mapping.x is None else mapping.x
mapping = mapping.merge(x=x, ildj=ildj)
self._cache(mapping)
return mapping.x
def _inverse_log_det_jacobian(self, y):
"""Subclass implementation for `inverse_log_det_jacobian` public function.""" # pylint: disable=line-too-long
raise NotImplementedError("inverse_log_det_jacobian not implemented.")
def inverse_log_det_jacobian(
self, y, name="inverse_log_det_jacobian", **condition_kwargs):
"""Returns the (log o det o Jacobian o inverse)(y).
Mathematically, returns: `log(det(dX/dY))(Y)`. (Recall that: `X=g^{-1}(Y)`.)
Note that `forward_log_det_jacobian` is the negative of this function.
Args:
y: `Tensor`. The input to the "inverse" Jacobian evaluation.
name: The name to give this op.
**condition_kwargs: Named arguments forwarded to subclass implementation.
Returns:
`Tensor`.
Raises:
TypeError: if `self.dtype` is specified and `y.dtype` is not
`self.dtype`.
NotImplementedError: if neither `_inverse_log_det_jacobian` nor
`_inverse_and_inverse_log_det_jacobian` are implemented.
"""
with self._name_scope(name, [y]):
if self._constant_ildj is not None:
return self._constant_ildj
y = ops.convert_to_tensor(y, name="y")
self._maybe_assert_dtype(y)
mapping = self._lookup(y=y, condition_kwargs=condition_kwargs)
if mapping.ildj is not None:
return mapping.ildj
try:
x = mapping.x
ildj = self._inverse_log_det_jacobian(y, **condition_kwargs)
except NotImplementedError as original_error:
# Since _inverse_log_det_jacobian was not implemented, try to see if
# it's implemented by the _inverse_and_inverse_log_det_jacobian member.
try:
x, ildj = self._inverse_and_inverse_log_det_jacobian(
y, **condition_kwargs)
except NotImplementedError:
raise original_error
if mapping.x is not None:
x = mapping.x
if self.is_constant_jacobian:
self._constant_ildj = ildj
x = x if mapping.x is None else mapping.x
mapping = mapping.merge(x=x, ildj=ildj)
self._cache(mapping)
return mapping.ildj
def _inverse_and_inverse_log_det_jacobian(self, y):
"""Subclass implementation for `inverse_and_inverse_log_det_jacobian` public function.""" # pylint: disable=line-too-long
raise NotImplementedError(
"inverse_and_inverse_log_det_jacobian not implemented.")
def inverse_and_inverse_log_det_jacobian(
self, y, name="inverse_and_inverse_log_det_jacobian", **condition_kwargs):
"""Returns both the inverse evaluation and inverse_log_det_jacobian.
Enables possibly more efficient calculation when both inverse and
corresponding Jacobian are needed.
See `inverse()`, `inverse_log_det_jacobian()` for more details.
Args:
y: `Tensor`. The input to the "inverse" Jacobian evaluation.
name: The name to give this op.
**condition_kwargs: Named arguments forwarded to subclass implementation.
Returns:
`Tensor`.
Raises:
TypeError: if `self.dtype` is specified and `y.dtype` is not
`self.dtype`.
NotImplementedError: if neither `_inverse_and_inverse_log_det_jacobian`
nor {`_inverse`, `_inverse_log_det_jacobian`} are implemented.
"""
with self._name_scope(name, [y]):
y = ops.convert_to_tensor(y, name="y")
self._maybe_assert_dtype(y)
mapping = self._lookup(y=y, condition_kwargs=condition_kwargs)
if mapping.x is not None and mapping.ildj is not None:
return mapping.x, mapping.ildj
try:
x, ildj = self._inverse_and_inverse_log_det_jacobian(
y, **condition_kwargs)
except NotImplementedError as original_error:
# Since _inverse_and_inverse_log_det_jacobian was not implemented, try
# to see if we can separately use _inverse and
# _inverse_log_det_jacobian members.
try:
# We want this same try/except to catch either NotImplementedError.
x = self._inverse(y, **condition_kwargs)
if self._constant_ildj is None:
ildj = self._inverse_log_det_jacobian(y, **condition_kwargs)
except NotImplementedError:
raise original_error
if self._constant_ildj is not None:
ildj = self._constant_ildj # Ignore any ildj we may/not have.
elif self.is_constant_jacobian:
self._constant_ildj = ildj
# We use the mapped version of x, even if we re-computed x above with a
# call to self._inverse_and_inverse_log_det_jacobian. This prevents
# re-evaluation of the inverse in a common case.
x = x if mapping.x is None else mapping.x
mapping = mapping.merge(x=x, ildj=ildj)
self._cache(mapping)
return mapping.x, mapping.ildj
def _forward_log_det_jacobian(self, x):
"""Subclass implementation for `forward_log_det_jacobian` public function.""" # pylint: disable=line-too-long
raise NotImplementedError(
"forward_log_det_jacobian not implemented.")
def forward_log_det_jacobian(
self, x, name="forward_log_det_jacobian", **condition_kwargs):
"""Returns both the forward_log_det_jacobian.
Args:
x: `Tensor`. The input to the "forward" Jacobian evaluation.
name: The name to give this op.
**condition_kwargs: Named arguments forwarded to subclass implementation.
Returns:
`Tensor`.
Raises:
TypeError: if `self.dtype` is specified and `y.dtype` is not
`self.dtype`.
NotImplementedError: if neither `_forward_log_det_jacobian`
nor {`_inverse`, `_inverse_log_det_jacobian`} are implemented.
"""
with self._name_scope(name, [x]):
if self._constant_ildj is not None:
# Need "-1. *" to avoid invalid-unary-operand-type linter warning.
return -1. * self._constant_ildj
x = ops.convert_to_tensor(x, name="x")
self._maybe_assert_dtype(x)
mapping = self._lookup(x=x, condition_kwargs=condition_kwargs)
if mapping.ildj is not None:
return -mapping.ildj
y = None
try:
ildj = -self._forward_log_det_jacobian(x, **condition_kwargs)
except NotImplementedError as original_error:
try:
# We want this same try/except to catch either NotImplementedError.
y = self.inverse(x, **condition_kwargs) if y is None else y
ildj = self.inverse_log_det_jacobian(y, **condition_kwargs)
except NotImplementedError:
raise original_error
if self.is_constant_jacobian:
self._constant_ildj = ildj
y = y if mapping.y is None else mapping.y
mapping = mapping.merge(y=y, ildj=ildj)
self._cache(mapping)
return -mapping.ildj
@contextlib.contextmanager
def _name_scope(self, name=None, values=None):
"""Helper function to standardize op scope."""
with ops.name_scope(self.name):
with ops.name_scope(
name, values=(values or []) + self.graph_parents) as scope:
yield scope
def _maybe_assert_dtype(self, x):
"""Helper to check dtype when self.dtype is known."""
if self.dtype is not None and self.dtype.base_dtype != x.dtype.base_dtype:
raise TypeError("Input had dtype %s but expected %s." %
(self.dtype, x.dtype))
def _cache(self, mapping):
"""Helper which stores mapping info in forward/inverse dicts."""
if self._constant_ildj is not None:
# Fold in ildj if known constant Jacobian.
mapping = mapping.merge(ildj=self._constant_ildj)
# Merging from lookup is an added check that we're not overwriting anything
# which is not None.
mapping = mapping.merge(mapping=self._lookup(
mapping.x, mapping.y, mapping.condition_kwargs))
if mapping.x is None and mapping.y is None:
raise ValueError("Caching expects at least one of (x,y) to be known, "
"i.e., not None.")
self._from_x[mapping.x_key] = mapping
self._from_y[mapping.y_key] = mapping
def _lookup(self, x=None, y=None, condition_kwargs=None):
"""Helper which retrieves mapping info from forward/inverse dicts."""
mapping = _Mapping(x=x, y=y, condition_kwargs=condition_kwargs)
# Since _cache requires both x,y to be set, we only need to do one cache
# lookup since the mapping is always in both or neither.
if mapping.x is not None:
return self._from_x.get(mapping.x_key, mapping)
if mapping.y is not None:
return self._from_y.get(mapping.y_key, mapping)
return mapping
class Inline(Bijector):
# pylint: disable=line-too-long
"""Bijector constructed from callables implementing forward, inverse, and inverse_log_det_jacobian.
Example Use:
```python
exp = Inline(
forward_fn=tf.exp,
inverse_fn=tf.log,
inverse_log_det_jacobian_fn=(
lambda y: -tf.reduce_sum(tf.log(y), reduction_indices=-1)),
name="exp")
```
The above example is equivalent to the `Bijector` `Exp(event_ndims=1)`.
"""
# pylint: enable=line-too-long
def __init__(self,
forward_fn=None,
inverse_fn=None,
inverse_log_det_jacobian_fn=None,
forward_log_det_jacobian_fn=None,
get_forward_event_shape_fn=None,
forward_event_shape_fn=None,
get_inverse_event_shape_fn=None,
inverse_event_shape_fn=None,
is_constant_jacobian=False,
validate_args=False,
name="inline"):
"""Creates a `Bijector` from callables.
Args:
forward_fn: Python callable implementing the forward transformation.
inverse_fn: Python callable implementing the inverse transformation.
inverse_log_det_jacobian_fn: Python callable implementing the
log o det o jacobian of the inverse transformation.
forward_log_det_jacobian_fn: Python callable implementing the
log o det o jacobian of the forward transformation.
get_forward_event_shape_fn: Python callable implementing non-identical
static event shape changes. Default: shape is assumed unchanged.
forward_event_shape_fn: Python callable implementing non-identical event
shape changes. Default: shape is assumed unchanged.
get_inverse_event_shape_fn: Python callable implementing non-identical
static event shape changes. Default: shape is assumed unchanged.
inverse_event_shape_fn: Python callable implementing non-identical event
shape changes. Default: shape is assumed unchanged.
is_constant_jacobian: `Boolean` indicating that the Jacobian is constant
for all input arguments.
validate_args: `Boolean` indicating whether arguments should be checked
for correctness.
name: `String`, name given to ops managed by this object.
"""
super(Inline, self).__init__(
batch_ndims=0,
event_ndims=0,
is_constant_jacobian=is_constant_jacobian,
validate_args=validate_args,
name=name)
self._forward_fn = forward_fn
self._inverse_fn = inverse_fn
self._inverse_log_det_jacobian_fn = inverse_log_det_jacobian_fn
self._forward_log_det_jacobian_fn = forward_log_det_jacobian_fn
self._get_forward_event_shape_fn = get_forward_event_shape_fn
self._forward_event_shape_fn = forward_event_shape_fn
self._get_inverse_event_shape_fn = get_inverse_event_shape_fn
self._inverse_event_shape_fn = inverse_event_shape_fn
def _get_forward_event_shape(self, input_shape):
if self._get_forward_event_shape_fn is None:
# By default assume shape doesn't change.
return input_shape
return self._get_forward_event_shape_fn(input_shape)
def _forward_event_shape(self, input_shape):
if self._forward_event_shape_fn is None:
# By default assume shape doesn't change.
return input_shape
return self._forward_event_shape_fn(input_shape)
def _get_inverse_event_shape(self, output_shape):
if self._get_inverse_event_shape_fn is None:
# By default assume shape doesn't change.
return output_shape
return self._get_inverse_event_shape_fn(output_shape)
def _inverse_event_shape(self, output_shape):
if self._inverse_event_shape_fn is None:
# By default assume shape doesn't change.
return output_shape
return self._inverse_event_shape_fn(output_shape)
def _forward(self, x, **condition_kwargs):
if not callable(self._forward_fn):
raise NotImplementedError(
"forward_fn is not a callable function.")
return self._forward_fn(x, **condition_kwargs)
def _inverse(self, y, **condition_kwargs):
if not callable(self._inverse_fn):
raise NotImplementedError(
"inverse_fn is not a callable function.")
return self._inverse_fn(y, **condition_kwargs)
def _inverse_log_det_jacobian(self, y, **condition_kwargs):
if not callable(self._inverse_log_det_jacobian_fn):
raise NotImplementedError(
"inverse_log_det_jacobian_fn is not a callable function.")
return self._inverse_log_det_jacobian_fn(y, **condition_kwargs)
def _forward_log_det_jacobian(self, y, **condition_kwargs):
if not callable(self._forward_log_det_jacobian_fn):
raise NotImplementedError(
"forward_log_det_jacobian_fn is not a callable function.")
return self._forward_log_det_jacobian_fn(y, **condition_kwargs)
class Invert(Bijector):
"""Bijector which inverts another Bijector.
Example Use: [ExpGammaDistribution (see Background & Context)](
https://reference.wolfram.com/language/ref/ExpGammaDistribution.html)
models `Y=log(X)` where `X ~ Gamma`.
```python
exp_gamma_distribution = TransformedDistribution(
Gamma(alpha=1., beta=2.),
bijector.Invert(bijector.Exp())
```
"""
def __init__(self, bijector, validate_args=False, name=None):
"""Creates a `Bijector` which swaps the meaning of `inverse` and `forward`.
Note: An inverted bijector's `inverse_log_det_jacobian` is often more
efficient if the base bijector implements `_forward_log_det_jacobian`. If
`_forward_log_det_jacobian` is not implemented then the following code is
used:
```python
y = self.inverse(x, **condition_kwargs)
return -self.inverse_log_det_jacobian(y, **condition_kwargs)
```
Args:
bijector: Bijector instance.
validate_args: `Boolean` indicating whether arguments should be checked
for correctness.
name: `String`, name given to ops managed by this object.
"""
self._bijector = bijector
super(Invert, self).__init__(
graph_parents=bijector.graph_parents,
is_constant_jacobian=bijector.is_constant_jacobian,
validate_args=validate_args,
dtype=bijector.dtype,
name=name or "_".join(["invert", bijector.name]))
self._shaper = bijector.shaper
def _get_forward_event_shape(self, input_shape):
return self.bijector.get_inverse_event_shape(input_shape)
def _forward_event_shape(self, input_shape):
return self.bijector.inverse_event_shape(input_shape)
def _get_inverse_event_shape(self, output_shape):
return self.bijector.get_forward_event_shape(output_shape)
def _inverse_event_shape(self, output_shape):
return self.bijector.forward_event_shape(output_shape)
@property
def bijector(self):
return self._bijector
def _forward(self, x, **condition_kwargs):
return self.bijector.inverse(x, **condition_kwargs)
def _inverse_and_inverse_log_det_jacobian(self, y, **condition_kwargs):
return (self.bijector.forward(y, **condition_kwargs),
self.bijector.forward_log_det_jacobian(y, **condition_kwargs))
def _forward_log_det_jacobian(self, x, **condition_kwargs):
return self.bijector.inverse_log_det_jacobian(x, **condition_kwargs)
class Chain(Bijector):
"""Bijector which applies a sequence of bijectors.
Example Use:
```python
chain = Chain([Exp(), Softplus()], name="one_plus_exp")
```
Results in:
* Forward:
```python
exp = Exp()
softplus = Softplus()
Chain([exp, softplus]).forward(x)
= exp.forward(softplus.forward(x))
= tf.exp(tf.log(1. + tf.exp(x)))
= 1. + tf.exp(x)
```
* Inverse:
```python
exp = Exp()
softplus = Softplus()
Chain([exp, softplus]).inverse(y)
= softplus.inverse(exp.inverse(y))
= tf.log(tf.exp(tf.log(y)) - 1.)
= tf.log(y - 1.)
```
"""
def __init__(self, bijectors=(), validate_args=False, name=None):
"""Instantiates `Chain` bijector.
Args:
bijectors: Python list of bijector instances. An empty list makes this
bijector equivalent to the `Identity` bijector.
validate_args: `Boolean` indicating whether arguments should be checked
for correctness.
name: `String`, name given to ops managed by this object. Default: E.g.,
`Chain([Exp(), Softplus()]).name == "chain_of_exp_of_softplus"`.
Raises:
ValueError: if bijectors have different dtypes.
"""
self._bijectors = bijectors
dtype = list(set([b.dtype for b in bijectors]))
if len(dtype) > 2:
raise ValueError("incompatible dtypes: %s" % dtype)
elif len(dtype) == 2:
dtype = dtype[1] if dtype[0] is None else dtype[0]
elif len(dtype) == 1:
dtype = dtype[0]
else:
dtype = None
super(Chain, self).__init__(
graph_parents=list(itertools.chain.from_iterable(
b.graph_parents for b in bijectors)),
is_constant_jacobian=all(b.is_constant_jacobian for b in bijectors),
validate_args=validate_args,
dtype=dtype,
name=name or ("identity" if not bijectors else
"_of_".join(["chain"] + [b.name for b in bijectors])))
@property
def bijectors(self):
return self._bijectors
def _shape_helper(self, func_name, input_shape, reverse):
new_shape = input_shape
for b in reversed(self.bijectors) if reverse else self.bijectors:
func = getattr(b, func_name, None)
if func is None:
raise ValueError("unable to call %s on bijector %s (%s)" %
(func_name, b.name, func))
new_shape = func(new_shape)
return new_shape
def _get_forward_event_shape(self, input_shape):
return self._shape_helper("get_forward_event_shape", input_shape,
reverse=True)
def _forward_event_shape(self, input_shape):
return self._shape_helper("forward_event_shape", input_shape, reverse=True)
def _get_inverse_event_shape(self, output_shape):
return self._shape_helper("get_inverse_event_shape", output_shape,
reverse=False)
def _inverse_event_shape(self, output_shape):
return self._shape_helper("inverse_event_shape", output_shape,
reverse=False)
def _forward(self, x, **condition_kwargs):
y = x
for b in reversed(self.bijectors):
y = b.forward(y, **condition_kwargs.get(b.name, {}))
return y
def _inverse_and_inverse_log_det_jacobian(self, y, **condition_kwargs):
x = y
ildj = constant_op.constant(0., dtype=x.dtype,
name="inverse_log_det_jacobian")
for b in self.bijectors:
x, j = b.inverse_and_inverse_log_det_jacobian(
x, **condition_kwargs.get(b.name, {}))
ildj += j
return x, ildj
def _forward_log_det_jacobian(self, x, **condition_kwargs):
y = x
fldj = constant_op.constant(0., dtype=x.dtype,
name="forward_log_det_jacobian")
for b in reversed(self.bijectors):
bijector_condition_kwargs = condition_kwargs.get(b.name, {})
fldj += b.forward_log_det_jacobian(y, **bijector_condition_kwargs)
y = b.forward(y, **bijector_condition_kwargs)
return fldj
class Identity(Bijector):
"""Bijector which computes Y = g(X) = X.
Example Use:
```python
# Create the Y=g(X)=X transform which is intended for Tensors with 1 batch
# ndim and 1 event ndim (i.e., vector of vectors).
identity = Identity(batch_ndims=1, event_ndims=1)
x = [[1., 2],
[3, 4]]
x == identity.forward(x) == identity.inverse(x)
```
"""
def __init__(self, validate_args=False, name="identity"):
super(Identity, self).__init__(
is_constant_jacobian=True,
validate_args=validate_args,
name=name)
def _forward(self, x):
return x
def _inverse_and_inverse_log_det_jacobian(self, y):
return y, constant_op.constant(0., dtype=y.dtype)
def _forward_log_det_jacobian(self, x):
return constant_op.constant(0., dtype=x.dtype)
class PowerTransform(Bijector):
"""Bijector which computes `Y = g(X) = (1 + X * c)**(1 / c), X >= -1 / c`.
The [power transform](https://en.wikipedia.org/wiki/Power_transform) maps
inputs from `[0, inf]` to `[-1/c, inf]`; this is equivalent to the `inverse`
of this bijector.
This bijector is equivalent to the `Exp` bijector when `c=0`.
"""
def __init__(self,
power=0.,
event_ndims=0,
validate_args=False,
name="power_transform"):
"""Instantiates the `PowerTransform` bijector.
Args:
power: Python `float` scalar indicating the transform power, i.e.,
`Y = g(X) = (1 + X * c)**(1 / c)` where `c` is the `power`.
event_ndims: Python scalar indicating the number of dimensions associated
with a particular draw from the distribution.
validate_args: `Boolean` indicating whether arguments should be checked
for correctness.
name: `String` name given to ops managed by this object.
Raises:
ValueError: if `power < 0` or is not known statically.
"""
self._graph_parents = []
self._name = name
self._validate_args = validate_args
with self._name_scope("init", values=[power]):
power = tensor_util.constant_value(
ops.convert_to_tensor(power, name="power"))
if power is None or power < 0:
raise ValueError("`power` must be a non-negative TF constant.")
self._power = power
super(PowerTransform, self).__init__(
batch_ndims=0,
event_ndims=event_ndims,
validate_args=validate_args,
name=name)
@property
def power(self):
"""The `c` in: `Y = g(X) = (1 + X * c)**(1 / c)`."""
return self._power
def _forward(self, x):
x = self._maybe_assert_valid_x(x)
if self.power == 0.:
return math_ops.exp(x)
# TODO(jvdillon): If large x accuracy is an issue, consider using
# (1. + x * self.power)**(1. / self.power) when x >> 1.
return math_ops.exp(math_ops.log1p(x * self.power) / self.power)
def _inverse_and_inverse_log_det_jacobian(self, y):
y = self._maybe_assert_valid_y(y)
if self.shaper is None:
raise ValueError("Jacobian cannot be computed with unknown event_ndims")
_, _, event_dims = self.shaper.get_dims(y)
if self.power == 0.:
x = math_ops.log(y)
ildj = -math_ops.reduce_sum(x, reduction_indices=event_dims)
return x, ildj
# TODO(jvdillon): If large y accuracy is an issue, consider using
# (y**self.power - 1.) / self.power when y >> 1.
x = math_ops.expm1(math_ops.log(y) * self.power) / self.power
ildj = (self.power - 1.) * math_ops.reduce_sum(
math_ops.log(y),
reduction_indices=event_dims)
return x, ildj
def _forward_log_det_jacobian(self, x):
x = self._maybe_assert_valid_x(x)
if self.shaper is None:
raise ValueError("Jacobian cannot be computed with unknown event_ndims")
_, _, event_dims = self.shaper.get_dims(x)
if self.power == 0.:
return math_ops.reduce_sum(x, reduction_indices=event_dims)
return (1. / self.power - 1.) * math_ops.reduce_sum(
math_ops.log1p(x * self.power),
reduction_indices=event_dims)
def _maybe_assert_valid_x(self, x):
if not self.validate_args or self.power == 0.:
return x
is_valid = check_ops.assert_non_negative(
1. + self.power * x,
message="Forward transformation input must be at least {}.".format(
-1. / self.power))
return control_flow_ops.with_dependencies([is_valid], x)
def _maybe_assert_valid_y(self, y):
if not self.validate_args:
return y
is_valid = check_ops.assert_positive(
y, message="Inverse transformation input must be greater than 0.")
return control_flow_ops.with_dependencies([is_valid], y)
class Exp(PowerTransform):
"""Bijector which computes Y = g(X) = exp(X).
Example Use:
```python
# Create the Y=g(X)=exp(X) transform which works only on Tensors with 1
# batch ndim and 2 event ndims (i.e., vector of matrices).
exp = Exp(batch_ndims=1, event_ndims=2)
x = [[[1., 2],
[3, 4]],
[[5, 6],
[7, 8]]]
exp(x) == exp.forward(x)
log(x) == exp.inverse(x)
```
Note: the exp(.) is applied element-wise but the Jacobian is a reduction
over the event space.
"""
def __init__(self,
event_ndims=0,
validate_args=False,
name="exp"):
"""Instantiates the `Exp` bijector.
Args:
event_ndims: Scalar `int32` `Tensor` indicating the number of dimensions
associated with a particular draw from the distribution.
validate_args: `Boolean` indicating whether arguments should be checked
for correctness.
name: `String` name given to ops managed by this object.
"""
super(Exp, self).__init__(
event_ndims=event_ndims,
validate_args=validate_args,
name=name)
# TODO(srvasude): Deprecate this class with a dedicated Linear Operator
# corresponding to TriL + V D V.T.
class _TriLPlusVDVTLightweightOperatorPD(object):
"""Helper/hidden class fake an OperatorPD for TriL+VDV.T."""
def __init__(self, tril, v, diag=None, validate_args=False):
"""Creates an instance of _TriLPlusVDVTLightweightOperatorPD.
WARNING: This object is not to be used outside of `Affine` where it is
currently being temporarily used for refactoring purposes.
Args:
tril: `Tensor` of shape `[B1,..,Bb, d, d]`.
v: `Tensor` of shape `[B1,...,Bb, d, k]`.
diag: `Tensor` of shape `[B1,...,Bb, k, k]` or None
validate_args: `Boolean` indicating whether arguments should be checked
for correctness.
"""
self._m = tril
self._v = v
self._validate_args = validate_args
self._inputs = [tril, v]
if diag is not None:
self._inputs += [diag]
self._d = operator_pd_diag.OperatorPDDiag(diag, verify_pd=validate_args)
self._d_inv = operator_pd_diag.OperatorPDDiag(1. / diag,
verify_pd=validate_args)
return
if v.get_shape().is_fully_defined():
v_shape = v.get_shape().as_list()
id_shape = v_shape[:-2] + [v_shape[-1], v_shape[-1]]
else:
v_shape = array_ops.shape(v)
id_shape = array_ops.concat([v_shape[:-2], [v_shape[-1], v_shape[-1]]], 0)
self._d = operator_pd_identity.OperatorPDIdentity(
id_shape, v.dtype, verify_pd=self.validate_args)
self._d_inv = self._d
@property
def inputs(self):
return self._inputs
@property
def dtype(self):
return self._m.dtype.base_dtype
@property
def validate_args(self):
return self._validate_args
def rank(self):
"""Returns `rank(self)`."""
return array_ops.rank(self._m)
def sqrt_matmul(self, x):
"""Computes `matmul(self, x)`.
Doesn't actually do the sqrt! Named as such to agree with API.
Args:
x: `Tensor`
Returns:
self_times_x: `Tensor`
"""
m_x = math_ops.matmul(self._m, x)
vt_x = math_ops.matmul(self._v, x, adjoint_a=True)
d_vt_x = self._d.matmul(vt_x)
v_d_vt_x = math_ops.matmul(self._v, d_vt_x)
return m_x + v_d_vt_x
def sqrt_solve(self, x):
"""Computes `solve(self, x)`.
Doesn't actually do the sqrt! Named as such to agree with API.
To compute (M + V D V.T), we use the the Woodbury matrix identity:
inv(M + V D V.T) = inv(M) - inv(M) V inv(C) V.T inv(M)
where,
C = inv(D) + V.T inv(M) V.
See: https://en.wikipedia.org/wiki/Woodbury_matrix_identity
Args:
x: `Tensor`
Returns:
inv_of_self_times_x: `Tensor`
"""
minv_x = linalg_ops.matrix_triangular_solve(self._m, x)
vt_minv_x = math_ops.matmul(self._v, minv_x, transpose_a=True)
cinv_vt_minv_x = linalg_ops.matrix_solve(
self._woodbury_sandwiched_term(), vt_minv_x)
v_cinv_vt_minv_x = math_ops.matmul(self._v, cinv_vt_minv_x)
minv_v_cinv_vt_minv_x = linalg_ops.matrix_triangular_solve(
self._m, v_cinv_vt_minv_x)
return minv_x - minv_v_cinv_vt_minv_x
def sqrt_log_abs_det(self):
"""Computes (log o abs o det)(X) for matrix X.
Doesn't actually do the sqrt! Named as such to agree with API.
To compute det(M + V D V.T), we use the matrix determinant lemma:
det(Tril + V D V.T) = det(C) det(D) det(M)
where C is defined as in `_inverse`, ie,
C = inv(D) + V.T inv(M) V.
See: https://en.wikipedia.org/wiki/Matrix_determinant_lemma
Returns:
log_abs_det: `Tensor`.
"""
log_det_c = math_ops.log(math_ops.abs(
linalg_ops.matrix_determinant(self._woodbury_sandwiched_term())))
# Reduction is ok because we always prepad inputs to this class.
log_det_m = math_ops.reduce_sum(math_ops.log(math_ops.abs(
array_ops.matrix_diag_part(self._m))), reduction_indices=[-1])
return log_det_c + 2. * self._d.sqrt_log_abs_det() + log_det_m
def _woodbury_sandwiched_term(self):
"""Computes the sandwiched term in the Woodbury identity.
Computes the "`C`" in the the identity:
inv(M + V D V.T) = inv(M) - inv(M) V inv(C) V.T inv(M)
where,
C = inv(D) + V.T inv(M) V.
See: https://en.wikipedia.org/wiki/Woodbury_matrix_identity
Returns:
woodbury_sandwich_term: A `Tensor` to be used like `C`, above.
"""
minv_v = linalg_ops.matrix_triangular_solve(self._m, self._v)
vt_minv_v = math_ops.matmul(self._v, minv_v, adjoint_a=True)
return self._d_inv.add_to_tensor(vt_minv_v)
class Affine(Bijector):
# pylint: disable=line-too-long
"""Bijector which computes `Y = g(X; shift, scale) = matmul(scale, X) + shift` where `scale = c * I + diag(D1) + tril(L) + V @ diag(D2) @ V.T`.
Write `A @ X` for `matmul(A, X)`. In TF parlance, the `scale` term is
logically equivalent to:
```python
scale = (
scale_identity_multiplier * tf.diag(tf.ones(d)) +
tf.diag(scale_diag) +
scale_tril +
scale_perturb_factor @ diag(scale_perturb_diag) @
tf.transpose([scale_perturb_factor])
)
```
The `scale` term is applied without necessarily materializing constituent
matrices, i.e., the matmul is [matrix-free](
https://en.wikipedia.org/wiki/Matrix-free_methods) when possible.
Examples:
```python
# Y = X
b = Affine()
# Y = X + shift
b = Affine(shift=[1., 2, 3])
# Y = 2 * I @ X.T + shift
b = Affine(shift=[1., 2, 3],
scale_identity_multiplier=2.)
# Y = tf.diag(d1) @ X.T + shift
b = Affine(shift=[1., 2, 3],
scale_diag=[-1., 2, 1]) # Implicitly 3x3.
# Y = (I + v * v.T) @ X.T + shift
b = Affine(shift=[1., 2, 3],
scale_perturb_factor=[[1., 0],
[0, 1],
[1, 1]])
# Y = (diag(d1) + v * diag(d2) * v.T) @ X.T + shift
b = Affine(shift=[1., 2, 3],
scale_diag=[1., 3, 3], # Implicitly 3x3.
scale_perturb_diag=[2., 1], # Implicitly 2x2.
scale_perturb_factor=[[1., 0],
[0, 1],
[1, 1]])
```
"""
# pylint: enable=line-too-long
def __init__(self,
shift=None,
scale_identity_multiplier=None,
scale_diag=None,
scale_tril=None,
scale_perturb_factor=None,
scale_perturb_diag=None,
event_ndims=1,
validate_args=False,
name="affine"):
"""Instantiates the `Affine` bijector.
This `Bijector` is initialized with `shift` `Tensor` and `scale` arguments,
giving the forward operation:
```none
Y = g(X) = scale @ X + shift
```
where the `scale` term is logically equivalent to:
```python
scale = (
scale_identity_multiplier * tf.diag(tf.ones(d)) +
tf.diag(scale_diag) +
scale_tril +
scale_perturb_factor @ diag(scale_perturb_diag) @
tf.transpose([scale_perturb_factor])
)
```
If none of `scale_identity_multiplier`, `scale_diag`, or `scale_tril` are
specified then `scale += IdentityMatrix`. Otherwise specifying a
`scale` argument has the semantics of `scale += Expand(arg)`, i.e.,
`scale_diag != None` means `scale += tf.diag(scale_diag)`.
Args:
shift: Numeric `Tensor`. If this is set to `None`, no shift is applied.
scale_identity_multiplier: floating point rank 0 `Tensor` representing a
scaling done to the identity matrix.
When `scale_identity_multiplier = scale_diag=scale_tril = None` then
`scale += IdentityMatrix`. Otherwise no scaled-identity-matrix is added
to `scale`.
scale_diag: Numeric `Tensor` representing the diagonal matrix.
`scale_diag` has shape [N1, N2, ... k], which represents a k x k
diagonal matrix.
When `None` no diagonal term is added to `scale`.
scale_tril: Numeric `Tensor` representing the diagonal matrix.
`scale_diag` has shape [N1, N2, ... k, k], which represents a k x k
lower triangular matrix.
When `None` no `scale_tril` term is added to `scale`.
The upper triangular elements above the diagonal are ignored.
scale_perturb_factor: Numeric `Tensor` representing factor matrix with
last two dimensions of shape `(k, r)`.
When `None`, no rank-r update is added to `scale`.
scale_perturb_diag: Numeric `Tensor` representing the diagonal matrix.
`scale_perturb_diag` has shape [N1, N2, ... r], which represents an
r x r Diagonal matrix.
When `None` low rank updates will take the form `scale_perturb_factor *
scale_perturb_factor.T`.
event_ndims: Scalar `int32` `Tensor` indicating the number of dimensions
associated with a particular draw from the distribution. Must be 0 or 1.
validate_args: `Boolean` indicating whether arguments should be checked
for correctness.
name: `String` name given to ops managed by this object.
Raises:
ValueError: if `perturb_diag` is specified but not `perturb_factor`.
TypeError: if `shift` has different `dtype` from `scale` arguments.
"""
self._graph_parents = []
self._name = name
self._validate_args = validate_args
# Ambiguous definition of low rank update.
if scale_perturb_diag is not None and scale_perturb_factor is None:
raise ValueError("When scale_perturb_diag is specified, "
"scale_perturb_factor must be specified.")
# Special case, only handling a scaled identity matrix. We don't know its
# dimensions, so this is special cased.
# We don't check identity_multiplier, since below we set it to 1. if all
# other scale args are None.
self._is_only_identity_multiplier = (scale_tril is None and
scale_diag is None and
scale_perturb_factor is None)
# When no args are specified, pretend the scale matrix is the identity
# matrix.
if self._is_only_identity_multiplier and scale_identity_multiplier is None:
scale_identity_multiplier = 1.
with self._name_scope("init", values=[
shift, scale_identity_multiplier, scale_diag, scale_tril,
scale_perturb_diag, scale_perturb_factor, event_ndims]):
event_ndims = ops.convert_to_tensor(event_ndims, name="event_ndims")
if validate_args:
is_less_than_two = check_ops.assert_less(
event_ndims, 2,
message="event_ndims must be 0 or 1")
event_ndims = control_flow_ops.with_dependencies(
[is_less_than_two], event_ndims)
self._shift = _as_tensor(shift, "shift")
# self._create_scale_operator returns an OperatorPD in all cases except if
# self._is_only_identity_multiplier; in which case it returns a scalar
# Tensor.
self._scale = self._create_scale_operator(
identity_multiplier=scale_identity_multiplier,
diag=scale_diag,
tril=scale_tril,
perturb_diag=scale_perturb_diag,
perturb_factor=scale_perturb_factor,
event_ndims=event_ndims,
validate_args=validate_args)
if (self._shift is not None and
self._shift.dtype.base_dtype != self._scale.dtype.base_dtype):
raise TypeError("shift.dtype({}) does not match scale.dtype({})".format(
self._shift.dtype, self._scale.dtype))
super(Affine, self).__init__(
batch_ndims=self._infer_batch_ndims(),
event_ndims=event_ndims,
graph_parents=(
[event_ndims] +
[self._scale] if contrib_framework.is_tensor(self._scale)
else self._scale.inputs +
[self._shift] if self._shift is not None else []),
is_constant_jacobian=True,
validate_args=validate_args,
name=name)
def _create_scale_operator(self, identity_multiplier, diag, tril,
perturb_diag, perturb_factor, event_ndims,
validate_args):
"""Construct `scale` from various components.
Args:
identity_multiplier: floating point rank 0 `Tensor` representing a scaling
done to the identity matrix.
diag: Numeric `Tensor` representing the diagonal matrix. `scale_diag` has
shape [N1, N2, ... k], which represents a k x k diagonal matrix.
tril: Numeric `Tensor` representing the diagonal matrix. `scale_tril` has
shape [N1, N2, ... k], which represents a k x k lower triangular matrix.
perturb_diag: Numeric `Tensor` representing the diagonal matrix of the
low rank update.
perturb_factor: Numeric `Tensor` representing factor matrix.
event_ndims: Scalar `int32` `Tensor` indicating the number of dimensions
associated with a particular draw from the distribution. Must be 0 or 1
validate_args: `Boolean` indicating whether arguments should be checked
for correctness.
Returns:
scale and batch_ndims. In the case of scaling by a constant, scale is a
floating point `Tensor`. Otherwise, scale is an `OperatorPD`.
Raises:
ValueError: if all of `tril`, `diag` and `identity_multiplier` are `None`.
"""
identity_multiplier = _as_tensor(identity_multiplier, "identity_multiplier")
diag = _as_tensor(diag, "diag")
tril = _as_tensor(tril, "tril")
perturb_diag = _as_tensor(perturb_diag, "perturb_diag")
perturb_factor = _as_tensor(perturb_factor, "perturb_factor")
identity_multiplier = self._maybe_validate_identity_multiplier(
identity_multiplier, validate_args)
if perturb_factor is not None:
perturb_factor = self._process_matrix(
perturb_factor, min_rank=2, event_ndims=event_ndims)
if perturb_diag is not None:
perturb_diag = self._process_matrix(
perturb_diag, min_rank=1, event_ndims=event_ndims)
# The following if-statments are ordered by increasingly stronger
# assumptions in the base matrix, i.e., we process in the order:
# TriL, Diag, Identity.
if tril is not None:
tril = self._preprocess_tril(
identity_multiplier, diag, tril, event_ndims)
if perturb_factor is None:
return operator_pd_cholesky.OperatorPDCholesky(
tril, verify_pd=validate_args)
return _TriLPlusVDVTLightweightOperatorPD(
tril=tril, v=perturb_factor, diag=perturb_diag,
validate_args=validate_args)
if diag is not None:
diag = self._preprocess_diag(identity_multiplier, diag, event_ndims)
if perturb_factor is None:
return operator_pd_diag.OperatorPDSqrtDiag(
diag, verify_pd=validate_args)
return operator_pd_vdvt_update.OperatorPDSqrtVDVTUpdate(
operator=operator_pd_diag.OperatorPDDiag(
diag, verify_pd=validate_args),
v=perturb_factor,
diag=perturb_diag,
verify_pd=validate_args)
if identity_multiplier is not None:
if perturb_factor is None:
return identity_multiplier
# Infer the shape from the V and D.
v_shape = array_ops.shape(perturb_factor)
identity_shape = array_ops.concat((v_shape[:-1], (v_shape[-2],)), 0)
scaled_identity = operator_pd_identity.OperatorPDIdentity(
identity_shape,
perturb_factor.dtype.base_dtype,
scale=identity_multiplier,
verify_pd=validate_args)
return operator_pd_vdvt_update.OperatorPDSqrtVDVTUpdate(
operator=scaled_identity,
v=perturb_factor,
diag=perturb_diag,
verify_pd=validate_args)
raise ValueError("One of tril, diag and/or identity_multiplier must be "
"specified.")
def _maybe_validate_identity_multiplier(self, identity_multiplier,
validate_args):
"""Check that the init arg `identity_multiplier` is valid."""
if identity_multiplier is None or not validate_args:
return identity_multiplier
if validate_args:
identity_multiplier = control_flow_ops.with_dependencies(
[check_ops.assert_positive(identity_multiplier)],
identity_multiplier)
return identity_multiplier
def _preprocess_tril(self, identity_multiplier, diag, tril, event_ndims):
"""Helper to preprocess a lower triangular matrix."""
tril = array_ops.matrix_band_part(tril, -1, 0) # Zero out TriU.
if identity_multiplier is None and diag is None:
return self._process_matrix(tril, min_rank=2, event_ndims=event_ndims)
new_diag = array_ops.matrix_diag_part(tril)
if identity_multiplier is not None:
new_diag += identity_multiplier
if diag is not None:
new_diag += diag
tril = array_ops.matrix_set_diag(tril, new_diag)
return self._process_matrix(tril, min_rank=2, event_ndims=event_ndims)
def _preprocess_diag(self, identity_multiplier, diag, event_ndims):
"""Helper to preprocess a diagonal matrix."""
if identity_multiplier is not None:
diag += identity_multiplier
return self._process_matrix(diag, min_rank=1, event_ndims=event_ndims)
def _process_matrix(self, matrix, min_rank, event_ndims):
"""Helper to __init__ which gets matrix in batch-ready form."""
# Pad the matrix so that matmul works in the case of a matrix and vector
# input. Keep track if the matrix was padded, to distinguish between a
# rank 3 tensor and a padded rank 2 tensor.
# TODO(srvasude): Remove side-effects from functions. Its currently unbroken
# but error-prone since the function call order may change in the future.
self._rank_two_event_ndims_one = math_ops.logical_and(
math_ops.equal(array_ops.rank(matrix), min_rank),
math_ops.equal(event_ndims, 1))
left = array_ops.where(self._rank_two_event_ndims_one, 1, 0)
pad = array_ops.concat(
[array_ops.ones(
[left], dtype=dtypes.int32), array_ops.shape(matrix)],
0)
return array_ops.reshape(matrix, pad)
def _infer_batch_ndims(self):
"""Return batch_ndims."""
if self._is_only_identity_multiplier:
return 0
# The real batch dims is one less when we pad in the case of event_ndims =
# 1, and the rank of the underlying scale being 2. This allows us to have
# non-negative sample dims.
return (self._scale.rank() - 2 -
array_ops.where(self._rank_two_event_ndims_one, 1, 0))
@property
def shift(self):
return self._shift
@property
def scale(self):
# TODO(srvasude): Remove this exception once TriLPlusVDVT is properly
# implemented.
if isinstance(self._scale, _TriLPlusVDVTLightweightOperatorPD):
raise NotImplementedError("Cannot access scale when Tril+VDV.T.")
return self._scale
def _forward(self, x):
y = x
if self._is_only_identity_multiplier:
y *= self._scale
if self.shift is not None:
return y + self.shift
return y
y, sample_shape = self.shaper.make_batch_of_event_sample_matrices(y)
y = self._scale.sqrt_matmul(y)
y = self.shaper.undo_make_batch_of_event_sample_matrices(y, sample_shape)
if self.shift is not None:
return y + self.shift
return y
def _inverse(self, y):
x = y
if self.shift is not None:
x -= self.shift
if self._is_only_identity_multiplier:
return x / self._scale
x, sample_shape = self.shaper.make_batch_of_event_sample_matrices(x)
x = self._scale.sqrt_solve(x)
x = self.shaper.undo_make_batch_of_event_sample_matrices(x, sample_shape)
return x
def _inverse_log_det_jacobian(self, y):
return -self._forward_log_det_jacobian(y)
def _forward_log_det_jacobian(self, x):
if self._is_only_identity_multiplier:
# TODO(jvdillon): We don't pad in this case and instead let the fldj be
# applied via broadcast.
d = math_ops.cast(array_ops.shape(x)[-1], dtype=self._scale.dtype)
return math_ops.log(math_ops.abs(self._scale)) * array_ops.where(
math_ops.equal(self.shaper.event_ndims, 0), 1., d)
fldj = self._scale.sqrt_log_abs_det()
# We need to squeeze off the padded dimension.
start = array_ops.where(self._rank_two_event_ndims_one, 1, 0)
return array_ops.reshape(fldj, array_ops.shape(fldj)[start:])
class AffineLinearOperator(Bijector):
"""Bijector which computes `Y = g(X; shift, scale) = scale @ X.T + shift`.
`shift` is a numeric `Tensor` and `scale` is a `LinearOperator`.
If `X` is a scalar then the forward transformation is: `scale * X + shift`
where `*` denotes the scalar product.
Note: we don't always simply transpose `X` (but write it this way for
brevity). Actually the input `X` undergoes the following transformation
before being premultiplied by `scale`:
1. If there are no sample dims, we call `X = tf.expand_dims(X, 0)`, i.e.,
`new_sample_shape = [1]`. Otherwise do nothing.
2. The sample shape is flattened to have one dimension, i.e.,
`new_sample_shape = [n]` where `n = tf.reduce_prod(old_sample_shape)`.
3. The sample dim is cyclically rotated left by 1, i.e.,
`new_shape = [B1,...,Bb, k, n]` where `n` is as above, `k` is the
event_shape, and `B1,...,Bb` are the batch shapes for each of `b` batch
dimensions.
(For more details see `shape.make_batch_of_event_sample_matrices`.)
The result of the above transformation is that `X` can be regarded as a batch
of matrices where each column is a draw from the distribution. After
premultiplying by `scale`, we take the inverse of this procedure. The input
`Y` also undergoes the same transformation before/after premultiplying by
`inv(scale)`.
Example Use:
```python
linalg = tf.contrib.linalg
x = [1., 2, 3]
shift = [-1., 0., 1]
diag = [1., 2, 3]
scale = linalg.LinearOperatorDiag(diag)
affine = AffineLinearOperator(shift, scale)
# In this case, `forward` is equivalent to:
# diag * scale + shift
y = affine.forward(x) # [0., 4, 10]
shift = [2., 3, 1]
tril = [[1., 0, 0],
[2, 1, 0],
[3, 2, 1]]
scale = linalg.LinearOperatorTriL(tril)
affine = AffineLinearOperator(shift, scale)
# In this case, `forward` is equivalent to:
# np.squeeze(np.matmul(tril, np.expand_dims(x, -1)), -1) + shift
y = affine.forward(x) # [3., 7, 11]
```
"""
def __init__(self,
shift=None,
scale=None,
event_ndims=1,
validate_args=False,
name="affine_linear_operator"):
"""Instantiates the `AffineLinearOperator` bijector.
Args:
shift: Numeric `Tensor`.
scale: Subclass of `LinearOperator`. Represents the (batch) positive
definite matrix `M` in `R^{k x k}`.
event_ndims: Scalar `integer` `Tensor` indicating the number of dimensions
associated with a particular draw from the distribution. Must be 0 or 1.
validate_args: `Boolean` indicating whether arguments should be checked
for correctness.
name: `String` name given to ops managed by this object.
Raises:
ValueError: if `event_ndims` is not 0 or 1.
TypeError: if `scale` is not a `LinearOperator`.
TypeError: if `shift.dtype` does not match `scale.dtype`.
ValueError: if not `scale.is_non_singular`.
"""
self._graph_parents = []
self._name = name
self._validate_args = validate_args
graph_parents = []
with self._name_scope("init", values=[shift]):
event_ndims = ops.convert_to_tensor(event_ndims, name="event_ndims")
if tensor_util.constant_value(event_ndims) is not None:
event_ndims = tensor_util.constant_value(event_ndims)
if event_ndims not in (0, 1):
raise ValueError("event_ndims({}) was not 0 or 1".format(event_ndims))
else:
if validate_args:
# Shape tool will catch if event_ndims is negative.
event_ndims = control_flow_ops.with_dependencies(
[check_ops.assert_less(
event_ndims, 2, message="event_ndims must be 0 or 1")],
event_ndims)
graph_parents += [event_ndims]
if shift is not None:
shift = ops.convert_to_tensor(shift, name="shift")
graph_parents += [shift]
self._shift = shift
if scale is not None:
if (shift is not None and
shift.dtype.base_dtype != scale.dtype.base_dtype):
raise TypeError(
"shift.dtype({}) is incompatible with scale.dtype({}).".format(
shift.dtype, scale.dtype))
if not isinstance(scale, linear_operator.LinearOperator):
raise TypeError("scale is not an instance of tf.LinearOperator")
if validate_args and not scale.is_non_singular:
raise ValueError("Scale matrix must be non-singular.")
graph_parents += scale.graph_parents
if scale.tensor_rank is not None:
batch_ndims = scale.tensor_rank - 2
else:
batch_ndims = scale.tensor_rank_tensor() - 2
graph_parents += [batch_ndims]
else:
batch_ndims = 0 # We won't need shape inference when scale is None.
self._scale = scale
super(AffineLinearOperator, self).__init__(
batch_ndims=batch_ndims,
event_ndims=event_ndims,
graph_parents=graph_parents,
is_constant_jacobian=True,
validate_args=validate_args,
name=name)
@property
def shift(self):
"""The `shift` `Tensor` in `Y = scale @ X.T + shift`."""
return self._shift
@property
def scale(self):
"""The `scale` `LinearOperator` in `Y = scale @ X.T + shift`."""
return self._scale
def _forward(self, x):
y = x
if self.scale is not None:
y, sample_shape = self.shaper.make_batch_of_event_sample_matrices(
y, expand_batch_dim=False)
with ops.control_dependencies([self.scale.assert_non_singular()] if
self.validate_args else []):
y = self.scale.apply(y)
y = self.shaper.undo_make_batch_of_event_sample_matrices(
y, sample_shape, expand_batch_dim=False)
if self.shift is not None:
y += self.shift
return y
def _inverse(self, y):
x = y
if self.shift is not None:
x -= self.shift
if self.scale is not None:
x, sample_shape = self.shaper.make_batch_of_event_sample_matrices(
x, expand_batch_dim=False)
# Solve fails if the op is singular so we may safely skip this assertion.
x = self.scale.solve(x)
x = self.shaper.undo_make_batch_of_event_sample_matrices(
x, sample_shape, expand_batch_dim=False)
return x
def _inverse_log_det_jacobian(self, y):
return -self._forward_log_det_jacobian(y)
def _forward_log_det_jacobian(self, x): # pylint: disable=unused-argument
if self.scale is None:
return constant_op.constant(0, dtype=x.dtype.base_dtype)
with ops.control_dependencies([self.scale.assert_non_singular()] if
self.validate_args else []):
return self.scale.log_abs_determinant()
class Softplus(Bijector):
"""Bijector which computes `Y = g(X) = Log[1 + exp(X)]`.
The softplus `Bijector` has the following two useful properties:
* The domain is the positive real numbers
* `softplus(x) approx x`, for large `x`, so it does not overflow as easily as
the `Exp` `Bijector`.
Example Use:
```python
# Create the Y=g(X)=softplus(X) transform which works only on Tensors with 1
# batch ndim and 2 event ndims (i.e., vector of matrices).
softplus = Softplus(batch_ndims=1, event_ndims=2)
x = [[[1., 2],
[3, 4]],
[[5, 6],
[7, 8]]]
log(1 + exp(x)) == softplus.forward(x)
log(exp(x) - 1) == softplus.inverse(x)
```
Note: log(.) and exp(.) are applied element-wise but the Jacobian is a
reduction over the event space.
"""
def __init__(self,
event_ndims=0,
validate_args=False,
name="softplus"):
super(Softplus, self).__init__(
batch_ndims=0,
event_ndims=event_ndims,
validate_args=validate_args,
name=name)
def _forward(self, x):
return nn_ops.softplus(x)
def _inverse_and_inverse_log_det_jacobian(self, y):
if self.shaper is None:
raise ValueError("Jacobian cannot be computed with unknown event_ndims")
_, _, event_dims = self.shaper.get_dims(y)
# Could also do:
# ildj = math_ops.reduce_sum(y - distribution_util.softplus_inverse(y),
# reduction_indices=event_dims)
# but the following is more numerically stable. Ie,
# Y = Log[1 + exp{X}] ==> X = Log[exp{Y} - 1]
# ==> dX/dY = exp{Y} / (exp{Y} - 1)
# = 1 / (1 - exp{-Y}),
# which is the most stable for large Y > 0. For small Y, we use
# 1 - exp{-Y} approx Y.
ildj = -math_ops.reduce_sum(math_ops.log(-math_ops.expm1(-y)),
reduction_indices=event_dims)
return distribution_util.softplus_inverse(y), ildj
def _forward_log_det_jacobian(self, x): # pylint: disable=unused-argument
if self.shaper is None:
raise ValueError("Jacobian cannot be computed with unknown event_ndims")
_, _, event_dims = self.shaper.get_dims(x)
return -math_ops.reduce_sum(
nn_ops.softplus(-x), reduction_indices=event_dims)
class SoftmaxCentered(Bijector):
"""Bijector which computes `Y = g(X) = exp([X 0]) / sum(exp([X 0]))`.
To implement [softmax](https://en.wikipedia.org/wiki/Softmax_function) as a
bijection, the forward transformation appends a value to the input and the
inverse removes this coordinate. The appended coordinate represents a pivot,
e.g., `softmax(x) = exp(x-c) / sum(exp(x-c))` where `c` is the implicit last
coordinate.
Because we append a coordinate, this bijector only supports `event_ndim in [0,
1]`, i.e., scalars and vectors.
Example Use:
```python
bijector.SoftmaxCentered(event_ndims=1).forward(tf.log([2, 3, 4]))
# Result: [0.2, 0.3, 0.4, 0.1]
# Extra result: 0.1
bijector.SoftmaxCentered(event_ndims=1).inverse([0.2, 0.3, 0.4, 0.1])
# Result: tf.log([2, 3, 4])
# Extra coordinate removed.
```
At first blush it may seem like the [Invariance of domain](
https://en.wikipedia.org/wiki/Invariance_of_domain) theorem implies this
implementation is not a bijection. However, the appended dimension
makes the (forward) image non-open and the theorem does not directly apply.
"""
def __init__(self,
event_ndims=0,
validate_args=False,
name="softmax_centered"):
self._graph_parents = []
self._name = name
with self._name_scope("init", values=[event_ndims]):
event_ndims = ops.convert_to_tensor(event_ndims, name="event_ndims")
event_ndims = tensor_util.constant_value(event_ndims)
if event_ndims is None or event_ndims not in [0, 1]:
raise ValueError("`event_ndims` must be a TF constant which is 0 or 1")
self._static_event_ndims = event_ndims
super(SoftmaxCentered, self).__init__(
batch_ndims=0, # We'll regard all non-event dims as sample dims.
event_ndims=event_ndims,
validate_args=validate_args,
name=name)
def _get_forward_event_shape(self, input_shape):
if input_shape.ndims is None:
return input_shape
if input_shape.ndims != self._static_event_ndims:
raise ValueError("input_shape.dims = %d != %d" %
(input_shape.ndims, self._static_event_ndims))
if input_shape.ndims == 0:
return tensor_shape.TensorShape([2])
if input_shape.ndims == 1:
return tensor_shape.TensorShape(input_shape[0] + 1)
# Unreachable code:
raise ValueError("event_ndims = %d must be 0 or 1" % input_shape.ndims)
def _forward_event_shape(self, input_shape):
ndims = array_ops.shape(input_shape)
if self.validate_args:
# It is not possible for a negative shape so we need only check <= 1.
is_zero_or_one = check_ops.assert_equal(
ndims, 0 if self._static_event_ndims == 0 else 1,
message="event_ndims must be 0 or 1")
ndims = control_flow_ops.with_dependencies([is_zero_or_one], ndims)
if self._static_event_ndims == 0:
return ops.convert_to_tensor(
[2], dtype=dtypes.int32, name="output_shape")
return input_shape + 1
def _get_inverse_event_shape(self, output_shape):
if output_shape.ndims is None:
return output_shape
if output_shape.ndims != 1:
raise ValueError("output_shape.ndims = %d != 1" % output_shape.ndims)
if self._static_event_ndims == 0:
return tensor_shape.TensorShape([])
return tensor_shape.TensorShape(output_shape[0] - 1)
def _inverse_event_shape(self, output_shape):
ndims = array_ops.shape(output_shape)[0]
if self.validate_args:
# It is not possible for a negative shape so we need only check <= 1.
is_one = check_ops.assert_equal(
ndims, 1, message="event_ndims must be 1")
ndims = control_flow_ops.with_dependencies([is_one], ndims)
if self._static_event_ndims == 0:
return ops.convert_to_tensor([], dtype=dtypes.int32, name="output_shape")
return array_ops.expand_dims(output_shape[0] - 1, dim=0)
def _forward(self, x):
# Pad the last dim with a zeros vector. We need this because it lets us
# infer the scale in the inverse function.
y = array_ops.expand_dims(x, dim=-1) if self._static_event_ndims == 0 else x
ndims = (y.get_shape().ndims if y.get_shape().ndims is not None
else array_ops.rank(y))
y = array_ops.pad(y,
paddings=array_ops.concat(
(array_ops.zeros(
(ndims - 1, 2), dtype=dtypes.int32), [[0, 1]]),
0))
# Set shape hints.
if x.get_shape().ndims is not None:
shape = x.get_shape().as_list()
if self._static_event_ndims == 0:
shape += [2]
elif shape[-1] is not None:
shape[-1] += 1
shape = tensor_shape.TensorShape(shape)
y.get_shape().assert_is_compatible_with(shape)
y.set_shape(shape)
# Since we only support event_ndims in [0, 1] and we do padding, we always
# reduce over the last dimension, i.e., dim=-1 (which is the default).
return nn_ops.softmax(y)
def _inverse(self, y):
# To derive the inverse mapping note that:
# y[i] = exp(x[i]) / normalization
# and
# y[end] = 1 / normalization.
# Thus:
# x[i] = log(exp(x[i])) - log(y[end]) - log(normalization)
# = log(exp(x[i])/normalization) - log(y[end])
# = log(y[i]) - log(y[end])
shape = (np.asarray(y.get_shape().as_list(), dtype=np.int32)
if y.get_shape().is_fully_defined()
else array_ops.shape(y, name="shape"))
ndims = y.get_shape().ndims or math_ops.rank(y, name="ndims")
# Do this first to make sure CSE catches that it'll happen again in
# _inverse_log_det_jacobian.
x = math_ops.log(y)
# We now extract the last coordinate of the rightmost dimension.
# Our trick is to slice from [0,0,...,shape[-1]-1] to shape[:-1]+[1].
begin = array_ops.one_hot(indices=ndims-1,
depth=ndims,
on_value=shape[-1]-np.array(1, dtype=shape.dtype),
dtype=shape.dtype)
size = array_ops.concat((shape[:-1], np.asarray([1], dtype=shape.dtype)), 0)
log_normalization = -array_ops.strided_slice(x, begin, begin + size)
# Here we slice out all but the last coordinate; see above for idea.
begin = array_ops.zeros_like(shape)
size = array_ops.concat((shape[:-1], [shape[-1] - 1]), 0)
x = array_ops.strided_slice(x, begin, begin + size)
x += log_normalization
if self._static_event_ndims == 0:
x = array_ops.squeeze(x, squeeze_dims=[ndims-1])
# Set shape hints.
if y.get_shape().ndims is not None:
shape = y.get_shape().as_list()
if self._static_event_ndims == 0:
shape = shape[:-1]
elif shape[-1] is not None:
shape[-1] -= 1
shape = tensor_shape.TensorShape(shape)
x.get_shape().assert_is_compatible_with(shape)
x.set_shape(shape)
return x
def _inverse_log_det_jacobian(self, y):
# WLOG, consider the vector case:
# x = log(y[:-1]) - log(y[-1])
# where,
# y[-1] = 1 - sum(y[:-1]).
# We have:
# det{ dX/dY } = det{ diag(1 ./ y[:-1]) + 1 / y[-1] }
# = det{ inv{ diag(y[:-1]) - y[:-1]' y[:-1] } } (1)
# = 1 / det{ diag(y[:-1]) - y[:-1]' y[:-1] }
# = 1 / { (1 + y[:-1]' inv(diag(y[:-1])) y[:-1]) *
# det(diag(y[:-1])) } (2)
# = 1 / { y[-1] prod(y[:-1]) }
# = 1 / prod(y)
# (1) - https://en.wikipedia.org/wiki/Sherman%E2%80%93Morrison_formula
# or by noting that det{ dX/dY } = 1 / det{ dY/dX } from Bijector
# docstring "Tip".
# (2) - https://en.wikipedia.org/wiki/Matrix_determinant_lemma
return -math_ops.reduce_sum(math_ops.log(y), reduction_indices=-1)
def _forward_log_det_jacobian(self, x):
if self._static_event_ndims == 0:
return x - 2. * nn_ops.softplus(x)
else:
# This code is similar to nn_ops.log_softmax but different because we have
# an implicit zero column to handle. I.e., instead of:
# reduce_sum(logits - reduce_sum(exp(logits), dim))
# we must do:
# log_normalization = 1 + reduce_sum(exp(logits))
# -log_normalization + reduce_sum(logits - log_normalization)
log_normalization = nn_ops.softplus(
math_ops.reduce_logsumexp(x, reduction_indices=-1, keep_dims=True))
fldj = (-log_normalization +
math_ops.reduce_sum(x - log_normalization,
reduction_indices=-1,
keep_dims=True))
return array_ops.squeeze(fldj, squeeze_dims=-1)
class SigmoidCentered(SoftmaxCentered):
"""Bijector which computes Y = g(X) = exp([X 0]) / (1 + exp(-X)).
Equivalent to: `bijector.SoftmaxCentered(event_ndims=0)`.
See `bijector.SoftmaxCentered` for more details.
"""
def __init__(self, validate_args=False, name="sigmoid_centered"):
super(SigmoidCentered, self).__init__(
validate_args=validate_args, name=name)
class CholeskyOuterProduct(Bijector):
# pylint: disable=line-too-long
"""Bijector which computes Y = g(X) = X X.T where X is a lower-triangular, positive-diagonal matrix.
`event_ndims` must be 0 or 2, i.e., scalar or matrix.
Note: the upper-triangular part of X is ignored (whether or not its zero).
Examples:
```python
bijector.CholeskyOuterProduct(event_ndims=2).forward(x=[[1., 0], [2, 1]])
# Result: [[1, 1], [1, 5]], i.e., x x.T
bijector.SoftmaxCentered(event_ndims=2).inverse(y=[[1., 1], [1, 5]])
# Result: [[1, 0], [2, 1]], i.e., chol(y).
```
"""
# pylint: enable=line-too-long
def __init__(self, event_ndims=2, validate_args=False,
name="cholesky_outer_product"):
"""Instantiates the `CholeskyOuterProduct` bijector.
Args:
event_ndims: `constant` `int32` scalar `Tensor` indicating the number of
dimensions associated with a particular draw from the distribution. Must
be 0 or 2.
validate_args: `Boolean` indicating whether arguments should be checked
for correctness.
name: `String` name given to ops managed by this object.
Raises:
ValueError: if event_ndims is neither 0 or 2.
"""
self._graph_parents = []
self._name = name
with self._name_scope("init", values=[event_ndims]):
event_ndims = ops.convert_to_tensor(event_ndims, name="event_ndims")
event_ndims = tensor_util.constant_value(event_ndims)
if event_ndims is None or event_ndims not in [0, 2]:
raise ValueError("`event_ndims` must be a TF constant which is 0 or 2")
self._static_event_ndims = event_ndims
super(CholeskyOuterProduct, self).__init__(
validate_args=validate_args,
name=name)
def _forward(self, x):
if self._static_event_ndims == 0:
return math_ops.square(x)
if self.validate_args:
is_matrix = check_ops.assert_rank_at_least(x, 2)
shape = array_ops.shape(x)
is_square = check_ops.assert_equal(shape[-2], shape[-1])
x = control_flow_ops.with_dependencies([is_matrix, is_square], x)
# For safety, explicitly zero-out the upper triangular part.
x = array_ops.matrix_band_part(x, -1, 0)
return math_ops.matmul(x, x, adjoint_b=True)
def _inverse_and_inverse_log_det_jacobian(self, y):
x = (math_ops.sqrt(y) if self._static_event_ndims == 0
else linalg_ops.cholesky(y))
return x, -self._forward_log_det_jacobian(x)
def _forward_log_det_jacobian(self, x):
# Let Y be a symmetric, positive definite matrix and write:
# Y = X X.T
# where X is lower-triangular.
#
# Observe that,
# dY[i,j]/dX[a,b]
# = d/dX[a,b] { X[i,:] X[j,:] }
# = sum_{d=1}^p { I[i=a] I[d=b] X[j,d] + I[j=a] I[d=b] X[i,d] }
#
# To compute the Jacobian dX/dY we must represent X,Y as vectors. Since Y is
# symmetric and X is lower-triangular, we need vectors of dimension:
# d = p (p + 1) / 2
# where X, Y are p x p matrices, p > 0. We use a row-major mapping, i.e.,
# k = { i (i + 1) / 2 + j i>=j
# { undef i<j
# and assume zero-based indexes. When k is undef, the element is dropped.
# Example:
# j k
# 0 1 2 3 /
# 0 [ 0 . . . ]
# i 1 [ 1 2 . . ]
# 2 [ 3 4 5 . ]
# 3 [ 6 7 8 9 ]
# Write vec[.] to indicate transforming a matrix to vector via k(i,j). (With
# slight abuse: k(i,j)=undef means the element is dropped.)
#
# We now show d vec[Y] / d vec[X] is lower triangular. Assuming both are
# defined, observe that k(i,j) < k(a,b) iff (1) i<a or (2) i=a and j<b.
# In both cases dvec[Y]/dvec[X]@[k(i,j),k(a,b)] = 0 since:
# (1) j<=i<a thus i,j!=a.
# (2) i=a>j thus i,j!=a.
#
# Since the Jacobian is lower-triangular, we need only compute the product
# of diagonal elements:
# d vec[Y] / d vec[X] @[k(i,j), k(i,j)]
# = X[j,j] + I[i=j] X[i,j]
# = 2 X[j,j].
# Since there is a 2 X[j,j] term for every lower-triangular element of X we
# conclude:
# |Jac(d vec[Y]/d vec[X])| = 2^p prod_{j=0}^{p-1} X[j,j]^{p-j}.
if self._static_event_ndims == 0:
if self.validate_args:
is_positive = check_ops.assert_positive(
x, message="All elements must be positive.")
x = control_flow_ops.with_dependencies([is_positive], x)
return math.log(2.) + math_ops.log(x)
diag = array_ops.matrix_diag_part(x)
if self.validate_args:
is_matrix = check_ops.assert_rank_at_least(
x, 2, message="Input must be a (batch of) matrix.")
shape = array_ops.shape(x)
is_square = check_ops.assert_equal(
shape[-2], shape[-1],
message="Input must be a (batch of) square matrix.")
# Assuming lower-triangular means we only need check diag>0.
is_positive_definite = check_ops.assert_positive(
diag, message="Input must be positive definite.")
x = control_flow_ops.with_dependencies(
[is_matrix, is_square, is_positive_definite], x)
# Create a column vector equal to: [p, p-1, ..., 2, 1].T.
if x.get_shape().ndims is None or x.get_shape()[-1].value is None:
p = array_ops.shape(x)[-1]
else:
p = x.get_shape()[-1].value
exponents = array_ops.expand_dims(
math_ops.linspace(math_ops.cast(p, dtype=x.dtype), 1., p),
dim=1)
sum_weighted_log_diag = array_ops.squeeze(
math_ops.matmul(math_ops.log(diag), exponents), squeeze_dims=-1)
fldj = p * math.log(2.) + sum_weighted_log_diag
if x.get_shape().ndims is not None:
fldj.set_shape(x.get_shape()[:-2])
return fldj
| apache-2.0 | -2,422,548,313,249,080,300 | 36.574434 | 145 | 0.632617 | false |
byronrau/tweepyScripts | twitterUserTimeline/twitterUserTimeline.py | 1 | 3599 | #!/usr/bin/python
import tweepy
import sys
import os
import codecs
import unicodecsv as csv
# API and ACCESS KEYS
API_KEY = 'jz3feMK2gN0kaN377FsTXY7uY'
API_SECRET = 'sGfCEayfwORloC9SvHy6BmDjifUsUEIF0EF51SgiYUgs054n7H'
# Don't buffer stdout, so we can tail the log output redirected to a file
sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)
# Max Tweets
maxTweets = int(sys.argv[1])
# Filename
fName = sys.argv[2]
tweetsPerQry = 200
# List of users read from users.txt
users = []
#open users.txt file and gets the list of users
with open('users.txt', 'r') as f:
for line in f:
users.append(line.strip())
sinceId = None
if(len(sys.argv) > 3):
if(sys.argv[3] != '-1'):
sinceId = sys.argv[3]
last_id = -1L
if(len(sys.argv) > 4):
last_id = long(sys.argv[4])
def getHashtags(hashes):
hashStr = ''
for i, h in enumerate(hashes):
if i == len(hashes)-1:
hashStr = hashStr + h['text']
else:
hashStr = hashStr + h['text'] + ','
return hashStr
def getMentions(mentions):
mentionStr = ''
for i, m in enumerate(mentions):
if i == len(mentions)-1:
mentionStr = mentionStr + m['screen_name']
else:
mentionStr = mentionStr + m['screen_name'] + ','
return mentionStr
auth = tweepy.AppAuthHandler(API_KEY, API_SECRET)
api = tweepy.API(auth, wait_on_rate_limit=True, wait_on_rate_limit_notify=True)
if (not api):
print ("Can't Authenticate Bye!")
sys.exit(-1)
tweetCount = 0
print("Downloading max {0} tweets".format(maxTweets))
with open(fName, 'ab') as f:
writer = csv.writer(f, encoding='utf-8')
writer.writerow(['Username','Created_at','ID','Tweet','RetweetCount','Name','Location','URL','Description','TweetCount','FollowersCount','FriendsCount','hashtags','mentions'])
for user in users:
tweetCount = 0
last_id = 0
while tweetCount < maxTweets:
print 'User is ' + user + ' Tweet count ' + str(tweetCount) + ' max Tweets ' + str(maxTweets) + ' SinceId ' + str(sinceId) + ' last_id ' + str(last_id)
try:
if (last_id <= 0):
if (not sinceId):
new_tweets = api.user_timeline(screen_name=user, count=tweetsPerQry)
else:
new_tweets = api.user_timeline(screen_name=user, count=tweetsPerQry, since_id=sinceId)
else:
if (not sinceId):
new_tweets = api.user_timeline(screen_name=user, count=tweetsPerQry, max_id=str(last_id - 1))
else:
new_tweets = api.user_timeline(screen_name=user, count=tweetsPerQry, max_id=str(last_id - 1), since_id=sinceId)
if not new_tweets:
print("No more tweets found")
break
for tweet in new_tweets:
try:
hashTags = getHashtags(tweet.entities.get('hashtags'))
mentions = getMentions(tweet.entities.get('user_mentions'))
writer.writerow([tweet.user.screen_name,tweet.created_at,tweet.id_str,tweet.text,str(tweet.retweet_count),tweet.user.name, tweet.user.location, str(tweet.user.url),tweet.user.description,str(tweet.user.statuses_count),str(tweet.user.followers_count),str(tweet.user.friends_count),hashTags,mentions])
except tweepy.TweepError as e:
print("some error : " + str(e) + " for user: " + user)
break
tweetCount += len(new_tweets)
print("Downloaded {0} tweets".format(tweetCount))
last_id = new_tweets[-1].id
except tweepy.TweepError as e:
# Just exit if any error
print("some error : " + str(e))
break
print ("Downloaded {0} tweets, Saved to {1}".format(tweetCount, fName)) | mit | 5,696,373,822,382,111,000 | 30.578947 | 311 | 0.639066 | false |
djfroofy/beatlounge | tutor/song5.py | 1 | 2172 | from itertools import cycle
from bl.ugen import W
from bl.arp import ChordPatternArp, OrderedArp, RandomArp, ArpMap
from bl.scheduler import clock
from bl.orchestra.midi import ChordPlayer
from tutor.complib import piano_f
pattern = [3, 3, [3, 1], 1, 2, 1, 2, 1, [3, 2, 1, 0, 4], 0, 1, 2, 3, 4, 3, 2,
[3, 2], 0, 0, [0, 1, 2], 2, 1, 2, 0, [0, 1, 2, 3], 3, 2, 1, 0,
[5, 4, 1], 5, 4, 3, 4, 2, 1, 5, 0, [5, 0]]
notes = cycle([[38, 50, 62, 65, 69, 80],
[38, 50, 62, 65, 69, 84],
[38, 50, 62, 65, 67, 84],
[38, 50, 62, 65, 69, 84],
[36, 50, 62, 65, 69, 84],
[36, 55, 62, 65, 69, 84],
[36, 55, 62, 67, 69, 84],
[36, 55, 60, 67, 69, 84],
[36, 53, 55, 67, 69, 84],
[36, 53, 55, 67, 69, 81],
[36, 53, 55, 65, 69, 81],
[36, 53, 55, 65, 67, 81],
[38, 53, 55, 65, 67, 81],
[38, 53, 55, 67, 69, 81],
[38, 53, 55, 67, 69, 74],
[38, 53, 55, 65, 67, 74],
[36, 53, 55, 65, 67, 74],
[36, 55, 57, 65, 67, 74],
[36, 55, 57, 60, 67, 74],
[36, 55, 57, 60, 64, 74],
[36, 55, 57, 60, 64, 80],
[36, 55, 57, 60, 64, 81],
[36, 55, 57, 60, 64, 84],
[36, 55, 57, 60, 63, 84],
[36, 55, 57, 60, 64, 84],
[36, 55, 57, 60, 69, 84],
[36, 55, 57, 60, 69, 81],
[36, 55, 57, 60, 69, 78],
[36, 53, 55, 60, 69, 78],
[36, 53, 55, 62, 69, 78]])
piano = piano_f()
piano.controlChange(reverb=120, sustain=100, chorus=50, vibrato=15)
r = W((0, 5), (12, 2), (-12, 3))
f = lambda chord: [r() + n for n in chord]
arp = ArpMap(f, ChordPatternArp(notes.next(), pattern))
player = ChordPlayer(piano, arp,
velocity=OrderedArp([127, 80, 90, 80, 90, 120, 120, 80]),
release=RandomArp([11, 10, 9, 8]))
resetter = clock.schedule(lambda: arp.reset(notes.next())
).startAfter((2, 1), (2, 1))
player.resumePlaying()
| mit | 760,528,155,715,385,200 | 36.448276 | 78 | 0.422652 | false |
MathGen/oppgavegenerator | oppgavegen/views/game_views.py | 1 | 8226 | from django.contrib.auth.decorators import login_required
from django.shortcuts import render_to_response, redirect
from django.http import HttpResponseForbidden
from django.template import RequestContext
from oppgavegen.generation_folder.generation import generate_level
from oppgavegen.view_logic.rating import *
from oppgavegen.view_logic.progress import *
from oppgavegen.models import Set, Chapter, Level
from oppgavegen.forms import QuestionForm
from oppgavegen.view_logic.submit_and_answer import *
@login_required
def game(request, set_id):
context = RequestContext(request)
set = Set.objects.get(pk=set_id)
set_title = set.name
if request.user in set.users.all():
goto = render_to_response('game/screen.html', {'set_id': set_id, 'set_title': set_title}, context)
else:
goto = render_to_response('game/set_notmember.html', {'set': set}, context)
return goto
def chapters(request, set_id):
game_set = Set.objects.get(pk=set_id)
set_title = game_set.name
is_requirement = game_set.is_requirement
is_password_protected = game_set.password_protected
set_chapters = game_set.chapters.all()
context = RequestContext(request)
medals = [] # Both lists get updated in chapter_progress
completed = []
if is_requirement:
# In case we want to do something special if the set is a requirement type set
progress_number = chapter_progress(request.user, game_set, medals, completed)
else:
progress_number = chapter_progress(request.user, game_set, medals, completed)
order = game_set.order
set_chapters_ordered = []
for x in order.split(','):
for chapter in set_chapters:
if chapter.pk == int(x):
set_chapters_ordered.append(chapter)
break
if request.is_ajax():
response = render_to_response('game/chapters.html',
{'chapters': set_chapters_ordered, 'medals': json.dumps(medals),
'completed': json.dumps(completed), 'progress_number': progress_number,
'set_id': set_id, 'is_requirement': is_requirement,
'is_password_protected': is_password_protected}, context)
else:
response = render_to_response('game/chapters_noajax.html',
{'chapters': set_chapters_ordered, 'medals': json.dumps(medals),
'completed': json.dumps(completed), 'progress_number': progress_number,
'set_id': set_id, "set_title": set_title, "is_requirement": is_requirement,
'is_password_protected': is_password_protected}, context)
return response
def levels(request, chapter_id):
game_chapter = Chapter.objects.get(pk=chapter_id)
in_requirement_set = game_chapter.in_requirement_set
chapter_levels = game_chapter.levels.all()
chapter_title = game_chapter.name
context = RequestContext(request)
if in_requirement_set:
progress_number = len(chapter_levels)
else:
progress_number = calculate_progress(request.user, game_chapter)
star_per_level = get_stars_per_level(request.user, game_chapter)
order = game_chapter.order
chapter_levels_ordered = []
for x in order.split(','):
for chapter in chapter_levels:
if chapter.pk == int(x):
chapter_levels_ordered.append(chapter)
break
if request.is_ajax():
return render_to_response('game/levels.html',
{'levels': chapter_levels_ordered, 'chapter_title': chapter_title,
'progress_number': progress_number, 'spl': star_per_level, 'chapter_id': chapter_id,
'in_requirement_set':in_requirement_set},
context)
else:
return render_to_response('game/levels_noajax.html',
{'levels': chapter_levels_ordered, 'chapter_title': chapter_title,
'progress_number': progress_number, 'spl': star_per_level, 'chapter_id': chapter_id,
'in_requirement_set':in_requirement_set},
context)
@login_required
def get_template(request):
"""Gets a template for a given level"""
context = RequestContext(request)
#if request.method == 'POST':
context_dict = {'message': 'Noe har gått feil.'}
form = request.POST
if int(form.get('level_id')) == None:
return redirect('/')
level_id = int(form.get('level_id'))
chapter_id = int(form.get('chapter_id'))
set_id = int(form.get('set_id'))
set = Set.objects.get(pk=set_id)
#if check_for_level_skip(request.user, Chapter.objects.get(pk=chapter_id), level_id):
# return render_to_response('game/template.html', context_dict, context)
context['set_title'] = set.name
context['set_id'] = set_id
context['chapter_id'] = chapter_id
context['chapter_title'] = Chapter.objects.get(pk=chapter_id).name
context['level_title'] = Level.objects.get(pk=level_id).name
context['level_id'] = level_id
context_dict = generate_level(request.user, level_id)
context_dict['rating'] = get_user_rating(request.user)
level = Level.objects.get(pk=level_id)
context_dict['stars'] = get_user_stars_for_level(request.user, level)
context_dict['ulp'] = get_user_rating_for_level(request.user, level)
if request.is_ajax():
return render_to_response('game/template.html', context_dict, context)
else:
return render_to_response('game/template_noajax.html', context_dict, context)
def get_solution(request, level=1):
"""Returns a render of answers.html"""
context = RequestContext(request)
cheat_message = '\\text{Ulovlig tegn har blitt brukt i svar}'
required_message = '\\text{Svaret ditt har ikke utfylt alle krav}'
render_to = 'game/answer.html'
if request.method == 'POST':
form = QuestionForm(request.POST)
if form.is_valid():
form_values = form.process()
template = Template.objects.get(pk=form_values['primary_key'])
user_answer = form_values['user_answer']
try:
disallowed = json.loads(template.disallowed)
except ValueError:
disallowed = []
try:
required = json.loads(template.required)
except ValueError:
required = []
context_dict = make_answer_context_dict(form_values)
if (cheat_check(user_answer, disallowed, form_values['variable_dictionary'].split('§'))) and\
(form_values['template_type'] == 'normal') and (context_dict['user_won']):
context_dict['answer'] = cheat_message
return render_to_response(render_to, context_dict, context)
elif (required_check(user_answer, required, form_values['variable_dictionary'].split('§'))) and \
(form_values['template_type'] == 'normal') and (context_dict['user_won']):
context_dict['answer'] = required_message
return render_to_response(render_to, context_dict, context)
if request.is_ajax():
new_user_rating, new_star = change_level_rating(template, request.user, context_dict['user_won'],
form_values['template_type'], level)
context_dict['chapter_id'] = request.POST['chapter_id']
context_dict['ulp'] = int(new_user_rating)
context_dict['new_star'] = new_star
context_dict['stars'] = get_user_stars_for_level(request.user, Level.objects.get(pk=level))
return render_to_response(render_to, context_dict, context)
else:
change_elo(template, request.user, context_dict['user_won'], form_values['template_type'])
render_to_response(render_to, context_dict, context)
else:
print(form.errors)
| bsd-3-clause | -671,454,598,317,702,500 | 44.181319 | 119 | 0.60501 | false |
mtommasi/pygiftparser | setup.py | 1 | 1462 | #!/usr/bin/python3
# -*- coding: utf-8 -*-
import os
from setuptools import setup
try:
long_description = open("README.rst").read()
except IOError:
long_description = ""
LOCALEDIR = os.path.join('share', 'locale')
setup(
name="pygiftparser",
version="1.1",
url="https://github.com/mtommasi/pygiftparser",
description="GIFT parser in python that parses a Gift source code and loads data in a Question/Answer model for further use in an application",
license="MIT",
author="Marc Tommasi - UdL/INRIA",
author_email="[email protected]",
py_modules=['pygiftparser.parser',
'pygiftparser.i18n',
'pygiftparser.answer',
'pygiftparser.question',
'pygiftparser.utils'],
install_requires=['yattag', 'markdown', 'MarkdownSuperscript'],
long_description=long_description,
classifiers=[
"Programming Language :: Python",
"Programming Language :: Python :: 3.4",
"Topic :: Text Processing"
],
data_files=[(os.path.join('share',
'locale',
lang,
'LC_MESSAGES'),
[os.path.join('share',
'locale',
lang,
'LC_MESSAGES',
'pygiftparser.mo')])
for lang in os.listdir(LOCALEDIR)]
)
| mit | -5,657,474,728,144,140,000 | 33 | 147 | 0.53078 | false |
agartland/utils | custom_legends.py | 1 | 2291 | import matplotlib.pyplot as plt
import numpy as np
__all__ = ['colorLegend',
'symbolLegend']
def colorLegend(colors, labels, alphas=None, edgecolor='black',loc='best', axh=None, **legendKwargs):
"""Custom matplotlib legend with colors and labels etc.
Useful in cases where it is awkward to include labels on the appropriate plot() objects.
Parameters specify the characteristics of each line in the legend.
Parameters
----------
colors : list of valid matplotlib colors
labels : list of strings
alphas : list of alpha values
edgecolor : single valid matplotlib color
All remaining kwargs are passed to legend()
"""
if axh is None:
axh = plt.gca()
if alphas is None:
alphas = np.ones(len(colors))
circles = (plt.Circle((0, 0), fc=c, ec=edgecolor, alpha=a) for c, a in zip(colors, alphas))
lh = axh.legend(circles,
labels,
loc=loc,
**legendKwargs)
return lh
def symbolLegend(symbols, labels, facecolors=None, edgecolors=None, alphas=None,loc='best', **legendKwargs):
"""Custom matplotlib legend with lines, symbols and labels etc.
Useful in cases where it is awkward to include labels on the appropriate plot() objects.
Parameters specify the characteristics of each line in the legend.
Parameters
----------
symbols : list of valid matplotlib symbols
E.g. 'xs^*.<>' or other matplotlib.markers
labels : list of strings
facecolors : list of valid matplotlib colors
edgecolors : list of valid matplotlib colors
alphas : list of alpha values
All remaining kwargs are passed to legend()
"""
if alphas is None:
alphas = np.ones(len(symbols))
if edgecolors is None:
edgecolors = ['black'] * len(symbols)
if facecolors is None:
facecolors = ['white'] * len(symbols)
lh = plt.legend((plt.Line2D([0], [0], ls = '', marker = s, markerfacecolor = mfc, markeredgecolor = ec, alpha = a) for s, mfc, ec, a in zip(symbols, facecolors, edgecolors, alphas)),
labels,
loc,
numpoints=1,
**legendKwargs)
return lh
| mit | 6,611,612,067,164,619,000 | 34.951613 | 186 | 0.61196 | false |
radez/packstack | packstack/installer/utils/shell.py | 1 | 4512 | # -*- coding: utf-8 -*-
import re
import types
import logging
import subprocess
from ..exceptions import (ExecuteRuntimeError, ScriptRuntimeError,
NetworkError)
from .strings import mask_string
block_fmt = ("\n============= %(title)s ==========\n%(content)s\n"
"======== END OF %(title)s ========")
def execute(cmd, workdir=None, can_fail=True, mask_list=None,
use_shell=False, log=True):
"""
Runs shell command cmd. If can_fail is set to False
ExecuteRuntimeError is raised if command returned non-zero return
code. Otherwise
"""
mask_list = mask_list or []
repl_list = [("'", "'\\''")]
if not isinstance(cmd, types.StringType):
import pipes
masked = ' '.join((pipes.quote(i) for i in cmd))
else:
masked = cmd
masked = mask_string(masked, mask_list, repl_list)
if log:
logging.info("Executing command:\n%s" % masked)
proc = subprocess.Popen(cmd, stdout=subprocess.PIPE,
stderr=subprocess.PIPE, cwd=workdir,
shell=use_shell, close_fds=True)
out, err = proc.communicate()
masked_out = mask_string(out, mask_list, repl_list)
masked_err = mask_string(err, mask_list, repl_list)
if log:
logging.debug(block_fmt % {'title': 'STDOUT', 'content': masked_out})
if proc.returncode:
if log:
logging.debug(block_fmt % {'title': 'STDERR',
'content': masked_err})
if can_fail:
msg = 'Failed to execute command: %s' % masked_out
raise ExecuteRuntimeError(msg, stdout=out, stderr=err)
return proc.returncode, out
class ScriptRunner(object):
_pkg_search = 'rpm -q'
def __init__(self, ip=None):
self.script = []
self.ip = ip
def append(self, s):
self.script.append(s)
def clear(self):
self.script = []
def execute(self, can_fail=True, mask_list=None, log=True):
mask_list = mask_list or []
repl_list = [("'", "'\\''")]
script = "\n".join(self.script)
masked = mask_string(script, mask_list, repl_list)
if log:
logging.info("[%s] Executing script:\n%s" %
(self.ip or 'localhost', masked))
_PIPE = subprocess.PIPE # pylint: disable=E1101
if self.ip:
cmd = ["ssh", "-o", "StrictHostKeyChecking=no",
"-o", "UserKnownHostsFile=/dev/null",
"root@%s" % self.ip, "bash -x"]
else:
cmd = ["bash", "-x"]
obj = subprocess.Popen(cmd, stdin=_PIPE, stdout=_PIPE, stderr=_PIPE,
close_fds=True, shell=False)
script = "function t(){ exit $? ; } \n trap t ERR \n" + script
out, err = obj.communicate(script)
masked_out = mask_string(out, mask_list, repl_list)
masked_err = mask_string(err, mask_list, repl_list)
if log:
logging.debug(block_fmt % {'title': 'STDOUT',
'content': masked_out})
if obj.returncode:
if log:
logging.debug(block_fmt % {'title': 'STDERR',
'content': masked_err})
if can_fail:
pattern = (r'^ssh\:')
if re.search(pattern, err):
raise NetworkError(masked_err, stdout=out, stderr=err)
else:
msg = 'Failed to run remote script: %s' % masked_out
raise ScriptRuntimeError(msg, stdout=out, stderr=err)
return obj.returncode, out
def template(self, src, dst, varsdict):
with open(src) as fp:
content = fp.read() % varsdict
self.append("cat > %s <<- EOF\n%s\nEOF\n" % (dst, content))
def if_not_exists(self, path, command):
self.append("[ -e %s ] || %s" % (path, command))
def if_exists(self, path, command):
self.append("[ -e %s ] && %s" % (path, command))
def if_installed(self, pkg, command):
self.append("%s %s && %s" % (self._pkg_search, pkg, command))
def if_not_installed(self, pkg, command):
self.append("%s %s || %s" % (self._pkg_search, pkg, command))
def chown(self, target, uid, gid):
self.append("chown %s:%s %s" % (uid, gid, target))
def chmod(self, target, mode):
self.append("chmod %s %s" % (mode, target))
| apache-2.0 | -8,818,339,688,155,416,000 | 33.707692 | 77 | 0.526596 | false |
hivesolutions/netius | src/netius/clients/mjpg.py | 1 | 4936 | #!/usr/bin/python
# -*- coding: utf-8 -*-
# Hive Netius System
# Copyright (c) 2008-2020 Hive Solutions Lda.
#
# This file is part of Hive Netius System.
#
# Hive Netius System is free software: you can redistribute it and/or modify
# it under the terms of the Apache License as published by the Apache
# Foundation, either version 2.0 of the License, or (at your option) any
# later version.
#
# Hive Netius System 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
# Apache License for more details.
#
# You should have received a copy of the Apache License along with
# Hive Netius System. If not, see <http://www.apache.org/licenses/>.
__author__ = "João Magalhães <[email protected]>"
""" The author(s) of the module """
__version__ = "1.0.0"
""" The version of the module """
__revision__ = "$LastChangedRevision$"
""" The revision number of the module """
__date__ = "$LastChangedDate$"
""" The last change date of the module """
__copyright__ = "Copyright (c) 2008-2020 Hive Solutions Lda."
""" The copyright for the module """
__license__ = "Apache License, Version 2.0"
""" The license for the module """
import os
import netius
from . import http
class MJPGProtocol(http.HTTPProtocol):
MAGIC_JPEG = b"\xff\xd8\xff\xe0"
""" The magic signature for the JPEG infra-structure, this
sequence of bytes is going to be used to detect new frames
coming from the HTTP based stream """
EOI_JPEG = b"\xff\xd9"
""" The sequence of bytes that indicate the end of the current
image, when these bytes are detected on the stream the message
should be "flushed" to the current output (emit) """
def __init__(self, *args, **kwargs):
http.HTTPProtocol.__init__(self, *args, **kwargs)
self.buffer_l = []
def add_buffer(self, data):
self.buffer_l.append(data)
def get_buffer(self, delete = True):
if not self.buffer_l: return b""
buffer = b"".join(self.buffer_l)
if delete: del self.buffer_l[:]
return buffer
def on_partial(self, data):
http.HTTPProtocol.on_partial(self, data)
# retrieves the reference to the top class that is going to
# be used for the correct parsing of the image
cls = self.__class__
# tries to find the end of image (EOI) indicator in the current
# received data, and in case it's not found add the (partial)
# data to the current buffer, to be latter processed
eoi_index = data.find(cls.EOI_JPEG)
if eoi_index == -1: self.buffer_l.append(data); return
# calculates the size of the end of image (EOI) token so that
# this value will be used for the calculus of the image data
eoi_size = len(cls.EOI_JPEG)
# adds the partial valid data of the current chunk to the buffer
# and then joins the current buffer as the frame data, removing
# the multipart header from it (to become a valid image)
self.buffer_l.append(data[:eoi_index + eoi_size])
frame = b"".join(self.buffer_l)
multipart_index = frame.find(b"\r\n\r\n")
frame = frame[multipart_index + 4:]
# clears the current buffer and adds the remaining part of the
# current chunk, that may be already part of a new image
del self.buffer_l[:]
self.buffer_l.append(data[eoi_index + eoi_size:])
# calls the proper event handler for the new frame data that has
# just been received, triggering the processing of the frame
self.on_frame_mjpg(frame)
def on_frame_mjpg(self, data):
self.trigger("frame", self, data)
class MJPGClient(http.HTTPClient):
protocol = MJPGProtocol
if __name__ == "__main__":
index = 0
limit = 30
def on_frame(protocol, data):
global index
index += 1
if index >= limit: return protocol.close()
base_path = netius.conf("IMAGES_PATH", "images")
base_path = os.path.abspath(base_path)
base_path = os.path.normpath(base_path)
if not os.path.exists(base_path): os.makedirs(base_path)
path = os.path.join(base_path, "%08d.jpg" % index)
file = open(path, "wb")
try: file.write(data)
finally: file.close()
print("Saved frame %08d of %d bytes" % (index, len(data)))
def on_finish(protocol):
netius.compat_loop(loop).stop()
url = netius.conf("MJPG_URL", "http://euglena.stanford.edu:20005/?action=stream")
client = MJPGClient()
loop, protocol = client.get(url)
protocol.bind("frame", on_frame)
protocol.bind("finish", on_finish)
loop.run_forever()
loop.close()
else:
__path__ = []
| apache-2.0 | 5,063,929,398,906,030,000 | 32.263889 | 85 | 0.625659 | false |
gameduell/pysupplies | tests/test_params.py | 1 | 3109 | import pytest
from supplies.annotate import delay
from supplies.params import param, Params
__author__ = 'dwae'
class Foo(Params):
@param
def bar(self, val: (1, 42)=23):
return val
@delay
def bla(self):
return ...
class Bar(Foo, Params):
@param
def baz(self, val: str='f00'):
return val
def test_basic():
foo = Foo()
assert foo.bar == 23
foo.bar = 1
assert foo.bar == 1
foo.bar = 42
assert foo.bar == 42
foo = Foo(bar=13)
assert foo.bar == 13
foo.bar = 37
assert foo.bar == 37
bar = Bar()
assert bar.bar == 23
assert bar.baz == 'f00'
bar = Bar(baz='')
assert bar.bar == 23
assert bar.baz == ''
bar = Bar(bar=6)
assert bar.bar == 6
assert bar.baz == 'f00'
bar = Bar(bar=12, baz='foo')
assert bar.bar == 12
assert bar.baz == 'foo'
bar.bar = 2
bar.baz = 'to'
assert bar.bar == 2
assert bar.baz == 'to'
with pytest.raises(TypeError):
Bar(bar=1, nil=None)
def test_export():
bar = Bar(bar=42, baz='foo')
params = bar.params
assert {'bar', 'baz'} == params.names
assert params.bar.name == 'bar'
assert params['baz'].name == 'baz'
assert params['bar'].value == 42
assert params.baz.value == 'foo'
assert params.bar.default == 23
assert params.baz.default == 'f00'
assert 'bar=42' in str(bar)
assert "baz='foo'" in repr(bar)
assert bar.bla is ...
with pytest.raises(KeyError):
params['bla']
with pytest.raises(AttributeError):
params.bla
class Convert(Params):
@param
def a(self, val=1):
return int(val)
@param
def b(self, val=''):
return str(val)
def test_convert():
conv = Convert()
assert conv.a == 1
assert conv.b == ''
conv = Convert(a='13', b=37)
assert conv.a == 13
assert conv.b == '37'
conv.a = '42'
assert conv.a == 42
conv.b = None
assert conv.b == str(None)
class Dependent(Params):
@param
def a(self, val=1):
return val
@param
def b(self, val=None):
if val is None:
return self.a + 1
else:
return val
@param
def c(self, val):
return self.a + val
@param
def d(self, val=3):
return self.a + val
def test_depend():
dep = Dependent()
assert dep.a == 1
assert dep.b == 2
dep.a = 2
assert dep.a == 2
assert dep.b == 3
dep.a = 1
assert dep.a == 1
assert dep.b == 2
dep.b = 4
dep.a = 5
assert dep.a == 5
assert dep.b == 4
dep.c = 3
assert dep.c == 8
dep.a = 3
dep.b = 2
assert dep.c == 6
assert dep.b == 2
del dep.b
assert dep.b == 4
del dep.a
assert dep.b == 2
del dep.c
with pytest.raises(TypeError):
dep.c
assert dep.d == 4
dep.a = 3
assert dep.d == 6
del dep.a
assert dep.d == 4
dep.d = 4
assert dep.d == 5
dep.a = 4
assert dep.d == 8
del dep.d
assert dep.d == 7
del dep.a
assert dep.d == 4
| mit | -5,483,111,285,384,543,000 | 15.537234 | 41 | 0.525893 | false |
onyb/cpp | DSATP/LinkedList/test_CH3_S6_Single_Linked_Lists.py | 1 | 2988 | import unittest
from LinkedList.CH3_S6_Single_Linked_Lists import LinkedList
from LinkedList.CH3_S6_Single_Linked_Lists import Node
from LinkedList.CH3_S6_Single_Linked_Lists import ElementNotFoundException
class TestSingleLinkedList(unittest.TestCase):
def test_node(self):
node_a = Node()
node_a.set_data('foo')
self.assertEqual(node_a.get_data(), 'foo')
node_b = Node()
node_b.set_data('baz')
node_a.set_next(node_b)
self.assertEqual(node_a.get_next(), node_b)
self.assertEqual(node_a.has_next, True)
self.assertEqual(node_b.has_next, False)
def test_linked_list(self):
ll = LinkedList()
node = Node()
node.set_data('foo')
ll.set_head(node)
self.assertEqual(ll.head, node)
self.assertEqual(ll.length, 1)
# Insert at beginning
ll.insert_at_pos('bar', 0)
self.assertEqual(ll.head.get_data(), 'bar')
self.assertEqual(ll.head.get_next().get_data(), 'foo')
self.assertEqual(ll.length, 2)
# Insert at end
ll.insert_at_pos('baz', 2)
self.assertEqual(ll.head.get_next().get_next().get_data(), 'baz')
self.assertEqual(ll.length, 3)
# Insert at position
ll.insert_at_pos('ani', 1)
self.assertEqual(ll.head.get_next().get_next().get_data(), 'ani')
self.assertEqual(ll.length, 4)
# Delete from beginning
ll.delete_from_beginning()
self.assertEqual(ll.head.get_data(), 'foo')
self.assertEqual(ll.length, 3)
# Delete last node
ll.delete_last_node()
self.assertEqual(ll.head.get_next().get_data(), 'ani')
self.assertEqual(ll.head.get_next().get_next(), None)
self.assertEqual(ll.length, 2)
# Delete node
ll.insert_at_pos('anirudha', 2)
ll.insert_at_pos('bose', 3)
self.assertEqual(ll.length, 4)
node = ll.head.get_next().get_next()
ll.delete_node(node)
self.assertEqual(ll.length, 3)
# Delete a non-existent node
node = Node()
node.set_data('pirated')
with self.assertRaises(ElementNotFoundException):
ll.delete_node(node)
self.assertEqual(ll.length, 3)
# Delete value
ll.insert_at_pos('onyb', 2)
self.assertEqual(ll.head.get_next().get_next().get_next().get_data(), 'onyb')
self.assertEqual(ll.length, 4)
ll.delete_value('onyb')
self.assertEqual(ll.head.get_next().get_data(), 'ani')
self.assertEqual(ll.length, 3)
# Delete position
ll.insert_at_pos('onyb', 2)
self.assertEqual(ll.head.get_next().get_next().get_next().get_data(), 'onyb')
self.assertEqual(ll.length, 4)
ll.delete_pos(2)
self.assertEqual(ll.head.get_next().get_data(), 'ani')
self.assertEqual(ll.length, 3)
# Clear linked list
ll.clear()
self.assertEqual(ll.length, 0) | mit | -401,720,435,719,677,000 | 31.846154 | 85 | 0.594712 | false |
jedie/DragonPy | PyDC/PyDC/wave2bitstream.py | 1 | 23203 | #!/usr/bin/env python2
"""
:copyleft: 2013 by Jens Diemer
:license: GNU GPL v3 or above, see LICENSE for more details.
"""
import array
import functools
import itertools
import logging
import math
import struct
import time
import wave
from PyDC.utils import (
ProcessInfo,
TextLevelMeter,
average,
bits2codepoint,
codepoints2bitstream,
count_sign,
diff_info,
duration2hz,
human_duration,
hz2duration,
iter_steps,
iter_window,
sinus_values_by_hz,
)
try:
import audioop
except ImportError as err:
# e.g. PyPy, see: http://bugs.pypy.org/msg4430
print("Can't use audioop:", err)
audioop = None
log = logging.getLogger("PyDC")
WAVE_READ_SIZE = 16 * 1024 # How many frames should be read from WAVE file at once?
WAV_ARRAY_TYPECODE = {
1: "b", # 8-bit wave file
2: "h", # 16-bit wave file
4: "l", # 32-bit wave file TODO: Test it
}
# Maximum volume value in wave files:
MAX_VALUES = {
1: 255, # 8-bit wave file
2: 32768, # 16-bit wave file
4: 2147483647, # 32-bit wave file
}
HUMAN_SAMPLEWIDTH = {
1: "8-bit",
2: "16-bit",
4: "32-bit",
}
class WaveBase:
def get_typecode(self, samplewidth):
try:
typecode = WAV_ARRAY_TYPECODE[samplewidth]
except KeyError:
raise NotImplementedError(
"Only %s wave files are supported, yet!" % (
", ".join(["%sBit" % (i * 8) for i in list(WAV_ARRAY_TYPECODE.keys())])
)
)
return typecode
def pformat_pos(self):
sec = float(self.wave_pos) / self.framerate / self.samplewidth
return f"{human_duration(sec)} (frame no.: {self.wave_pos})"
def _hz2duration(self, hz):
return hz2duration(hz, framerate=self.framerate)
def _duration2hz(self, duration):
return duration2hz(duration, framerate=self.framerate)
def set_wave_properties(self):
self.framerate = self.wavefile.getframerate() # frames / second
self.samplewidth = self.wavefile.getsampwidth() # 1 for 8-bit, 2 for 16-bit, 4 for 32-bit samples
self.max_value = MAX_VALUES[self.samplewidth]
self.nchannels = self.wavefile.getnchannels() # typically 1 for mono, 2 for stereo
log.info("Framerate: %sHz samplewidth: %i (%sBit, max volume value: %s) channels: %s" % (
self.framerate,
self.samplewidth, self.samplewidth * 8, self.max_value,
self.nchannels,
))
assert self.nchannels == 1, "Only MONO files are supported, yet!"
class Wave2Bitstream(WaveBase):
def __init__(self, wave_filename, cfg):
self.wave_filename = wave_filename
self.cfg = cfg
self.half_sinus = False # in trigger yield the full cycle
self.wave_pos = 0 # Absolute position in the frame stream
assert cfg.END_COUNT > 0 # Sample count that must be pos/neg at once
assert cfg.MID_COUNT > 0 # Sample count that can be around null
print(f"open wave file '{wave_filename}'...")
try:
self.wavefile = wave.open(wave_filename, "rb")
except OSError as err:
msg = f"Error opening {repr(wave_filename)}: {err}"
log.error(msg)
sys.stderr.write(msg)
sys.exit(-1)
self.set_wave_properties()
self.frame_count = self.wavefile.getnframes()
print("Number of audio frames:", self.frame_count)
self.min_volume = int(round(self.max_value * cfg.MIN_VOLUME_RATIO / 100))
print(f"Ignore sample lower than {cfg.MIN_VOLUME_RATIO:.1f}% = {self.min_volume:d}")
self.half_sinus = False # in trigger yield the full cycle
self.frame_no = None
# create the generator chain:
# get frame numer + volume value from the WAVE file
self.wave_values_generator = self.iter_wave_values()
if cfg.AVG_COUNT > 1:
# merge samples to a average sample
log.debug(f"Merge {cfg.AVG_COUNT} audio sample to one average sample")
self.avg_wave_values_generator = self.iter_avg_wave_values(
self.wave_values_generator, cfg.AVG_COUNT
)
# trigger sinus cycle
self.iter_trigger_generator = self.iter_trigger(self.avg_wave_values_generator)
else:
# trigger sinus cycle
self.iter_trigger_generator = self.iter_trigger(self.wave_values_generator)
# duration of a complete sinus cycle
self.iter_duration_generator = self.iter_duration(self.iter_trigger_generator)
# build from sinus cycle duration the bit stream
self.iter_bitstream_generator = self.iter_bitstream(self.iter_duration_generator)
def _print_status(self, process_info):
percent = float(self.wave_pos) / self.frame_count * 100
rest, eta, rate = process_info.update(self.wave_pos)
sys.stdout.write(
f"\r{percent:.1f}% wav pos:{self.pformat_pos()} - eta: {eta} (rate: {rate:d}Frames/sec) ")
sys.stdout.flush()
def _get_statistics(self, max=None):
statistics = {}
iter_duration_generator = self.iter_duration(self.iter_trigger_generator)
for count, duration in enumerate(iter_duration_generator):
try:
statistics[duration] += 1
except KeyError:
statistics[duration] = 1
if max is not None and count >= max:
break
return statistics
def analyze(self):
"""
Example output:
394Hz ( 28 Samples) exist: 1
613Hz ( 18 Samples) exist: 1
788Hz ( 14 Samples) exist: 1
919Hz ( 12 Samples) exist: 329 *********
1002Hz ( 11 Samples) exist: 1704 **********************************************
1103Hz ( 10 Samples) exist: 1256 **********************************
1225Hz ( 9 Samples) exist: 1743 ***********************************************
1378Hz ( 8 Samples) exist: 1
1575Hz ( 7 Samples) exist: 322 *********
1838Hz ( 6 Samples) exist: 1851 **************************************************
2205Hz ( 5 Samples) exist: 1397 **************************************
2756Hz ( 4 Samples) exist: 913 *************************
"""
log.debug("enable half sinus scan")
self.half_sinus = True
statistics = self._get_statistics()
width = 50
max_count = max(statistics.values())
print()
print("Found this zeror crossing timings in the wave file:")
print()
for duration, count in sorted(list(statistics.items()), reverse=True):
hz = duration2hz(duration, self.framerate / 2)
w = int(round(float(width) / max_count * count))
stars = "*" * w
print(f"{hz:>5}Hz ({duration:>5} Samples) exist: {count:>4} {stars}")
print()
print("Notes:")
print(" - Hz values are converted to full sinus cycle duration.")
print(" - Sample cound is from half sinus cycle.")
def sync(self, length):
"""
synchronized weave sync trigger
"""
# go in wave stream to the first bit
try:
next(self)
except StopIteration:
print("Error: no bits identified!")
sys.exit(-1)
log.info("First bit is at: %s" % self.pformat_pos())
log.debug("enable half sinus scan")
self.half_sinus = True
# Toggle sync test by consuming one half sinus sample
# self.iter_trigger_generator.next() # Test sync
# get "half sinus cycle" test data
test_durations = itertools.islice(self.iter_duration_generator, length)
# It's a tuple like: [(frame_no, duration)...]
test_durations = list(test_durations)
diff1, diff2 = diff_info(test_durations)
log.debug(f"sync diff info: {diff1:d} vs. {diff2:d}")
if diff1 > diff2:
log.info("\nbit-sync one step.")
next(self.iter_trigger_generator)
log.debug("Synced.")
else:
log.info("\nNo bit-sync needed.")
self.half_sinus = False
log.debug("disable half sinus scan")
def __iter__(self):
return self
def __next__(self):
return next(self.iter_bitstream_generator)
def iter_bitstream(self, iter_duration_generator):
"""
iterate over self.iter_trigger() and
yield the bits
"""
assert self.half_sinus is False # Allways trigger full sinus cycle
# build min/max Hz values
bit_nul_min_hz = self.cfg.BIT_NUL_HZ - self.cfg.HZ_VARIATION
bit_nul_max_hz = self.cfg.BIT_NUL_HZ + self.cfg.HZ_VARIATION
bit_one_min_hz = self.cfg.BIT_ONE_HZ - self.cfg.HZ_VARIATION
bit_one_max_hz = self.cfg.BIT_ONE_HZ + self.cfg.HZ_VARIATION
bit_nul_max_duration = self._hz2duration(bit_nul_min_hz)
bit_nul_min_duration = self._hz2duration(bit_nul_max_hz)
bit_one_max_duration = self._hz2duration(bit_one_min_hz)
bit_one_min_duration = self._hz2duration(bit_one_max_hz)
log.info(f"bit-0 in {bit_nul_min_hz}Hz - {bit_nul_max_hz}Hz (duration: {bit_nul_min_duration}-{bit_nul_max_duration}) | bit-1 in {bit_one_min_hz}Hz - {bit_one_max_hz}Hz (duration: {bit_one_min_duration}-{bit_one_max_duration})")
assert bit_nul_max_hz < bit_one_min_hz, "HZ_VARIATION value is %sHz too high!" % (
((bit_nul_max_hz - bit_one_min_hz) / 2) + 1
)
assert bit_one_max_duration < bit_nul_min_duration, "HZ_VARIATION value is too high!"
# for end statistics
bit_one_count = 0
one_hz_min = sys.maxsize
one_hz_avg = None
one_hz_max = 0
bit_nul_count = 0
nul_hz_min = sys.maxsize
nul_hz_avg = None
nul_hz_max = 0
for duration in iter_duration_generator:
if bit_one_min_duration < duration < bit_one_max_duration:
hz = self._duration2hz(duration)
log.log(5,
f"bit 1 at {self.pformat_pos()} in {duration}Samples = {hz}Hz"
)
yield 1
bit_one_count += 1
if hz < one_hz_min:
one_hz_min = hz
if hz > one_hz_max:
one_hz_max = hz
one_hz_avg = average(one_hz_avg, hz, bit_one_count)
elif bit_nul_min_duration < duration < bit_nul_max_duration:
hz = self._duration2hz(duration)
log.log(5,
f"bit 0 at {self.pformat_pos()} in {duration}Samples = {hz}Hz"
)
yield 0
bit_nul_count += 1
if hz < nul_hz_min:
nul_hz_min = hz
if hz > nul_hz_max:
nul_hz_max = hz
nul_hz_avg = average(nul_hz_avg, hz, bit_nul_count)
else:
hz = self._duration2hz(duration)
log.log(7,
f"Skip signal at {self.pformat_pos()} with {hz}Hz ({duration}Samples) out of frequency range."
)
continue
bit_count = bit_one_count + bit_nul_count
if bit_count == 0:
print("ERROR: No information from wave to generate the bits")
print("trigger volume to high?")
sys.exit(-1)
log.info(f"\n{bit_count:d} Bits: {bit_one_count:d} positive bits and {bit_nul_count:d} negative bits")
if bit_one_count > 0:
log.info("Bit 1: {}Hz - {}Hz avg: {:.1f}Hz variation: {}Hz".format(
one_hz_min, one_hz_max, one_hz_avg, one_hz_max - one_hz_min
))
if bit_nul_count > 0:
log.info("Bit 0: {}Hz - {}Hz avg: {:.1f}Hz variation: {}Hz".format(
nul_hz_min, nul_hz_max, nul_hz_avg, nul_hz_max - nul_hz_min
))
def iter_duration(self, iter_trigger):
"""
yield the duration of two frames in a row.
"""
print()
process_info = ProcessInfo(self.frame_count, use_last_rates=4)
start_time = time.time()
next_status = start_time + 0.25
old_pos = next(iter_trigger)
for pos in iter_trigger:
duration = pos - old_pos
# log.log(5, "Duration: %s" % duration)
yield duration
old_pos = pos
if time.time() > next_status:
next_status = time.time() + 1
self._print_status(process_info)
self._print_status(process_info)
print()
def iter_trigger(self, iter_wave_values):
"""
trigger middle crossing of the wave sinus curve
"""
window_size = (2 * self.cfg.END_COUNT) + self.cfg.MID_COUNT
# sinus curve goes from negative into positive:
pos_null_transit = [(0, self.cfg.END_COUNT), (self.cfg.END_COUNT, 0)]
# sinus curve goes from positive into negative:
neg_null_transit = [(self.cfg.END_COUNT, 0), (0, self.cfg.END_COUNT)]
if self.cfg.MID_COUNT > 3:
mid_index = int(round(self.cfg.MID_COUNT / 2.0))
else:
mid_index = 0
in_pos = False
for values in iter_window(iter_wave_values, window_size):
# Split the window
previous_values = values[:self.cfg.END_COUNT] # e.g.: 123-----
mid_values = values[self.cfg.END_COUNT:self.cfg.END_COUNT + self.cfg.MID_COUNT] # e.g.: ---45---
next_values = values[-self.cfg.END_COUNT:] # e.g.: -----678
# get only the value and strip the frame_no
# e.g.: (frame_no, value) tuple -> value list
previous_values = [i[1] for i in previous_values]
next_values = [i[1] for i in next_values]
# Count sign from previous and next values
sign_info = [
count_sign(previous_values, 0),
count_sign(next_values, 0)
]
# log.log(5, "sign info: %s" % repr(sign_info))
# yield the mid crossing
if in_pos is False and sign_info == pos_null_transit:
log.log(5, "sinus curve goes from negative into positive")
# log.debug(" %s | %s | %s" % (previous_values, mid_values, next_values))
yield mid_values[mid_index][0]
in_pos = True
elif in_pos and sign_info == neg_null_transit:
if self.half_sinus:
log.log(5, "sinus curve goes from positive into negative")
# log.debug(" %s | %s | %s" % (previous_values, mid_values, next_values))
yield mid_values[mid_index][0]
in_pos = False
def iter_avg_wave_values(self, wave_values_generator, avg_count):
if log.level >= 5:
tlm = TextLevelMeter(self.max_value, 79)
for value_tuples in iter_steps(wave_values_generator, avg_count):
values = [i[1] for i in value_tuples]
avg_value = int(round(
float(sum(values)) / avg_count
))
if tlm:
msg = tlm.feed(avg_value)
percent = 100.0 / self.max_value * abs(avg_value)
log.log(5,
f"{msg} average {','.join([str(v) for v in values])} samples to: {avg_value} ({percent:.1f}%)"
)
yield (self.wave_pos, avg_value)
def iter_wave_values(self):
"""
yield frame numer + volume value from the WAVE file
"""
typecode = self.get_typecode(self.samplewidth)
if log.level >= 5:
if self.cfg.AVG_COUNT > 1:
# merge samples -> log output in iter_avg_wave_values
tlm = None
else:
tlm = TextLevelMeter(self.max_value, 79)
# Use only a read size which is a quare divider of the samplewidth
# Otherwise array.array will raise: ValueError: string length not a multiple of item size
divider = int(round(float(WAVE_READ_SIZE) / self.samplewidth))
read_size = self.samplewidth * divider
if read_size != WAVE_READ_SIZE:
log.info(f"Real use wave read size: {read_size:d} Bytes")
get_wave_block_func = functools.partial(self.wavefile.readframes, read_size)
skip_count = 0
manually_audioop_bias = self.samplewidth == 1 and audioop is None
for frames in iter(get_wave_block_func, ""):
if self.samplewidth == 1:
if audioop is None:
log.warning("use audioop.bias() work-a-round for missing audioop.")
else:
# 8 bit samples are unsigned, see:
# http://docs.python.org/2/library/audioop.html#audioop.lin2lin
frames = audioop.bias(frames, 1, 128)
try:
values = array.array(typecode, frames)
except ValueError as err:
# e.g.:
# ValueError: string length not a multiple of item size
# Work-a-round: Skip the last frames of this block
frame_count = len(frames)
divider = int(math.floor(float(frame_count) / self.samplewidth))
new_count = self.samplewidth * divider
frames = frames[:new_count] # skip frames
log.error(
"Can't make array from %s frames: Value error: %s (Skip %i and use %i frames)" % (
frame_count, err, frame_count - new_count, len(frames)
))
values = array.array(typecode, frames)
for value in values:
self.wave_pos += 1 # Absolute position in the frame stream
if manually_audioop_bias:
# audioop.bias can't be used.
# See: http://hg.python.org/cpython/file/482590320549/Modules/audioop.c#l957
value = value % 0xff - 128
# if abs(value) < self.min_volume:
# # log.log(5, "Ignore to lower amplitude")
# skip_count += 1
# continue
yield (self.wave_pos, value)
log.info(f"Skip {skip_count:d} samples that are lower than {self.min_volume:d}")
log.info("Last readed Frame is: %s" % self.pformat_pos())
class Bitstream2Wave(WaveBase):
def __init__(self, destination_filepath, cfg):
self.destination_filepath = destination_filepath
self.cfg = cfg
wave_max_value = MAX_VALUES[self.cfg.SAMPLEWIDTH]
self.used_max_values = int(round(
float(wave_max_value) / 100 * self.cfg.VOLUME_RATIO
))
log.info(
f"Create {HUMAN_SAMPLEWIDTH[self.cfg.SAMPLEWIDTH]} wave file with {self.cfg.FRAMERATE}Hz and {self.used_max_values} max volumen ({self.cfg.VOLUME_RATIO}%)")
self.typecode = self.get_typecode(self.cfg.SAMPLEWIDTH)
self.bit_nul_samples = self.get_samples(self.cfg.BIT_NUL_HZ)
self.bit_one_samples = self.get_samples(self.cfg.BIT_ONE_HZ)
log.info(f"create wave file '{destination_filepath}'...")
try:
self.wavefile = wave.open(destination_filepath, "wb")
except OSError as err:
log.error(f"Error opening {repr(destination_filepath)}: {err}")
sys.exit(-1)
self.wavefile.setnchannels(1) # Mono
self.wavefile.setsampwidth(self.cfg.SAMPLEWIDTH)
self.wavefile.setframerate(self.cfg.FRAMERATE)
self.set_wave_properties()
@property
def wave_pos(self):
pos = self.wavefile._nframeswritten * self.samplewidth
return pos
def pack_values(self, values):
value_length = len(values)
pack_format = f"{value_length:d}{self.typecode}"
packed_samples = struct.pack(pack_format, *values)
return packed_samples
def get_samples(self, hz):
values = tuple(
sinus_values_by_hz(self.cfg.FRAMERATE, hz, self.used_max_values)
)
real_hz = float(self.cfg.FRAMERATE) / len(values)
log.debug(f"Real frequency: {real_hz:.2f}")
return self.pack_values(values)
def write_codepoint(self, codepoints):
written_codepoints = []
bits = []
for bit in codepoints2bitstream(codepoints):
bits.append(bit)
if len(bits) == 8:
written_codepoints.append(bits2codepoint(bits))
bits = []
if bit == 0:
# wavefile.writeframes(self.bit_nul_samples)
self.wavefile.writeframes(self.bit_nul_samples)
elif bit == 1:
# wavefile.writeframes(self.bit_one_samples)
self.wavefile.writeframes(self.bit_one_samples)
else:
raise TypeError
log.debug(f"Written at {self.pformat_pos()}: {','.join([hex(x) for x in written_codepoints])}")
def write_silence(self, sec):
start_pos = self.pformat_pos()
silence = [0x00] * int(round(sec * self.framerate))
packed_samples = self.pack_values(silence)
self.wavefile.writeframes(packed_samples)
log.debug(f"Write {sec}sec. silence {start_pos} - {self.pformat_pos()}")
def close(self):
self.wavefile.close()
log.info(f"Wave file {self.destination_filepath} written ({self.pformat_pos()})")
if __name__ == "__main__":
import doctest
print(doctest.testmod(
verbose=False
# verbose=True
))
# sys.exit()
# test via CLI:
import sys
import subprocess
# subprocess.Popen([sys.executable, "../PyDC_cli.py", "--help"])
# sys.exit()
# subprocess.Popen([sys.executable, "../PyDC_cli.py", "--verbosity=10",
# # "--log_format=%(module)s %(lineno)d: %(message)s",
# "--analyze",
# "../test_files/HelloWorld1 xroar.wav"
# # "../test_files/HelloWorld1 origin.wav"
# ])
# print "\n"*3
# print "="*79
# print "\n"*3
# bas -> wav
subprocess.Popen([sys.executable, "../PyDC_cli.py",
"--verbosity=10",
# "--verbosity=5",
# "--logfile=5",
# "--log_format=%(module)s %(lineno)d: %(message)s",
"../test_files/HelloWorld1.bas", "--dst=../test.wav"
]).wait()
# print "\n"*3
# print "="*79
# print "\n"*3
#
# # wav -> bas
# subprocess.Popen([sys.executable, "../PyDC_cli.py",
# "--verbosity=10",
# # "--verbosity=5",
# # "--logfile=5",
# # "--log_format=%(module)s %(lineno)d: %(message)s",
# "../test.wav", "--dst=../test.bas",
# # "../test_files/HelloWorld1 origin.wav", "--dst=../test_files/HelloWorld1.bas",
# ]).wait()
#
# print "-- END --"
| gpl-3.0 | 9,016,746,850,299,839,000 | 35.425432 | 238 | 0.545274 | false |
andyliuliming/azure-linux-extensions | VMBackup/main/handle.py | 1 | 27941 | #!/usr/bin/env python
#
# VM Backup extension
#
# Copyright 2014 Microsoft Corporation
#
# 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 array
import base64
import os
import os.path
import re
import json
import string
import subprocess
import sys
import imp
import time
import shlex
import traceback
import xml.parsers.expat
import datetime
try:
import ConfigParser as ConfigParsers
except ImportError:
import configparser as ConfigParsers
from threading import Thread
from time import sleep
from os.path import join
from mounts import Mounts
from mounts import Mount
from patch import *
from fsfreezer import FsFreezer
from common import CommonVariables
from parameterparser import ParameterParser
from Utils import HandlerUtil
from Utils import SizeCalculation
from Utils import Status
from freezesnapshotter import FreezeSnapshotter
from backuplogger import Backuplogger
from blobwriter import BlobWriter
from taskidentity import TaskIdentity
from MachineIdentity import MachineIdentity
import ExtensionErrorCodeHelper
from PluginHost import PluginHost
from PluginHost import PluginHostResult
#Main function is the only entrence to this extension handler
def main():
global MyPatching,backup_logger,hutil,run_result,run_status,error_msg,freezer,freeze_result,snapshot_info_array,total_used_size,size_calculation_failed
try:
run_result = CommonVariables.success
run_status = 'success'
error_msg = ''
freeze_result = None
snapshot_info_array = None
total_used_size = 0
size_calculation_failed = False
HandlerUtil.waagent.LoggerInit('/dev/console','/dev/stdout')
## HandlerUtil.waagent.Logger.Log((CommonVariables.extension_name) + " started to handle." )
hutil = HandlerUtil.HandlerUtility(HandlerUtil.waagent.Log, HandlerUtil.waagent.Error, CommonVariables.extension_name)
backup_logger = Backuplogger(hutil)
MyPatching = GetMyPatching(backup_logger)
hutil.patching = MyPatching
for a in sys.argv[1:]:
if re.match("^([-/]*)(disable)", a):
disable()
elif re.match("^([-/]*)(uninstall)", a):
uninstall()
elif re.match("^([-/]*)(install)", a):
install()
elif re.match("^([-/]*)(enable)", a):
enable()
elif re.match("^([-/]*)(update)", a):
update()
elif re.match("^([-/]*)(daemon)", a):
daemon()
except Exception as e:
sys.exit(0)
def install():
global hutil
hutil.do_parse_context('Install')
hutil.do_exit(0, 'Install','success','0', 'Install Succeeded')
def timedelta_total_seconds(delta):
if not hasattr(datetime.timedelta, 'total_seconds'):
return delta.days * 86400 + delta.seconds
else:
return delta.total_seconds()
def status_report_to_file(file_report_msg):
global backup_logger,hutil
hutil.write_to_status_file(file_report_msg)
backup_logger.log("file status report message:",True)
backup_logger.log(file_report_msg,True)
def status_report_to_blob(blob_report_msg):
global backup_logger,hutil,para_parser
try:
if(para_parser is not None and para_parser.statusBlobUri is not None and para_parser.statusBlobUri != ""):
blobWriter = BlobWriter(hutil)
if(blob_report_msg is not None):
blobWriter.WriteBlob(blob_report_msg,para_parser.statusBlobUri)
backup_logger.log("blob status report message:",True)
backup_logger.log(blob_report_msg,True)
else:
backup_logger.log("blob_report_msg is none",True)
except Exception as e:
err_msg='cannot write status to the status blob'+traceback.format_exc()
backup_logger.log(err_msg, True, 'Warning')
def get_status_to_report(status, status_code, message, snapshot_info = None):
global MyPatching,backup_logger,hutil,para_parser,total_used_size,size_calculation_failed
blob_report_msg = None
file_report_msg = None
try:
if total_used_size == -1 :
sizeCalculation = SizeCalculation.SizeCalculation(patching = MyPatching , logger = backup_logger)
total_used_size,size_calculation_failed = sizeCalculation.get_total_used_size()
number_of_blobs = len(para_parser.blobs)
maximum_possible_size = number_of_blobs * 1099511627776
if(total_used_size>maximum_possible_size):
total_used_size = maximum_possible_size
backup_logger.log("Assertion Check, total size : {0} ,maximum_possible_size : {1}".format(total_used_size,maximum_possible_size),True)
if(para_parser is not None and para_parser.statusBlobUri is not None and para_parser.statusBlobUri != ""):
blob_report_msg, file_report_msg = hutil.do_status_report(operation='Enable',status=status,\
status_code=str(status_code),\
message=message,\
taskId=para_parser.taskId,\
commandStartTimeUTCTicks=para_parser.commandStartTimeUTCTicks,\
snapshot_info=snapshot_info,\
total_size = total_used_size,\
failure_flag = size_calculation_failed)
except Exception as e:
err_msg='cannot get status report parameters , Exception %s, stack trace: %s' % (str(e), traceback.format_exc())
backup_logger.log(err_msg, True, 'Warning')
return blob_report_msg, file_report_msg
def exit_with_commit_log(status,result,error_msg, para_parser):
global backup_logger
backup_logger.log(error_msg, True, 'Error')
if(para_parser is not None and para_parser.logsBlobUri is not None and para_parser.logsBlobUri != ""):
backup_logger.commit(para_parser.logsBlobUri)
blob_report_msg, file_report_msg = get_status_to_report(status, result, error_msg, None)
status_report_to_file(file_report_msg)
status_report_to_blob(blob_report_msg)
sys.exit(0)
def exit_if_same_taskId(taskId):
global backup_logger,hutil,para_parser
trans_report_msg = None
taskIdentity = TaskIdentity()
last_taskId = taskIdentity.stored_identity()
if(taskId == last_taskId):
backup_logger.log("TaskId is same as last, so skip with Processed Status, current:" + str(taskId) + "== last:" + str(last_taskId), True)
status=CommonVariables.status_success
hutil.SetExtErrorCode(ExtensionErrorCodeHelper.ExtensionErrorCodeEnum.SuccessAlreadyProcessedInput)
status_code=CommonVariables.SuccessAlreadyProcessedInput
message='TaskId AlreadyProcessed nothing to do'
try:
if(para_parser is not None):
blob_report_msg, file_report_msg = hutil.do_status_report(operation='Enable',status=status,\
status_code=str(status_code),\
message=message,\
taskId=taskId,\
commandStartTimeUTCTicks=para_parser.commandStartTimeUTCTicks,\
snapshot_info=None)
status_report_to_file(file_report_msg)
except Exception as e:
err_msg='cannot write status to the status file, Exception %s, stack trace: %s' % (str(e), traceback.format_exc())
backup_logger.log(err_msg, True, 'Warning')
sys.exit(0)
def convert_time(utcTicks):
return datetime.datetime(1, 1, 1) + datetime.timedelta(microseconds = utcTicks / 10)
def freeze_snapshot(timeout):
try:
global hutil,backup_logger,run_result,run_status,error_msg,freezer,freeze_result,para_parser,snapshot_info_array,g_fsfreeze_on
if(hutil.get_value_from_configfile('doseq') == '2'):
hutil.set_value_to_configfile('doseq', '1')
if(hutil.get_value_from_configfile('doseq') != '1'):
hutil.set_value_to_configfile('doseq', '2')
freeze_snap_shotter = FreezeSnapshotter(backup_logger, hutil, freezer, g_fsfreeze_on, para_parser)
backup_logger.log("Calling do snapshot method", True, 'Info')
run_result, run_status, snapshot_info_array = freeze_snap_shotter.doFreezeSnapshot()
except Exception as e:
if(hutil.get_value_from_configfile('doseq') == '2'):
hutil.set_value_to_configfile('doseq', '0')
errMsg = 'Failed to do the snapshot with error: %s, stack trace: %s' % (str(e), traceback.format_exc())
backup_logger.log(errMsg, True, 'Error')
run_result = CommonVariables.error
run_status = 'error'
error_msg = 'Enable failed with exception in safe freeze or snapshot '
hutil.SetExtErrorCode(ExtensionErrorCodeHelper.ExtensionErrorCodeEnum.error)
#snapshot_done = True
def check_snapshot_array_fail():
global snapshot_info_array, backup_logger
snapshot_array_fail = False
if snapshot_info_array is not None and snapshot_info_array !=[]:
for snapshot_index in range(len(snapshot_info_array)):
if(snapshot_info_array[snapshot_index].isSuccessful == False):
backup_logger.log('T:S snapshot failed at index ' + str(snapshot_index), True)
snapshot_array_fail = True
break
return snapshot_array_fail
def daemon():
global MyPatching,backup_logger,hutil,run_result,run_status,error_msg,freezer,para_parser,snapshot_done,snapshot_info_array,g_fsfreeze_on,total_used_size
#this is using the most recent file timestamp.
hutil.do_parse_context('Executing')
freezer = FsFreezer(patching= MyPatching, logger = backup_logger)
global_error_result = None
# precheck
freeze_called = False
configfile='/etc/azure/vmbackup.conf'
thread_timeout=str(60)
#Adding python version to the telemetry
try:
python_version_info = sys.version_info
python_version = str(sys.version_info[0])+ '.' + str(sys.version_info[1]) + '.' + str(sys.version_info[2])
HandlerUtil.HandlerUtility.add_to_telemetery_data("pythonVersion", python_version)
except Exception as e:
errMsg = 'Failed to do retrieve python version with error: %s, stack trace: %s' % (str(e), traceback.format_exc())
backup_logger.log(errMsg, True, 'Error')
try:
if(freezer.mounts is not None):
hutil.partitioncount = len(freezer.mounts.mounts)
backup_logger.log(" configfile " + str(configfile), True)
config = ConfigParsers.ConfigParser()
config.read(configfile)
if config.has_option('SnapshotThread','timeout'):
thread_timeout= config.get('SnapshotThread','timeout')
except Exception as e:
errMsg='cannot read config file or file not present'
backup_logger.log(errMsg, True, 'Warning')
backup_logger.log("final thread timeout" + thread_timeout, True)
snapshot_info_array = None
try:
# we need to freeze the file system first
backup_logger.log('starting daemon', True)
"""
protectedSettings is the privateConfig passed from Powershell.
WATCHOUT that, the _context_config are using the most freshest timestamp.
if the time sync is alive, this should be right.
"""
if(hutil.is_prev_in_transition()):
backup_logger.log('retrieving the previous logs for this again inside daemon', True)
backup_logger.set_prev_log()
protected_settings = hutil._context._config['runtimeSettings'][0]['handlerSettings'].get('protectedSettings')
public_settings = hutil._context._config['runtimeSettings'][0]['handlerSettings'].get('publicSettings')
para_parser = ParameterParser(protected_settings, public_settings)
commandToExecute = para_parser.commandToExecute
#validate all the required parameter here
backup_logger.log(commandToExecute,True)
if(CommonVariables.iaas_install_command in commandToExecute.lower()):
backup_logger.log('install succeed.',True)
run_status = 'success'
error_msg = 'Install Succeeded'
run_result = CommonVariables.success
backup_logger.log(error_msg)
elif(CommonVariables.iaas_vmbackup_command in commandToExecute.lower()):
if(para_parser.backup_metadata is None or para_parser.public_config_obj is None or para_parser.private_config_obj is None):
run_result = CommonVariables.error_parameter
hutil.SetExtErrorCode(ExtensionErrorCodeHelper.ExtensionErrorCodeEnum.error_parameter)
run_status = 'error'
error_msg = 'required field empty or not correct'
backup_logger.log(error_msg, True, 'Error')
else:
backup_logger.log('commandToExecute is ' + commandToExecute, True)
"""
make sure the log is not doing when the file system is freezed.
"""
temp_status= 'success'
temp_result=CommonVariables.ExtensionTempTerminalState
temp_msg='Transitioning state in extension'
blob_report_msg, file_report_msg = get_status_to_report(temp_status, temp_result, temp_msg, None)
if(hutil.is_status_file_exists()):
status_report_to_file(file_report_msg)
status_report_to_blob(blob_report_msg)
#partial logging before freeze
if(para_parser is not None and para_parser.logsBlobUri is not None and para_parser.logsBlobUri != ""):
backup_logger.commit_to_blob(para_parser.logsBlobUri)
else:
backup_logger.log("the logs blob uri is not there, so do not upload log.")
backup_logger.log('commandToExecute is ' + commandToExecute, True)
PluginHostObj = PluginHost(logger=backup_logger)
PluginHostErrorCode,dobackup,g_fsfreeze_on = PluginHostObj.pre_check()
doFsConsistentbackup = False
appconsistentBackup = False
if not (PluginHostErrorCode == CommonVariables.FailedPrepostPluginhostConfigParsing or
PluginHostErrorCode == CommonVariables.FailedPrepostPluginConfigParsing or
PluginHostErrorCode == CommonVariables.FailedPrepostPluginhostConfigNotFound or
PluginHostErrorCode == CommonVariables.FailedPrepostPluginhostConfigPermissionError or
PluginHostErrorCode == CommonVariables.FailedPrepostPluginConfigNotFound):
backup_logger.log('App Consistent Consistent Backup Enabled', True)
HandlerUtil.HandlerUtility.add_to_telemetery_data("isPrePostEnabled", "true")
appconsistentBackup = True
if(PluginHostErrorCode != CommonVariables.PrePost_PluginStatus_Success):
backup_logger.log('Triggering File System Consistent Backup because of error code' + ExtensionErrorCodeHelper.ExtensionErrorCodeHelper.StatusCodeStringBuilder(PluginHostErrorCode), True)
doFsConsistentbackup = True
preResult = PluginHostResult()
postResult = PluginHostResult()
if not doFsConsistentbackup:
preResult = PluginHostObj.pre_script()
dobackup = preResult.continueBackup
if(g_fsfreeze_on == False and preResult.anyScriptFailed):
dobackup = False
if dobackup:
freeze_snapshot(thread_timeout)
if not doFsConsistentbackup:
postResult = PluginHostObj.post_script()
if not postResult.continueBackup:
dobackup = False
if(g_fsfreeze_on == False and postResult.anyScriptFailed):
dobackup = False
if not dobackup:
if run_result == CommonVariables.success and PluginHostErrorCode != CommonVariables.PrePost_PluginStatus_Success:
run_status = 'error'
run_result = PluginHostErrorCode
hutil.SetExtErrorCode(PluginHostErrorCode)
error_msg = 'Plugin Host Precheck Failed'
error_msg = error_msg + ExtensionErrorCodeHelper.ExtensionErrorCodeHelper.StatusCodeStringBuilder(hutil.ExtErrorCode)
backup_logger.log(error_msg, True)
if run_result == CommonVariables.success:
pre_plugin_errors = preResult.errors
for error in pre_plugin_errors:
if error.errorCode != CommonVariables.PrePost_PluginStatus_Success:
run_status = 'error'
run_result = error.errorCode
hutil.SetExtErrorCode(error.errorCode)
error_msg = 'PreScript failed for the plugin ' + error.pluginName
error_msg = error_msg + ExtensionErrorCodeHelper.ExtensionErrorCodeHelper.StatusCodeStringBuilder(hutil.ExtErrorCode)
backup_logger.log(error_msg, True)
break
if run_result == CommonVariables.success:
post_plugin_errors = postResult.errors
for error in post_plugin_errors:
if error.errorCode != CommonVariables.PrePost_PluginStatus_Success:
run_status = 'error'
run_result = error.errorCode
hutil.SetExtErrorCode(error.errorCode)
error_msg = 'PostScript failed for the plugin ' + error.pluginName
error_msg = error_msg + ExtensionErrorCodeHelper.ExtensionErrorCodeHelper.StatusCodeStringBuilder(hutil.ExtErrorCode)
backup_logger.log(error_msg, True)
break
if appconsistentBackup:
if(PluginHostErrorCode != CommonVariables.PrePost_PluginStatus_Success):
hutil.SetExtErrorCode(PluginHostErrorCode)
pre_plugin_errors = preResult.errors
for error in pre_plugin_errors:
if error.errorCode != CommonVariables.PrePost_PluginStatus_Success:
hutil.SetExtErrorCode(error.errorCode)
post_plugin_errors = postResult.errors
for error in post_plugin_errors:
if error.errorCode != CommonVariables.PrePost_PluginStatus_Success:
hutil.SetExtErrorCode(error.errorCode)
if run_result == CommonVariables.success and not doFsConsistentbackup and not (preResult.anyScriptFailed or postResult.anyScriptFailed):
run_status = 'success'
run_result = CommonVariables.success_appconsistent
hutil.SetExtErrorCode(ExtensionErrorCodeHelper.ExtensionErrorCodeEnum.success_appconsistent)
error_msg = 'Enable Succeeded with App Consistent Snapshot'
backup_logger.log(error_msg, True)
else:
run_status = 'error'
run_result = CommonVariables.error_parameter
hutil.SetExtErrorCode(ExtensionErrorCodeHelper.ExtensionErrorCodeEnum.error_parameter)
error_msg = 'command is not correct'
backup_logger.log(error_msg, True, 'Error')
except Exception as e:
errMsg = 'Failed to enable the extension with error: %s, stack trace: %s' % (str(e), traceback.format_exc())
backup_logger.log(errMsg, True, 'Error')
global_error_result = e
"""
we do the final report here to get rid of the complex logic to handle the logging when file system be freezed issue.
"""
try:
if(global_error_result is not None):
if(hasattr(global_error_result,'errno') and global_error_result.errno == 2):
run_result = CommonVariables.error_12
hutil.SetExtErrorCode(ExtensionErrorCodeHelper.ExtensionErrorCodeEnum.error_12)
elif(para_parser is None):
run_result = CommonVariables.error_parameter
hutil.SetExtErrorCode(ExtensionErrorCodeHelper.ExtensionErrorCodeEnum.error_parameter)
else:
run_result = CommonVariables.error
hutil.SetExtErrorCode(ExtensionErrorCodeHelper.ExtensionErrorCodeEnum.error)
run_status = 'error'
error_msg += ('Enable failed.' + str(global_error_result))
status_report_msg = None
HandlerUtil.HandlerUtility.add_to_telemetery_data("extErrorCode", str(ExtensionErrorCodeHelper.ExtensionErrorCodeHelper.ExtensionErrorCodeNameDict[hutil.ExtErrorCode]))
total_used_size = -1
blob_report_msg, file_report_msg = get_status_to_report(run_status,run_result,error_msg, snapshot_info_array)
if(hutil.is_status_file_exists()):
status_report_to_file(file_report_msg)
status_report_to_blob(blob_report_msg)
except Exception as e:
errMsg = 'Failed to log status in extension'
backup_logger.log(errMsg, True, 'Error')
if(para_parser is not None and para_parser.logsBlobUri is not None and para_parser.logsBlobUri != ""):
backup_logger.commit(para_parser.logsBlobUri)
else:
backup_logger.log("the logs blob uri is not there, so do not upload log.")
backup_logger.commit_to_local()
sys.exit(0)
def uninstall():
hutil.do_parse_context('Uninstall')
hutil.do_exit(0,'Uninstall','success','0', 'Uninstall succeeded')
def disable():
hutil.do_parse_context('Disable')
hutil.do_exit(0,'Disable','success','0', 'Disable Succeeded')
def update():
hutil.do_parse_context('Upadate')
hutil.do_exit(0,'Update','success','0', 'Update Succeeded')
def enable():
global backup_logger,hutil,error_msg,para_parser
hutil.do_parse_context('Enable')
try:
backup_logger.log('starting to enable', True)
# handle the restoring scenario.
mi = MachineIdentity()
stored_identity = mi.stored_identity()
if(stored_identity is None):
mi.save_identity()
else:
current_identity = mi.current_identity()
if(current_identity != stored_identity):
current_seq_no = -1
backup_logger.log("machine identity not same, set current_seq_no to " + str(current_seq_no) + " " + str(stored_identity) + " " + str(current_identity), True)
hutil.set_last_seq(current_seq_no)
mi.save_identity()
hutil.exit_if_same_seq()
"""
protectedSettings is the privateConfig passed from Powershell.
WATCHOUT that, the _context_config are using the most freshest timestamp.
if the time sync is alive, this should be right.
"""
protected_settings = hutil._context._config['runtimeSettings'][0]['handlerSettings'].get('protectedSettings')
public_settings = hutil._context._config['runtimeSettings'][0]['handlerSettings'].get('publicSettings')
para_parser = ParameterParser(protected_settings, public_settings)
if(bool(public_settings) and not protected_settings): #Protected settings decryption failed case
error_msg = "unable to load certificate"
hutil.SetExtErrorCode(ExtensionErrorCodeHelper.ExtensionErrorCodeEnum.FailedHandlerGuestAgentCertificateNotFound)
temp_result=CommonVariables.FailedHandlerGuestAgentCertificateNotFound
temp_status= 'error'
exit_with_commit_log(temp_status, temp_result,error_msg, para_parser)
if(para_parser.commandStartTimeUTCTicks is not None and para_parser.commandStartTimeUTCTicks != ""):
utcTicksLong = int(para_parser.commandStartTimeUTCTicks)
backup_logger.log('utcTicks in long format' + str(utcTicksLong), True)
commandStartTime = convert_time(utcTicksLong)
utcNow = datetime.datetime.utcnow()
backup_logger.log('command start time is ' + str(commandStartTime) + " and utcNow is " + str(utcNow), True)
timespan = utcNow - commandStartTime
MAX_TIMESPAN = 150 * 60 # in seconds
# handle the machine identity for the restoration scenario.
total_span_in_seconds = timedelta_total_seconds(timespan)
backup_logger.log('timespan is ' + str(timespan) + ' ' + str(total_span_in_seconds))
if(para_parser.taskId is not None and para_parser.taskId != ""):
backup_logger.log('taskId: ' + str(para_parser.taskId), True)
exit_if_same_taskId(para_parser.taskId)
taskIdentity = TaskIdentity()
taskIdentity.save_identity(para_parser.taskId)
hutil.save_seq()
temp_status= 'transitioning'
temp_result=CommonVariables.success
temp_msg='Transitioning state in enable'
blob_report_msg, file_report_msg = get_status_to_report(temp_status, temp_result, temp_msg, None)
file_status_upload_thread=Thread(target=status_report_to_file, args=(file_report_msg,))
file_status_upload_thread.start()
blob_status_upload_thread=Thread(target=status_report_to_blob, args=(blob_report_msg,))
blob_status_upload_thread.start()
if(hutil.is_prev_in_transition()):
backup_logger.log('retrieving the previous logs for this', True)
backup_logger.set_prev_log()
if(para_parser is not None and para_parser.logsBlobUri is not None and para_parser.logsBlobUri != ""):
log_upload_thread=Thread(target=thread_for_log_upload)
log_upload_thread.start()
log_upload_thread.join(60)
file_status_upload_thread.join(30)
blob_status_upload_thread.join(60)
start_daemon();
sys.exit(0)
except Exception as e:
errMsg = 'Failed to call the daemon with error: %s, stack trace: %s' % (str(e), traceback.format_exc())
backup_logger.log(errMsg, True, 'Error')
global_error_result = e
temp_status= 'error'
temp_result=CommonVariables.error
hutil.SetExtErrorCode(ExtensionErrorCodeHelper.ExtensionErrorCodeEnum.error)
error_msg = 'Failed to call the daemon'
exit_with_commit_log(temp_status, temp_result,error_msg, para_parser)
def thread_for_log_upload():
global para_parser,backup_logger
backup_logger.commit(para_parser.logsBlobUri)
def start_daemon():
args = [os.path.join(os.getcwd(), "main/handle.sh"), "daemon"]
backup_logger.log("start_daemon with args: {0}".format(args), True)
#This process will start a new background process by calling
# handle.py -daemon
#to run the script and will exit itself immediatelly.
#Redirect stdout and stderr to /dev/null. Otherwise daemon process will
#throw Broke pipe exeception when parent process exit.
devnull = open(os.devnull, 'w')
child = subprocess.Popen(args, stdout=devnull, stderr=devnull)
if __name__ == '__main__' :
main()
| apache-2.0 | 1,799,172,088,873,042,700 | 49.344144 | 206 | 0.642318 | false |
michimussato/pypelyne2 | pypelyne2/src/parser/tests/test_parse_outputs.py | 1 | 1455 | import unittest
import pypelyne2.src.parser.parse_outputs as parse_outputs
import pypelyne2.src.modules.output.output as output
class ParseOutputsTester(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.output_objects = parse_outputs.get_outputs()
def test_get_outputs(self):
""" Test checks if the outputs are output objects """
for output_object in self.output_objects:
self.assertIsInstance(output_object, output.Output)
def test_abbreviation(self):
""" Test checks if the output object has this method """
self.assertTrue('abbreviation' in dir(self.output_objects[0]))
def test_color(self):
""" Test checks if the output object has this method """
self.assertTrue('color' in dir(self.output_objects[0]))
def test_formats(self):
""" Test checks if the output object has this method """
self.assertTrue('_formats' in dir(self.output_objects[0]))
def test_icon(self):
""" Test checks if the output object has this method """
self.assertTrue('icon' in dir(self.output_objects[0]))
def test_output(self):
""" Test checks if the output object has this method """
self.assertTrue('output' in dir(self.output_objects[0]))
def test_output_enable(self):
""" Test checks if the output object has this method """
self.assertTrue('output_enable' in dir(self.output_objects[0]))
| gpl-2.0 | -5,201,670,322,074,896,000 | 36.307692 | 71 | 0.666667 | false |
kinnou02/navitia | source/jormungandr/jormungandr/street_network/tests/streetnetwork_backend_manager_test.py | 1 | 16126 | # Copyright (c) 2001-2016, Canal TP and/or its affiliates. All rights reserved.
#
# This file is part of Navitia,
# the software to build cool stuff with public transport.
#
# Hope you'll enjoy and contribute to this project,
# powered by Canal TP (www.canaltp.fr).
# Help us simplify mobility and open public transport:
# a non ending quest to the responsive locomotion way of traveling!
#
# LICENCE: This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU Affero 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 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/>.
#
# Stay tuned using
# twitter @navitia
# channel `#navitia` on riot https://riot.im/app/#/room/#navitia:matrix.org
# https://groups.google.com/d/forum/navitia
# www.navitia.io
from __future__ import absolute_import
import pytest
from jormungandr.instance import Instance
from jormungandr.street_network.streetnetwork_backend_manager import StreetNetworkBackendManager
from navitiacommon.models.streetnetwork_backend import StreetNetworkBackend
from jormungandr.street_network.kraken import Kraken
from jormungandr.street_network.valhalla import Valhalla
from jormungandr.exceptions import ConfigException, TechnicalError
import datetime
KRAKEN_CLASS = 'jormungandr.street_network.kraken.Kraken'
VALHALLA_CLASS = 'jormungandr.street_network.valhalla.Valhalla'
ALL_MODES = ['walking', 'bike', 'bss', 'car']
def _init_and_create_backend_without_default(conf):
sn_manager = StreetNetworkBackendManager()
sn_manager._create_street_network_backends("instance", conf)
return sn_manager.get_all_street_networks_legacy("instance")
def kraken_class_test():
kraken_conf = [{'modes': ALL_MODES, 'class': KRAKEN_CLASS}]
services = _init_and_create_backend_without_default(kraken_conf)
assert len(services) == 1
assert isinstance(services[0], Kraken)
def kraken_klass_test():
kraken_conf = [{'modes': ALL_MODES, 'klass': KRAKEN_CLASS}]
services = _init_and_create_backend_without_default(kraken_conf)
assert len(services) == 1
assert isinstance(services[0], Kraken)
def valhalla_class_without_url_test():
with pytest.raises(ValueError) as excinfo:
valhalla_without_url = [{'modes': ALL_MODES, 'class': VALHALLA_CLASS}]
_init_and_create_backend_without_default(valhalla_without_url)
assert 'service_url None is not a valid url' in str(excinfo.value)
def valhalla_class_wit_empty_url_test():
with pytest.raises(ValueError) as excinfo:
kraken_conf = [{'modes': ALL_MODES, 'class': VALHALLA_CLASS, 'args': {"service_url": ""}}]
_init_and_create_backend_without_default(kraken_conf)
assert 'service_url is not a valid url' in str(excinfo.value)
def valhalla_class_with_invalid_url_test():
with pytest.raises(ValueError) as excinfo:
kraken_conf = [{'modes': ALL_MODES, 'class': VALHALLA_CLASS, 'args': {"service_url": "bob"}}]
_init_and_create_backend_without_default(kraken_conf)
assert 'service_url bob is not a valid url' in str(excinfo.value)
def valhalla_class_without_costing_options_test():
kraken_conf = [
{'modes': ALL_MODES, 'class': VALHALLA_CLASS, 'args': {"service_url": "http://localhost:8002"}}
]
services = _init_and_create_backend_without_default(kraken_conf)
assert len(services) == 1
assert isinstance(services[0], Valhalla)
def valhalla_class_with_empty_costing_options_test():
kraken_conf = [
{
'modes': ALL_MODES,
'class': VALHALLA_CLASS,
'args': {"service_url": "http://localhost:8002", "costing_options": {}},
}
]
services = _init_and_create_backend_without_default(kraken_conf)
assert len(services) == 1
assert isinstance(services[0], Valhalla)
def valhalla_class_with_url_valid_test():
kraken_conf = [
{
'modes': ALL_MODES,
'class': VALHALLA_CLASS,
'args': {
"service_url": "http://localhost:8002",
"costing_options": {"pedestrian": {"walking_speed": 50.1}},
},
}
]
services = _init_and_create_backend_without_default(kraken_conf)
assert len(services) == 1
assert isinstance(services[0], Valhalla)
def street_network_without_class_test():
with pytest.raises(KeyError) as excinfo:
kraken_conf = [
{
'modes': ['walking'],
'args': {
"service_url": "http://localhost:8002",
"costing_options": {"pedestrian": {"walking_speed": 50.1}},
},
}
]
_init_and_create_backend_without_default(kraken_conf)
assert (
'impossible to build a StreetNetwork, missing mandatory field in configuration: class or klass'
in str(excinfo.value)
)
def valhalla_class_with_class_invalid_test():
with pytest.raises(ConfigException) as excinfo:
kraken_conf = [
{
'class': 'jormungandr',
'modes': ['walking'],
'args': {
"service_url": "http://localhost:8002",
"costing_options": {"pedestrian": {"walking_speed": 50.1}},
},
}
]
_init_and_create_backend_without_default(kraken_conf)
def valhalla_class_with_class_not_exist_test():
with pytest.raises(ConfigException) as excinfo:
kraken_conf = [
{
'class': 'jormungandr.street_network.valhalla.bob',
'modes': ['walking'],
'args': {
"service_url": "http://localhost:8002",
"costing_options": {"pedestrian": {"walking_speed": 50.1}},
},
}
]
_init_and_create_backend_without_default(kraken_conf)
def sn_backends_getter_ok():
sn_backend1 = StreetNetworkBackend(id='kraken')
sn_backend1.klass = 'jormungandr.street_network.tests.StreetNetworkBackendMock'
sn_backend1.args = {'url': 'kraken.url'}
sn_backend1.created_at = datetime.datetime.utcnow()
sn_backend2 = StreetNetworkBackend(id='asgard')
sn_backend2.klass = 'jormungandr.street_network.tests.StreetNetworkBackendMock'
sn_backend2.args = {'url': 'asgard.url'}
return [sn_backend1, sn_backend2]
def sn_backends_getter_update():
sn_backend = StreetNetworkBackend(id='kraken')
sn_backend.klass = 'jormungandr.street_network.tests.StreetNetworkBackendMock'
sn_backend.args = {'url': 'kraken.url.UPDATE'}
sn_backend.updated_at = datetime.datetime.utcnow()
return [sn_backend]
def sn_backends_getter_wrong_class():
sn_backend = StreetNetworkBackend(id='kraken')
sn_backend.klass = 'jormungandr/street_network/tests/StreetNetworkBackendMock'
sn_backend.args = {'url': 'kraken.url'}
return [sn_backend]
def streetnetwork_backend_manager_db_test():
"""
Test that streetnetwork backends are created from db when conditions are met
"""
manager = StreetNetworkBackendManager(sn_backends_getter_ok, -1)
# 2 sn_backends defined in db are associated to the coverage
# -> 2 sn_backends created
manager._update_config("instance")
assert not manager._streetnetwork_backends_by_instance_legacy
assert len(manager._streetnetwork_backends) == 2
assert 'kraken' in manager._streetnetwork_backends
assert manager._streetnetwork_backends['kraken'].url == 'kraken.url'
assert 'asgard' in manager._streetnetwork_backends
assert manager._streetnetwork_backends['asgard'].url == 'asgard.url'
manager_update = manager._last_update
assert 'kraken' in manager._streetnetwork_backends_last_update
kraken_update = manager._streetnetwork_backends_last_update['kraken']
# Sn_backend already existing is updated
manager._sn_backends_getter = sn_backends_getter_update
manager._update_config("instance")
assert manager._last_update > manager_update
assert not manager._streetnetwork_backends_by_instance_legacy
assert len(manager._streetnetwork_backends) == 2
assert 'kraken' in manager._streetnetwork_backends
assert manager._streetnetwork_backends['kraken'].url == 'kraken.url.UPDATE'
assert 'kraken' in manager._streetnetwork_backends_last_update
assert manager._streetnetwork_backends_last_update['kraken'] > kraken_update
# Long update interval so sn_backend shouldn't be updated
manager = StreetNetworkBackendManager(sn_backends_getter_ok, 600)
manager._update_config("instance")
assert not manager._streetnetwork_backends_by_instance_legacy
assert len(manager._streetnetwork_backends) == 2
assert 'kraken' in manager._streetnetwork_backends
assert manager._streetnetwork_backends['kraken'].url == 'kraken.url'
manager_update = manager._last_update
manager.sn_backends_getter = sn_backends_getter_update
manager._update_config("instance")
assert manager._last_update == manager_update
assert not manager._streetnetwork_backends_by_instance_legacy
assert len(manager._streetnetwork_backends) == 2
assert 'kraken' in manager._streetnetwork_backends
assert manager._streetnetwork_backends['kraken'].url == 'kraken.url'
def wrong_streetnetwork_backend_test():
"""
Test that streetnetwork backends with wrong parameters aren't created
"""
# Sn_backend has a class wrongly formatted
manager = StreetNetworkBackendManager(sn_backends_getter_wrong_class, -1)
manager._update_config("instance")
assert not manager._streetnetwork_backends_by_instance_legacy
assert not manager._streetnetwork_backends
# No sn_backends available in db
manager._sn_backends_getter = []
manager._update_config("instance")
assert not manager._streetnetwork_backends_by_instance_legacy
assert not manager._streetnetwork_backends
def append_default_street_network_to_config_test():
manager = StreetNetworkBackendManager(sn_backends_getter=None, update_interval=-1)
# Kraken is used for all the modes.
config_full_default = [
{
'args': {
'street_network': {
'args': {'timeout': 10},
'class': 'jormungandr.street_network.Kraken',
'modes': [],
}
},
'class': 'jormungandr.street_network.Taxi',
'modes': ['taxi'],
},
{
'args': {
'street_network': {
'args': {'timeout': 10},
'class': 'jormungandr.street_network.Kraken',
'modes': [],
}
},
'class': 'jormungandr.street_network.Ridesharing',
'modes': ['ridesharing'],
},
{
'args': {'timeout': 10},
'class': 'jormungandr.street_network.Kraken',
'modes': ['car', 'walking', 'bike', 'bss'],
},
]
response = manager._append_default_street_network_to_config(None)
assert response == config_full_default
# Asgard is used for car, Kraken for all the other modes.
config_car_asgard = [{'class': 'jormungandr.street_network.Asgard', 'modes': ['car']}]
response = manager._append_default_street_network_to_config(config_car_asgard)
config_asgard_plus_default = [
{'class': 'jormungandr.street_network.Asgard', 'modes': ['car']},
{
'args': {
'street_network': {
'args': {'timeout': 10},
'class': 'jormungandr.street_network.Kraken',
'modes': [],
}
},
'class': 'jormungandr.street_network.Taxi',
'modes': ['taxi'],
},
{
'args': {
'street_network': {
'args': {'timeout': 10},
'class': 'jormungandr.street_network.Kraken',
'modes': [],
}
},
'class': 'jormungandr.street_network.Ridesharing',
'modes': ['ridesharing'],
},
{
'args': {'timeout': 10},
'class': 'jormungandr.street_network.Kraken',
'modes': ['walking', 'bike', 'bss'],
},
]
assert response == config_asgard_plus_default
# Surf is used for surf, Kraken for all the other modes.
# Surf stay in the config but is not used.
wrong_config = [{'class': 'jormungandr.street_network.Surf', 'modes': ['surf']}]
response = manager._append_default_street_network_to_config(wrong_config)
wrong_plus_default_config = [
{'class': 'jormungandr.street_network.Surf', 'modes': ['surf']},
{
'args': {
'street_network': {
'args': {'timeout': 10},
'class': 'jormungandr.street_network.Kraken',
'modes': [],
}
},
'class': 'jormungandr.street_network.Taxi',
'modes': ['taxi'],
},
{
'args': {
'street_network': {
'args': {'timeout': 10},
'class': 'jormungandr.street_network.Kraken',
'modes': [],
}
},
'class': 'jormungandr.street_network.Ridesharing',
'modes': ['ridesharing'],
},
{
'args': {'timeout': 10},
'class': 'jormungandr.street_network.Kraken',
'modes': ['car', 'walking', 'bike', 'bss'],
},
]
assert response == wrong_plus_default_config
def get_street_network_db_test():
manager = StreetNetworkBackendManager(sn_backends_getter_ok, -1)
sn = manager.get_street_network_db("instance", "kraken")
assert sn is not None
assert sn.timeout == 2
assert sn.url == 'kraken.url'
sn = manager.get_street_network_db("instance", "asgard")
assert sn is not None
assert sn.timeout == 2
assert sn.url == 'asgard.url'
with pytest.raises(TechnicalError) as excinfo:
sn = manager.get_street_network_db("instance", "plopi")
assert (
str(excinfo.value.data['message'])
== 'impossible to find a streetnetwork module for instance instance with configuration plopi'
)
assert 'TechnicalError' == str(excinfo.typename)
class FakeInstance(Instance):
street_network_car = "asgard"
street_network_walking = "asgard"
street_network_bike = "geovelo"
street_network_bss = "kraken"
street_network_taxi = None
street_network_ridesharing = None
def __init__(self):
super(FakeInstance, self).__init__(
context=None,
name="instance",
zmq_socket=None,
street_network_configurations=[],
ridesharing_configurations=None,
realtime_proxies_configuration=[],
zmq_socket_type=None,
autocomplete_type='kraken',
instance_equipment_providers=[],
streetnetwork_backend_manager=None,
)
def get_all_street_networks_db_test():
manager = StreetNetworkBackendManager(sn_backends_getter_ok, -1)
instance = FakeInstance()
all_sn = manager.get_all_street_networks_db(instance)
assert len(all_sn) == 2
# So that Asgard and kraken are always in the same order
all_sn_sorted = sorted(all_sn, key=lambda sn: sn.url)
assert all_sn_sorted[0].url == "asgard.url"
assert sorted(all_sn_sorted[0].modes) == sorted(["walking", "car"])
assert all_sn_sorted[1].url == "kraken.url"
assert all_sn_sorted[1].modes == ["bss"]
| agpl-3.0 | -8,971,987,324,433,375,000 | 35.817352 | 103 | 0.622163 | false |
ddico/odoo | addons/fleet/models/fleet_vehicle_cost.py | 1 | 9422 | # -*- coding: utf-8 -*-
# Part of Odoo. See LICENSE file for full copyright and licensing details.
from odoo import api, fields, models, _
from odoo.exceptions import UserError
from dateutil.relativedelta import relativedelta
class FleetVehicleLogContract(models.Model):
_inherit = ['mail.thread', 'mail.activity.mixin']
_name = 'fleet.vehicle.log.contract'
_description = 'Contract information on a vehicle'
_order = 'state desc,expiration_date'
def compute_next_year_date(self, strdate):
oneyear = relativedelta(years=1)
start_date = fields.Date.from_string(strdate)
return fields.Date.to_string(start_date + oneyear)
vehicle_id = fields.Many2one('fleet.vehicle', 'Vehicle', default=1, required=True, help='Vehicle concerned by this log')
cost_subtype_id = fields.Many2one('fleet.service.type', 'Type', help='Cost type purchased with this cost', domain=[('category', '=', 'contract')])
amount = fields.Float('Cost')
date = fields.Date(help='Date when the cost has been executed')
company_id = fields.Many2one('res.company', 'Company', default=lambda self: self.env.company)
currency_id = fields.Many2one('res.currency', related='company_id.currency_id')
name = fields.Char(string='Name', compute='_compute_contract_name', store=True)
active = fields.Boolean(default=True)
user_id = fields.Many2one('res.users', 'Responsible', default=lambda self: self.env.user, index=True)
start_date = fields.Date('Contract Start Date', default=fields.Date.context_today,
help='Date when the coverage of the contract begins')
expiration_date = fields.Date('Contract Expiration Date', default=lambda self:
self.compute_next_year_date(fields.Date.context_today(self)),
help='Date when the coverage of the contract expirates (by default, one year after begin date)')
days_left = fields.Integer(compute='_compute_days_left', string='Warning Date')
insurer_id = fields.Many2one('res.partner', 'Vendor')
purchaser_id = fields.Many2one(related='vehicle_id.driver_id', string='Driver')
ins_ref = fields.Char('Reference', size=64, copy=False)
state = fields.Selection([
('futur', 'Incoming'),
('open', 'In Progress'),
('expired', 'Expired'),
('closed', 'Closed')
], 'Status', default='open', readonly=True,
help='Choose whether the contract is still valid or not',
tracking=True,
copy=False)
notes = fields.Text('Terms and Conditions', help='Write here all supplementary information relative to this contract', copy=False)
cost_generated = fields.Float('Recurring Cost')
cost_frequency = fields.Selection([
('no', 'No'),
('daily', 'Daily'),
('weekly', 'Weekly'),
('monthly', 'Monthly'),
('yearly', 'Yearly')
], 'Recurring Cost Frequency', default='monthly', help='Frequency of the recuring cost', required=True)
service_ids = fields.Many2many('fleet.service.type', string="Included Services")
@api.depends('vehicle_id', 'cost_subtype_id')
def _compute_contract_name(self):
for record in self:
name = record.vehicle_id.name
if record.cost_subtype_id.name:
name = record.cost_subtype_id.name + ' ' + name
record.name = name
@api.depends('expiration_date', 'state')
def _compute_days_left(self):
"""return a dict with as value for each contract an integer
if contract is in an open state and is overdue, return 0
if contract is in a closed state, return -1
otherwise return the number of days before the contract expires
"""
for record in self:
if record.expiration_date and record.state in ['open', 'expired']:
today = fields.Date.from_string(fields.Date.today())
renew_date = fields.Date.from_string(record.expiration_date)
diff_time = (renew_date - today).days
record.days_left = diff_time > 0 and diff_time or 0
else:
record.days_left = -1
def write(self, vals):
res = super(FleetVehicleLogContract, self).write(vals)
if vals.get('expiration_date') or vals.get('user_id'):
self.activity_reschedule(['fleet.mail_act_fleet_contract_to_renew'], date_deadline=vals.get('expiration_date'), new_user_id=vals.get('user_id'))
return res
def contract_close(self):
for record in self:
record.state = 'closed'
def contract_draft(self):
for record in self:
record.state = 'futur'
def contract_open(self):
for record in self:
record.state = 'open'
@api.model
def scheduler_manage_contract_expiration(self):
# This method is called by a cron task
# It manages the state of a contract, possibly by posting a message on the vehicle concerned and updating its status
params = self.env['ir.config_parameter'].sudo()
delay_alert_contract = int(params.get_param('hr_fleet.delay_alert_contract', default=30))
date_today = fields.Date.from_string(fields.Date.today())
outdated_days = fields.Date.to_string(date_today + relativedelta(days=+delay_alert_contract))
nearly_expired_contracts = self.search([('state', '=', 'open'), ('expiration_date', '<', outdated_days)])
for contract in nearly_expired_contracts.filtered(lambda contract: contract.user_id):
contract.activity_schedule(
'fleet.mail_act_fleet_contract_to_renew', contract.expiration_date,
user_id=contract.user_id.id)
expired_contracts = self.search([('state', 'not in', ['expired', 'closed']), ('expiration_date', '<',fields.Date.today() )])
expired_contracts.write({'state': 'expired'})
futur_contracts = self.search([('state', 'not in', ['futur', 'closed']), ('start_date', '>', fields.Date.today())])
futur_contracts.write({'state': 'futur'})
now_running_contracts = self.search([('state', '=', 'futur'), ('start_date', '<=', fields.Date.today())])
now_running_contracts.write({'state': 'open'})
def run_scheduler(self):
self.scheduler_manage_contract_expiration()
class FleetVehicleLogServices(models.Model):
_name = 'fleet.vehicle.log.services'
_inherit = ['mail.thread', 'mail.activity.mixin']
_rec_name = 'service_type_id'
_description = 'Services for vehicles'
@api.model
def default_get(self, default_fields):
res = super(FleetVehicleLogServices, self).default_get(default_fields)
service = self.env.ref('fleet.type_service_service_8', raise_if_not_found=False)
res.update({
'date': fields.Date.context_today(self),
'service_type_id': service.id if service else None,
})
return res
active = fields.Boolean(default=True)
vehicle_id = fields.Many2one('fleet.vehicle', 'Vehicle', default=1, required=True, help='Vehicle concerned by this log')
amount = fields.Float('Cost')
description = fields.Char('Description')
odometer_id = fields.Many2one('fleet.vehicle.odometer', 'Odometer', help='Odometer measure of the vehicle at the moment of this log')
odometer = fields.Float(compute="_get_odometer", inverse='_set_odometer', string='Odometer Value',
help='Odometer measure of the vehicle at the moment of this log')
odometer_unit = fields.Selection(related='vehicle_id.odometer_unit', string="Unit", readonly=True)
date = fields.Date(help='Date when the cost has been executed')
company_id = fields.Many2one('res.company', 'Company', default=lambda self: self.env.company)
currency_id = fields.Many2one('res.currency', related='company_id.currency_id')
purchaser_id = fields.Many2one(related='vehicle_id.driver_id', string="Driver")
inv_ref = fields.Char('Vendor Reference')
vendor_id = fields.Many2one('res.partner', 'Vendor')
notes = fields.Text()
service_type_id = fields.Many2one('fleet.service.type', 'Service Type', required=True)
state = fields.Selection([
('todo', 'To Do'),
('running', 'Running'),
('done', 'Done'),
('cancelled', 'Cancelled'),
], default='todo', string='Stage')
def _get_odometer(self):
self.odometer = 0
for record in self:
if record.odometer_id:
record.odometer = record.odometer_id.value
def _set_odometer(self):
for record in self:
if not record.odometer:
raise UserError(_('Emptying the odometer value of a vehicle is not allowed.'))
odometer = self.env['fleet.vehicle.odometer'].create({
'value': record.odometer,
'date': record.date or fields.Date.context_today(record),
'vehicle_id': record.vehicle_id.id
})
self.odometer_id = odometer
@api.model_create_multi
def create(self, vals_list):
for data in vals_list:
if 'odometer' in data and not data['odometer']:
# if received value for odometer is 0, then remove it from the
# data as it would result to the creation of a
# odometer log with 0, which is to be avoided
del data['odometer']
return super(FleetVehicleLogServices, self).create(vals_list) | agpl-3.0 | 1,315,773,969,023,667,500 | 48.335079 | 156 | 0.641159 | false |
bird-house/bird-feeder | birdfeeder/walker.py | 1 | 5030 | import os
from netCDF4 import Dataset as NCDataset
from dateutil import parser as dateparser
from datetime import datetime
from birdfeeder.utils import humanize_filesize
import logging
logger = logging.getLogger(__name__)
SPATIAL_VARIABLES = [
'longitude', 'lon',
'latitude', 'lat',
'altitude', 'alt', 'level', 'height',
'rotated_pole',
'rotated_latitude_longitude',
'time']
class Dataset(object):
def __init__(self, filepath, basedir='/'):
self.filepath = filepath
self.path = os.path.sep + os.path.relpath(filepath, basedir)
self.bytes = os.path.getsize(filepath)
self.size = humanize_filesize(self.bytes)
self.name = os.path.basename(filepath)
self.url = 'file://' + filepath
self.content_type = 'application/netcdf'
self.resourcename = filepath
self._last_modified = None
self.attributes = {}
self._parse(filepath)
def __str__(self):
return "attributes={0}".format(self.attributes)
@property
def last_modified(self):
if self._last_modified is None:
mtime = os.path.getmtime(self.filepath)
self._last_modified = datetime.fromtimestamp(mtime).strftime('%Y-%m-%dT%H:%M:%SZ')
return self._last_modified
@property
def variable(self):
return self.attributes.get('variable')
@property
def variable_long_name(self):
return self.attributes.get('variable_long_name')
@property
def cf_standard_name(self):
return self.attributes.get('cf_standard_name')
@property
def units(self):
return self.attributes.get('units')
@property
def comments(self):
return self.attributes.get('comments')
@property
def institute(self):
return self.attributes.get('institute_id')
@property
def experiment(self):
return self.attributes.get('experiment_id')
@property
def project(self):
return self.attributes.get('project_id')
@property
def model(self):
return self.attributes.get('model_id')
@property
def frequency(self):
return self.attributes.get('frequency')
@property
def creation_date(self):
if 'creation_date' in self.attributes:
return self.attributes['creation_date'][0]
else:
return None
def _add_attribute(self, key, value):
if not key in self.attributes:
self.attributes[key] = []
self.attributes[key].append(value)
def _parse(self, filepath):
filepath = os.path.abspath(filepath)
logger.debug("parse %s", filepath)
try:
ds = NCDataset(filepath, 'r')
# loop over global attributes
for attname in ds.ncattrs():
attvalue = getattr(ds, attname)
if 'date' in attname.lower():
# must format dates in Solr format, if possible
try:
solr_dt = dateparser.parse(attvalue)
self._add_attribute(attname, solr_dt.strftime('%Y-%m-%dT%H:%M:%SZ') )
except:
pass # disregard this attribute
else:
self._add_attribute(attname, attvalue)
# loop over dimensions
for key, dim in ds.dimensions.items():
self._add_attribute('dimension', "%s:%s" % (key, len(dim)) )
# loop over variable attributes
for key, variable in ds.variables.items():
if key.lower() in ds.dimensions:
# skip dimension variables
continue
if '_bnds' in key.lower():
continue
if key.lower() in SPATIAL_VARIABLES:
continue
self._add_attribute('variable', key)
self._add_attribute('variable_long_name', getattr(variable, 'long_name', None) )
cf_standard_name = getattr(variable, 'standard_name', None)
if cf_standard_name is not None:
self._add_attribute('cf_standard_name', getattr(variable, 'standard_name', None) )
self._add_attribute('units', getattr(variable, 'units', None) )
except Exception as e:
logging.error(e)
finally:
try:
ds.close()
except:
pass
def crawl(start_dir):
if not os.path.isdir(start_dir):
raise Exception("Invalid start directory: %s", start_dir)
logger.info('start directory = %s', start_dir)
for directory, subdirs, files in os.walk(start_dir):
# loop over files in this directory
for filename in files:
# only parse .nc files
if filename.endswith('.nc'):
filepath = os.path.join(directory, filename)
yield Dataset(filepath, basedir=start_dir)
| apache-2.0 | -8,682,199,717,071,598,000 | 28.763314 | 102 | 0.56501 | false |
dvcolgan/ludumdare27 | game/management/commands/generate_map_pngs.py | 1 | 2676 | from django.core.management.base import BaseCommand, CommandError
from game.models import *
from settings import MIN_COL, MAX_COL, MIN_ROW, MAX_ROW, GRID_SIZE
from PIL import Image
from PIL import ImageDraw
def hex_to_rgb(value):
value = value.lstrip('#')
lv = len(value)
if lv == 1:
v = int(value, 16)*17
return v, v, v
if lv == 3:
return tuple(int(value[i:i+1], 16)*17 for i in range(0, 3))
return tuple(int(value[i:i+lv/3], 16) for i in range(0, lv, lv/3))
class Command(BaseCommand):
args = ''
help = 'Generate pngs of the board for zooming'
def handle(self, *args, **options):
squares = Square.objects.order_by('row', 'col')
width = (20 + MAX_COL - MIN_COL) * GRID_SIZE
height = (20 + MAX_ROW - MIN_ROW) * GRID_SIZE
im = Image.new('RGB', (width, height), 'black')
#http://effbot.org/imagingbook/imagedraw.htm
draw = ImageDraw.Draw(im)
for square in squares:
if square.owner != None:
fill_color = square.owner.color
else:
fill_color = '#ffffff'
x1 = square.col*GRID_SIZE+width/2
y1 = square.row*GRID_SIZE+height/2
x2 = square.col*GRID_SIZE+GRID_SIZE+width/2
y2 = square.row*GRID_SIZE+GRID_SIZE+height/2
draw.rectangle(((x1, y1), (x2, y2)), fill=fill_color)
for i, unit in enumerate(square.units.all()):
if i == 0:
ax1 = x1 + GRID_SIZE/4 - GRID_SIZE/8
ay1 = y1 + GRID_SIZE/4 - GRID_SIZE/8
ax2 = x1 + GRID_SIZE/4 + GRID_SIZE/8
ay2 = y1 + GRID_SIZE/4 + GRID_SIZE/8
if i == 1:
ax1 = x1 + 3*GRID_SIZE/4 - GRID_SIZE/8
ay1 = y1 + 3*GRID_SIZE/4 - GRID_SIZE/8
ax2 = x1 + GRID_SIZE/4 + GRID_SIZE/8
ay2 = y1 + GRID_SIZE/4 + GRID_SIZE/8
if i == 2:
ax1 = x1 + 3*GRID_SIZE/4 - GRID_SIZE/8
ay1 = y1 + 3*GRID_SIZE/4 - GRID_SIZE/8
ax2 = x1 + 3*GRID_SIZE/4 + GRID_SIZE/8
ay2 = y1 + 3*GRID_SIZE/4 + GRID_SIZE/8
if i == 3:
ax1 = x1 + GRID_SIZE/4 - GRID_SIZE/8
ay1 = y1 + GRID_SIZE/4 - GRID_SIZE/8
ax2 = x1 + 3*GRID_SIZE/4 + GRID_SIZE/8
ay2 = y1 + 3*GRID_SIZE/4 + GRID_SIZE/8
draw.ellipse(((ax1, ay1, ax2, ay2)), outline='#000000', fill=unit.owner.color)
im.save('static/images/minimap.png', 'PNG')
print 'Saved full image'
| mit | -4,220,150,537,329,599,500 | 36.690141 | 94 | 0.501495 | false |
petr-kalinin/progrobot | tools/import_python3.py | 1 | 9519 | #!/usr/bin/python3
from pymongo import MongoClient
import os
import os.path
import re
import bs4
import itertools
from bs4 import BeautifulSoup
import utils
class ReferenceItem:
def __init__(self):
self.name = ""
self.module = ""
self.usage = ""
self.short = ""
self.full = ""
self.fullest = ""
self.href = ""
self.copyright = ""
self.subitems = []
def __str__(self):
return ("name: " + self.name + "\n"
+ "href: " + self.href + "\n"
+ "module: " + str(self.module) + "\n"
+ "usage: " + str(self.usage) + "\n"
+ "short: " + self.short + "\n\n"
#+ "full: " + self.full + "\n\n"
#+ "fullest: " + self.fullest + "\n\n"
+ "subitems: " + str(self.subitems)
+ "copyright: " + self.copyright)
def to_dict(self):
return {"name" : self.name,
"href": self.href,
"module" : self.module,
"usage" : self.usage,
"short" : self.short,
"full" : self.full,
"fullest" : self.fullest,
"subitems" : self.subitems,
"copyright": self.copyright}
def hasclass(tag, classes):
for cl in tag.get("class", []):
if cl in classes:
return True
return False
def create_ref(refs, name, module, base_href):
if not name in refs:
refs[name] = ReferenceItem()
refs[name].name = name
if module:
refs[name].module = "import " + module
refs[name].href = base_href + "#" + name
refs[name].copyright = "ⓒ Python developers, " + refs[name].href
parent = ".".join(name.split(".")[:-1])
if parent != "" and parent[0] == "@":
parent = parent[1:]
if not parent in refs:
refs[parent] = ReferenceItem()
subitem = (name, "")
if not subitem in refs[parent].subitems:
refs[parent].subitems.append(subitem)
def can_be_short(text):
#print("Testing string `" + text + "`")
if re.match("New in version", text):
return False
if re.match("Source code:", text):
return False
return True
def next_tag(tag):
while not tag.next_sibling and tag.parent:
tag = tag.parent
if tag.next_sibling:
return tag.next_sibling
else:
return None
def parse_file(filename, refs):
base_href = "https://docs.python.org/" + filename[2:]
soup = BeautifulSoup(open(filename), 'lxml')
module_a = soup.h1.a
if not "headerlink" in module_a.get("class"):
module = module_a.string
else:
module = None
#print("found module", module)
currentName = module
if currentName:
create_ref(refs, currentName, module, base_href)
tag = soup.h1.next_sibling
while tag is not None:
#print("Tag: `", tag, "`")
if isinstance(tag, bs4.element.Comment):
tag = tag.next_element
continue
if isinstance(tag, bs4.element.NavigableString):
text = tag.strip()
if text != "" and currentName:
if refs[currentName].short == "":
if can_be_short(text):
refs[currentName].short = text
refs[currentName].full += text
tag = tag.next_element
continue
#if currentName:
# print(currentName, tag.name, "`"+refs[currentName].full+"`", "\n\n")
if hasclass(tag, ["sphinxsidebar"]):
break
elif hasclass(tag, ["section", "seealso"]):
currentName = None
tag = tag.next_element
elif hasclass(tag, ['class', 'classmethod', 'method', 'function', 'data', 'exception', 'attribute', 'staticmethod', 'cmdoption']):
currentName = tag.dt.get('id')
usage = "".join(tag.dt.strings).strip()
if currentName and usage[0] == "@":
currentName = "@" + currentName
if currentName:
create_ref(refs, currentName, module, base_href)
refs[currentName].usage = usage[:-1].strip()
tag = tag.dd.next_element
elif tag.name in ('p', 'pre', 'code', 'li', 'dt', 'dd', 'tr', 'td', 'th'):
if (tag.name == 'p'
and len(tag.contents) == 1
and isinstance(tag.contents[0], bs4.element.Tag)
and tag.contents[0].name=="strong"):
currentName = None
if currentName:
if refs[currentName].short == "":
text = "".join(tag.strings)
if can_be_short(text):
refs[currentName].short = "".join(str(x) for x in tag.contents)
refs[currentName].full += str(tag)
tag = next_tag(tag)
if not tag:
break
else:
tag = tag.next_element
return refs
def insert_ref(ref, reference, index):
result = reference.insert_one(ref.to_dict())
#print("insert: ", ref.to_dict())
names = [ref.name]
for name in names:
split_name = name.strip('@ ').split(".")
if len(split_name) > 3:
print(split_name," --- ", ref.name)
for i in range(len(split_name)):
perm = [x.lower() for x in split_name[i:]]
subname = " ".join(sorted(perm))
doc = {
"reference_id" : result.inserted_id,
"name" : subname,
"relevance" : 1-i/len(split_name),
"full_name" : ref.name
}
#print("index: ", doc)
index.insert_one(doc)
def process_file(filename, refs):
print("\n-----------\n" + filename)
print(".", end="", flush=True)
parse_file(filename, refs)
def finalize(refs):
for ref_name, ref in refs.items():
if ref.name == "":
ref.name = ref_name
new_subitems = []
for item in ref.subitems:
new_subitems.append((item[0], utils.first_sentence(refs[item[0]].short)))
ref.subitems = new_subitems
os.chdir("../raw_data/python3/docs.python.org")
client = MongoClient()
client.drop_database("python3")
db = client.python3
reference = db.reference
index = db.index
index.create_index("name")
refs = {}
for directory, subdirs, files in os.walk("."):
for f in files:
process_file(os.path.join(directory, f), refs)
#process_file("3/library/itertools.html", refs)
#process_file("3/library/re.html", refs)
#process_file("3/library/json.html", refs)
#process_file("3/library/pprint.html", refs)
#process_file("3/library/unittest.html", refs)
#process_file("3/library/ctypes.html", refs)
finalize(refs)
#print(refs['datetime.datetime'].subitems)
for ref in refs.values():
if ref.name != "":
#print(ref)
#print("\n")
insert_ref(ref, reference, index)
#------- Testing
def assert_starts_with(text, start):
if not text.startswith(start):
print("Text `" + text + "` does not start with `" + start + "`")
raise AssertionError()
def assert_ends_with(text, start):
if not text.endswith(start):
print("Text `" + text + "` does not end with `" + start + "`")
raise AssertionError()
def find_subitem(ref, subitem):
found = None
for item in ref.subitems:
if item[0] == subitem:
assert not found
found = item
return found
def check_urllib_parse():
assert_starts_with(refs["urllib.parse"].short, "This module")
item = find_subitem(refs["urllib"], "urllib.parse")
assert_starts_with(item[1], "This module")
assert_ends_with(item[1], "“base URL.”")
def check_unittest_mock():
assert_starts_with(refs["unittest.mock"].short, '<a class="reference internal"')
item = find_subitem(refs["unittest"], "unittest.mock")
assert_starts_with(item[1], '<a class="reference internal"')
def check_urllib():
assert_ends_with(refs["urllib"].full, "files</li>")
def check_re():
assert len(refs["re"].subitems) > 0
assert "re.match" in refs
assert refs["re"].subitems[0][0] == "re.compile"
assert_ends_with(refs["re"].subitems[0][1], "described below.")
assert len(refs["re"].subitems[0][1].strip()) > 0
def check_unittest():
assert_ends_with(refs["unittest"].full, "executing the tests.</dd>")
def check_unittest_skip():
assert "@unittest.skip" in refs
assert find_subitem(refs["unittest"], "@unittest.skip")
def check_utcnow():
assert "datetime.datetime.utcnow" in refs
assert find_subitem(refs["datetime.datetime"], "datetime.datetime.utcnow")
def check_pprint():
assert "pprint.pprint" in refs
assert_ends_with(refs["pprint.pprint"].full, "</pre>")
def check_itertools():
assert_ends_with(refs['itertools'].full, 'vector2))</span></code>.</p>')
def check_ctypes():
assert "ctypes.Array._length_" in refs
assert find_subitem(refs["ctypes.Array"], "ctypes.Array._length_")
def check_paragraph_signs():
found = False
for ref in refs:
if "¶" in refs[ref].full:
print("¶ found in ", ref)
found = True
assert not found
check_paragraph_signs()
check_ctypes()
check_itertools()
check_re()
check_pprint()
check_utcnow()
check_urllib_parse()
check_unittest_mock()
check_urllib()
check_unittest()
check_unittest_skip()
| agpl-3.0 | 1,616,040,906,343,496,200 | 30.916107 | 138 | 0.551887 | false |
arunkgupta/gramps | gramps/gen/filters/rules/person/_haslds.py | 1 | 1723 | #
# Gramps - a GTK+/GNOME based genealogy program
#
# Copyright (C) 2008 Brian G. Matherly
# Copyright (C) 2008 Jerome Rapinat
# Copyright (C) 2008 Benny Malengier
#
# 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, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# gen.filters.rules/Person/_HasLDS.py
# $Id$
#
#-------------------------------------------------------------------------
#
# Standard Python modules
#
#-------------------------------------------------------------------------
from ....ggettext import gettext as _
#-------------------------------------------------------------------------
#
# GRAMPS modules
#
#-------------------------------------------------------------------------
from .._hasldsbase import HasLDSBase
#-------------------------------------------------------------------------
#
# HasLDS
#
#-------------------------------------------------------------------------
class HasLDS(HasLDSBase):
"""Rule that checks for a person with a LDS event"""
name = _('People with <count> LDS events')
description = _("Matches people with a certain number of LDS events")
| gpl-2.0 | 813,847,480,302,232,000 | 33.46 | 75 | 0.536274 | false |
vitobasso/audio-ml | src/train_raw.py | 1 | 2372 | __author__ = 'victor'
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers import RPropMinusTrainer
from pybrain import FeedForwardNetwork, FullConnection, IdentityConnection, TanhLayer
from datasource import *
# dataset
timeWidth = 5140 # num of samples to input to the net
mixer = MixedStream('piano', 'acapella', timeWidth)
# training
batchsize = 100
epochs = 1000
def build_net(width):
net = FeedForwardNetwork()
# layers
net.addInputModule(TanhLayer(width, name='in'))
net.addOutputModule(TanhLayer(width, name='out'))
net.addModule(TanhLayer(100, name='h1'))
net.addModule(TanhLayer(50, name='h2'))
net.addModule(TanhLayer(100, name='h3'))
# connections
net.addConnection(FullConnection(net['in'], net['h1']))
net.addConnection(FullConnection(net['h1'], net['h2']))
# net.addConnection(FullConnection(net['h1'], net['h3']))
# net.addConnection(FullConnection(net['h1'], net['out']))
net.addConnection(FullConnection(net['h2'], net['h3']))
# net.addConnection(FullConnection(net['h2'], net['out']))
net.addConnection(FullConnection(net['h3'], net['out']))
net.addConnection(IdentityConnection(net['in'], net['out']))
net.sortModules()
return net
def train(mix, target):
print 'preparing to train, netwidth=%d, batchsize=%d, epochs=%d' % (timeWidth, batchsize, epochs)
net = build_net(timeWidth)
trainer = RPropMinusTrainer(net, batchlearning=True, learningrate=0.1, lrdecay=1, momentum=0.03, weightdecay=0.01)
def train_batch(i):
batch = SupervisedDataSet(timeWidth, timeWidth)
begin = i * batchsize
end = begin + batchsize
for i in np.arange(begin, end):
batch.addSample(mix[i], target[i])
trainer.setData(batch)
err = trainer.train()
return err
print 'training...'
plot_cont(train_batch, epochs)
# print 'saving net...'
# err = trainer.train() # train an extra time just to get the final error
# savenet(trainer.module, partlen, err)
return net
def test(net, mix):
print 'testing...'
result = np.empty(timeWidth)
for i in np.arange(500):
netout = net.activate(mix[i])
result = np.append(result, netout, axis=0)
wavwrite(result, outputfile='output.wav')
net = train(mixer, mixer.stream1)
test(net, mixer) | gpl-2.0 | -8,458,553,163,728,513,000 | 28.296296 | 118 | 0.670742 | false |
NCAR/mizuRoute | manage_externals/test/test_unit_repository_git.py | 1 | 31259 | #!/usr/bin/env python
"""Unit test driver for checkout_externals
Note: this script assume the path to the checkout_externals.py module is
already in the python path.
"""
# pylint: disable=too-many-lines,protected-access
from __future__ import absolute_import
from __future__ import unicode_literals
from __future__ import print_function
import os
import shutil
import unittest
from manic.repository_git import GitRepository
from manic.externals_status import ExternalStatus
from manic.externals_description import ExternalsDescription
from manic.externals_description import ExternalsDescriptionDict
from manic.global_constants import EMPTY_STR
# NOTE(bja, 2017-11) order is important here. origin should be a
# subset of other to trap errors on processing remotes!
GIT_REMOTE_OUTPUT_ORIGIN_UPSTREAM = '''
upstream /path/to/other/repo (fetch)
upstream /path/to/other/repo (push)
other /path/to/local/repo2 (fetch)
other /path/to/local/repo2 (push)
origin /path/to/local/repo (fetch)
origin /path/to/local/repo (push)
'''
class TestGitRepositoryCurrentRef(unittest.TestCase):
"""test the current_ref command on a git repository
"""
def setUp(self):
self._name = 'component'
rdata = {ExternalsDescription.PROTOCOL: 'git',
ExternalsDescription.REPO_URL:
'/path/to/local/repo',
ExternalsDescription.TAG:
'tag1',
}
data = {self._name:
{
ExternalsDescription.REQUIRED: False,
ExternalsDescription.PATH: 'junk',
ExternalsDescription.EXTERNALS: EMPTY_STR,
ExternalsDescription.REPO: rdata,
},
}
model = ExternalsDescriptionDict(data)
repo = model[self._name][ExternalsDescription.REPO]
self._repo = GitRepository('test', repo)
#
# mock methods replacing git system calls
#
@staticmethod
def _git_current_branch(branch_found, branch_name):
"""Return a function that takes the place of
repo._git_current_branch, which returns the given output."""
def my_git_current_branch():
"""mock function that can take the place of repo._git_current_branch"""
return branch_found, branch_name
return my_git_current_branch
@staticmethod
def _git_current_tag(tag_found, tag_name):
"""Return a function that takes the place of
repo._git_current_tag, which returns the given output."""
def my_git_current_tag():
"""mock function that can take the place of repo._git_current_tag"""
return tag_found, tag_name
return my_git_current_tag
@staticmethod
def _git_current_hash(hash_found, hash_name):
"""Return a function that takes the place of
repo._git_current_hash, which returns the given output."""
def my_git_current_hash():
"""mock function that can take the place of repo._git_current_hash"""
return hash_found, hash_name
return my_git_current_hash
# ------------------------------------------------------------------------
# Begin tests
# ------------------------------------------------------------------------
def test_ref_branch(self):
"""Test that we correctly identify we are on a branch
"""
self._repo._git_current_branch = self._git_current_branch(
True, 'feature3')
self._repo._git_current_tag = self._git_current_tag(True, 'foo_tag')
self._repo._git_current_hash = self._git_current_hash(True, 'abc123')
expected = 'feature3'
result = self._repo._current_ref()
self.assertEqual(result, expected)
def test_ref_detached_tag(self):
"""Test that we correctly identify that the ref is detached at a tag
"""
self._repo._git_current_branch = self._git_current_branch(False, '')
self._repo._git_current_tag = self._git_current_tag(True, 'foo_tag')
self._repo._git_current_hash = self._git_current_hash(True, 'abc123')
expected = 'foo_tag'
result = self._repo._current_ref()
self.assertEqual(result, expected)
def test_ref_detached_hash(self):
"""Test that we can identify ref is detached at a hash
"""
self._repo._git_current_branch = self._git_current_branch(False, '')
self._repo._git_current_tag = self._git_current_tag(False, '')
self._repo._git_current_hash = self._git_current_hash(True, 'abc123')
expected = 'abc123'
result = self._repo._current_ref()
self.assertEqual(result, expected)
def test_ref_none(self):
"""Test that we correctly identify that we're not in a git repo.
"""
self._repo._git_current_branch = self._git_current_branch(False, '')
self._repo._git_current_tag = self._git_current_tag(False, '')
self._repo._git_current_hash = self._git_current_hash(False, '')
result = self._repo._current_ref()
self.assertEqual(result, EMPTY_STR)
class TestGitRepositoryCheckSync(unittest.TestCase):
"""Test whether the GitRepository _check_sync_logic functionality is
correct.
Note: there are a lot of combinations of state:
- external description - tag, branch
- working copy
- doesn't exist (not checked out)
- exists, no git info - incorrect protocol, e.g. svn, or tarball?
- exists, git info
- as expected:
- different from expected:
- detached tag,
- detached hash,
- detached branch (compare remote and branch),
- tracking branch (compare remote and branch),
- same remote
- different remote
- untracked branch
Test list:
- doesn't exist
- exists no git info
- num_external * (working copy expected + num_working copy different)
- total tests = 16
"""
# NOTE(bja, 2017-11) pylint complains about long method names, but
# it is hard to differentiate tests without making them more
# cryptic. Also complains about too many public methods, but it
# doesn't really make sense to break this up.
# pylint: disable=invalid-name,too-many-public-methods
TMP_FAKE_DIR = 'fake'
TMP_FAKE_GIT_DIR = os.path.join(TMP_FAKE_DIR, '.git')
def setUp(self):
"""Setup reusable git repository object
"""
self._name = 'component'
rdata = {ExternalsDescription.PROTOCOL: 'git',
ExternalsDescription.REPO_URL:
'/path/to/local/repo',
ExternalsDescription.TAG: 'tag1',
}
data = {self._name:
{
ExternalsDescription.REQUIRED: False,
ExternalsDescription.PATH: self.TMP_FAKE_DIR,
ExternalsDescription.EXTERNALS: EMPTY_STR,
ExternalsDescription.REPO: rdata,
},
}
model = ExternalsDescriptionDict(data)
repo = model[self._name][ExternalsDescription.REPO]
self._repo = GitRepository('test', repo)
# The unit tests here don't care about the result of
# _current_ref, but we replace it here so that we don't need to
# worry about calling a possibly slow and possibly
# error-producing command (since _current_ref calls various git
# functions):
self._repo._current_ref = self._current_ref_empty
self._create_tmp_git_dir()
def tearDown(self):
"""Cleanup tmp stuff on the file system
"""
self._remove_tmp_git_dir()
def _create_tmp_git_dir(self):
"""Create a temporary fake git directory for testing purposes.
"""
if not os.path.exists(self.TMP_FAKE_GIT_DIR):
os.makedirs(self.TMP_FAKE_GIT_DIR)
def _remove_tmp_git_dir(self):
"""Remove the temporary fake git directory
"""
if os.path.exists(self.TMP_FAKE_DIR):
shutil.rmtree(self.TMP_FAKE_DIR)
#
# mock methods replacing git system calls
#
@staticmethod
def _current_ref_empty():
"""Return an empty string.
"""
return EMPTY_STR
@staticmethod
def _git_remote_origin_upstream():
"""Return an info string that is a checkout hash
"""
return GIT_REMOTE_OUTPUT_ORIGIN_UPSTREAM
@staticmethod
def _git_remote_none():
"""Return an info string that is a checkout hash
"""
return EMPTY_STR
@staticmethod
def _git_current_hash(myhash):
"""Return a function that takes the place of repo._git_current_hash,
which returns the given hash
"""
def my_git_current_hash():
"""mock function that can take the place of repo._git_current_hash"""
return 0, myhash
return my_git_current_hash
def _git_revparse_commit(self, expected_ref, mystatus, myhash):
"""Return a function that takes the place of
repo._git_revparse_commit, which returns a tuple:
(mystatus, myhash).
Expects the passed-in ref to equal expected_ref
status = 0 implies success, non-zero implies failure
"""
def my_git_revparse_commit(ref):
"""mock function that can take the place of repo._git_revparse_commit"""
self.assertEqual(expected_ref, ref)
return mystatus, myhash
return my_git_revparse_commit
# ----------------------------------------------------------------
#
# Tests where working copy doesn't exist or is invalid
#
# ----------------------------------------------------------------
def test_sync_dir_not_exist(self):
"""Test that a directory that doesn't exist returns an error status
Note: the Repository classes should be prevented from ever
working on an empty directory by the _Source object.
"""
stat = ExternalStatus()
self._repo._check_sync(stat, 'invalid_directory_name')
self.assertEqual(stat.sync_state, ExternalStatus.STATUS_ERROR)
# check_dir should only modify the sync_state, not clean_state
self.assertEqual(stat.clean_state, ExternalStatus.DEFAULT)
def test_sync_dir_exist_no_git_info(self):
"""Test that a non-existent git repo returns an unknown status
"""
stat = ExternalStatus()
# Now we over-ride the _git_remote_verbose method on the repo to return
# a known value without requiring access to git.
self._repo._git_remote_verbose = self._git_remote_origin_upstream
self._repo._tag = 'tag1'
self._repo._git_current_hash = self._git_current_hash('')
self._repo._git_revparse_commit = self._git_revparse_commit(
'tag1', 1, '')
self._repo._check_sync(stat, self.TMP_FAKE_DIR)
self.assertEqual(stat.sync_state, ExternalStatus.UNKNOWN)
# check_sync should only modify the sync_state, not clean_state
self.assertEqual(stat.clean_state, ExternalStatus.DEFAULT)
# ------------------------------------------------------------------------
#
# Tests where version in configuration file is not a valid reference
#
# ------------------------------------------------------------------------
def test_sync_invalid_reference(self):
"""Test that an invalid reference returns out-of-sync
"""
stat = ExternalStatus()
self._repo._git_remote_verbose = self._git_remote_origin_upstream
self._repo._tag = 'tag1'
self._repo._git_current_hash = self._git_current_hash('abc123')
self._repo._git_revparse_commit = self._git_revparse_commit(
'tag1', 1, '')
self._repo._check_sync_logic(stat, self.TMP_FAKE_DIR)
self.assertEqual(stat.sync_state, ExternalStatus.MODEL_MODIFIED)
# check_sync should only modify the sync_state, not clean_state
self.assertEqual(stat.clean_state, ExternalStatus.DEFAULT)
# ----------------------------------------------------------------
#
# Tests where external description specifies a tag
#
# ----------------------------------------------------------------
def test_sync_tag_on_same_hash(self):
"""Test expect tag on same hash --> status ok
"""
stat = ExternalStatus()
self._repo._git_remote_verbose = self._git_remote_origin_upstream
self._repo._tag = 'tag1'
self._repo._git_current_hash = self._git_current_hash('abc123')
self._repo._git_revparse_commit = self._git_revparse_commit(
'tag1', 0, 'abc123')
self._repo._check_sync_logic(stat, self.TMP_FAKE_DIR)
self.assertEqual(stat.sync_state, ExternalStatus.STATUS_OK)
# check_sync should only modify the sync_state, not clean_state
self.assertEqual(stat.clean_state, ExternalStatus.DEFAULT)
def test_sync_tag_on_different_hash(self):
"""Test expect tag on a different hash --> status modified
"""
stat = ExternalStatus()
self._repo._git_remote_verbose = self._git_remote_origin_upstream
self._repo._tag = 'tag1'
self._repo._git_current_hash = self._git_current_hash('def456')
self._repo._git_revparse_commit = self._git_revparse_commit(
'tag1', 0, 'abc123')
self._repo._check_sync_logic(stat, self.TMP_FAKE_DIR)
self.assertEqual(stat.sync_state, ExternalStatus.MODEL_MODIFIED)
# check_sync should only modify the sync_state, not clean_state
self.assertEqual(stat.clean_state, ExternalStatus.DEFAULT)
# ----------------------------------------------------------------
#
# Tests where external description specifies a hash
#
# ----------------------------------------------------------------
def test_sync_hash_on_same_hash(self):
"""Test expect hash on same hash --> status ok
"""
stat = ExternalStatus()
self._repo._git_remote_verbose = self._git_remote_origin_upstream
self._repo._tag = ''
self._repo._hash = 'abc'
self._repo._git_current_hash = self._git_current_hash('abc123')
self._repo._git_revparse_commit = self._git_revparse_commit(
'abc', 0, 'abc123')
self._repo._check_sync_logic(stat, self.TMP_FAKE_DIR)
self.assertEqual(stat.sync_state, ExternalStatus.STATUS_OK)
# check_sync should only modify the sync_state, not clean_state
self.assertEqual(stat.clean_state, ExternalStatus.DEFAULT)
def test_sync_hash_on_different_hash(self):
"""Test expect hash on a different hash --> status modified
"""
stat = ExternalStatus()
self._repo._git_remote_verbose = self._git_remote_origin_upstream
self._repo._tag = ''
self._repo._hash = 'abc'
self._repo._git_current_hash = self._git_current_hash('def456')
self._repo._git_revparse_commit = self._git_revparse_commit(
'abc', 0, 'abc123')
self._repo._check_sync_logic(stat, self.TMP_FAKE_DIR)
self.assertEqual(stat.sync_state, ExternalStatus.MODEL_MODIFIED)
# check_sync should only modify the sync_state, not clean_state
self.assertEqual(stat.clean_state, ExternalStatus.DEFAULT)
# ----------------------------------------------------------------
#
# Tests where external description specifies a branch
#
# ----------------------------------------------------------------
def test_sync_branch_on_same_hash(self):
"""Test expect branch on same hash --> status ok
"""
stat = ExternalStatus()
self._repo._git_remote_verbose = self._git_remote_origin_upstream
self._repo._branch = 'feature-2'
self._repo._tag = ''
self._repo._git_current_hash = self._git_current_hash('abc123')
self._repo._git_revparse_commit = (
self._git_revparse_commit('origin/feature-2', 0, 'abc123'))
self._repo._check_sync_logic(stat, self.TMP_FAKE_DIR)
self.assertEqual(stat.sync_state, ExternalStatus.STATUS_OK)
# check_sync should only modify the sync_state, not clean_state
self.assertEqual(stat.clean_state, ExternalStatus.DEFAULT)
def test_sync_branch_on_diff_hash(self):
"""Test expect branch on diff hash --> status modified
"""
stat = ExternalStatus()
self._repo._git_remote_verbose = self._git_remote_origin_upstream
self._repo._branch = 'feature-2'
self._repo._tag = ''
self._repo._git_current_hash = self._git_current_hash('abc123')
self._repo._git_revparse_commit = (
self._git_revparse_commit('origin/feature-2', 0, 'def456'))
self._repo._check_sync_logic(stat, self.TMP_FAKE_DIR)
self.assertEqual(stat.sync_state, ExternalStatus.MODEL_MODIFIED)
# check_sync should only modify the sync_state, not clean_state
self.assertEqual(stat.clean_state, ExternalStatus.DEFAULT)
def test_sync_branch_diff_remote(self):
"""Test _determine_remote_name with a different remote
"""
stat = ExternalStatus()
self._repo._git_remote_verbose = self._git_remote_origin_upstream
self._repo._branch = 'feature-2'
self._repo._tag = ''
self._repo._url = '/path/to/other/repo'
self._repo._git_current_hash = self._git_current_hash('abc123')
self._repo._git_revparse_commit = (
self._git_revparse_commit('upstream/feature-2', 0, 'def456'))
self._repo._check_sync_logic(stat, self.TMP_FAKE_DIR)
# The test passes if _git_revparse_commit is called with the
# expected argument
def test_sync_branch_diff_remote2(self):
"""Test _determine_remote_name with a different remote
"""
stat = ExternalStatus()
self._repo._git_remote_verbose = self._git_remote_origin_upstream
self._repo._branch = 'feature-2'
self._repo._tag = ''
self._repo._url = '/path/to/local/repo2'
self._repo._git_current_hash = self._git_current_hash('abc123')
self._repo._git_revparse_commit = (
self._git_revparse_commit('other/feature-2', 0, 'def789'))
self._repo._check_sync_logic(stat, self.TMP_FAKE_DIR)
# The test passes if _git_revparse_commit is called with the
# expected argument
def test_sync_branch_on_unknown_remote(self):
"""Test expect branch, but remote is unknown --> status modified
"""
stat = ExternalStatus()
self._repo._git_remote_verbose = self._git_remote_origin_upstream
self._repo._branch = 'feature-2'
self._repo._tag = ''
self._repo._url = '/path/to/unknown/repo'
self._repo._git_current_hash = self._git_current_hash('abc123')
self._repo._git_revparse_commit = (
self._git_revparse_commit('unknown_remote/feature-2', 1, ''))
self._repo._check_sync_logic(stat, self.TMP_FAKE_DIR)
self.assertEqual(stat.sync_state, ExternalStatus.MODEL_MODIFIED)
# check_sync should only modify the sync_state, not clean_state
self.assertEqual(stat.clean_state, ExternalStatus.DEFAULT)
def test_sync_branch_on_untracked_local(self):
"""Test expect branch, on untracked branch in local repo --> status ok
Setting the externals description to '.' indicates that the
user only wants to consider the current local repo state
without fetching from remotes. This is required to preserve
the current branch of a repository during an update.
"""
stat = ExternalStatus()
self._repo._git_remote_verbose = self._git_remote_origin_upstream
self._repo._branch = 'feature3'
self._repo._tag = ''
self._repo._url = '.'
self._repo._git_current_hash = self._git_current_hash('abc123')
self._repo._git_revparse_commit = (
self._git_revparse_commit('feature3', 0, 'abc123'))
self._repo._check_sync_logic(stat, self.TMP_FAKE_DIR)
self.assertEqual(stat.sync_state, ExternalStatus.STATUS_OK)
# check_sync should only modify the sync_state, not clean_state
self.assertEqual(stat.clean_state, ExternalStatus.DEFAULT)
class TestGitStatusPorcelain(unittest.TestCase):
"""Test parsing of output from git status --porcelain=v1 -z
"""
# pylint: disable=C0103
GIT_STATUS_PORCELAIN_V1_ALL = (
r' D INSTALL\0MM Makefile\0M README.md\0R cmakelists.txt\0'
r'CMakeLists.txt\0D commit-message-template.txt\0A stuff.txt\0'
r'?? junk.txt')
GIT_STATUS_PORCELAIN_CLEAN = r''
def test_porcelain_status_dirty(self):
"""Verify that git status output is considered dirty when there are
listed files.
"""
git_output = self.GIT_STATUS_PORCELAIN_V1_ALL
is_dirty = GitRepository._status_v1z_is_dirty(git_output)
self.assertTrue(is_dirty)
def test_porcelain_status_clean(self):
"""Verify that git status output is considered clean when there are no
listed files.
"""
git_output = self.GIT_STATUS_PORCELAIN_CLEAN
is_dirty = GitRepository._status_v1z_is_dirty(git_output)
self.assertFalse(is_dirty)
class TestGitCreateRemoteName(unittest.TestCase):
"""Test the create_remote_name method on the GitRepository class
"""
def setUp(self):
"""Common infrastructure for testing _create_remote_name
"""
self._rdata = {ExternalsDescription.PROTOCOL: 'git',
ExternalsDescription.REPO_URL:
'empty',
ExternalsDescription.TAG:
'very_useful_tag',
ExternalsDescription.BRANCH: EMPTY_STR,
ExternalsDescription.HASH: EMPTY_STR, }
self._repo = GitRepository('test', self._rdata)
def test_remote_git_proto(self):
"""Test remote with git protocol
"""
self._repo._url = '[email protected]:very_nice_org/useful_repo'
remote_name = self._repo._create_remote_name()
self.assertEqual(remote_name, 'very_nice_org_useful_repo')
def test_remote_https_proto(self):
"""Test remote with git protocol
"""
self._repo._url = 'https://www.github.com/very_nice_org/useful_repo'
remote_name = self._repo._create_remote_name()
self.assertEqual(remote_name, 'very_nice_org_useful_repo')
def test_remote_local_abs(self):
"""Test remote with git protocol
"""
self._repo._url = '/path/to/local/repositories/useful_repo'
remote_name = self._repo._create_remote_name()
self.assertEqual(remote_name, 'repositories_useful_repo')
def test_remote_local_rel(self):
"""Test remote with git protocol
"""
os.environ['TEST_VAR'] = '/my/path/to/repos'
self._repo._url = '${TEST_VAR}/../../useful_repo'
remote_name = self._repo._create_remote_name()
self.assertEqual(remote_name, 'path_useful_repo')
del os.environ['TEST_VAR']
class TestVerifyTag(unittest.TestCase):
"""Test logic verifying that a tag exists and is unique
"""
def setUp(self):
"""Setup reusable git repository object
"""
self._name = 'component'
rdata = {ExternalsDescription.PROTOCOL: 'git',
ExternalsDescription.REPO_URL:
'/path/to/local/repo',
ExternalsDescription.TAG: 'tag1',
}
data = {self._name:
{
ExternalsDescription.REQUIRED: False,
ExternalsDescription.PATH: 'tmp',
ExternalsDescription.EXTERNALS: EMPTY_STR,
ExternalsDescription.REPO: rdata,
},
}
model = ExternalsDescriptionDict(data)
repo = model[self._name][ExternalsDescription.REPO]
self._repo = GitRepository('test', repo)
@staticmethod
def _shell_true(url, remote=None):
_ = url
_ = remote
return 0
@staticmethod
def _shell_false(url, remote=None):
_ = url
_ = remote
return 1
@staticmethod
def _mock_function_true(ref):
_ = ref
return (TestValidRef._shell_true, '97ebc0e0deadc0de')
@staticmethod
def _mock_function_false(ref):
_ = ref
return (TestValidRef._shell_false, '97ebc0e0deadc0de')
def test_tag_not_tag_branch_commit(self):
"""Verify a non-tag returns false
"""
self._repo._git_showref_tag = self._shell_false
self._repo._git_showref_branch = self._shell_false
self._repo._git_lsremote_branch = self._shell_false
self._repo._git_revparse_commit = self._mock_function_false
self._repo._tag = 'something'
remote_name = 'origin'
received, _ = self._repo._is_unique_tag(self._repo._tag, remote_name)
self.assertFalse(received)
def test_tag_not_tag(self):
"""Verify a non-tag, untracked remote returns false
"""
self._repo._git_showref_tag = self._shell_false
self._repo._git_showref_branch = self._shell_true
self._repo._git_lsremote_branch = self._shell_true
self._repo._git_revparse_commit = self._mock_function_false
self._repo._tag = 'tag1'
remote_name = 'origin'
received, _ = self._repo._is_unique_tag(self._repo._tag, remote_name)
self.assertFalse(received)
def test_tag_indeterminant(self):
"""Verify an indeterminant tag/branch returns false
"""
self._repo._git_showref_tag = self._shell_true
self._repo._git_showref_branch = self._shell_true
self._repo._git_lsremote_branch = self._shell_true
self._repo._git_revparse_commit = self._mock_function_true
self._repo._tag = 'something'
remote_name = 'origin'
received, _ = self._repo._is_unique_tag(self._repo._tag, remote_name)
self.assertFalse(received)
def test_tag_is_unique(self):
"""Verify a unique tag match returns true
"""
self._repo._git_showref_tag = self._shell_true
self._repo._git_showref_branch = self._shell_false
self._repo._git_lsremote_branch = self._shell_false
self._repo._git_revparse_commit = self._mock_function_true
self._repo._tag = 'tag1'
remote_name = 'origin'
received, _ = self._repo._is_unique_tag(self._repo._tag, remote_name)
self.assertTrue(received)
def test_tag_is_not_hash(self):
"""Verify a commit hash is not classified as a tag
"""
self._repo._git_showref_tag = self._shell_false
self._repo._git_showref_branch = self._shell_false
self._repo._git_lsremote_branch = self._shell_false
self._repo._git_revparse_commit = self._mock_function_true
self._repo._tag = '97ebc0e0'
remote_name = 'origin'
received, _ = self._repo._is_unique_tag(self._repo._tag, remote_name)
self.assertFalse(received)
def test_hash_is_commit(self):
"""Verify a commit hash is not classified as a tag
"""
self._repo._git_showref_tag = self._shell_false
self._repo._git_showref_branch = self._shell_false
self._repo._git_lsremote_branch = self._shell_false
self._repo._git_revparse_commit = self._mock_function_true
self._repo._tag = '97ebc0e0'
remote_name = 'origin'
received, _ = self._repo._is_unique_tag(self._repo._tag, remote_name)
self.assertFalse(received)
class TestValidRef(unittest.TestCase):
"""Test logic verifying that a reference is a valid tag, branch or sha1
"""
def setUp(self):
"""Setup reusable git repository object
"""
self._name = 'component'
rdata = {ExternalsDescription.PROTOCOL: 'git',
ExternalsDescription.REPO_URL:
'/path/to/local/repo',
ExternalsDescription.TAG: 'tag1',
}
data = {self._name:
{
ExternalsDescription.REQUIRED: False,
ExternalsDescription.PATH: 'tmp',
ExternalsDescription.EXTERNALS: EMPTY_STR,
ExternalsDescription.REPO: rdata,
},
}
model = ExternalsDescriptionDict(data)
repo = model[self._name][ExternalsDescription.REPO]
self._repo = GitRepository('test', repo)
@staticmethod
def _shell_true(url, remote=None):
_ = url
_ = remote
return 0
@staticmethod
def _shell_false(url, remote=None):
_ = url
_ = remote
return 1
@staticmethod
def _mock_function_false(ref):
_ = ref
return (TestValidRef._shell_false, '')
@staticmethod
def _mock_function_true(ref):
_ = ref
return (TestValidRef._shell_true, '')
def test_valid_ref_is_invalid(self):
"""Verify an invalid reference raises an exception
"""
self._repo._git_showref_tag = self._shell_false
self._repo._git_showref_branch = self._shell_false
self._repo._git_lsremote_branch = self._shell_false
self._repo._git_revparse_commit = self._mock_function_false
self._repo._tag = 'invalid_ref'
with self.assertRaises(RuntimeError):
self._repo._check_for_valid_ref(self._repo._tag)
def test_valid_tag(self):
"""Verify a valid tag return true
"""
self._repo._git_showref_tag = self._shell_true
self._repo._git_showref_branch = self._shell_false
self._repo._git_lsremote_branch = self._shell_false
self._repo._git_revparse_commit = self._mock_function_true
self._repo._tag = 'tag1'
received = self._repo._check_for_valid_ref(self._repo._tag)
self.assertTrue(received)
def test_valid_branch(self):
"""Verify a valid tag return true
"""
self._repo._git_showref_tag = self._shell_false
self._repo._git_showref_branch = self._shell_true
self._repo._git_lsremote_branch = self._shell_false
self._repo._git_revparse_commit = self._mock_function_true
self._repo._tag = 'tag1'
received = self._repo._check_for_valid_ref(self._repo._tag)
self.assertTrue(received)
def test_valid_hash(self):
"""Verify a valid hash return true
"""
def _mock_revparse_commit(ref):
_ = ref
return (0, '56cc0b539426eb26810af9e')
self._repo._git_showref_tag = self._shell_false
self._repo._git_showref_branch = self._shell_false
self._repo._git_lsremote_branch = self._shell_false
self._repo._git_revparse_commit = _mock_revparse_commit
self._repo._hash = '56cc0b5394'
received = self._repo._check_for_valid_ref(self._repo._hash)
self.assertTrue(received)
if __name__ == '__main__':
unittest.main()
| gpl-3.0 | 9,038,250,738,399,458,000 | 37.73482 | 84 | 0.595572 | false |
brefsdal/sherpa | sherpa/estmethods/__init__.py | 1 | 43921 | #_PYTHON_INSERT_SAO_COPYRIGHT_HERE_(2007)_
#_PYTHON_INSERT_GPL_LICENSE_HERE_
import numpy
_ = numpy.seterr(invalid='ignore')
from sherpa.utils import NoNewAttributesAfterInit, print_fields, Knuth_close, is_iterable, list_to_open_interval, mysgn, quad_coef, apache_muller, bisection, demuller, zeroin, OutOfBoundErr, func_counter, _multi, _ncpus
import logging
import sherpa.estmethods._est_funcs
from itertools import izip
try:
import multiprocessing
except:
pass
__all__ = ('EstNewMin', 'Covariance', 'Confidence',
'Projection', 'est_success', 'est_failure', 'est_hardmin',
'est_hardmax', 'est_hardminmax', 'est_newmin', 'est_maxiter',
'est_hitnan')
est_success = 0
est_failure = 1
est_hardmin = 2
est_hardmax = 3
est_hardminmax = 4
est_newmin = 5
est_maxiter = 6
est_hitnan = 7
# For every method listed here, we have the same goal: derive confidence
# limits for thawed parameters. Thawed parameters are allowed to vary
# during a fit; when a model has been fit to data, then the current
# parameter values are presumably the best-fit values. Think of the
# best-fit values as being at the lowest point in a valley in parameter
# space--any step away, in any direction, means a worse fit (i.e., the
# value of the fit statistic is greater). Confidence limits tell you
# how well constrained those best fit values are; i.e., are we in a deep,
# narrow valley in parameter space? If so, we can be confident the limits
# are small. But if the valley is shallow and broad, then the confidence
# limits will also be very broad.
#
# Every method is passed the same information:
# the current values of all thawed parameters;
# the soft limits of all thawed parameters;
# the hard limits of all thawed parameters;
# the list of parameters for which we are actually want confidence
# limits (this can be a subset of all thawed parameters)
# a reference to the statistic function;
# a reference to the fitting function.
#class EstMethodError(SherpaError):
# "Reached an error while computing parameter confidence limits"
# pass
#
#class EstHardMin(EstMethodError):
# "Reached a parameter hard minimum"
# pass
#
#class EstHardMax(EstMethodError):
# "Reached a parameter hard maximum"
# pass
#
class EstNewMin(Exception):
"Reached a new minimum fit statistic"
pass
#
#class EstMaxIter(EstMethodError):
# "Reached maxmimum iterations in scaling function"
# pass
#
#class EstNaN(EstMethodError):
# "Reached a NaN during computation"
# pass
class EstMethod(NoNewAttributesAfterInit):
# defined pre-instantiation for pickling
config = {'sigma' : 1,
'eps' : 0.01,
'maxiters' : 200,
'soft_limits' : False}
def __init__(self, name, estfunc):
self._estfunc = estfunc
self.name = name
# config should be defined pre-instantiation for pickling
# however, for some unknown reason membership in self.__dict__
# requires declaration in __init__()
self.config = self.config.copy()
NoNewAttributesAfterInit.__init__(self)
def __getattr__(self, name):
if name in self.__dict__.get('config', ()):
return self.config[name]
raise AttributeError("'%s' object has no attribute '%s'" %
(type(self).__name__, name))
def __setattr__(self, name, val):
if name in self.__dict__.get('config', ()):
self.config[name] = val
else:
NoNewAttributesAfterInit.__setattr__(self, name, val)
def __repr__(self):
return ("<%s error-estimation method instance '%s'>" %
(type(self).__name__, self.name))
def __str__(self):
# Put name first always
keylist = self.config.keys()
keylist = ['name'] + keylist
full_config = {'name' : self.name}
full_config.update(self.config)
return print_fields(keylist, full_config)
def __setstate__(self, state):
self.__dict__.update(state)
# obtain config values from object class
self.__dict__['config'] = getattr(self.__class__(),'config',{})
# update new config dict with user defined from old
self.__dict__['config'].update(state.get('config',{}))
def compute(self, statfunc, fitfunc, pars,
parmins, parmaxes, parhardmins,
parhardmaxes, limit_parnums, freeze_par, thaw_par,
report_progress, get_par_name,
statargs=(), statkwargs={}):
def stat_cb(pars):
return statfunc(pars)[0]
def fit_cb(scb, pars, parmins, parmaxes, i):
# parameter i is a no-op usually
return fitfunc(scb, pars, parmins, parmaxes)[2]
# remin means reminimize -- *generally* not done (only
# proj needs to reminimize).
#
# covar still needs to pass a reminimize flag to
# get_one_sided_interval; a value less than zero is
# interpreted as "never reminimize", so pass that value here.
remin = -1.0
tol = -1.0
return self._estfunc(pars, parmins, parmaxes, parhardmins,
parhardmaxes, self.sigma, self.eps,
tol,
self.maxiters, remin, limit_parnums,
stat_cb, fit_cb, report_progress)
class Covariance(EstMethod):
def __init__(self, name='covariance'):
EstMethod.__init__(self, name, covariance)
class Confidence(EstMethod):
# defined pre-instantiation for pickling
_added_config = {'remin': 0.01,
'fast': False,
'parallel': True,
'numcores' : _ncpus,
'maxfits' : 5,
'max_rstat' : 3,
'tol' : 0.2,
'verbose' : False,
'openinterval': False }
def __init__(self, name='confidence'):
EstMethod.__init__(self, name, confidence)
# Update EstMethod.config dict with Confidence specifics
self.config.update(self._added_config)
def compute(self, statfunc, fitfunc, pars,
parmins, parmaxes, parhardmins,
parhardmaxes, limit_parnums, freeze_par, thaw_par,
report_progress, get_par_name,
statargs=(), statkwargs={}):
def stat_cb(pars):
return statfunc(pars)[0]
def fit_cb(pars, parmins, parmaxes, i):
# freeze model parameter i
(current_pars,
current_parmins,
current_parmaxes) = freeze_par(pars, parmins, parmaxes, i)
fit_pars = fitfunc(statfunc, current_pars,
current_parmins,
current_parmaxes)[1]
# If stat is not chi-squared, and fit method is
# lmdif, need to recalculate stat at end, just
# like in sherpa/sherpa/fit.py:fit()
stat = statfunc(fit_pars)[0]
#stat = fitfunc(scb, pars, parmins, parmaxes)[2]
# thaw model parameter i
thaw_par(i)
return stat
#
# convert stat call back to have the same signature as fit call back
#
def stat_cb_extra_args( fcn ):
def stat_cb_wrapper( x, *args ):
return fcn( x )
return stat_cb_wrapper
statcb = stat_cb_extra_args( stat_cb )
if 1 == len( pars ):
fitcb = statcb
else:
fitcb = fit_cb
return self._estfunc(pars, parmins, parmaxes, parhardmins,
parhardmaxes, self.sigma, self.eps,
self.tol, self.maxiters, self.remin,
self.verbose, limit_parnums,
statcb, fitcb, report_progress, get_par_name,
self.parallel, self.numcores, self.openinterval)
class Projection(EstMethod):
# defined pre-instantiation for pickling
_added_config = {'remin': 0.01,
'fast': True,
'parallel':True,
'numcores' : _ncpus,
'maxfits' : 5,
'max_rstat' : 3,
'tol' : 0.2}
def __init__(self, name='projection'):
EstMethod.__init__(self, name, projection)
# Update EstMethod.config dict with Projection specifics
self.config.update(self._added_config)
def compute(self, statfunc, fitfunc, pars,
parmins, parmaxes, parhardmins,
parhardmaxes, limit_parnums, freeze_par, thaw_par,
report_progress, get_par_name,
statargs=(), statkwargs={}):
def stat_cb(pars):
return statfunc(pars)[0]
def fit_cb(pars, parmins, parmaxes, i):
# freeze model parameter i
(current_pars,
current_parmins,
current_parmaxes) = freeze_par(pars, parmins, parmaxes, i)
fit_pars = fitfunc(statfunc, current_pars,
current_parmins,
current_parmaxes)[1]
# If stat is not chi-squared, and fit method is
# lmdif, need to recalculate stat at end, just
# like in sherpa/sherpa/fit.py:fit()
stat = statfunc(fit_pars)[0]
#stat = fitfunc(scb, pars, parmins, parmaxes)[2]
# thaw model parameter i
thaw_par(i)
return stat
return self._estfunc(pars, parmins, parmaxes, parhardmins,
parhardmaxes, self.sigma, self.eps,
self.tol,
self.maxiters, self.remin, limit_parnums,
stat_cb, fit_cb, report_progress, get_par_name,
self.parallel, self.numcores)
def covariance(pars, parmins, parmaxes, parhardmins, parhardmaxes, sigma, eps,
tol, maxiters, remin, limit_parnums, stat_cb, fit_cb,
report_progress):
# Do nothing with tol
# Do nothing with report_progress (generally fast enough we don't
# need to report back per-parameter progress)
# Even though we only want limits on certain parameters, we have to
# compute the matrix for *all* thawed parameters. So we will do that,
# and then pick the parameters of interest out of the result.
try:
info = _est_funcs.info_matrix(pars, parmins, parmaxes, parhardmins,
parhardmaxes, sigma, eps, maxiters,
remin, stat_cb)
except EstNewMin:
# catch the EstNewMin exception and attach the modified
# parameter values to the exception obj. These modified
# parvals determine the new lower statistic.
raise EstNewMin(pars)
except:
raise
# Invert matrix, take its square root and multiply by sigma to get
# parameter uncertainties; parameter uncertainties are the
# diagonal elements of the matrix.
# Use simpler matrix inversion function from numpy. If that
# doesn't work, assume it's an ill-conditioned or singular matrix,
# and call pinv from numpy -- pinv will call the SVD function to
# invert the matrix. But call pinv *only* when inv is shown not
# to work in a particular case -- use inv by default!
# The reason for this is that pinv can give back very strange
# results, when you don't *need* to use pinv, and it *also*
# happens that the ratio between smallest and largest diagonal
# elements approaches the machine precision for the data type.
# The result is that errors that come from the largest diagonal
# element are ludicrously small; you can't have a parameter value
# of order 1.0, and an error of order 10^-30, for example. The
# simpler inv function for inverting matrices does not appear to
# have the same issue.
invfunc = numpy.linalg.inv
inv_info = None
try:
inv_info = invfunc(info)
except numpy.linalg.linalg.LinAlgError:
# catch the SVD exception and exit gracefully
inv_info = numpy.zeros_like(info)
inv_info[:] = numpy.nan
except:
# Compatibility with pre-0.9.8 numpy
if hasattr(numpy.linalg, 'pinv'):
invfunc = numpy.linalg.pinv
else:
invfunc = numpy.linalg.generalized_inverse
try:
inv_info = invfunc(info)
except numpy.linalg.linalg.LinAlgError:
# catch the SVD exception and exit gracefully
inv_info = numpy.zeros_like(info)
inv_info[:] = numpy.nan
diag = (sigma * numpy.sqrt(inv_info)).diagonal()
# limit_parnums lists the indices of the array pars, that
# correspond to the parameters of interest. We will pick out
# the diagonal elements corresponding to entries in limits_parnums,
# and return only those bounds to the user.
upper_bounds = []
lower_bounds = []
error_flags = []
for num in limit_parnums:
eflag = est_success
ubound = diag[num]
lbound = -diag[num]
if (pars[num] + ubound < parhardmaxes[num]):
pass
else:
ubound = numpy.nan
eflag = est_hardmax
if (pars[num] + lbound > parhardmins[num]):
pass
else:
lbound = numpy.nan
if (eflag == est_hardmax):
eflag = est_hardminmax
else:
eflag = est_hardmin
upper_bounds.append(ubound)
lower_bounds.append(lbound)
error_flags.append(eflag)
return (numpy.array(lower_bounds), numpy.array(upper_bounds),
numpy.array(error_flags), 0, inv_info)
def projection(pars, parmins, parmaxes, parhardmins, parhardmaxes, sigma, eps,
tol, maxiters, remin, limit_parnums, stat_cb, fit_cb,
report_progress, get_par_name, do_parallel, numcores):
i = 0 # Iterate through parameters
# to be searched on
numsearched = len(limit_parnums) # Number of parameters to be
# searched on (*not* number
# of thawed parameters, just
# number we are searching on
# (i.e., len(limit_parnums))
lower_limits = numpy.array([]) # Lower limits for parameters
# searched on
upper_limits = numpy.array([]) # Upper limits for parameters
# searched on
eflags = numpy.array([], numpy.int) # Fail status after search for
# each parameter
nfits = 0 # Total number of fits
# _est_funcs.projection can be called on any subset of the thawed
# parameters. So we made a change here to call _est_funcs.projection
# once per parameter number listed in limit_parnums, instead of
# calling _est_funcs.projection once, with the original limit_parnums
# array. This way, we can report pack progress after the confidence
# limit search is completed for each parameter, without descending
# into the C++ code.
#
# It does mean we have to take apart the tuple returned by each call
# to _est_funcs.projection; take the data we've pulled out, and
# upon exiting the while loop, constructing a new tuple to return.
# SMD 03/17/2009
# Keep references to numpy.append, _est_funcs.projection, because
# we call these functions every time through the loop.
append = numpy.append
proj_func = _est_funcs.projection
def func(i, singleparnum, lock=None):
try:
singlebounds = proj_func(pars, parmins, parmaxes,
parhardmins, parhardmaxes,
sigma, eps, tol, maxiters,
remin, [singleparnum], stat_cb,
fit_cb)
except EstNewMin:
# catch the EstNewMin exception and attach the modified
# parameter values to the exception obj. These modified
# parvals determine the new lower statistic.
raise EstNewMin(pars)
except:
raise
if lock is not None:
lock.acquire()
report_progress(singleparnum, singlebounds[0], singlebounds[1])
if lock is not None:
lock.release()
return (singlebounds[0][0], singlebounds[1][0], singlebounds[2][0],
singlebounds[3], None)
if len(limit_parnums) < 2 or not _multi or numcores < 2:
do_parallel = False
if not do_parallel:
append = numpy.append
lower_limits = numpy.array([])
upper_limits = numpy.array([])
eflags = numpy.array([], numpy.int)
nfits = 0
for i in range(len(limit_parnums)):
singlebounds = func(i, limit_parnums[i])
lower_limits = append(lower_limits, singlebounds[0])
upper_limits = append(upper_limits, singlebounds[1])
eflags = append(eflags, singlebounds[2])
nfits = nfits + singlebounds[3]
return (lower_limits, upper_limits, eflags, nfits, None)
return parallel_est(func, limit_parnums, pars, numcores)
#################################confidence###################################
class ConfArgs( object ):
"""The class ConfArgs is responsible for the arguments to the fit
call back function."""
def __init__( self, xpars, smin, smax, hmin, hmax, target_stat ):
self.ith_par = 0
self.xpars = numpy.array( xpars, copy=True )
self.slimit = ( numpy.array( smin, copy=True ),
numpy.array( smax, copy=True ) )
self.hlimit = ( numpy.array( hmin, copy=True ),
numpy.array( hmax, copy=True ) )
self.target_stat = target_stat
def __call__( self ):
return ( self.ith_par, self.xpars, self.slimit, self.hlimit,
self.target_stat )
def __str__( self ):
a2s = numpy.array2string
msg = ''
msg += '# smin = ' + a2s(self.slimit[0],precision=6) + '\n'
msg += '# smax = ' + a2s(self.slimit[1],precision=6) + '\n'
msg += '# hmin = ' + a2s(self.hlimit[0],precision=6) + '\n'
msg += '# hmax = ' + a2s(self.hlimit[1],precision=6) + '\n#\n'
msg += '# Note: for the intermediate steps, the notation:\n'
msg += ' par.name -/+: f( x ) = stat\n'
msg += '# ==> `stat` is the statistic when parameter `par.name` is frozen at `x`\n'
msg += '# while searching for the `lower/upper` confidence level, repectively.\n#'
return msg
def __rep__( self ):
return ( "<%s ConfArgs method instance'%s'>" %
(type(self).__name__, self.name) )
def get_par( self ):
"""return the current (worked on) par"""
return self.xpars[ self.ith_par ]
def get_hlimit( self, dir ):
""" return the current (worked on) hard limit"""
return self.hlimit[ dir ][ self.ith_par ]
def get_slimit( self, dir ):
""" return the current (worked on) soft limit"""
return self.slimit[ dir ][ self.ith_par ]
class ConfBlog( object ):
def __init__( self, blogger, prefix, verbose, lock, debug=False ):
self.blogger = blogger
self.prefix = prefix
self.verbose = verbose
self.lock = lock
self.debug = debug
def __str__( self ):
return 'ConfBlog::__str__( )'
def __rep__( self ):
return 'ConfBlog::__rep__( )'
class ConfBracket( object ):
"""The class ConfBracket is reponsible for bracketing the root within
the interval (a,b) where f(a)*f(b) < 0.0"""
neg_pos = ( -1, 1 )
class Limit( object ):
def __init__( self, limit ):
self.limit = limit
class LowerLimit( Limit ):
def __init__( self, limit ):
ConfBracket.Limit.__init__( self, limit )
def __str__( self ):
str = 'LowerLimit: limit=%e' % self.limit
return str
def is_beyond_limit( self, x ):
if x < self.limit:
return True
else:
return False
class UpperLimit( Limit ):
def __init__( self, limit ):
ConfBracket.Limit.__init__( self, limit )
def __str__( self ):
str = 'UpperLimit: limit=%e' % self.limit
return str
def is_beyond_limit( self, x ):
if x > self.limit:
return True
else:
return False
def __init__( self, myargs, trial_points ):
self.myargs = myargs
self.trial_points = trial_points
self.fcn = None
def __repr__( self ):
return ("<%s Bracket error-estimation method instance '%s'>" %
(type(self).__name__, self.name))
def __call__( self, dir, iter, step_size, open_interval, maxiters, tol,
bloginfo ):
#
# Either 1) a root has been found (ConfRootZero), 2) an interval
# where the root has been confined (ConfRootBracket) or 3) No
# possible chance for a root (ConfRootNone), ie by trying points
# upto/beyond the hard limit and no chance for a root has been found.
#
find = trace_fcn( self.find, bloginfo )
return find( dir, iter, step_size, open_interval, maxiters, tol,
bloginfo )
def find( self, dir, iter, step_size, open_interval, maxiters, tol,
bloginfo, base=2.0 ):
assert self.fcn != None, 'callback func has not been set'
hlimit = [ ConfBracket.LowerLimit( self.myargs.get_hlimit( dir ) ),
ConfBracket.UpperLimit( self.myargs.get_hlimit( dir ) ) ]
slimit = [ ConfBracket.LowerLimit( self.myargs.get_slimit( dir ) ),
ConfBracket.UpperLimit( self.myargs.get_slimit( dir ) ) ]
xxx = self.trial_points[ 0 ]
fff = self.trial_points[ 1 ]
conf_step = ConfStep( xxx, fff )
mymaxiters = maxiters
if mymaxiters > 16:
mymaxiters = 16
plateau = 0
max_plateau_iter = 5
try:
for iter in range( mymaxiters ):
if 0 == iter:
x = conf_step.covar( dir, iter, step_size, base )
elif 1 == iter:
x = conf_step.secant( dir, iter, step_size, base )
#x = conf_step.covar( dir, iter, step_size, base )
else:
x = conf_step.quad( dir, iter, step_size, base, bloginfo )
if x is None or numpy.isnan( x ):
return ConfRootNone( )
# Make sure x is not beyond the **hard** limit
if hlimit[ dir ].is_beyond_limit( x ):
x = hlimit[ dir ].limit
f = self.fcn( x, self.myargs( ) )
#print 'find(): beyond hard limit: f(%.14e)=%.14e' % (x,f)
if abs( f ) <= tol:
return ConfRootZero( x )
if f >= 0.0:
return ConfRootBracket( self.fcn, self.trial_points,
open_interval )
else:
return ConfRootNone( )
elif slimit[ dir ].is_beyond_limit( x ):
f = self.fcn( x, self.myargs( ) )
#print 'find(): beyond soft limit: f(%.14e)=%.14e' % (x,f)
if abs( f ) <= tol:
return ConfRootZero( x )
if f >= 0.0:
return ConfRootBracket( self.fcn, self.trial_points,
open_interval )
elif f < fff[ -2 ]:
# if the fit beyond the soft limit is a better fit
# then the confidence for the parameter does not exist
return ConfRootNone( )
else:
f = self.fcn( x, self.myargs( ) )
#print 'find(): f(%.14e)=%.14e' % (x,f)
if abs( f ) <= tol:
return ConfRootZero( x )
elif f >= 0.0:
return ConfRootBracket( self.fcn, self.trial_points,
open_interval )
if Knuth_close( fff[-2], fff[-1], 1.0e-6 ):
plateau += 1
if plateau > max_plateau_iter:
#print 'find( %d ): plateau = %d', (iter,plateau)
return ConfRootNone( None )
#else:
# if plateau > 0:
# plateau -= 1
return ConfRootNone( None )
except OutOfBoundErr:
return ConfRootNone( )
class ConfRootNone( object ):
"""The base class for the root of the confidence interval"""
def __init__( self, root=None ):
"""If self.root == None, then
1) points up to the hard limits were tried and it was not possible
to bracketed the solution.
2) a parameter beyond the soft limit has been tried and the new stat
was found to be **less** then the initial minimum"""
self.root = root
def __call__( self, tol, bloginfo ):
return self.root
def __str__( self ):
return 'No possible root exist'
class ConfRootBracket( ConfRootNone ):
"""The class contains the bracket where the confidence root has
been bracketed, ie where f(a)*f(b) < 0"""
def __init__( self, fcn, trial_points, open_interval ):
ConfRootNone.__init__( self, None )
self.fcn = fcn
self.trial_points = trial_points
self.open_interval = open_interval
def __call__( self, tol, bloginfo ):
def warn_user_about_open_interval( list ):
if bloginfo.lock is not None:
bloginfo.lock.acquire()
if 0 == bloginfo.verbose:
prefix = '%s ' % bloginfo.prefix.lstrip()
else:
prefix = '%s ' % bloginfo.prefix
interval = list_to_open_interval( list )
bloginfo.blogger.info( prefix +
'WARNING: The confidence level lies within '
+ interval )
if bloginfo.lock is not None:
bloginfo.lock.release()
return
xxx = self.trial_points[ 0 ]
fff = self.trial_points[ 1 ]
if mysgn( fff[ -2 ] ) == mysgn( fff[ -1 ] ):
self.root = None
return None
myzeroin = trace_fcn( zeroin, bloginfo )
answer = myzeroin( self.fcn, xxx[ -2 ], xxx[ -1 ], fa=fff[ -2 ],
fb=fff[ -1 ], maxfev=32, tol=tol )
if abs( answer[0][1] ) > tol:
xafa = answer[ 1 ][ 0 ]
xa = xafa[ 0 ]
fa = xafa[ 1 ]
xbfb = answer[ 1 ][ 1 ]
xb = xbfb[ 0 ]
fb = xbfb[ 1 ]
if mysgn( fa ) != mysgn( fb ):
if False == self.open_interval:
warn_user_about_open_interval( [ xa, xb ] )
return ( xa + xb ) / 2.0
else:
if xa < xb:
return ( xa, xb )
else:
return ( xb, xa )
else:
return None
self.root = answer[ 0 ][ 0 ]
return self.root
def __str__( self ):
str = 'root is within the interval ( f(%e)=%e, f(%e)=%e )' \
% ( self.trial_points[ 0 ][ -2 ], self.trial_points[ 1 ][ -2 ],
self.trial_points[ 0 ][ -1 ], self.trial_points[ 1 ][ -1 ], )
return str
class ConfRootZero( ConfRootNone ):
"""The class with the root/zero of the confidence interval"""
def __init__( self, root ):
ConfRootNone.__init__( self, root )
def __str__( self ):
str = 'root = %e' % self.root
return str
class ConfStep( object ):
def __init__( self, xtrial, ftrial ):
self.xtrial = xtrial
self.ftrial = ftrial
def covar( self, dir, iter, stepsize, base ):
return self.xtrial[ -1 ] + \
ConfBracket.neg_pos[ dir ] * pow( base, iter ) * stepsize
#return self.xtrial[ 0 ] + \
# ConfBracket.neg_pos[ dir ] * pow( base, iter ) * stepsize
def Halley( self, coeffs, x, maxfev=8, tol=1.0e-3 ):
for nfev in range( maxfev ):
ax = coeffs[ 0 ] * x
fval = ( ax + coeffs[ 1 ] ) * x + coeffs[ 2 ]
if abs( fval ) <= tol:
return [x, fval]
fdif = 2.0 * ax + coeffs[ 1 ]
fdif2 = 2.0
numer = 2.0 * fval * fdif
denom = 2.0 * fdif * fdif - fval * fdif2
x -= numer / denom
nfev += 1
return [x, fval]
def is_same_dir( self, dir, current_pos, proposed_pos ):
delta = proposed_pos - current_pos
return mysgn( delta ) == ConfBracket.neg_pos[ dir ]
def quad( self, dir, iter, step_size, base, bloginfo ):
coeffs = quad_coef( self.xtrial[ -3: ], self.ftrial[ -3: ] )
delta = ConfBracket.neg_pos[ dir ]
delta *= abs( self.xtrial[ -1 ] - self.xtrial[ -2 ] )
lastx = self.xtrial[ -1 ]
mroot = demuller( numpy.poly1d( coeffs ), lastx + delta,
lastx + 2 * delta, lastx + 3 * delta,
tol=1.0e-2 )
xroot = mroot[ 0 ][ 0 ]
if xroot is None or numpy.isnan( xroot ):
return self.covar( dir, iter, step_size, base )
try:
Halley = trace_fcn( self.Halley, bloginfo )
[xroot, froot] = Halley( coeffs, xroot, tol=1.0e-3 )
except ZeroDivisionError:
xroot = None
if (None != xroot and False == numpy.isnan( xroot )) and \
self.is_same_dir( dir, self.xtrial[ -1 ], xroot ):
return xroot
else:
return self.covar( dir, iter, step_size, base )
def secant( self, dir, iter, step_size, base ):
xb = self.xtrial[ -2 ]
fb = self.ftrial[ -2 ]
xa = self.xtrial[ -1 ]
fa = self.ftrial[ -1 ]
if abs( fb ) > abs( fa ) or 0.0 == fa:
return self.covar( dir, iter, step_size, base )
s = fb / fa
p = ( xa - xb ) * s
if 1.0 == s:
return self.covar( dir, iter, step_size, base )
q = 1.0 - s
x = xb - p / q
if self.is_same_dir( dir, xa, x ):
return x
else:
return self.covar( dir, iter, step_size, base )
def trace_fcn( fcn, bloginfo ):
if False == bloginfo.debug:
return fcn
from itertools import chain
def echo( *args, **kwargs ):
'''compact but more details then debugger'''
name = fcn.__name__
str = '%s%s(%s)' % (bloginfo.prefix,fcn.__name__, ", ".join(map(repr, chain(args, kwargs.values()))))
bloginfo.blogger.info( str )
return fcn( *args, **kwargs )
def debugger( *args, **kwargs ):
str = '%s%s( ' % ( bloginfo.prefix, fcn.__name__ )
if len( args ) > 1:
str += args[ 0 ].__str__( )
for arg in args[ 1: ]:
str = '%s, %s' % ( str, arg )
for key in kwargs.iterkeys( ):
value = kwargs[ key ]
str = '%s, %s=%s' % ( str, key, value )
val = fcn( *args, **kwargs )
str += ' ) %s ' % val
bloginfo.blogger.info( str )
return val
return debugger
def confidence(pars, parmins, parmaxes, parhardmins, parhardmaxes, sigma, eps,
tol, maxiters, remin, verbose, limit_parnums, stat_cb,
fit_cb, report_progress, get_par_name, do_parallel, numcores,
open_interval):
def get_prefix( index, name, minus_plus ):
'''To print the prefix/indent when verbose is on'''
prefix = [[],[]]
blank = 3 * index * ' '
for dir in range( 2 ):
prefix[ dir ] = blank + name + ' ' + minus_plus[ dir ] + ':'
return prefix
def get_delta_root( arg, dir, par_at_min ):
my_neg_pos = ConfBracket.neg_pos[ dir ]
if is_iterable( arg ):
return arg
#return map( lambda x: my_neg_pos * abs( x - par_at_min ), arg )
elif None != arg:
arg -= par_at_min
return my_neg_pos * abs( arg )
else:
return arg
def get_step_size( error_scales, upper_scales, index, par ):
if 0 != error_scales[ index ]:
# if covar error is NaN then set it to fraction of the par value.
ith_covar_err = 0.0625 * abs( par )
else:
ith_covar_err = abs( upper_scales[ index ] )
if 0.0 == ith_covar_err:
# just in case covar and/or par is 0
ith_covar_err = 1.0e-6
return ith_covar_err
def monitor_func( fcn, history ):
def myfunc( x, *args ):
fval = fcn( x, *args )
history[ 0 ].append( x )
history[ 1 ].append( fval )
return fval
return myfunc
def print_status( myblog, verbose, prefix, answer, lock ):
if lock is not None:
lock.acquire()
if 0 == verbose:
msg = '%s\t' % prefix.lstrip()
else:
msg = '%s\t' % prefix
if is_iterable( answer ):
msg += list_to_open_interval( answer )
elif answer is None:
msg += '-----'
else:
msg += '%g' % answer
myblog( msg )
if lock is not None:
lock.release()
#
# Work in the translated coordinate. Hence the 'errors/confidence'
# are the zeros/roots in the translated coordinate system.
#
def translated_fit_cb( fcn, myargs ):
def translated_fit_cb_wrapper( x, *args ):
hlimit = myargs.hlimit
slimit = myargs.slimit
hmin = hlimit[ 0 ]
hmax = hlimit[ 1 ]
xpars = myargs.xpars
ith_par = myargs.ith_par
# The parameter must be within the hard limits
if x < hmin[ ith_par ] or x > hmax[ ith_par ]:
raise OutOfBoundErr
smin = slimit[ 0 ]
smax = slimit[ 1 ]
orig_ith_xpar = xpars[ ith_par ]
xpars[ ith_par ] = x
translated_stat = fcn( xpars, smin, smax, ith_par ) - myargs.target_stat
xpars[ ith_par ] = orig_ith_xpar
return translated_stat
return translated_fit_cb_wrapper
def verbose_fitcb( fcn, bloginfo ):
if 0 == bloginfo.verbose:
return fcn
def verbose_fcn( x, *args ):
fval = fcn( x, *args )
str = '%s f( %e ) =' % ( bloginfo.prefix, x )
if fval is None:
str = '%s None' % str
else:
str = '%s %e' % ( str, fval )
bloginfo.blogger.info( str )
return fval
return verbose_fcn
sherpablog = logging.getLogger( 'sherpa' ) # where to print progress report
# Get minimum fit statistic, and calculate target statistic value
orig_min_stat = stat_cb(pars)
delta_stat = sigma * sigma
target_stat = orig_min_stat + delta_stat
lower_scales = None
upper_scales = None
error_scales = None
nfits = 0
results = None
try:
(lower_scales, upper_scales, error_scales, nfits,
results) = covariance( pars, parmins, parmaxes, parhardmins,
parhardmaxes, 1.0, eps, tol, maxiters,
remin, limit_parnums, stat_cb,
fit_cb, report_progress )
except EstNewMin, e:
raise e
except:
error_scales = numpy.array( len( pars ) * [ est_hardminmax ] )
debug = False # for internal use only
myargs = ConfArgs( pars, parmins, parmaxes, parhardmins, parhardmaxes,
target_stat )
if 0 != verbose:
msg = '#\n# f' + numpy.array2string(numpy.asarray(pars),precision=6)
msg += ' = %e\n' % orig_min_stat
msg += '# sigma = %e\n' % sigma
msg += '# target_stat = %e\n' % target_stat
msg += '# tol = %e\n' % eps
msg += '%s' % myargs
sherpablog.info( msg )
dict = { }
def func( counter, singleparnum, lock=None ):
# nfev contains the number of times it was fitted
nfev, counter_cb = func_counter( fit_cb )
#
# These are the bounds to be returned by this method
#
conf_int = [ [], [] ]
error_flags = []
#
# If the user has requested a specific parameter to be
# calculated then 'ith_par' represents the index of the
# free parameter to deal with.
#
myargs.ith_par = singleparnum
fitcb = translated_fit_cb( counter_cb, myargs )
par_name = get_par_name( myargs.ith_par )
ith_covar_err = get_step_size( error_scales, upper_scales, counter,
pars[ myargs.ith_par ] )
trial_points = [ [ ], [ ] ]
fitcb = monitor_func( fitcb, trial_points )
bracket = ConfBracket( myargs, trial_points )
# the parameter name is set, may as well get the prefix
prefix = get_prefix( counter, par_name, ['-', '+' ] )
myfitcb = [ verbose_fitcb( fitcb,
ConfBlog(sherpablog,prefix[0],verbose,lock) ),
verbose_fitcb( fitcb,
ConfBlog(sherpablog,prefix[1],verbose,lock) ) ]
for dir in range( 2 ):
#
# trial_points stores the history of the points for the
# parameter which has been evaluated in order to locate
# the root. Note the first point is 'given' since the info
# of the minimum is crucial to the search.
#
bracket.trial_points[0].append( pars[ myargs.ith_par ] )
bracket.trial_points[1].append( - delta_stat )
myblog = ConfBlog( sherpablog, prefix[ dir ], verbose, lock,
debug )
# have to set the callback func otherwise disaster.
bracket.fcn = myfitcb[ dir ]
root = bracket( dir, iter, ith_covar_err, open_interval, maxiters,
eps, myblog )
myzero = root( eps, myblog )
delta_zero = get_delta_root( myzero, dir, pars[ myargs.ith_par ] )
conf_int[ dir ].append( delta_zero )
status_prefix = get_prefix( counter, par_name, ['lower bound',
'upper bound' ] )
print_status( myblog.blogger.info, verbose, status_prefix[ dir ],
delta_zero, lock )
error_flags.append( est_success )
#
# include the minimum point to seperate the -/+ interval
#
dict[ par_name ] = trial_points
return ( conf_int[ 0 ][0], conf_int[ 1 ][0], error_flags[0],
nfev[0], None )
if len(limit_parnums) < 2 or not _multi or numcores < 2:
do_parallel = False
if not do_parallel:
lower_limits = []
upper_limits = []
eflags = []
nfits = 0
for i in range(len(limit_parnums)):
lower_limit, upper_limit, flags, nfit, extra = func(i, limit_parnums[i])
lower_limits.append(lower_limit)
upper_limits.append(upper_limit)
eflags.append(flags)
nfits += nfit
return (lower_limits, upper_limits, eflags, nfits, None)
return parallel_est(func, limit_parnums, pars, numcores)
#################################confidence###################################
def parallel_est(estfunc, limit_parnums, pars, numcores=_ncpus):
tasks = []
def worker(out_q, err_q, parids, parnums, parvals, lock):
results = []
for parid, singleparnum in izip(parids, parnums):
try:
result = estfunc(parid, singleparnum, lock)
results.append( (parid, result) )
except EstNewMin:
# catch the EstNewMin exception and include the exception
# class and the modified parameter values to the error queue.
# These modified parvals determine the new lower statistic.
# The exception class will be instaniated re-raised with the
# parameter values attached. C++ Python exceptions are not
# picklable for use in the queue.
err_q.put( EstNewMin(parvals) )
return
except Exception, e:
#err_q.put( e.__class__() )
err_q.put(e)
return
out_q.put(results)
# The multiprocessing manager provides references to process-safe
# shared objects like Queue and Lock
manager = multiprocessing.Manager()
out_q = manager.Queue()
err_q = manager.Queue()
lock = manager.Lock()
size = len(limit_parnums)
parids = numpy.arange(size)
# if len(limit_parnums) is less than numcores, only use length number of
# processes
if size < numcores:
numcores = size
# group limit_parnums into numcores-worth of chunks
limit_parnums = numpy.array_split(limit_parnums, numcores)
parids = numpy.array_split(parids, numcores)
tasks = [multiprocessing.Process(target=worker,
args=(out_q, err_q, parid, parnum, pars, lock))
for parid, parnum in izip(parids, limit_parnums)]
return run_tasks(tasks, out_q, err_q, size)
def run_tasks(tasks, out_q, err_q, size):
die = (lambda tasks : [task.terminate() for task in tasks
if task.exitcode is None])
try:
for task in tasks:
task.start()
for task in tasks:
task.join()
except KeyboardInterrupt, e:
# kill all slave processes on ctrl-C
die(tasks)
raise e
if not err_q.empty():
die(tasks)
raise err_q.get()
lower_limits = size*[None]
upper_limits = size*[None]
eflags = size*[None]
nfits = 0
while not out_q.empty():
for parid, singlebounds in out_q.get():
# Have to guarantee that the tuple returned by projection
# is always (array, array, array, int) for this to work.
lower_limits[parid] = singlebounds[0]
upper_limits[parid] = singlebounds[1]
eflags[parid] = singlebounds[2]
nfits += singlebounds[3]
return (lower_limits, upper_limits, eflags, nfits, None)
| gpl-2.0 | 2,263,206,828,706,974,500 | 34.88317 | 219 | 0.526787 | false |
olivierverdier/sfepy | sfepy/postprocess/dataset_manager.py | 1 | 9486 | """
Code to help with managing a TVTK data set in Pythonic ways.
"""
# Author: Prabhu Ramachandran <[email protected]>
# Copyright (c) 2008, Enthought, Inc.
# License: BSD Style.
from enthought.traits.api import (HasTraits, Instance, Array, Str,
Property, Dict)
from enthought.tvtk.api import tvtk
from enthought.tvtk.array_handler import array2vtk
######################################################################
# Utility functions.
######################################################################
def get_array_type(arr):
"""Returns if the array is a scalar ('scalars'), vector
('vectors') or tensor ('tensors'). It looks at the number of
components to decide. If it has a wierd number of components it
returns the empty string.
"""
n = arr.number_of_components
ret = {1: 'scalars', 3: 'vectors', 4: 'scalars', 9:'tensors'}
return ret.get(n) or ''
def get_attribute_list(data):
""" Gets scalar, vector and tensor information from the given data
(either cell or point data).
"""
attr = {'scalars':[], 'vectors':[], 'tensors':[]}
if data is not None:
n = data.number_of_arrays
for i in range(n):
name = data.get_array_name(i)
t = get_array_type(data.get_array(i))
if len(t) > 0 and name is not None:
attr[t].extend([name])
def _mk_first(lst, value):
"""Makes the specified `value` the first item in `lst`."""
lst.remove(value)
lst.insert(0, value)
attr1 = attr.copy()
for a in attr:
v = getattr(data, a)
if v is not None:
name = v.name
if name is not None:
try:
_mk_first(attr[a], v.name)
except ValueError:
# Sometimes we have a multi-component scalar.
attr1[a].insert(0, name)
return attr1
def get_all_attributes(obj):
"""Gets the scalar, vector and tensor attributes that are
available in the given VTK data object.
"""
point_attr = get_attribute_list(obj.point_data)
cell_attr = get_attribute_list(obj.cell_data)
return point_attr, cell_attr
################################################################################
# `DatasetManager` class.
################################################################################
class DatasetManager(HasTraits):
# The TVTK dataset we manage.
dataset = Instance(tvtk.DataSet)
# Our output, this is the dataset modified by us with different
# active arrays.
output = Property(Instance(tvtk.DataSet))
# The point scalars for the dataset. You may manipulate the arrays
# in-place. However adding new keys in this dict will not set the
# data in the `dataset` for that you must explicitly call
# `add_array`.
point_scalars = Dict(Str, Array)
# Point vectors.
point_vectors = Dict(Str, Array)
# Point tensors.
point_tensors = Dict(Str, Array)
# The cell scalars for the dataset.
cell_scalars = Dict(Str, Array)
cell_vectors = Dict(Str, Array)
cell_tensors = Dict(Str, Array)
# This filter allows us to change the attributes of the data
# object and will ensure that the pipeline is properly taken care
# of. Directly setting the array in the VTK object will not do
# this.
_assign_attribute = Instance(tvtk.AssignAttribute, args=(),
allow_none=False)
######################################################################
# Public interface.
######################################################################
def add_array(self, array, name, category='point'):
"""
Add an array to the dataset to specified category ('point' or
'cell').
"""
assert len(array.shape) <= 2, "Only 2D arrays can be added."
data = getattr(self.dataset, '%s_data'%category)
if len(array.shape) == 2:
assert array.shape[1] in [1, 3, 4, 9], \
"Only Nxm arrays where (m in [1,3,4,9]) are supported"
va = tvtk.to_tvtk(array2vtk(array))
va.name = name
data.add_array(va)
mapping = {1:'scalars', 3: 'vectors', 4: 'scalars',
9: 'tensors'}
dict = getattr(self, '%s_%s'%(category,
mapping[array.shape[1]]))
dict[name] = array
else:
va = tvtk.to_tvtk(array2vtk(array))
va.name = name
data.add_array(va)
dict = getattr(self, '%s_scalars'%(category))
dict[name] = array
def remove_array(self, name, category='point'):
"""Remove an array by its name and optional category (point and
cell). Returns the removed array.
"""
type = self._find_array(name, category)
data = getattr(self.dataset, '%s_data'%category)
data.remove_array(name)
d = getattr(self, '%s_%s'%(category, type))
return d.pop(name)
def rename_array(self, name1, name2, category='point'):
"""Rename a particular array from `name1` to `name2`.
"""
type = self._find_array(name1, category)
data = getattr(self.dataset, '%s_data'%category)
arr = data.get_array(name1)
arr.name = name2
d = getattr(self, '%s_%s'%(category, type))
d[name2] = d.pop(name1)
def activate(self, name, category='point'):
"""Make the specified array the active one.
"""
type = self._find_array(name, category)
self._activate_data_array(type, category, name)
def update(self):
"""Update the dataset when the arrays are changed.
"""
self.dataset.modified()
self._assign_attribute.update()
######################################################################
# Non-public interface.
######################################################################
def _dataset_changed(self, value):
self._setup_data()
self._assign_attribute.input = value
def _get_output(self):
return self._assign_attribute.output
def _setup_data(self):
"""Updates the arrays from what is available in the input data.
"""
input = self.dataset
pnt_attr, cell_attr = get_all_attributes(input)
self._setup_data_arrays(cell_attr, 'cell')
self._setup_data_arrays(pnt_attr, 'point')
def _setup_data_arrays(self, attributes, d_type):
"""Given the dict of the attributes from the
`get_all_attributes` function and the data type (point/cell)
data this will setup the object and the data.
"""
attrs = ['scalars', 'vectors', 'tensors']
aa = self._assign_attribute
input = self.dataset
data = getattr(input, '%s_data'%d_type)
for attr in attrs:
values = attributes[attr]
# Get the arrays from VTK, create numpy arrays and setup our
# traits.
arrays = {}
for name in values:
va = data.get_array(name)
npa = va.to_array()
# Now test if changes to the numpy array are reflected
# in the VTK array, if they are we are set, else we
# have to set the VTK array back to the numpy array.
if len(npa.shape) > 1:
old = npa[0,0]
npa[0][0] = old - 1
if abs(va[0][0] - npa[0,0]) > 1e-8:
va.from_array(npa)
npa[0][0] = old
else:
old = npa[0]
npa[0] = old - 1
if abs(va[0] - npa[0]) > 1e-8:
va.from_array(npa)
npa[0] = old
arrays[name] = npa
setattr(self, '%s_%s'%(d_type, attr), arrays)
def _activate_data_array(self, data_type, category, name):
"""Activate (or deactivate) a particular array.
Given the nature of the data (scalars, vectors etc.) and the
type of data (cell or points) it activates the array given by
its name.
Parameters:
-----------
data_type: one of 'scalars', 'vectors', 'tensors'
category: one of 'cell', 'point'.
name: string of array name to activate.
"""
input = self.dataset
data = None
data = getattr(input, category + '_data')
method = getattr(data, 'set_active_%s'%data_type)
if len(name) == 0:
# If the value is empty then we deactivate that attribute.
method(None)
else:
aa = self._assign_attribute
method(name)
aa.assign(name, data_type.upper(), category.upper() +'_DATA')
aa.update()
def _find_array(self, name, category='point'):
"""Return information on which kind of attribute contains the
specified named array in a particular category."""
types = ['scalars', 'vectors', 'tensors']
for type in types:
attr = '%s_%s'%(category, type)
d = getattr(self, attr)
if name in d.keys():
return type
raise KeyError('No %s array named %s available in dataset'
%(category, name))
| bsd-3-clause | -8,936,205,743,073,525,000 | 35.767442 | 81 | 0.519713 | false |
iproduct/course-social-robotics | 11-dnn-keras/venv/Lib/site-packages/matplotlib/sphinxext/mathmpl.py | 1 | 3759 | import hashlib
from pathlib import Path
from docutils import nodes
from docutils.parsers.rst import Directive, directives
import sphinx
import matplotlib as mpl
from matplotlib import cbook
from matplotlib.mathtext import MathTextParser
mathtext_parser = MathTextParser("Bitmap")
# Define LaTeX math node:
class latex_math(nodes.General, nodes.Element):
pass
def fontset_choice(arg):
return directives.choice(arg, MathTextParser._font_type_mapping)
def math_role(role, rawtext, text, lineno, inliner,
options={}, content=[]):
i = rawtext.find('`')
latex = rawtext[i+1:-1]
node = latex_math(rawtext)
node['latex'] = latex
node['fontset'] = options.get('fontset', 'cm')
return [node], []
math_role.options = {'fontset': fontset_choice}
class MathDirective(Directive):
has_content = True
required_arguments = 0
optional_arguments = 0
final_argument_whitespace = False
option_spec = {'fontset': fontset_choice}
def run(self):
latex = ''.join(self.content)
node = latex_math(self.block_text)
node['latex'] = latex
node['fontset'] = self.options.get('fontset', 'cm')
return [node]
# This uses mathtext to render the expression
def latex2png(latex, filename, fontset='cm'):
latex = "$%s$" % latex
with mpl.rc_context({'mathtext.fontset': fontset}):
if Path(filename).exists():
depth = mathtext_parser.get_depth(latex, dpi=100)
else:
try:
depth = mathtext_parser.to_png(filename, latex, dpi=100)
except Exception:
cbook._warn_external(
f"Could not render math expression {latex}")
depth = 0
return depth
# LaTeX to HTML translation stuff:
def latex2html(node, source):
inline = isinstance(node.parent, nodes.TextElement)
latex = node['latex']
fontset = node['fontset']
name = 'math-{}'.format(
hashlib.md5((latex + fontset).encode()).hexdigest()[-10:])
destdir = Path(setup.app.builder.outdir, '_images', 'mathmpl')
destdir.mkdir(parents=True, exist_ok=True)
dest = destdir / f'{name}.png'
depth = latex2png(latex, dest, fontset)
if inline:
cls = ''
else:
cls = 'class="center" '
if inline and depth != 0:
style = 'style="position: relative; bottom: -%dpx"' % (depth + 1)
else:
style = ''
return (f'<img src="{setup.app.builder.imgpath}/mathmpl/{name}.png"'
f' {cls}{style}/>')
def setup(app):
setup.app = app
# Add visit/depart methods to HTML-Translator:
def visit_latex_math_html(self, node):
source = self.document.attributes['source']
self.body.append(latex2html(node, source))
def depart_latex_math_html(self, node):
pass
# Add visit/depart methods to LaTeX-Translator:
def visit_latex_math_latex(self, node):
inline = isinstance(node.parent, nodes.TextElement)
if inline:
self.body.append('$%s$' % node['latex'])
else:
self.body.extend(['\\begin{equation}',
node['latex'],
'\\end{equation}'])
def depart_latex_math_latex(self, node):
pass
app.add_node(latex_math,
html=(visit_latex_math_html, depart_latex_math_html),
latex=(visit_latex_math_latex, depart_latex_math_latex))
app.add_role('mathmpl', math_role)
app.add_directive('mathmpl', MathDirective)
if sphinx.version_info < (1, 8):
app.add_role('math', math_role)
app.add_directive('math', MathDirective)
metadata = {'parallel_read_safe': True, 'parallel_write_safe': True}
return metadata
| gpl-2.0 | 8,906,122,994,853,540,000 | 28.833333 | 73 | 0.611865 | false |
mitodl/bootcamp-ecommerce | profiles/utils_test.py | 1 | 2363 | """User utils tests"""
import pytest
from profiles.utils import ensure_active_user, is_duplicate_username_error, usernameify
@pytest.mark.parametrize(
"full_name,email,expected_username",
[
[" John Doe ", None, "john-doe"],
["Tabby Tabberson", None, "tabby-tabberson"],
["Àccèntèd Ñame, Ësq.", None, "àccèntèd-ñame-ësq"],
["-Dashy_St._Underscores-", None, "dashy-st-underscores"],
["Repeated-----Chars___Jr.", None, "repeated-chars-jr"],
["Numbers123 !$!@ McStrange!!##^", None, "numbers-mcstrange"],
["Кирил Френков", None, "кирил-френков"],
["年號", None, "年號"],
["abcdefghijklmnopqrstuvwxyz", None, "abcdefghijklmnopqrst"],
["ai bi cı dI eİ fI", None, "ai-bi-ci-di-ei-fi"],
["", "[email protected]", "someemail"],
],
)
def test_usernameify(mocker, full_name, email, expected_username):
"""usernameify should turn a user's name into a username, or use the email if necessary"""
# Change the username max length to 20 for test data simplicity's sake
temp_username_max_len = 20
mocker.patch("profiles.utils.USERNAME_MAX_LEN", temp_username_max_len)
patched_log_error = mocker.patch("profiles.utils.log.error")
assert usernameify(full_name, email=email) == expected_username
assert patched_log_error.called == bool(email and not full_name)
def test_usernameify_fail():
"""usernameify should raise an exception if the full name and email both fail to produce a username"""
with pytest.raises(ValueError):
assert usernameify("!!!", email="[email protected]")
@pytest.mark.parametrize(
"exception_text,expected_value",
[
["DETAILS: (username)=(ABCDEFG) already exists", True],
["DETAILS: (email)=(ABCDEFG) already exists", False],
],
)
def test_is_duplicate_username_error(exception_text, expected_value):
"""
is_duplicate_username_error should return True if the exception text provided indicates a duplicate username error
"""
assert is_duplicate_username_error(exception_text) is expected_value
def test_ensure_active_user(user):
"""
Test that ensure_active_user activates
"""
user.is_active = False
user.save()
assert not user.is_active
ensure_active_user(user)
assert user.is_active
| bsd-3-clause | -5,640,492,194,927,244,000 | 35.809524 | 118 | 0.660198 | false |
akshayms/eho | eho/server/storage/models.py | 1 | 8401 | # Copyright (c) 2013 Mirantis Inc.
#
# 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 uuid import uuid4
from eho.server.storage.storage import DB
class NodeTemplate(DB.Model):
__tablename__ = 'NodeTemplate'
id = DB.Column(DB.String(36), primary_key=True)
name = DB.Column(DB.String(80), unique=True, nullable=False)
node_type_id = DB.Column(DB.String(36), DB.ForeignKey('NodeType.id'),
nullable=False)
tenant_id = DB.Column(DB.String(36), nullable=False) # is it needed?
flavor_id = DB.Column(DB.String(36), nullable=False)
node_template_configs = DB.relationship('NodeTemplateConfig',
cascade="all,delete",
backref='node_template')
cluster_node_counts = DB.relationship('ClusterNodeCount',
cascade="all,delete",
backref='node_template')
nodes = DB.relationship('Node', cascade="all,delete",
backref='node_template')
def __init__(self, name, node_type_id, tenant_id, flavor_id):
self.id = uuid4().hex
self.name = name
self.node_type_id = node_type_id
self.tenant_id = tenant_id
self.flavor_id = flavor_id
def __repr__(self):
return '<NodeTemplate %s / %s>' % (self.name, self.node_type_id)
class Cluster(DB.Model):
__tablename__ = 'Cluster'
id = DB.Column(DB.String(36), primary_key=True)
name = DB.Column(DB.String(80), unique=True, nullable=False)
base_image_id = DB.Column(DB.String(36), nullable=False)
status = DB.Column(DB.String(80))
tenant_id = DB.Column(DB.String(36), nullable=False)
nodes = DB.relationship('Node', cascade="all,delete", backref='cluster')
service_urls = DB.relationship('ServiceUrl', cascade="all,delete",
backref='cluster')
node_counts = DB.relationship('ClusterNodeCount', cascade="all,delete",
backref='cluster')
# node_templates: [(node_template_id, count), ...]
def __init__(self, name, base_image_id, tenant_id, status=None):
self.id = uuid4().hex
self.name = name
self.base_image_id = base_image_id
if not status:
status = 'Starting'
self.status = status
self.tenant_id = tenant_id
def __repr__(self):
return '<Cluster %s / %s>' % (self.name, self.status)
NODE_TYPE_NODE_PROCESS = DB.Table('NodeType_NodeProcess', DB.metadata,
DB.Column('node_type_id', DB.String(36),
DB.ForeignKey('NodeType.id')),
DB.Column('node_process_id', DB.String(36),
DB.ForeignKey('NodeProcess.id')))
class NodeType(DB.Model):
__tablename__ = 'NodeType'
id = DB.Column(DB.String(36), primary_key=True)
name = DB.Column(DB.String(80), unique=True, nullable=False)
processes = DB.relationship('NodeProcess',
cascade="all,delete",
secondary=NODE_TYPE_NODE_PROCESS,
backref='node_types')
node_templates = DB.relationship('NodeTemplate', cascade="all,delete",
backref='node_type')
def __init__(self, name):
self.id = uuid4().hex
self.name = name
def __repr__(self):
return '<NodeType %s>' % self.name
class NodeProcess(DB.Model):
__tablename__ = 'NodeProcess'
id = DB.Column(DB.String(36), primary_key=True)
name = DB.Column(DB.String(80), unique=True, nullable=False)
node_process_properties = DB.relationship('NodeProcessProperty',
cascade="all,delete",
backref='node_process')
def __init__(self, name):
self.id = uuid4().hex
self.name = name
def __repr__(self):
return '<NodeProcess %s>' % self.name
class NodeProcessProperty(DB.Model):
__tablename__ = 'NodeProcessProperty'
__table_args__ = (
DB.UniqueConstraint('node_process_id', 'name'),
)
id = DB.Column(DB.String(36), primary_key=True)
node_process_id = DB.Column(DB.String(36), DB.ForeignKey('NodeProcess.id'))
name = DB.Column(DB.String(80), nullable=False)
required = DB.Column(DB.Boolean, nullable=False)
default = DB.Column(DB.String(36))
node_template_configs = DB.relationship('NodeTemplateConfig',
cascade="all,delete",
backref='node_process_property')
def __init__(self, node_process_id, name, required=True, default=None):
self.id = uuid4().hex
self.node_process_id = node_process_id
self.name = name
self.required = required
self.default = default
def __repr__(self):
return '<NodeProcessProperty %s>' % self.name
class NodeTemplateConfig(DB.Model):
__tablename__ = 'NodeTemplateConfig'
__table_args__ = (
DB.UniqueConstraint('node_template_id', 'node_process_property_id'),
)
id = DB.Column(DB.String(36), primary_key=True)
node_template_id = DB.Column(
DB.String(36),
DB.ForeignKey('NodeTemplate.id'))
node_process_property_id = DB.Column(
DB.String(36),
DB.ForeignKey('NodeProcessProperty.id'))
value = DB.Column(DB.String(36))
def __init__(self, node_template_id, node_process_property_id, value):
self.id = uuid4().hex
self.node_template_id = node_template_id
self.node_process_property_id = node_process_property_id
self.value = value
def __repr__(self):
return '<NodeTemplateConfig %s.%s / %s>' \
% (self.node_template_id, self.node_process_property_id,
self.value)
class ClusterNodeCount(DB.Model):
__tablename__ = 'ClusterNodeCount'
__table_args__ = (
DB.UniqueConstraint('cluster_id', 'node_template_id'),
)
id = DB.Column(DB.String(36), primary_key=True)
cluster_id = DB.Column(DB.String(36), DB.ForeignKey('Cluster.id'))
node_template_id = DB.Column(DB.String(36),
DB.ForeignKey('NodeTemplate.id'))
count = DB.Column(DB.Integer, nullable=False)
def __init__(self, cluster_id, node_template_id, count):
self.id = uuid4().hex
self.cluster_id = cluster_id
self.node_template_id = node_template_id
self.count = count
def __repr__(self):
return '<ClusterNodeCount %s / %s>' \
% (self.node_template_id, self.count)
class Node(DB.Model):
__tablename__ = 'Node'
# do we need own id?
vm_id = DB.Column(DB.String(36), primary_key=True)
cluster_id = DB.Column(DB.String(36), DB.ForeignKey('Cluster.id'))
node_template_id = DB.Column(DB.String(36),
DB.ForeignKey('NodeTemplate.id'))
def __init__(self, vm_id, cluster_id, node_template_id):
self.vm_id = vm_id
self.cluster_id = cluster_id
self.node_template_id = node_template_id
def __repr__(self):
return '<Node based on %s>' % self.node_template.name
class ServiceUrl(DB.Model):
__tablename__ = 'ServiceUrl'
id = DB.Column(DB.String(36), primary_key=True)
cluster_id = DB.Column(DB.String(36), DB.ForeignKey('Cluster.id'))
name = DB.Column(DB.String(80))
url = DB.Column(DB.String(80), nullable=False)
def __init__(self, cluster_id, name, url):
self.id = uuid4().hex
self.cluster_id = cluster_id
self.name = name
self.url = url
def __repr__(self):
return '<ServiceUrl %s / %s>' % (self.name, self.url)
| apache-2.0 | 8,855,471,069,699,424,000 | 34.901709 | 79 | 0.578145 | false |
VJftw/invoke-tools | invoke_tools/lxc/docker.py | 1 | 5987 | """
invoke_tools.lxc.docker
"""
from __future__ import print_function
import os
import json
import getpass
class Docker:
"""
Docker
"""
@staticmethod
def __print_line(line):
"""
"""
try:
line = line.decode('utf-8')
except:
print("Could not decode line")
return
try:
line = json.loads(line)
if "stream" in line:
line = line["stream"]
pass
elif "status" in line:
o = line["status"]
if "progress" in line:
o += "{0}".format(line["progress"])
if "id" in line:
o = "{0} {1}".format(line["id"], o)
if line["status"] == "Download complete" or "Pulling" in line["status"] or "Digest" in line["status"] or "Image" in line["status"] or "image" in line["status"]:
line = " {0}{1}\n".format(o, " " * 80)
else:
line = " {0}\r".format(o)
except:
pass
print(line, end="", flush=True)
@staticmethod
def pull(cli, image):
print("#")
print("# Pulling Docker image: {0}".format(image))
print("#")
for line in cli.pull(image, stream=True):
Docker.__print_line(line)
@staticmethod
def build(cli, dockerfile, tag):
print("#")
print("# Building Docker image from '{0}' with tag '{1}'".format(dockerfile, tag))
print("#")
for line in cli.build(
dockerfile=dockerfile,
pull=True,
path=".",
rm=True,
tag=tag):
Docker.__print_line(line)
print()
@staticmethod
def execute(cli, container_id, cmd):
print("#")
print("# Executing on {1}: {0}".format(cmd, container_id))
print("#")
exec_container = cli.exec_create(
container=container_id,
cmd=cmd
# user='root' if CI else 'app'
)
for line in cli.exec_start(
exec_id=exec_container.get('Id'),
stream=True):
Docker.__print_line(line)
print()
inspect = cli.exec_inspect(exec_container.get('Id'))
exit_code = inspect.get('ExitCode')
if exit_code != 0:
cli.stop(container_id)
cli.remove_container(container_id)
raise Exception("Exit Code: {0}\n{1}".format(exit_code, inspect))
@staticmethod
def clean(cli, objs):
print("#")
print("# Cleaning files & directories: {0}".format(objs))
print("#")
cli.pull("alpine:latest")
container = cli.create_container(
image='alpine:latest',
volumes=[
'{0}:/app'.format(os.getcwd())
],
working_dir='/app',
host_config=cli.create_host_config(binds=[
'{0}:/app'.format(os.getcwd())
]),
command='/bin/sh -c "rm -rf {0}"'.format(" ".join(objs))
)
response = cli.start(container=container.get('Id'))
cli.wait(container=container.get('Id'), timeout=600)
print(response)
cli.remove_container(container.get('Id'))
print()
@staticmethod
def push(cli, tags):
"""
"""
for tag in tags:
print("#")
print("# Pushing {0} to Registry".format(tag))
print("#")
for line in cli.push(tag, stream=True):
Docker.__print_line(line)
print()
@staticmethod
def login(cli):
"""
"""
if os.getenv('DOCKER_EMAIL') and os.getenv('DOCKER_USERNAME') and os.getenv('DOCKER_PASSWORD'):
email = os.getenv('DOCKER_EMAIL')
username = os.getenv('DOCKER_USERNAME')
password = os.getenv('DOCKER_PASSWORD')
else:
email = input('Docker email:')
username = input('Docker username:')
password = getpass.getpass('Docker password:')
cli.login(
username=username,
email=email,
password=password,
registry='https://index.docker.io/v1/'
)
print()
return cli, username
@staticmethod
def run(
cli,
tag,
command,
volumes=None,
working_dir="",
environment=None,
links=None,
detach=False,
privileged=False):
"""
"""
if environment is None:
environment = {}
if volumes is None:
volumes = []
print("#")
print("# Running on {1}: {0}".format(command, tag))
print("#")
params = dict()
params['image'] = tag
params['command'] = command
if len(volumes) > 0:
params['volumes'] = volumes
params['host_config'] = cli.create_host_config(binds=volumes, links=links, privileged=privileged)
if working_dir != "":
params['working_dir'] = working_dir
if environment:
params['environment'] = environment
if links:
params['host_config'] = cli.create_host_config(binds=volumes, links=links, privileged=privileged)
if privileged:
params['host_config'] = cli.create_host_config(binds=volumes, links=links, privileged=privileged)
container = cli.create_container(**params)
cli.start(container.get('Id'))
if detach:
return container
for line in cli.attach(container=container.get('Id'), stream=True, logs=True):
Docker.__print_line(line)
exit_code = cli.wait(container=container.get('Id'))
cli.remove_container(container.get('Id'))
if exit_code != 0:
raise Exception("Exit Code: {0}".format(exit_code))
| mit | 3,646,104,151,735,492,000 | 28.063107 | 176 | 0.496743 | false |
msoula/cosmicbox | board/cosmicbox/cosmicboxfs/lib/psogen.py | 1 | 4151 | #!/usr/bin/python
# Modificated ShoutBox Library
# enables further modifications for the ShoutBox
# Run without to generate htmlfile
# Run the following to enter a new line from command line
# psogen.py input Anonymous default "Text"
import os, re
import messages, broadcast
datafilename = os.environ["SHOUTBOX_CHATFILE"]
htmlfilename = os.environ["SHOUTBOX_GEN_HTMLFILE"]
style=("name { font-weight: bold; font-family:Tahoma } "
"data { font-family: Tahoma } "
"data.def { color: #000000 } "
"data.blue { color: #0000FF } "
"data.green { color: #008000 } "
"data.orange { color: #FF8040 } "
"data.red { color: #FF0000 }")
try:
raw_dest = os.environ["SHOUTBOX_BROADCAST_DESTINATIONS"]
finished_dest = re.sub ( '#' , '"' , raw_dest )
broadcast_destination = eval ( finished_dest )
except KeyError:
broadcast_destination = False
#--------------
# Generates Shoutbox-HTML-Frame ...
# Imports:
# content - String containing preformatted data
#--------------
def generate_html(content):
htmlstring = "<html><head><meta http-equiv='cache-control' content='no-cache'><meta name='GENERATOR' content='PyShoutOut'><title>Shout-Out Data</title>"
htmlstring += "<style type='text/css'>" + style + "</style></head><body>"
htmlstring += content
htmlstring += "</body></html>"
return htmlstring
#--------------
# Generates HTML Data based on given content and write it to static html file
# Imports:
# content - String containing preformatted data
#--------------
def generate_html_into_file(content):
htmlstring = generate_html ( content )
htmlfile = open( htmlfilename , 'w' )
htmlfile.write( htmlstring )
htmlfile.close()
#--------------
# Generates HTML Data based on datafilename 's content
#--------------
def generate_html_from_file():
old = read_data_file()
generate_html_into_file( old )
#--------------
# Generates and Displays generated HTML
#--------------
def generate_html_to_display_from_file():
old = read_data_file()
htmlstring = generate_html ( old )
print htmlstring
#--------------
# Reads Data file from datafilename given name
#--------------
def read_data_file():
datafile = open(datafilename, 'r')
old = datafile.read()
datafile.close()
return old
#--------------
# Function for saving new Shoubox-Content & Regenerate static HTML file -- usually called by HTML-Form
#--------------
def process_form( name , indata , color ):
content = save_input( name , indata , color )
if broadcast_destination == False:
generate_html_into_file ( content )
#--------------
# Acutally Saves SB-Content to datafile
#--------------
def save_input( name , indata , color ):
content = prepare_line ( name, indata, color )
if broadcast_destination != False:
return writeToNetwork( content , broadcast_destination )
else:
return writeToDisk ( content )
def writeToNetwork ( content , broadcast_destination ):
message = messages.shoutbox_message()
message.set(content)
casting = broadcast.broadcast( )
casting.setDestination(broadcast_destination)
casting.set( message.get_message() )
casting.send()
return None
def writeToDisk ( content ):
old = read_data_file()
finalcontent = content + old
datafile = open(datafilename, 'r+')
datafile.write(finalcontent)
datafile.close()
return finalcontent
def prepare_line ( name, indata, color ):
datapass = re.sub("<", "<", indata)
data = re.sub(">", ">", datapass)
content = "<name>" + name + ":</name> <data class='" + color + "'>" + data + "</data><br>\n"
return content
#--------------
# Testing or Generating static HTML File
#--------------
if __name__ == "__main__":
import sys
if sys.argv.count("input") >= 1 :
save_input( sys.argv[2] , sys.argv[3] , sys.argv[4] )
generate_html_to_display_from_file()
print "Entered Text."
generate_html_from_file ()
print "Generated HTML-Shoutbox File."
| gpl-2.0 | -128,107,883,562,125,100 | 28.65 | 158 | 0.611419 | false |