qiskit_classroom.converter_model

  1"""
  2    module for ConverterModel
  3"""
  4
  5#  Licensed to the Apache Software Foundation (ASF) under one
  6#  or more contributor license agreements.  See the NOTICE file
  7#  distributed with this work for additional information
  8#  regarding copyright ownership.  The ASF licenses this file
  9#  to you under the Apache License, Version 2.0 (the
 10#  "License"); you may not use this file except in compliance
 11#  with the License.  You may obtain a copy of the License at
 12#
 13#    http://www.apache.org/licenses/LICENSE-2.0
 14#
 15#  Unless required by applicable law or agreed to in writing,
 16#  software distributed under the License is distributed on an
 17#  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 18#  KIND, either express or implied.  See the License for the
 19#  specific language governing permissions and limitations
 20#  under the License.
 21
 22import os
 23from .expression_enum import QuantumExpression
 24from .worker import ConverterWorker
 25from .input_model import Input
 26
 27
 28class ConvertingRuleException(Exception):
 29    """
 30    Exception class for converting rule
 31    matrix cannot convert to dirac notation directly
 32    """
 33
 34    def __init__(self) -> None:
 35        super().__init__(
 36            "Expression converting rule error: Matrix cannot convert to dirac Notation directly."
 37        )
 38
 39
 40# pylint: disable=too-many-instance-attributes
 41class ConverterModel:
 42    """
 43    class for converter
 44    """
 45
 46    def __init__(self) -> None:
 47        self.__from_expression = None
 48        self.__to_expression = None
 49        self.__result_img_path = ""
 50        self.__input_data = None
 51        self.__expression_text = ""
 52
 53    @property
 54    def from_expression(self) -> QuantumExpression:
 55        """
 56        property of __from_expression
 57        """
 58        return self.__from_expression
 59
 60    @from_expression.setter
 61    def from_expression(self, value: QuantumExpression) -> None:
 62        if (
 63            value is QuantumExpression.MATRIX
 64            and self.__to_expression is QuantumExpression.DIRAC
 65        ):
 66            raise ConvertingRuleException()
 67
 68        self.__from_expression = value
 69        print(f"from expression changed to {value}")
 70
 71    @property
 72    def to_expression(self) -> QuantumExpression:
 73        """
 74        property of __to_expression
 75        """
 76        return self.__to_expression
 77
 78    @to_expression.setter
 79    def to_expression(self, value: QuantumExpression) -> None:
 80        # cannot converte from matrix to dirac dicrectly
 81        if (
 82            value is QuantumExpression.DIRAC
 83            and self.__from_expression is QuantumExpression.MATRIX
 84        ):
 85            raise ConvertingRuleException()
 86
 87        self.__to_expression = value
 88        print(f"to expression changed to {value}")
 89
 90    @property
 91    def result_img_path(self) -> str:
 92        """property of __result_img_path
 93
 94        Returns:
 95            str: result_img_path
 96        """
 97
 98        return self.__result_img_path
 99
100    @result_img_path.setter
101    def result_img_path(self, value: str) -> None:
102        self.__result_img_path = value
103        print(f"result img path change to {value}")
104
105    @property
106    def input_data(self) -> Input:
107        """property of __input_date
108
109        Returns:
110            Input: user input data
111        """
112        return self.__input_data
113
114    @input_data.setter
115    def input_data(self, value: Input) -> None:
116        self.__input_data = value
117        print(f"input_data change to {value}")
118
119    @property
120    def expression_text(self) -> str:
121        """property of __expression_text
122
123        Returns:
124            str: expression text
125        """
126        return self.__expression_text
127
128    @expression_text.setter
129    def expression_text(self, value: str) -> None:
130        self.__expression_text = value
131        print(f"expression_text change to {value}")
132
133    async def convert_and_draw(self, shows_result: bool) -> bool:
134        """run worker to converting expression and visualizating expression
135
136        Returns:
137            bool: if converting and drawing was success return true
138        """
139
140        worker = ConverterWorker(
141            self.from_expression,
142            self.to_expression,
143            self.input_data,
144            self.expression_text,
145            shows_result=shows_result,
146        )
147        img_path = await worker.run()
148
149        # replace image and remove previously generated image
150        if img_path is not None:
151            self.remove_result_img_path()
152            self.result_img_path = img_path
153        return True
154
155    def remove_result_img_path(self) -> None:
156        """remove generated img file"""
157        if self.__result_img_path is not None:
158            if os.path.isfile(self.__result_img_path):
159                os.remove(self.__result_img_path)
160                print(f"remove {self.result_img_path}")