from abc import abstractmethod

import warnings

from git.util import (

IterableList,

IterableObj,

Actor

)

import re

from collections import deque

from string import digits

import time

import calendar

from datetime import datetime, timedelta, tzinfo

from typing import (Any, Callable, Deque, Iterator, NamedTuple, overload, Sequence,

TYPE_CHECKING, Tuple, Type, TypeVar, Union, cast)

from git.types import Has_id_attribute, Literal, Protocol, runtime_checkable

if TYPE_CHECKING:

from io import BytesIO, StringIO

from .commit import Commit

from .blob import Blob

from .tag import TagObject

from .tree import Tree, TraversedTreeTup

from subprocess import Popen

from .submodule.base import Submodule

class TraverseNT(NamedTuple):

depth: int

item: Union['Traversable', 'Blob']

src: Union['Traversable', None]

T_TIobj = TypeVar('T_TIobj', bound='TraversableIterableObj') # for TraversableIterableObj.traverse()

TraversedTup = Union[Tuple[Union['Traversable', None], 'Traversable'], # for commit, submodule

'TraversedTreeTup'] # for tree.traverse()

__all__ = ('get_object_type_by_name', 'parse_date', 'parse_actor_and_date',

'ProcessStreamAdapter', 'Traversable', 'altz_to_utctz_str', 'utctz_to_altz',

'verify_utctz', 'Actor', 'tzoffset', 'utc')

ZERO = timedelta(0)

def mode_str_to_int(modestr: Union[bytes, str]) -> int:

return mode

def get_object_type_by_name(object_type_name: bytes

raise ValueError("Cannot handle unknown object type: %s" % object_type_name.decode())

def utctz_to_altz(utctz: str) -> int:

return -1 * int(float(utctz) / 100 * 3600)

def altz_to_utctz_str(altz: float) -> str:

return prefix + utcs

def verify_utctz(offset: str) -> str:

return offset

class tzoffset(tzinfo):

return ZERO

utc = tzoffset(0, 'UTC')

def from_timestamp(timestamp, tz_offset: float) -> datetime:

return utc_dt

def parse_date(string_date: str) -> Tuple[int, int]:

# END handle exceptions

_re_actor_epoch = re.compile(r'^.+? (.*) (\d+) ([+-]\d+).*$')

_re_only_actor = re.compile(r'^.+? (.*)$')

def parse_actor_and_date(line: str) -> Tuple[Actor, int, int]:

return (Actor._from_string(actor), int(epoch), utctz_to_altz(offset))

class ProcessStreamAdapter(object):

return getattr(self._stream, attr)

class Traversable(Protocol):

# END for each item on work stack

class Serializable(Protocol):

raise NotImplementedError("To be implemented in subclass")

class TraversableIterableObj(IterableObj, Traversable):

))