


# Copyright 2023 The HuggingFace Team. 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 typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__lowerCAmelCase			=							{
    "configuration_mgp_str": ["MGP_STR_PRETRAINED_CONFIG_ARCHIVE_MAP", "MgpstrConfig"],
    "processing_mgp_str": ["MgpstrProcessor"],
    "tokenization_mgp_str": ["MgpstrTokenizer"],
}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	__lowerCAmelCase			=							[
	    "MGP_STR_PRETRAINED_MODEL_ARCHIVE_LIST",
	    "MgpstrModel",
	    "MgpstrPreTrainedModel",
	    "MgpstrForSceneTextRecognition",
	]

if TYPE_CHECKING:
	from .configuration_mgp_str import MGP_STR_PRETRAINED_CONFIG_ARCHIVE_MAP, MgpstrConfig
	from .processing_mgp_str import MgpstrProcessor
	from .tokenization_mgp_str import MgpstrTokenizer

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_mgp_str import (
		    MGP_STR_PRETRAINED_MODEL_ARCHIVE_LIST,
		    MgpstrForSceneTextRecognition,
		    MgpstrModel,
		    MgpstrPreTrainedModel,
		)
else:
	import sys

	__lowerCAmelCase			=							_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)






def        snake_case_					(  snake_case					)  ->    list[int]:
       lowercase__:       Dict        =       [0 for i in range(len(snake_case					)					)]

       # initialize interval's left pointer and right pointer
       lowercase__      ,						lowercase__:       Union[str, Any]        =       0, 0

       for i in range(1      ,							len(snake_case					)					):
              # case when current index is inside the interval
              if i <= right_pointer:
                     lowercase__:       List[Any]        =       min(right_pointer - i + 1      ,							z_result[i - left_pointer]					)
                     lowercase__:       List[str]        =       min_edge

              while go_next(snake_case      ,							snake_case      ,							snake_case					):
                     z_result[i] += 1

              # if new index's result gives us more right interval,
              # we've to update left_pointer and right_pointer
              if i + z_result[i] - 1 > right_pointer:
                     lowercase__      ,						lowercase__:       List[Any]        =       i, i + z_result[i] - 1

       return z_result




def        snake_case_					(  snake_case      ,							snake_case      ,							snake_case					)  ->    bool:
       return i + z_result[i] < len(snake_case					) and s[z_result[i]] == s[i + z_result[i]]




def        snake_case_					(  snake_case      ,							snake_case					)  ->    int:
       lowercase__:       Tuple        =       0
       # concatenate 'pattern' and 'input_str' and call z_function
       # with concatenated string
       lowercase__:       Any        =       z_function(pattern + input_str					)

       for val in z_result:
              # if value is greater then length of the pattern string
              # that means this index is starting position of substring
              # which is equal to pattern string
              if val >= len(snake_case					):
                     answer += 1

       return answer


if __name__ == "__main__":
 import doctest

 doctest.testmod()


