Initial commit (1e5e99d5) · Commits · TDL Open Source / PyTDL

LICENSE.txt

0 → 100644

+203 −0

Original line number	Diff line number	Diff line
		Eclipse Public License - v 1.0

		THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC
		LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM
		CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.

		1. DEFINITIONS

		"Contribution" means:

		a) in the case of the initial Contributor, the initial code and documentation
		distributed under this Agreement, and
		b) in the case of each subsequent Contributor:
		i) changes to the Program, and
		ii) additions to the Program;

		where such changes and/or additions to the Program originate from and are
		distributed by that particular Contributor. A Contribution 'originates'
		from a Contributor if it was added to the Program by such Contributor
		itself or anyone acting on such Contributor's behalf. Contributions do not
		include additions to the Program which: (i) are separate modules of
		software distributed in conjunction with the Program under their own
		license agreement, and (ii) are not derivative works of the Program.

		"Contributor" means any person or entity that distributes the Program.

		"Licensed Patents" mean patent claims licensable by a Contributor which are
		necessarily infringed by the use or sale of its Contribution alone or when
		combined with the Program.

		"Program" means the Contributions distributed in accordance with this
		Agreement.

		"Recipient" means anyone who receives the Program under this Agreement,
		including all Contributors.

		2. GRANT OF RIGHTS
		a) Subject to the terms of this Agreement, each Contributor hereby grants
		Recipient a non-exclusive, worldwide, royalty-free copyright license to
		reproduce, prepare derivative works of, publicly display, publicly
		perform, distribute and sublicense the Contribution of such Contributor,
		if any, and such derivative works, in source code and object code form.
		b) Subject to the terms of this Agreement, each Contributor hereby grants
		Recipient a non-exclusive, worldwide, royalty-free patent license under
		Licensed Patents to make, use, sell, offer to sell, import and otherwise
		transfer the Contribution of such Contributor, if any, in source code and
		object code form. This patent license shall apply to the combination of
		the Contribution and the Program if, at the time the Contribution is
		added by the Contributor, such addition of the Contribution causes such
		combination to be covered by the Licensed Patents. The patent license
		shall not apply to any other combinations which include the Contribution.
		No hardware per se is licensed hereunder.
		c) Recipient understands that although each Contributor grants the licenses
		to its Contributions set forth herein, no assurances are provided by any
		Contributor that the Program does not infringe the patent or other
		intellectual property rights of any other entity. Each Contributor
		disclaims any liability to Recipient for claims brought by any other
		entity based on infringement of intellectual property rights or
		otherwise. As a condition to exercising the rights and licenses granted
		hereunder, each Recipient hereby assumes sole responsibility to secure
		any other intellectual property rights needed, if any. For example, if a
		third party patent license is required to allow Recipient to distribute
		the Program, it is Recipient's responsibility to acquire that license
		before distributing the Program.
		d) Each Contributor represents that to its knowledge it has sufficient
		copyright rights in its Contribution, if any, to grant the copyright
		license set forth in this Agreement.

		3. REQUIREMENTS

		A Contributor may choose to distribute the Program in object code form under
		its own license agreement, provided that:

		a) it complies with the terms and conditions of this Agreement; and
		b) its license agreement:
		i) effectively disclaims on behalf of all Contributors all warranties
		and conditions, express and implied, including warranties or
		conditions of title and non-infringement, and implied warranties or
		conditions of merchantability and fitness for a particular purpose;
		ii) effectively excludes on behalf of all Contributors all liability for
		damages, including direct, indirect, special, incidental and
		consequential damages, such as lost profits;
		iii) states that any provisions which differ from this Agreement are
		offered by that Contributor alone and not by any other party; and
		iv) states that source code for the Program is available from such
		Contributor, and informs licensees how to obtain it in a reasonable
		manner on or through a medium customarily used for software exchange.

		When the Program is made available in source code form:

		a) it must be made available under this Agreement; and
		b) a copy of this Agreement must be included with each copy of the Program.
		Contributors may not remove or alter any copyright notices contained
		within the Program.

		Each Contributor must identify itself as the originator of its Contribution,
		if
		any, in a manner that reasonably allows subsequent Recipients to identify the
		originator of the Contribution.

		4. COMMERCIAL DISTRIBUTION

		Commercial distributors of software may accept certain responsibilities with
		respect to end users, business partners and the like. While this license is
		intended to facilitate the commercial use of the Program, the Contributor who
		includes the Program in a commercial product offering should do so in a manner
		which does not create potential liability for other Contributors. Therefore,
		if a Contributor includes the Program in a commercial product offering, such
		Contributor ("Commercial Contributor") hereby agrees to defend and indemnify
		every other Contributor ("Indemnified Contributor") against any losses,
		damages and costs (collectively "Losses") arising from claims, lawsuits and
		other legal actions brought by a third party against the Indemnified
		Contributor to the extent caused by the acts or omissions of such Commercial
		Contributor in connection with its distribution of the Program in a commercial
		product offering. The obligations in this section do not apply to any claims
		or Losses relating to any actual or alleged intellectual property
		infringement. In order to qualify, an Indemnified Contributor must:
		a) promptly notify the Commercial Contributor in writing of such claim, and
		b) allow the Commercial Contributor to control, and cooperate with the
		Commercial Contributor in, the defense and any related settlement
		negotiations. The Indemnified Contributor may participate in any such claim at
		its own expense.

		For example, a Contributor might include the Program in a commercial product
		offering, Product X. That Contributor is then a Commercial Contributor. If
		that Commercial Contributor then makes performance claims, or offers
		warranties related to Product X, those performance claims and warranties are
		such Commercial Contributor's responsibility alone. Under this section, the
		Commercial Contributor would have to defend claims against the other
		Contributors related to those performance claims and warranties, and if a
		court requires any other Contributor to pay any damages as a result, the
		Commercial Contributor must pay those damages.

		5. NO WARRANTY

		EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN
		"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR
		IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE,
		NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each
		Recipient is solely responsible for determining the appropriateness of using
		and distributing the Program and assumes all risks associated with its
		exercise of rights under this Agreement , including but not limited to the
		risks and costs of program errors, compliance with applicable laws, damage to
		or loss of data, programs or equipment, and unavailability or interruption of
		operations.

		6. DISCLAIMER OF LIABILITY

		EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY
		CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL,
		SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION
		LOST PROFITS), 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 OR DISTRIBUTION OF THE PROGRAM OR THE
		EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY
		OF SUCH DAMAGES.

		7. GENERAL

		If any provision of this Agreement is invalid or unenforceable under
		applicable law, it shall not affect the validity or enforceability of the
		remainder of the terms of this Agreement, and without further action by the
		parties hereto, such provision shall be reformed to the minimum extent
		necessary to make such provision valid and enforceable.

		If Recipient institutes patent litigation against any entity (including a
		cross-claim or counterclaim in a lawsuit) alleging that the Program itself
		(excluding combinations of the Program with other software or hardware)
		infringes such Recipient's patent(s), then such Recipient's rights granted
		under Section 2(b) shall terminate as of the date such litigation is filed.

		All Recipient's rights under this Agreement shall terminate if it fails to
		comply with any of the material terms or conditions of this Agreement and does
		not cure such failure in a reasonable period of time after becoming aware of
		such noncompliance. If all Recipient's rights under this Agreement terminate,
		Recipient agrees to cease use and distribution of the Program as soon as
		reasonably practicable. However, Recipient's obligations under this Agreement
		and any licenses granted by Recipient relating to the Program shall continue
		and survive.

		Everyone is permitted to copy and distribute copies of this Agreement, but in
		order to avoid inconsistency the Agreement is copyrighted and may only be
		modified in the following manner. The Agreement Steward reserves the right to
		publish new versions (including revisions) of this Agreement from time to
		time. No one other than the Agreement Steward has the right to modify this
		Agreement. The Eclipse Foundation is the initial Agreement Steward. The
		Eclipse Foundation may assign the responsibility to serve as the Agreement
		Steward to a suitable separate entity. Each new version of the Agreement will
		be given a distinguishing version number. The Program (including
		Contributions) may always be distributed subject to the version of the
		Agreement under which it was received. In addition, after a new version of the
		Agreement is published, Contributor may elect to distribute the Program
		(including its Contributions) under the new version. Except as expressly
		stated in Sections 2(a) and 2(b) above, Recipient receives no rights or
		licenses to the intellectual property of any Contributor under this Agreement,
		whether expressly, by implication, estoppel or otherwise. All rights in the
		Program not expressly granted under this Agreement are reserved.

		This Agreement is governed by the laws of the State of New York and the
		intellectual property laws of the United States of America. No party to this
		Agreement will bring a legal action under this Agreement more than one year
		after the cause of action arose. Each party waives its rights to a jury trial in
		any resulting litigation.
		No newline at end of file

Readme.md

0 → 100644

+11 −0

Original line number	Diff line number	Diff line
		# PyTDL

		A Python package to parse ETSI TDL concrete syntax and manipulate the TDL models.

		## Licensing

		TDL examples taken from ETSI specifications are under Copyright of ETSI ([www.etsi.org](www.etsi.org)) with
		no rights granted.

		All other files are released under the Eclipse Public License v1.
		The complete text of the EPL is available in the LICENSE.txt file.
		No newline at end of file

pytdl

0 → 100644

+9 −0

Original line number	Diff line number	Diff line
		#!/bin/bash
		#
		# Released under Eclipse Public License v1
		#
		# https://tdl.etsi.org/open-source

		DIR="$( dirname "${BASH_SOURCE[0]}" )"

		python ${DIR}/src/pytdl.py $@
		No newline at end of file

src/pytdl.py

0 → 100644

+71 −0

Original line number	Diff line number	Diff line
		'''
		PyTDL - validate ETSI TDL, with Python

		Released under Eclipse Public License v1
		'''

		import argparse
		import os

		from textx.metamodel import metamodel_from_file
		from textx.exceptions import TextXSemanticError, TextXSyntaxError
		import pytdl_lib as lib

		DIR = os.path.dirname(os.path.abspath(__file__))

		try:
		TDL_MM = metamodel_from_file(DIR+'/../tdl_grammars/TDLan2.tx',
		classes=[
		lib.Package,
		lib.TestDescription,
		lib.BehaviourDescription,
		lib.CompoundBehaviour,
		lib.Block,
		lib.Message]
		)
		except TextXSemanticError as err:
		print "Error in TDL grammar files:"
		print err
		print "Quitting."
		exit(-1)

		PARSER = argparse.ArgumentParser(description='TDL python utilities.')
		PARSER.add_argument('command', nargs=1, help='the command to be executed')
		PARSER.add_argument('filename', nargs=1, help='the TDL script to manipulate')

		ARGS = PARSER.parse_args()

		FN = ARGS.filename[0]
		CMD = ARGS.command[0]

		P = None
		try:
		P = TDL_MM.model_from_file(FN)
		except TextXSyntaxError as err:
		print "Syntax error found in file " + FN + ":"
		print ""
		print "\t" + str(err)
		print ""
		print "Quitting."
		exit(-2)

		if CMD == "validate":
		exit(0)

		if CMD == "python":
		print "import pytdl.interpreter"
		print ""

		P.to_python()
		exit(0)

		print "###################"
		print "Tests in the package:"

		lib.list_test_descriptions(P)

		print "###################"
		print "Everything in the package:"

		for i in P.packagedElement:
		print i.name

src/pytdl_lib.py

0 → 100644

+141 −0

Original line number	Diff line number	Diff line
		#!/env/python2.7
		'''
		Library for Pytdl

		Released under Eclipse Public License v1
		'''

		def indent(x):
		return " " * x

		class Element(object):
		"""docstring for Element"""
		def __init__(self, name=None, parent=None, comment=None, annotation=None):
		super(Element, self).__init__()
		self.name = name
		self.parent = parent
		self.comment = comment
		self.annotation = annotation


		class Package(Element):
		"""docstring for TdlPackage"""
		def __init__(self, name, packagedElement, imported, nestedPackage=None, annotation=None, comment=None, parent=None):
		super(Package, self).__init__(name=name, parent=parent, comment=comment, annotation=annotation)
		self.imported = imported
		self.nestedPackage = nestedPackage
		self.packagedElement = packagedElement

		def __str__(self):
		return ("Package " + self.name + " containing: ")

		def all(self, tdl_class=None):
		'''
		Generator of packagedElements
		@tdl_class Filter class of elements to be yield
		'''
		for pel in self.packagedElement:
		if (not tdl_class) or pel.__class__.__name__ == tdl_class:
		yield pel

		def test_descriptions(self):
		return self.all("TestDescription")

		def test_configurations(self):
		return self.all("TestConfiguration")

		def to_python(self, ind=0):
		print "class Package_"+self.name+"(TDL_Package):"
		print " self.name = "+self.name
		for i in self.all():
		if hasattr(i, 'to_python'):
		i.to_python(ind+1)
		else:
		print i
		print ""

		class TestDescription(Element):
		"""docstring for TestDescription"""
		def __init__(self, name, behaviourDescription,
		parent, formalParameter, testConfiguration,
		testObjective, isLocallyOrdered, comment, annotation):
		super(TestDescription, self).__init__(name=name, parent=parent, comment=comment, annotation=annotation)
		self.behaviourDescription = behaviourDescription
		self.formalParameter = formalParameter
		self.testConfiguration = testConfiguration
		self.testObjective = testObjective
		self.isLocallyOrdered = isLocallyOrdered

		def to_python(self, ind=0):
		print indent(ind) + "def test_"+self.name+"():"
		self.behaviourDescription.to_python(ind+1)

		class BehaviourDescription(Element):
		"""docstring for BehaviourDescription"""
		def __init__(self, name, behaviour,
		parent,comment, annotation):
		super(BehaviourDescription, self).__init__(name=name, parent=parent, comment=comment, annotation=annotation)
		self.behaviour = behaviour

		def to_python(self, ind=0):
		self.behaviour.to_python(ind)

		class CompoundBehaviour(Element):
		"""docstring for TestDescription"""
		def __init__(self,
		block,
		#comment, annotation,
		#testObjective, periodic, exceptional,
		parent,
		#behaviour
		):
		super(CompoundBehaviour, self).__init__(name=None, parent=parent, comment=None, annotation=None)
		self.block = block
		#self.comment = comment
		#self.annotation = annotation
		#self.testObjective = testObjective
		#elf.periodic = periodic
		#elf.exceptional = exceptional
		#self.parent = parent
		#self.behaviour = behaviour

		def to_python(self, ind=0):
		# print indent(ind) + "compound_behaviour_thing()"
		self.block.to_python(ind+1)

		class Block(Element):
		def __init__(self, comment, name, parent, behaviour, guard, annotation):
		super(Block, self).__init__(name=name, parent=parent, comment=comment, annotation=annotation)
		self.comment = comment
		self.guard = guard
		self.annotation = annotation
		self.name = name
		self.behaviour = behaviour

		def to_python(self, ind):
		# print indent(ind) + "block()"
		for i in self.behaviour:
		i.to_python(ind+1)

		class Message(Element):
		"""docstring for Message"""
		def __init__(self, name, parent, comment, annotation, testObjective, timeLabel, target, timeConstraint, sourceGate, argument, isTrigger ):
		super(Message, self).__init__(name=name, parent=parent, comment=comment, annotation=annotation)
		self.isTrigger = isTrigger
		self.argument = argument
		self.target = target
		self.timeLabel = timeLabel
		self.timeConstraint = timeConstraint
		self.sourceGate = sourceGate

		def to_python(self, ind):
		print indent(ind) + "tdl_send(from="+self.sourceGate+",to="+str(self.target[0].targetGate)+")"


		def list_test_descriptions(package):
		for tds in package.test_descriptions():
		print(tds.name)

		def list_all(package):
		for i in package.all():
		print(i)