PySimultan 0.6.0.8__tar.gz → 0.6.2__tar.gz

pysimultan-0.6.2/LICENSE.txt

@@ -0,0 +1,29 @@
+Academic GPL License Agreement
+
+1. PreambleThis software is released under the terms of the GNU General Public License (GPL) with additional restrictions limiting use to academic, research, and educational purposes. It ensures that users have the freedom to study, modify, and share the software while prohibiting commercial exploitation.
+
+2. Grant of LicenseThis software is licensed under the GPL with the following additional condition: You may use, modify, and distribute this software only for academic, research, and educational purposes. Any commercial use, including but not limited to for-profit applications, services, or product development, is strictly prohibited.
+
+3. RestrictionsYou may not:
+
+Use the software for commercial, business, or for-profit purposes.
+
+Distribute, sublicense, or sell copies of the software for commercial purposes.
+
+Remove or alter any copyright, trademark, or proprietary notices.
+
+4. Compliance with GPLAs this software is based on the GPL, you must also:
+
+Include a copy of this license with any distribution.
+
+Provide access to the source code when distributing the software.
+
+Allow modifications and redistribution under these same terms.
+
+5. Disclaimer of WarrantyThis software is provided "as is" without any warranties, express or implied. The author disclaims any liability for damages arising from its use.
+
+6. TerminationThis license is effective until terminated. If you violate any terms, your rights under this license will terminate automatically, and you must cease using the software and delete all copies.
+
+7. Governing LawThis agreement shall be governed by and construed in accordance with the laws of [Your Jurisdiction].
+
+By using this software, you agree to abide by the terms of this license and the GNU General Public License.

{pysimultan-0.6.0.8 → pysimultan-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySimultan
-Version: 0.6.0.8
+Version: 0.6.2
 Project-URL: Documentation, https://github.com/Bühler Maximilian/PySimultan2#readme
 Project-URL: Issues, https://github.com/Bühler Maximilian/PySimultan2/issues
 Project-URL: Source, https://github.com/Bühler Maximilian/PySimultan2

{pysimultan-0.6.0.8 → pysimultan-0.6.2}/src/PySimultan2/CHANGELOG.md

@@ -1,3 +1,10 @@
+Version 0.6.2 (28.03.2024)
+- Added extended functionality to ComponentDictionary
+- Bugfixing
+
+Version 0.6.1 (24.02.2024)
+- Bugfixes in default_types and File/Directory handling
+
 Version 0.6.0.7 (16.02.2024)
 - Fixed Asset creation and deletion bugs
 

pysimultan-0.6.2/src/PySimultan2/__about__.py

@@ -0,0 +1 @@
+version = '0.6.2'

{pysimultan-0.6.0.8 → pysimultan-0.6.2}/src/PySimultan2/data_model.py

@@ -1,4 +1,5 @@
 import atexit
+import pathlib
 import os
 import shutil
 from uuid import uuid4
@@ -528,6 +529,17 @@ class DataModel:
             if isinstance(target_dir, SystemFileInfo):
                 target_dir = target_dir.FullPath
 
+            if target_dir.startswith(self.project.ProjectUnpackFolder.FullPath):
+                return self.project.AddEmptyResource(SystemFileInfo(os.path.join(target_dir, str(filename))))
+            else:
+                return self.project.AddEmptyResource(SystemFileInfo(os.path.join(
+                    self.project.ProjectUnpackFolder.FullPath,
+                    target_dir,
+                    str(filename))
+                )
+                )
+
+
             return self.project.AddEmptyResource(FileInfo(
                 os.path.join(target_dir, str(filename))
                                                           )
@@ -595,6 +607,9 @@ class DataModel:
 
             if not act_filename.startswith(self.project.ProjectUnpackFolder.FullPath) and target_dir is None:
                 target_dir_str = self.project.ProjectUnpackFolder.FullPath
+            elif act_filename.startswith(self.project.ProjectUnpackFolder.FullPath):
+                target_dir_str = ''
+
             elif target_dir is not None:
                 if isinstance(target_dir, ResourceDirectoryEntry):
                     target_dir_str = target_dir.CurrentFullPath
@@ -626,7 +641,7 @@ class DataModel:
             if target_dir is None:
                 resource = self.project.CopyResourceAsContainedFileEntry(filename,
                                                                          self.project.ProjectUnpackFolder,
-                                                                         '1')
+                                                                         '{0} ({1})')
             else:
                 if isinstance(target_dir, str):
                     target_dir = DirectoryInfo(target_dir)
@@ -685,40 +700,102 @@ class DataModel:
         self.get_file_infos.cache_clear()
         return success
 
+    def get_existing_resource_directory_entry(self,
+                                              full_path: str) -> ResourceDirectoryEntry:
+        return self.project_data_manager.AssetManager.GetResource(DirectoryInfo(full_path))
+
     def create_resource_directory(self,
                                   name: str,
-                                  parent_directory: DirectoryInfo=None,
+                                  parent_directory: Union[DirectoryInfo, str, pathlib.Path]=None,
+                                  create_parents: bool = True,
                                   collision_name_format: str = '{0} ({1})') -> ResourceEntry:
 
-        # check if directory already exists
         if parent_directory is None:
-            full_path = os.path.join(self.project.ProjectUnpackFolder.FullPath, name)
+            if name.startswith(self.project.ProjectUnpackFolder.FullPath):
+                full_path = name
+            else:
+                full_path = os.path.join(self.project.ProjectUnpackFolder.FullPath, name)
         else:
-            full_path = os.path.join(parent_directory.FullPath, name)
-
-        def get_existing(full_file_path: str):
-            new_directory = self.project_data_manager.AssetManager.GetResource(DirectoryInfo(full_path))
-            if new_directory is None:
-                res = self.project_data_manager.AssetManager.CreateResourceDirIn(os.path.basename(full_path),
-                                                                                 DirectoryInfo(
-                                                                                     os.path.dirname(
-                                                                                         full_path)),
-                                                                                 '0')
-
-                new_directory = self.project_data_manager.AssetManager.GetResource(res.Item1)
-            return new_directory
-
-        if os.path.exists(full_path):
-            new_directory = get_existing(full_path)
-            return new_directory
+            if isinstance(parent_directory, str):
+                if not parent_directory.startswith(self.project.ProjectUnpackFolder.FullPath):
+                    full_path = os.path.join(self.project.ProjectUnpackFolder.FullPath, parent_directory, name)
+                else:
+                    full_path = parent_directory
+            elif isinstance(parent_directory, DirectoryInfo):
+                full_path = os.path.join(parent_directory.FullPath, name)
+            elif isinstance(parent_directory, pathlib.Path):
+                full_path = os.path.join(parent_directory, name)
+
+
+        existing_resource_directory = self.get_existing_resource_directory_entry(str(full_path))
+        if existing_resource_directory is not None:
+            return existing_resource_directory
+
+        if str(pathlib.Path(full_path).parents[0]) == self.project.ProjectUnpackFolder.FullPath:
+            # create directory in ProjectUnpackFolder
+            resource_directory_entry = self.get_existing_resource_directory_entry(full_path)
+            if resource_directory_entry is not None:
+                return resource_directory_entry
+            else:
+                new_resource_entry = self.project.CreateResourceDirIn(
+                    str(
+                        pathlib.Path(full_path).relative_to(pathlib.Path(self.project.ProjectUnpackFolder.FullPath))
+                    ),
+                    None,
+                    collision_name_format)
+                if new_resource_entry not in self.project_data_manager.AssetManager.Resources:
+                    self.project_data_manager.AssetManager.AddResourceEntry(new_resource_entry)
+                return new_resource_entry
+        else:
+            if parent_directory is None:
+                parent = None
+                for i in reversed(range(pathlib.Path(full_path).parents.__len__())):
+                    parent = pathlib.Path(full_path).parents[i]
+                    if str(parent) in self.project.ProjectUnpackFolder.FullPath:
+                        continue
+                    if not os.path.exists(parent):
+                        if create_parents:
+                            parent_directory = self.create_resource_directory(parent.name,
+                                                                        parent_directory=parent.parents[0],
+                                                                        create_parents=False)
+                        else:
+                            raise FileNotFoundError(f'Parent directory {parent} does not exist')
+                    else:
+                        parent_directory = self.get_existing_resource_directory_entry(str(parent))
 
         if parent_directory is None:
-            new_directory = self.project.CreateResourceDirIn(name, None, collision_name_format)
-        if parent_directory is not None:
-            new_directory = self.project.CreateResourceDirIn(name, parent_directory, collision_name_format)
-
-        return new_directory
+            new_resource_entry = self.project.CreateResourceDirIn(
+                str(
+                    pathlib.Path(full_path).relative_to(pathlib.Path(self.project.ProjectUnpackFolder.FullPath))
+                ),
+                parent_directory,
+                collision_name_format)
+            self.project_data_manager.AssetManager.AddResourceEntry(new_resource_entry)
+            return new_resource_entry
+        else:
+            if isinstance(parent_directory, pathlib.Path):
+                target = str(pathlib.Path(full_path).relative_to(parent_directory))
+                parent_directory_target = DirectoryInfo(str(parent_directory))
+            elif isinstance(parent_directory, str):
+                target = str(pathlib.Path(full_path).relative_to(pathlib.Path(parent_directory)))
+                parent_directory_target = DirectoryInfo(parent_directory)
+            elif isinstance(parent_directory, DirectoryInfo):
+                target = str(pathlib.Path(full_path).relative_to(pathlib.Path(parent_directory.CurrentFullPath)))
+                parent_directory_target = parent_directory
+            elif isinstance(parent_directory, ResourceDirectoryEntry):
+                target = str(pathlib.Path(full_path).relative_to(pathlib.Path(parent_directory.CurrentFullPath)))
+                parent_directory_target = DirectoryInfo(parent_directory.CurrentFullPath)
 
+            else:
+                raise ValueError(f'Parent directory {parent_directory} not found')
+
+            new_resource_entry = self.project.CreateResourceDirIn(
+                target,
+                parent_directory_target,
+                collision_name_format)
+            if new_resource_entry.manager is None:
+                self.project_data_manager.AssetManager.AddResourceEntry(new_resource_entry)
+            return new_resource_entry
 
     def add_table(self, table: SimMultiValueBigTable):
         self.project_data_manager.ValueManager.Add(table)

{pysimultan-0.6.0.8 → pysimultan-0.6.2}/src/PySimultan2/default_types.py

@@ -520,11 +520,13 @@ class ComponentDictionary(SimultanObject):
 
     def __setitem__(self, key, value):
 
-        if key in self._dict:
-            del self._dict[key]
+        # if key in self._dict:
+        #     del self._dict[key]
 
         if key in self._taxonomy_map.content_dict.keys():
             content = self._taxonomy_map.content_dict[key]
+        elif '__dict_key__' + key in self._taxonomy_map.content_dict.keys():
+            content = self._taxonomy_map.content_dict['__dict_key__' + key]
         else:
             content = Content(text_or_key=f'__dict_key__{key}',
                               property_name=key,
@@ -574,7 +576,10 @@ class ComponentDictionary(SimultanObject):
 
     def __delitem__(self, key):
         self[key] = None
-        del self._dict[key]
+        try:
+            del self._dict[key]
+        except KeyError:
+            pass
 
     def items(self):
         if self._dict is None or not self._dict:
@@ -686,5 +691,22 @@ class ComponentDictionary(SimultanObject):
         }
         }
 
+    def get_raw_attr(self, attr: Optional[str] = None, text_or_key: Optional[str] = None):
+        if attr is not None:
+            content = self._taxonomy_map.get_content_by_property_name(attr)
+            if content is None:
+                content = Content(text_or_key=f'__dict_key__{attr}',
+                                  property_name=attr,
+                                  type=None,
+                                  unit=None,
+                                  documentation=f'Property {attr} in ComponentDictionary',
+                                  component_policy=self.component_policy)
+                self._taxonomy_map.add_content(content)
+
+            return get_component_taxonomy_entry(self._wrapped_obj, content.text_or_key)
+
+        if text_or_key is not None:
+            return get_component_taxonomy_entry(self._wrapped_obj, text_or_key)
+
 
 component_dict_map = ComponentDictionary._taxonomy_map

{pysimultan-0.6.0.8 → pysimultan-0.6.2}/src/PySimultan2/files.py

@@ -301,12 +301,19 @@ class FileInfo(object, metaclass=MetaMock):
         data_model = kwargs.get('data_model', config.get_default_data_model())
 
         if target_dir is not None:
-            full_path = os.path.join(target_dir.full_path, filename)
+            if isinstance(target_dir, DirectoryInfo):
+                full_path = os.path.join(target_dir.full_path, filename)
+            elif isinstance(target_dir, ResourceDirectoryEntry):
+                full_path = os.path.join(target_dir.CurrentFullPath, filename)
+            elif isinstance(target_dir, str):
+                full_path = os.path.join(target_dir, filename)
+            else:
+                raise ValueError(f'Unsupported target_dir format')
         else:
-            full_path = os.path.join(data_model.project.ProjectUnpackFolder, filename)
-
-
-
+            if not filename.startswith(str(data_model.project.ProjectUnpackFolder)):
+                full_path = os.path.join(str(data_model.project.ProjectUnpackFolder), filename)
+            else:
+                full_path = filename
 
         if os.path.isfile(full_path):
             # check if resource entry exists
@@ -609,6 +616,15 @@ class DirectoryInfo(object, metaclass=DirectoryInfoMetaMock):
                                 add_sub_directories: bool = True,
                                 *args,
                                 **kwargs) -> DirectoryInfo:
+        """
+        Create a directory info object from an existing directory.
+        :param directory_path: the path to the directory
+        :param add_files:
+        :param add_sub_directories:
+        :param args:
+        :param kwargs:
+        :return:
+        """
 
         data_model = kwargs.get('data_model', config.get_default_data_model())
 
@@ -642,6 +658,33 @@ class DirectoryInfo(object, metaclass=DirectoryInfoMetaMock):
 
         return directory_info
 
+    @classmethod
+    def from_existing_directory_copy(cls,
+                                     directory_path: str,
+                                     destination_path: str,
+                                     add_files: bool = True,
+                                     add_sub_directories: bool = True,
+                                     *args,
+                                     **kwargs) -> DirectoryInfo:
+
+        """
+        Create a directory info object from an existing directory which is copied to a directory in the project.
+        :param directory_path:
+        :param destination_path: the path to the directory (in the project)
+        :param add_files:
+        :param add_sub_directories:
+        :param args:
+        :param kwargs:
+        :return:
+        """
+
+        shutil.copytree(directory_path, destination_path)
+        return cls.from_existing_directory(destination_path,
+                                             add_files=add_files,
+                                             add_sub_directories=add_sub_directories,
+                                             *args,
+                                             **kwargs)
+
     def __init__(self,
                  path: Optional[str] = None,
                  helper_file: Optional[FileInfo] = None,
@@ -776,11 +819,7 @@ class DirectoryInfo(object, metaclass=DirectoryInfoMetaMock):
 
     def get_file(self, filename: str) -> Optional[FileInfo]:
         resource = next((x for x in self.files if x.resource_entry.Name == filename), None)
-        if resource is not None:
-            return FileInfo(resource_entry=resource,
-                            data_model=self.data_model)
-        else:
-            return None
+        return resource
 
     def add_file(self,
                  filename: str,

{pysimultan-0.6.0.8 → pysimultan-0.6.2}/src/PySimultan2/multi_values.py

@@ -129,7 +129,9 @@ def simultan_multi_value_big_table_to_pandas(field: SimMultiValueBigTable) -> pd
     return df
 
 
-def simultan_multi_value_field_3d_to_numpy(field: SimMultiValueField3D, assert_ordered=False) -> np.ndarray:
+def simultan_multi_value_field_3d_to_numpy(field: SimMultiValueField3D,
+                                           assert_ordered=False,
+                                           squeeze: bool = True) -> np.ndarray:
     """
     Convert a SimMultiValueField3D object to a numpy array.
     :param field:
@@ -150,7 +152,10 @@ def simultan_multi_value_field_3d_to_numpy(field: SimMultiValueField3D, assert_o
         for comb in product(range(len(field.XAxis)), range(len(field.YAxis)), range(len(field.ZAxis)), repeat=1):
             array[comb[0], comb[1], comb[2]] = field[comb[0], comb[1], comb[2]]
 
-    return np.squeeze(array)
+    if squeeze:
+        return np.squeeze(array)
+    else:
+        return array
 
 
 def add_field_to_data_model(field: SimMultiValueField3D, data_model: 'SimultanObject') -> SimMultiValueField3D:
@@ -288,3 +293,55 @@ def create_field_parameter(value: Union[SimMultiValueField3D, np.ndarray, DataFr
                                  )
 
     return param
+
+
+def add_row(field: SimMultiValueField3D,
+            dim: int = 0):
+
+    array = simultan_multi_value_field_3d_to_numpy(field, squeeze=False)
+
+    new_shape = list(array.shape)
+    if new_shape.__len__() - 1 < dim:
+        while new_shape.__len__() - 1 < dim:
+            new_shape.append(1)
+    new_shape[dim] += 1
+
+    # data = NetList[Double](Array[Double](array.astype(float).flatten(order='F')))
+
+    while field.XAxis.Count < new_shape[0]:
+        field.XAxis.Add(field.XAxis.Count+1)
+    while field.YAxis.Count < new_shape[1]:
+        field.YAxis.Add(field.YAxis.Count+1)
+    while field.ZAxis.Count < new_shape[2]:
+        field.ZAxis.Add(field.ZAxis.Count+1)
+
+    resized_array = np.resize(array, new_shape)
+
+    for i, j, k in zip(range(new_shape[0]), range(new_shape[1]), range(new_shape[2])):
+        field[i, j, k] = resized_array[i, j, k]
+
+    return field
+
+
+def resize(field: SimMultiValueField3D,
+           new_shape: list[int]) -> SimMultiValueField3D:
+    """
+    Resize a SimMultiValueField3D object to a new shape.
+    :param field: The SimMultiValueField3D object
+    :param new_shape: The new shape of the field, e.g. [10, 20, 30]
+    :return: SimMultiValueField3D
+    """
+    array = simultan_multi_value_field_3d_to_numpy(field, squeeze=False)
+    resized_array = np.resize(array, new_shape)
+
+    while field.XAxis.Count < resized_array.shape[0]:
+        field.XAxis.Add(field.XAxis.Count+1)
+    while field.YAxis.Count < resized_array.shape[1]:
+        field.YAxis.Add(field.YAxis.Count+1)
+    while field.ZAxis.Count < resized_array.shape[2]:
+        field.ZAxis.Add(field.ZAxis.Count+1)
+
+    for i, j, k in zip(range(new_shape[0]), range(new_shape[1]), range(new_shape[2])):
+        field[i, j, k] = resized_array[i, j, k]
+
+    return field

{pysimultan-0.6.0.8 → pysimultan-0.6.2}/src/PySimultan2/utils.py

@@ -2,11 +2,12 @@ from __future__ import annotations
 
 import sys
 import traceback
+import functools
+import numpy as np
+import pandas as pd
 
 from enum import Enum
 from weakref import WeakSet
-import numpy as np
-import pandas as pd
 from typing import List as TypeList, Union, Optional, Type, Any, TYPE_CHECKING
 from SIMULTAN.Data import SimId
 
@@ -1375,7 +1376,7 @@ def set_property_to_dict(value: dict,
                 return
 
     if component_idx is not None:
-        component = component._wrapped_obj.Components.Items[component_idx].Component
+        sub_component = component._wrapped_obj.Components.Items[component_idx].Component
 
         if 'ComponentDictionary' in [x.Target.Key for x in component.Slots]:
             if not hasattr(component, '_object_mapper'):
@@ -1395,7 +1396,6 @@ def set_property_to_dict(value: dict,
             component_dict.update(value)
             return component_dict
         else:
-            component._data_model.remove_subcomponent(component)
             component._wrapped_obj.Components.RemoveItem(component_idx)
         component_idx = None
     if ref_component_idx is not None:

{pysimultan-0.6.0.8 → pysimultan-0.6.2}/tests/test_directory_and_files.py

@@ -19,6 +19,11 @@ def test_files_and_directory_creation():
     new_directory_info = DirectoryInfo(path='directory_info_dir',
                                        data_model=new_data_model)
 
+
+    new_directory_info = DirectoryInfo(path='not_existing_dir/directory_to_create',
+                                       data_model=new_data_model)
+
+
     print(new_data_model.file_directories)
 
     print(new_directory_info.resource_entry)
@@ -148,7 +153,12 @@ def test_load_component_with_directory():
     mapper.clear()
 
 
+def test_complex_file_and_directory_info():
+    pass
+
+
 if __name__ == '__main__':
-    # test_files_and_directory_creation()
+    test_files_and_directory_creation()
+    test_complex_file_and_directory_info()
     test_component_with_directory()
     test_load_component_with_directory()

pysimultan-0.6.2/tests/test_numpy.py

@@ -0,0 +1,108 @@
+import numpy as np
+
+from PySimultan2.data_model import DataModel
+from PySimultan2.object_mapper import PythonMapper
+from PySimultan2.taxonomy_maps import TaxonomyMap, Content
+from PySimultan2.multi_values import simultan_multi_value_field_3d_to_numpy, add_row
+
+
+import resources
+
+try:
+    import importlib.resources as pkg_resources
+except ImportError:
+    # Try backported to PY<37 importlib_resources.
+    import importlib_resources as pkg_resources
+
+
+with pkg_resources.path(resources, 'test_set_dictionary.simultan') as r_path:
+    project_path = str(r_path)
+
+
+data_model = DataModel.create_new_project(project_path=project_path,
+                                          user_name='admin',
+                                          password='admin')
+
+mapper = PythonMapper()
+
+
+def map_classes():
+    class TestComponent(object):
+        def __init__(self, *args, **kwargs):
+            self.mapped_property = kwargs.get('mapped_property')
+            self.value2 = kwargs.get('value2')
+
+    content0 = Content(text_or_key='value',  # text or key of the content/parameter/property
+                       property_name='mapped_property',  # name of the generated property
+                       type=None,  # type of the content/parameter/property
+                       unit=None,  # unit of the content/parameter/property
+                       documentation='mapped_property to test',
+                       component_policy='subcomponent')
+
+    content1 = Content(text_or_key='value2',  # text or key of the content/parameter/property
+                       property_name='value2',  # name of the generated property
+                       type=None,  # type of the content/parameter/property
+                       unit=None,  # unit of the content/parameter/property
+                       documentation='value2',
+                       component_policy='reference')
+
+    test_component_map = TaxonomyMap(taxonomy_name='PySimultan',
+                                     taxonomy_key='PySimultan',
+                                     taxonomy_entry_name='TestComponent',
+                                     taxonomy_entry_key='TestComponent',
+                                     content=[content0, content1],
+                                     )
+
+    mapper.register(test_component_map.taxonomy_entry_key, TestComponent, taxonomy_map=test_component_map)
+    cls1 = mapper.get_mapped_class(test_component_map.taxonomy_entry_key)
+
+
+    return cls1
+
+
+mapped_cls_1 = map_classes()
+component = mapped_cls_1(name='test_component',
+                         mapped_property=None)
+
+
+def test_set_dictionary_param(component):
+
+    component_1 = mapped_cls_1(name='test_component_1',
+                               mapped_property=np.array([1, 2, 3]),
+                               value2=np.array([[1, 2, 3], [4, 5, 6]]))
+
+    field1 = component_1.get_raw_attr('mapped_property').ValueSource.Field
+    field2 = component_1.get_raw_attr('value2').ValueSource.Field
+
+    add_row(field1, 0)
+    add_row(field2, 0)
+
+
+def load_data_model(data_model: DataModel):
+    data_model = DataModel(project_path=project_path,
+                           user_name='admin',
+                           password='admin')
+    typed_data = data_model.get_typed_data(mapper=mapper,
+                                           create_all=True)
+
+    TestComponent = mapper.get_mapped_class('TestComponent')
+    test_component = TestComponent.cls_instances[0]
+
+
+
+    return data_model
+
+
+if __name__ == '__main__':
+    test_set_dictionary_param(component)
+    data_model.save()
+    mapper.clear()
+    data_model.cleanup()
+    data_model = DataModel(project_path=project_path,
+                           user_name='admin',
+                           password='admin')
+    load_data_model(data_model)
+
+
+data_model.cleanup()
+print('Test passed')

pysimultan-0.6.0.8/LICENSE.txt

@@ -1,9 +0,0 @@
-MIT License
-
-Copyright (c) 2024-present Bühler Maximilian <maximilian.buehler@a1.digital>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

pysimultan-0.6.0.8/src/PySimultan2/__about__.py

@@ -1 +0,0 @@
-version = '0.6.0.8'