http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/8ee1470e/extensions/aria_extension_tosca/simple_v1_0/types.py ---------------------------------------------------------------------- diff --git a/extensions/aria_extension_tosca/simple_v1_0/types.py b/extensions/aria_extension_tosca/simple_v1_0/types.py new file mode 100644 index 0000000..37608a2 --- /dev/null +++ b/extensions/aria_extension_tosca/simple_v1_0/types.py @@ -0,0 +1,859 @@ +# Licensed to the Apache Software Foundation (ASF) under one or more +# contributor license agreements. See the NOTICE file distributed with +# this work for additional information regarding copyright ownership. +# The ASF licenses this file to You under the Apache License, Version 2.0 +# (the "License"); you may not use this file except in compliance with +# the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from aria.parser import dsl_specification +from aria.parser.presentation import (has_fields, allow_unknown_fields, primitive_field, + primitive_list_field, object_field, object_dict_field, + object_list_field, object_sequenced_list_field, + object_dict_unknown_fields, field_getter, field_validator, + list_type_validator, derived_from_validator, + get_parent_presentation) +from aria.parser.utils import (FrozenDict, FrozenList, cachedmethod) + +from .assignments import ArtifactAssignment +from .data_types import Version +from .definitions import (PropertyDefinition, AttributeDefinition, InterfaceDefinition, + RequirementDefinition, CapabilityDefinition, OperationDefinition) +from .misc import (Description, ConstraintClause) +from .modeling.artifacts import get_inherited_artifact_definitions +from .modeling.capabilities import (get_inherited_valid_source_types, + get_inherited_capability_definitions) +from .modeling.data_types import (get_data_type, get_inherited_constraints, coerce_data_type_value, + validate_data_type_name) +from .modeling.interfaces import get_inherited_interface_definitions, get_inherited_operations +from .modeling.policies import get_inherited_targets +from .modeling.properties import get_inherited_property_definitions +from .modeling.requirements import get_inherited_requirement_definitions +from .presentation.extensible import ExtensiblePresentation +from .presentation.field_getters import data_type_class_getter +from .presentation.field_validators import (data_type_derived_from_validator, + data_type_constraints_validator, + data_type_properties_validator, + list_node_type_or_group_type_validator) +from .presentation.types import convert_shorthand_to_full_type_name + +@has_fields +@dsl_specification('3.6.3', 'tosca-simple-1.0') +class ArtifactType(ExtensiblePresentation): + """ + An Artifact Type is a reusable entity that defines the type of one or more files that are used + to define implementation or deployment artifacts that are referenced by nodes or relationships + on their operations. + + See the `TOSCA Simple Profile v1.0 cos01 specification <http://docs.oasis-open.org/tosca + /TOSCA-Simple-Profile-YAML/v1.0/cos01/TOSCA-Simple-Profile-YAML-v1.0-cos01.html + #DEFN_ENTITY_ARTIFACT_TYPE>`__ + """ + + @field_validator(derived_from_validator(convert_shorthand_to_full_type_name, 'artifact_types')) + @primitive_field(str) + def derived_from(self): + """ + An optional parent Artifact Type name the Artifact Type derives from. + + :rtype: str + """ + + @field_getter(data_type_class_getter(Version)) + @primitive_field() + def version(self): + """ + An optional version for the Artifact Type definition. + + :rtype: :class:`Version` + """ + + @object_field(Description) + def description(self): + """ + An optional description for the Artifact Type. + + :rtype: :class:`Description` + """ + + @primitive_field(str) + def mime_type(self): + """ + The required mime type property for the Artifact Type. + + :rtype: str + """ + + @primitive_list_field(str) + def file_ext(self): + """ + The required file extension property for the Artifact Type. + + :rtype: list of str + """ + + @object_dict_field(PropertyDefinition) + def properties(self): + """ + An optional list of property definitions for the Artifact Type. + + :rtype: dict of str, :class:`PropertyDefinition` + """ + + @cachedmethod + def _get_parent(self, context): + return get_parent_presentation(context, self, convert_shorthand_to_full_type_name, + 'artifact_types') + + @cachedmethod + def _get_properties(self, context): + return FrozenDict(get_inherited_property_definitions(context, self, 'properties')) + + def _validate(self, context): + super(ArtifactType, self)._validate(context) + self._get_properties(context) + + def _dump(self, context): + self._dump_content(context, ( + 'description', + 'version', + 'derived_from', + 'mime_type', + 'file_ext', + 'properties')) + +@has_fields +@dsl_specification('3.6.5', 'tosca-simple-1.0') +class DataType(ExtensiblePresentation): + """ + A Data Type definition defines the schema for new named datatypes in TOSCA. + + See the `TOSCA Simple Profile v1.0 cos01 specification <http://docs.oasis-open.org/tosca + /TOSCA-Simple-Profile-YAML/v1.0/cos01/TOSCA-Simple-Profile-YAML-v1.0-cos01.html + #DEFN_ENTITY_DATA_TYPE>`__ + """ + + @field_validator(data_type_derived_from_validator) + @primitive_field(str) + def derived_from(self): + """ + The optional key used when a datatype is derived from an existing TOSCA Data Type. + + :rtype: str + """ + + @object_field(Version) + def version(self): + """ + An optional version for the Data Type definition. + + :rtype: :class:`Version` + """ + + @object_field(Description) + def description(self): + """ + The optional description for the Data Type. + + :rtype: :class:`Description` + """ + + @field_validator(data_type_constraints_validator) + @object_list_field(ConstraintClause) + def constraints(self): + """ + The optional list of sequenced constraint clauses for the Data Type. + + :rtype: list of (str, :class:`ConstraintClause`) + """ + + @field_validator(data_type_properties_validator) + @object_dict_field(PropertyDefinition) + def properties(self): + """ + The optional list property definitions that comprise the schema for a complex Data Type in + TOSCA. + + :rtype: dict of str, :class:`PropertyDefinition` + """ + + @cachedmethod + def _get_parent(self, context): + return get_data_type(context, self, 'derived_from', allow_none=True) + + @cachedmethod + def _get_primitive_ancestor(self, context): + parent = self._get_parent(context) + if parent is not None: + if not isinstance(parent, DataType): + return parent + else: + return parent._get_primitive_ancestor(context) # pylint: disable=no-member + return None + + @cachedmethod + def _get_properties(self, context): + return FrozenDict(get_inherited_property_definitions(context, self, 'properties')) + + @cachedmethod + def _get_constraints(self, context): + return get_inherited_constraints(context, self) + + def _validate(self, context): + super(DataType, self)._validate(context) + validate_data_type_name(context, self) + self._get_properties(context) + + def _coerce_value(self, context, presentation, entry_schema, constraints, value, aspect): + return coerce_data_type_value(context, presentation, self, entry_schema, constraints, value, + aspect) + + def _dump(self, context): + self._dump_content(context, ( + 'description', + 'version', + 'derived_from', + 'constraints', + 'properties')) + +@has_fields +@dsl_specification('3.6.6', 'tosca-simple-1.0') +class CapabilityType(ExtensiblePresentation): + """ + A Capability Type is a reusable entity that describes a kind of capability that a Node Type can + declare to expose. Requirements (implicit or explicit) that are declared as part of one node can + be matched to (i.e., fulfilled by) the Capabilities declared by another node. + + See the `TOSCA Simple Profile v1.0 cos01 specification <http://docs.oasis-open.org/tosca + /TOSCA-Simple-Profile-YAML/v1.0/cos01/TOSCA-Simple-Profile-YAML-v1.0-cos01.html + #DEFN_ENTITY_CAPABILITY_TYPE>`__ + """ + + @field_validator(derived_from_validator(convert_shorthand_to_full_type_name, + 'capability_types')) + @primitive_field(str) + def derived_from(self): + """ + An optional parent capability type name this new Capability Type derives from. + + :rtype: str + """ + + @object_field(Version) + def version(self): + """ + An optional version for the Capability Type definition. + + :rtype: :class:`Version` + """ + + @object_field(Description) + def description(self): + """ + An optional description for the Capability Type. + + :rtype: :class:`Description` + """ + + @object_dict_field(PropertyDefinition) + def properties(self): + """ + An optional list of property definitions for the Capability Type. + + ARIA NOTE: The spec says 'list', but the examples are all of dicts. + + :rtype: dict of str, :class:`PropertyDefinition` + """ + + @object_dict_field(AttributeDefinition) + def attributes(self): + """ + An optional list of attribute definitions for the Capability Type. + + :rtype: dict of str, :class:`AttributeDefinition` + """ + + @field_validator(list_type_validator('node type', convert_shorthand_to_full_type_name, + 'node_types')) + @primitive_list_field(str) + def valid_source_types(self): + """ + An optional list of one or more valid names of Node Types that are supported as valid + sources of any relationship established to the declared Capability Type. + + :rtype: list of str + """ + + @cachedmethod + def _get_parent(self, context): + return get_parent_presentation(context, self, convert_shorthand_to_full_type_name, + 'capability_types') + + @cachedmethod + def _is_descendant(self, context, the_type): + if the_type is None: + return False + elif the_type._name == self._name: + return True + return self._is_descendant(context, the_type._get_parent(context)) + + @cachedmethod + def _get_properties(self, context): + return FrozenDict(get_inherited_property_definitions(context, self, 'properties')) + + @cachedmethod + def _get_valid_source_types(self, context): + return get_inherited_valid_source_types(context, self) + + def _validate(self, context): + super(CapabilityType, self)._validate(context) + self._get_properties(context) + + def _dump(self, context): + self._dump_content(context, ( + 'description', + 'version', + 'derived_from', + 'valid_source_types', + 'properties', + 'attributes')) + +@allow_unknown_fields +@has_fields +@dsl_specification('3.6.4', 'tosca-simple-1.0') +class InterfaceType(ExtensiblePresentation): + """ + An Interface Type is a reusable entity that describes a set of operations that can be used to + interact with or manage a node or relationship in a TOSCA topology. + + See the `TOSCA Simple Profile v1.0 cos01 specification <http://docs.oasis-open.org/tosca + /TOSCA-Simple-Profile-YAML/v1.0/cos01/TOSCA-Simple-Profile-YAML-v1.0-cos01.html + #DEFN_ENTITY_INTERFACE_TYPE>`__ + """ + + @field_validator(derived_from_validator(convert_shorthand_to_full_type_name, 'interface_types')) + @primitive_field(str) + def derived_from(self): + """ + An optional parent Interface Type name this new Interface Type derives from. + + :rtype: str + """ + + @object_field(Version) + def version(self): + """ + An optional version for the Interface Type definition. + + :rtype: :class:`Version` + """ + + @object_field(Description) + def description(self): + """ + An optional description for the Interface Type. + + :rtype: :class:`Description` + """ + + @object_dict_field(PropertyDefinition) + def inputs(self): + """ + The optional list of input parameter definitions. + + :rtype: dict of str, :class:`PropertyDefinition` + """ + + @object_dict_unknown_fields(OperationDefinition) + def operations(self): + """ + :rtype: dict of str, :class:`OperationDefinition` + """ + + @cachedmethod + def _get_parent(self, context): + return get_parent_presentation(context, self, convert_shorthand_to_full_type_name, + 'interface_types') + + @cachedmethod + def _get_inputs(self, context): + return FrozenDict(get_inherited_property_definitions(context, self, 'inputs')) + + @cachedmethod + def _get_operations(self, context): + return FrozenDict(get_inherited_operations(context, self)) + + def _validate(self, context): + super(InterfaceType, self)._validate(context) + self._get_inputs(context) + for operation in self.operations.itervalues(): # pylint: disable=no-member + operation._validate(context) + + def _dump(self, context): + self._dump_content(context, ( + 'description', + 'version', + 'derived_from', + 'inputs', + 'operations')) + +@has_fields +@dsl_specification('3.6.9', 'tosca-simple-1.0') +class RelationshipType(ExtensiblePresentation): + """ + A Relationship Type is a reusable entity that defines the type of one or more relationships + between Node Types or Node Templates. + + See the `TOSCA Simple Profile v1.0 cos01 specification <http://docs.oasis-open.org/tosca + /TOSCA-Simple-Profile-YAML/v1.0/cos01/TOSCA-Simple-Profile-YAML-v1.0-cos01.html + #DEFN_ENTITY_RELATIONSHIP_TYPE>`__ + """ + + @field_validator(derived_from_validator(convert_shorthand_to_full_type_name, + 'relationship_types')) + @primitive_field(str) + def derived_from(self): + """ + An optional parent Relationship Type name the Relationship Type derives from. + + :rtype: str + """ + + @object_field(Version) + def version(self): + """ + An optional version for the Relationship Type definition. + + :rtype: :class:`Version` + """ + + @object_field(Description) + def description(self): + """ + An optional description for the Relationship Type. + + :rtype: :class:`Description` + """ + + @object_dict_field(PropertyDefinition) + def properties(self): + """ + An optional list of property definitions for the Relationship Type. + + :rtype: dict of str, :class:`PropertyDefinition` + """ + + @object_dict_field(AttributeDefinition) + def attributes(self): + """ + An optional list of attribute definitions for the Relationship Type. + + :rtype: dict of str, :class:`AttributeDefinition` + """ + + @object_dict_field(InterfaceDefinition) + def interfaces(self): + """ + An optional list of interface definitions interfaces supported by the Relationship Type. + + :rtype: dict of str, :class:`InterfaceDefinition` + """ + + @field_validator(list_type_validator('capability type', convert_shorthand_to_full_type_name, + 'capability_types')) + @primitive_list_field(str) + def valid_target_types(self): + """ + An optional list of one or more names of Capability Types that are valid targets for this + relationship. + + :rtype: list of str + """ + + @cachedmethod + def _get_parent(self, context): + return get_parent_presentation(context, self, convert_shorthand_to_full_type_name, + 'relationship_types') + + @cachedmethod + def _get_properties(self, context): + return FrozenDict(get_inherited_property_definitions(context, self, 'properties')) + + @cachedmethod + def _get_attributes(self, context): + return FrozenDict(get_inherited_property_definitions(context, self, 'attributes')) + + @cachedmethod + def _get_interfaces(self, context): + return FrozenDict(get_inherited_interface_definitions(context, self, 'relationship type')) + + def _validate(self, context): + super(RelationshipType, self)._validate(context) + self._get_properties(context) + self._get_attributes(context) + self._get_interfaces(context) + + def _dump(self, context): + self._dump_content(context, ( + 'description', + 'version', + 'derived_from', + 'valid_target_types', + 'properties', + 'attributes', + 'interfaces')) + +@has_fields +@dsl_specification('3.6.8', 'tosca-simple-1.0') +class NodeType(ExtensiblePresentation): + """ + A Node Type is a reusable entity that defines the type of one or more Node Templates. As such, a + Node Type defines the structure of observable properties via a Properties Definition, the + Requirements and Capabilities of the node as well as its supported interfaces. + + See the `TOSCA Simple Profile v1.0 cos01 specification <http://docs.oasis-open.org/tosca + /TOSCA-Simple-Profile-YAML/v1.0/cos01/TOSCA-Simple-Profile-YAML-v1.0-cos01.html + #DEFN_ENTITY_NODE_TYPE>`__ + """ + + @field_validator(derived_from_validator(convert_shorthand_to_full_type_name, 'node_types')) + @primitive_field(str) + def derived_from(self): + """ + An optional parent Node Type name this new Node Type derives from. + + :rtype: str + """ + + @object_field(Version) + def version(self): + """ + An optional version for the Node Type definition. + + :rtype: :class:`Version` + """ + + @object_field(Description) + def description(self): + """ + An optional description for the Node Type. + + :rtype: :class:`Description` + """ + + @object_dict_field(PropertyDefinition) + def properties(self): + """ + An optional list of property definitions for the Node Type. + + :rtype: dict of str, :class:`PropertyDefinition` + """ + + @object_dict_field(AttributeDefinition) + def attributes(self): + """ + An optional list of attribute definitions for the Node Type. + + :rtype: dict of str, :class:`AttributeDefinition` + """ + + @object_sequenced_list_field(RequirementDefinition) + def requirements(self): + """ + An optional sequenced list of requirement definitions for the Node Type. + + ARIA NOTE: The spec seems wrong to make this a sequenced list. It seems that when you have + more than one requirement of the same name, behavior is undefined. The idea is to use the + "occurrences" field if you need to limit the number of requirement assignments. + + :rtype: list of (str, :class:`RequirementDefinition`) + """ + + @object_dict_field(CapabilityDefinition) + def capabilities(self): + """ + An optional list of capability definitions for the Node Type. + + :rtype: list of :class:`CapabilityDefinition` + """ + + @object_dict_field(InterfaceDefinition) + def interfaces(self): + """ + An optional list of interface definitions supported by the Node Type. + + :rtype: dict of str, :class:`InterfaceDefinition` + """ + + @object_dict_field(ArtifactAssignment) + def artifacts(self): + """ + An optional list of named artifact definitions for the Node Type. + + :rtype: dict of str, :class:`ArtifactAssignment` + """ + + @cachedmethod + def _get_parent(self, context): + return get_parent_presentation(context, self, convert_shorthand_to_full_type_name, + 'node_types') + + @cachedmethod + def _is_descendant(self, context, the_type): + if the_type is None: + return False + elif the_type._name == self._name: + return True + return self._is_descendant(context, the_type._get_parent(context)) + + @cachedmethod + def _get_properties(self, context): + return FrozenDict(get_inherited_property_definitions(context, self, 'properties')) + + @cachedmethod + def _get_attributes(self, context): + return FrozenDict(get_inherited_property_definitions(context, self, 'attributes')) + + @cachedmethod + def _get_requirements(self, context): + return FrozenList(get_inherited_requirement_definitions(context, self)) + + @cachedmethod + def _get_capabilities(self, context): + return FrozenDict(get_inherited_capability_definitions(context, self)) + + @cachedmethod + def _get_interfaces(self, context): + return FrozenDict(get_inherited_interface_definitions(context, self, 'node type')) + + @cachedmethod + def _get_artifacts(self, context): + return FrozenDict(get_inherited_artifact_definitions(context, self)) + + def _validate(self, context): + super(NodeType, self)._validate(context) + self._get_properties(context) + self._get_attributes(context) + self._get_requirements(context) + self._get_capabilities(context) + self._get_interfaces(context) + self._get_artifacts(context) + + def _dump(self, context): + self._dump_content(context, ( + 'description', + 'version', + 'derived_from', + 'properties', + 'attributes', + 'interfaces', + 'artifacts', + 'requirements', + 'capabilities')) + +@has_fields +@dsl_specification('3.6.10', 'tosca-simple-1.0') +class GroupType(ExtensiblePresentation): + """ + A Group Type defines logical grouping types for nodes, typically for different management + purposes. Groups can effectively be viewed as logical nodes that are not part of the physical + deployment topology of an application, yet can have capabilities and the ability to attach + policies and interfaces that can be applied (depending on the group type) to its member nodes. + + Conceptually, group definitions allow the creation of logical "membership" relationships to + nodes in a service template that are not a part of the application's explicit requirement + dependencies in the topology template (i.e. those required to actually get the application + deployed and running). Instead, such logical membership allows for the introduction of things + such as group management and uniform application of policies (i.e., requirements that are also + not bound to the application itself) to the group's members. + + See the `TOSCA Simple Profile v1.0 cos01 specification <http://docs.oasis-open.org/tosca + /TOSCA-Simple-Profile-YAML/v1.0/cos01/TOSCA-Simple-Profile-YAML-v1.0-cos01.html + #DEFN_ENTITY_GROUP_TYPE>`__ + """ + + @field_validator(derived_from_validator(convert_shorthand_to_full_type_name, 'group_types')) + @primitive_field(str) + def derived_from(self): + """ + An optional parent Group Type name the Group Type derives from. + + :rtype: str + """ + + @object_field(Version) + def version(self): + """ + An optional version for the Group Type definition. + + :rtype: :class:`Version` + """ + + @object_field(Description) + def description(self): + """ + The optional description for the Group Type. + + :rtype: :class:`Description` + """ + + @object_dict_field(PropertyDefinition) + def properties(self): + """ + An optional list of property definitions for the Group Type. + + :rtype: dict of str, :class:`PropertyDefinition` + """ + + @field_validator(list_type_validator('node type', convert_shorthand_to_full_type_name, + 'node_types')) + @primitive_list_field(str) + def members(self): + """ + An optional list of one or more names of Node Types that are valid (allowed) as members of + the Group Type. + + Note: This can be viewed by TOSCA Orchestrators as an implied relationship from the listed + members nodes to the group, but one that does not have operational lifecycle considerations. + For example, if we were to name this as an explicit Relationship Type we might call this + "MemberOf" (group). + + :rtype: list of str + """ + + @object_dict_field(InterfaceDefinition) + def interfaces(self): + """ + An optional list of interface definitions supported by the Group Type. + + :rtype: dict of str, :class:`InterfaceDefinition` + """ + + @cachedmethod + def _get_parent(self, context): + return get_parent_presentation(context, self, convert_shorthand_to_full_type_name, + 'group_types') + + @cachedmethod + def _is_descendant(self, context, the_type): + if the_type is None: + return False + elif the_type._name == self._name: + return True + return self._is_descendant(context, the_type._get_parent(context)) + + @cachedmethod + def _get_properties(self, context): + return FrozenDict(get_inherited_property_definitions(context, self, 'properties')) + + @cachedmethod + def _get_interfaces(self, context): + return FrozenDict(get_inherited_interface_definitions(context, self, 'group type')) + + def _validate(self, context): + super(GroupType, self)._validate(context) + self._get_properties(context) + self._get_interfaces(context) + + def _dump(self, context): + self._dump_content(context, ( + 'description', + 'version', + 'derived_from', + 'members', + 'properties', + 'interfaces')) + +@has_fields +@dsl_specification('3.6.11', 'tosca-simple-1.0') +class PolicyType(ExtensiblePresentation): + """ + A Policy Type defines a type of requirement that affects or governs an application or service's + topology at some stage of its lifecycle, but is not explicitly part of the topology itself + (i.e., it does not prevent the application or service from being deployed or run if it did not + exist). + + See the `TOSCA Simple Profile v1.0 cos01 specification <http://docs.oasis-open.org/tosca + /TOSCA-Simple-Profile-YAML/v1.0/cos01/TOSCA-Simple-Profile-YAML-v1.0-cos01.html + #DEFN_ENTITY_POLICY_TYPE>`__ + """ + + @field_validator(derived_from_validator(convert_shorthand_to_full_type_name, 'policy_types')) + @primitive_field(str) + def derived_from(self): + """ + An optional parent Policy Type name the Policy Type derives from. + + :rtype: str + """ + + @object_field(Version) + def version(self): + """ + An optional version for the Policy Type definition. + + :rtype: :class:`Version` + """ + + @object_field(Description) + def description(self): + """ + The optional description for the Policy Type. + + :rtype: :class:`Description` + """ + + @object_dict_field(PropertyDefinition) + def properties(self): + """ + An optional list of property definitions for the Policy Type. + + :rtype: :class:`PropertyDefinition` + """ + + @field_validator(list_node_type_or_group_type_validator) + @primitive_list_field(str) + def targets(self): + """ + An optional list of valid Node Types or Group Types the Policy Type can be applied to. + + Note: This can be viewed by TOSCA Orchestrators as an implied relationship to the target + nodes, but one that does not have operational lifecycle considerations. For example, if we + were to name this as an explicit Relationship Type we might call this "AppliesTo" (node or + group). + + :rtype: list of str + """ + + @cachedmethod + def _get_parent(self, context): + return get_parent_presentation(context, self, convert_shorthand_to_full_type_name, + 'policy_types') + + @cachedmethod + def _get_properties(self, context): + return FrozenDict(get_inherited_property_definitions(context, self, 'properties')) + + @cachedmethod + def _get_targets(self, context): + node_types, group_types = get_inherited_targets(context, self) + return FrozenList(node_types), FrozenList(group_types) + + def _validate(self, context): + super(PolicyType, self)._validate(context) + self._get_properties(context) + + def _dump(self, context): + self._dump_content(context, ( + 'description', + 'version', + 'derived_from', + 'targets', + 'properties'))
http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/8ee1470e/requirements.txt ---------------------------------------------------------------------- diff --git a/requirements.txt b/requirements.txt index b550a58..a9a7963 100644 --- a/requirements.txt +++ b/requirements.txt @@ -18,3 +18,9 @@ blinker==1.4 importlib==1.0.4 ; python_version < '2.7' ordereddict==1.1 ; python_version < '2.7' jsonpickle +ruamel.yaml==0.11.15 +Jinja2==2.8 +shortuuid==0.4.3 +CacheControl[filecache]==0.11.6 +clint==0.5.1 +python-daemon==2.1.2 \ No newline at end of file http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/8ee1470e/setup.py ---------------------------------------------------------------------- diff --git a/setup.py b/setup.py index 6d7a30c..14c5873 100644 --- a/setup.py +++ b/setup.py @@ -40,11 +40,35 @@ except IOError: setup( name=_PACKAGE_NAME, version=version, - author='aria-core', + description='ARIA', + license='Apache License Version 2.0', + author='aria', author_email='dev@ariatosca.incubator.apache.org', + url='http://ariatosca.org', + + classifiers=[ + 'Development Status :: 4 - Beta', + 'Environment :: Console', + 'Environment :: Web Environment', + 'Intended Audience :: Developers', + 'Intended Audience :: System Administrators', + 'License :: OSI Approved :: Apache Software License', + 'Operating System :: OS Independent', + 'Programming Language :: Python', + 'Topic :: Software Development :: Libraries :: Python Modules', + 'Topic :: System :: Networking', + 'Topic :: System :: Systems Administration'], + packages=find_packages(exclude=('*tests*',)), - license='LICENSE', - description='ARIA Project', + package_data={ + 'aria.tools': [ + 'web/**'], + 'aria_extension_tosca': [ + 'profiles/tosca-simple-1.0/**', + 'profiles/tosca-simple-nfv-1.0/**'], + 'aria_extension_open_o': [ + 'web/**']}, + zip_safe=False, install_requires=install_requires, entry_points={ http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/8ee1470e/tests/.pylintrc ---------------------------------------------------------------------- diff --git a/tests/.pylintrc b/tests/.pylintrc index 5556304..23251af 100644 --- a/tests/.pylintrc +++ b/tests/.pylintrc @@ -77,7 +77,7 @@ confidence= # --enable=similarities". If you want to run only the classes checker, but have # no Warning level messages displayed, use"--disable=all --enable=classes # --disable=W" -disable=import-star-module-level,old-octal-literal,oct-method,print-statement,unpacking-in-except,parameter-unpacking,backtick,old-raise-syntax,old-ne-operator,long-suffix,dict-view-method,dict-iter-method,metaclass-assignment,next-method-called,raising-string,indexing-exception,raw_input-builtin,long-builtin,file-builtin,execfile-builtin,coerce-builtin,cmp-builtin,buffer-builtin,basestring-builtin,apply-builtin,filter-builtin-not-iterating,using-cmp-argument,useless-suppression,range-builtin-not-iterating,suppressed-message,no-absolute-import,old-division,cmp-method,reload-builtin,zip-builtin-not-iterating,intern-builtin,unichr-builtin,reduce-builtin,standarderror-builtin,unicode-builtin,xrange-builtin,coerce-method,delslice-method,getslice-method,setslice-method,input-builtin,round-builtin,hex-method,nonzero-method,map-builtin-not-iterating,redefined-builtin,no-self-use,missing-docstring,attribute-defined-outside-init,redefined-outer-name,import-error,too-many-locals, protected-ac cess +disable=import-star-module-level,old-octal-literal,oct-method,print-statement,unpacking-in-except,parameter-unpacking,backtick,old-raise-syntax,old-ne-operator,long-suffix,dict-view-method,dict-iter-method,metaclass-assignment,next-method-called,raising-string,indexing-exception,raw_input-builtin,long-builtin,file-builtin,execfile-builtin,coerce-builtin,cmp-builtin,buffer-builtin,basestring-builtin,apply-builtin,filter-builtin-not-iterating,using-cmp-argument,useless-suppression,range-builtin-not-iterating,suppressed-message,no-absolute-import,old-division,cmp-method,reload-builtin,zip-builtin-not-iterating,intern-builtin,unichr-builtin,reduce-builtin,standarderror-builtin,unicode-builtin,xrange-builtin,coerce-method,delslice-method,getslice-method,setslice-method,input-builtin,round-builtin,hex-method,nonzero-method,map-builtin-not-iterating,redefined-builtin,no-self-use,missing-docstring,attribute-defined-outside-init,redefined-outer-name,import-error,redefined-variable-type,broad -except,protected-access,global-statement,too-many-locals [REPORTS] @@ -162,7 +162,7 @@ logging-modules=logging [BASIC] # Good variable names which should always be accepted, separated by a comma -good-names=i,j,k,ex,e,_,id +good-names=i,j,k,v,f,ex,e,_,id # Bad variable names which should always be refused, separated by a comma bad-names=foo,bar,baz,toto,tutu,tata @@ -315,7 +315,7 @@ single-line-if-stmt=no no-space-check=trailing-comma,dict-separator # Maximum number of lines in a module -max-module-lines=1000 +max-module-lines=1500 # String used as indentation unit. This is usually " " (4 spaces) or "\t" (1 # tab). @@ -357,7 +357,7 @@ ignored-argument-names=_.* max-locals=30 # Maximum number of return / yield for function / method body -max-returns=6 +max-returns=10 # Maximum number of branch for function / method body max-branches=12 http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/8ee1470e/tox.ini ---------------------------------------------------------------------- diff --git a/tox.ini b/tox.ini index 8432c85..2efc329 100644 --- a/tox.ini +++ b/tox.ini @@ -30,7 +30,7 @@ commands=pytest tests --cov-report term-missing --cov aria commands=pytest tests --cov-report term-missing --cov aria [testenv:pylint_code] -commands=pylint --rcfile=aria/.pylintrc --disable=fixme --ignore=commands.py aria +commands=pylint --rcfile=aria/.pylintrc --disable=fixme,missing-docstring --ignore=commands.py aria [testenv:pylint_tests] -commands=pylint --rcfile=tests/.pylintrc --disable=fixme tests +commands=pylint --rcfile=tests/.pylintrc --disable=fixme,missing-docstring tests
