I am not aware of any possible way to achieve this in Python as you cannot provide such constraints in type hints.

However, probably the Collection type might be useful in your context as a workaround:

class collections.abc.Collection

ABC for sized iterable container classes.

This requires objects to have a __len__, which is a more strict requirement than being finite. For example, finite generators don't count as Collection.

As of March 2022, the answer is no.

This issue has been discussed since at least July 2016. On a proposal to distinguish between str and Iterable[str], Guido van Rossum writes:

Since str is a valid iterable of str this is tricky. Various proposals have been made but they don't fit easily in the type system.

You'll need to list out all of the types that you want your functions to accept explicitly, using Union (pre-3.10) or | (3.10 and higher).

e.g. For pre-3.10, use:

from typing import Union
## Heading ##
def operate_on_files(file_paths: Union[TypeOneName, TypeTwoName, etc.]) -> None:
    for path in file_paths:
        ...

For 3.10 and higher, use:

## Heading ##
def operate_on_files(file_paths: TypeOneName | TypeTwoName | etc.) -> None:
    for path in file_paths:
        ...

If you happen to be using Pytype, it will not treat str as an Iterable[str] (as pointed out by Kelly Bundy). But, this behavior is typechecker-specific, and isn't widely supported in other typecheckers.

Starting from Python3.6 there's a new type called Collection. See here.

You can use typing.Iterable:

from typing import Iterable

def mysum(x: Iterable[int]) -> int:
    s = 0
    for i in x:
        s += i
    return s

Edit: typing.Iterable is an alias for collections.abc.Iterable, so you should use that instead, as suggested in the comments.

The Sequence and Iterable abstract base classes (can also be used as type annotations) mostly* follow Python's definition of sequence and iterable. To be specific:

• Iterable is any object that defines __iter__ or __getitem__.
• Sequence is any object that defines __getitem__ and __len__. By definition, any sequence is an iterable. The Sequence class also defines other methods such as __contains__, __reversed__ that calls the two required methods.

Some examples:

• list, tuple, str are the most common sequences.
• Some built-in iterables are not sequences. For example, reversed returns a reversed object (or list_reverseiterator for lists) that cannot be subscripted.

* Iterable does not exactly conform to Python's definition of iterables — it only checks if the object defines __iter__, and does not work for objects that's only iterable via __getitem__ (see this table for details). The gold standard of checking if an object is iterable is using the iter builtin.

Running mypy in --strict mode actually tells you everything you need.

1) Incomplete Iterable

:13: error: Missing type parameters for generic type "Iterable"  [type-arg]

Since Iterable is generic and parameterized with one type variable, you should subclass it accordingly, i.e.

...
T = typing.TypeVar("T", bound="Element")
...
class BaseIterableClass(
    abc.ABC,
    collections.abc.Iterable[T],
    SomeClassIHaveToDeriveFrom,
):

2) Now we get a new error

:17: error: Return type "Iterator[Element]" of "__iter__" incompatible with return type "Iterator[T]" in supertype "Iterable"  [override]

Easily solvable:

...
    @abc.abstractmethod
    def __iter__(self) -> typing.Iterator[T]:

3) Now that we made BaseIterableClass properly generic...

:20: error: Missing type parameters for generic type "BaseIterableClass"  [type-arg]

Here we can specify Element:

class A(BaseIterableClass[Element]):
...

4) Missing return types

:21: error: Function is missing a type annotation  [no-untyped-def]
:24: error: Function is missing a return type annotation  [no-untyped-def]

Since we are defining the methods __iter__ and __next__ for A, we need to annotate them properly:

...
    def __iter__(self) -> collections.abc.Iterator[Element]:
...
    def __next__(self) -> Element:

5) Wrong return value

Now that we annotated the __next__ return type, mypy picks up that "some string that isn't an Element" is not, in fact, an instance of Element. 🙂

:25: error: Incompatible return value type (got "str", expected "Element")  [return-value]

Fully annotated code

from abc import ABC, abstractmethod
from collections.abc import Iterable, Iterator
from typing import TypeVar


T = TypeVar("T", bound="Element")


class Element:
    pass


class SomeClassIHaveToDeriveFrom:
    pass


class BaseIterableClass(
    ABC,
    Iterable[T],
    SomeClassIHaveToDeriveFrom,
):
    @abstractmethod
    def __iter__(self) -> Iterator[T]:
        ...


class A(BaseIterableClass[Element]):
    def __iter__(self) -> Iterator[Element]:
        return self

    def __next__(self) -> Element:
        return "some string that isn't an Element"  # error
        # return Element()

Fixed type argument

If you don't want BaseIterableClass to be generic, you can change steps 1)-3) and specify the type argument for all subclasses. Then you don't need to pass a type argument for A. The code would then look like so:

from abc import ABC, abstractmethod
from collections.abc import Iterable, Iterator


class Element:
    pass


class SomeClassIHaveToDeriveFrom:
    pass


class BaseIterableClass(
    ABC,
    Iterable[Element],
    SomeClassIHaveToDeriveFrom,
):
    @abstractmethod
    def __iter__(self) -> Iterator[Element]:
        ...


class A(BaseIterableClass):
    def __iter__(self) -> Iterator[Element]:
        return self

    def __next__(self) -> Element:
        return "some string that isn't an Element"  # error
        # return Element()

Maybe Iterator instead?

Finally, it seems that you actually want the Iterator interface, since you are defining the __next__ method on your subclass A. In that case, you don't need to define __iter__ at all. Iterator inherits from Iterable and automatically gets __iter__ mixed in, when you inherit from it and implement __next__. (see docs)

Also, since the Iterator base class is abstract already, you don't need to include __next__ as an abstract method.

Then the (generic version of the) code would look like this:

from abc import ABC
from collections.abc import Iterator
from typing import TypeVar


T = TypeVar("T", bound="Element")


class Element:
    pass


class SomeClassIHaveToDeriveFrom:
    pass


class BaseIteratorClass(
    ABC,
    Iterator[T],
    SomeClassIHaveToDeriveFrom,
):
    pass


class A(BaseIteratorClass[Element]):
    def __next__(self) -> Element:
        return "some string that isn't an Element"  # error
        # return Element()

Both iter(A()) and next(A()) work.

Hope this helps.