You are accidentally calling numpy.any() instead of the built-in any(). The latter does work for your example.

To fix this, you need to sort out the imports. Look for from numpy import * and from numpy import any, and for similar imports involving scipy and pylab.

The example the docs give is for a function that accepts either flavour of string, and returns the same type:

def concat(a: AnyStr, b: AnyStr) -> AnyStr:

With that in mind, here is how AnyStr could be used in your code:

def logic1(s:AnyStr) -> AnyStr:
    return 2 * s # For example

def logic2() -> dict:
    return {}

something = True

def x(s:AnyStr) -> Tuple[Optional[AnyStr], Optional[dict]]:
   if something:
      return logic1(s), logic2()
   return None, None

This passes through mypy with no problem.

If you simply want a type that might be either a string or a bytes, you would be better off with Union[str,bytes]:

def logic1() -> Union[str,bytes]:
    return 'hi'

def logic2() -> dict:
    return {}

something = True

def x() -> Tuple[Optional[Union[str,bytes]], Optional[dict]]:
   if something:
      return logic1(), logic2()
   return None, None

Yep! Normally python variables are mutable (types can change), but specifying it like this is good documentation and makes it very clear what goes where.

More usage documentation can be found here! https://docs.python.org/3/library/typing.html

EDIT: Elaborate on answer on updated question

The PEP documentation you refer to identifies how type-hints, albeit useful, are still error prone.

By specifying Dict[str, Any], the str can be "arbitrary", meaning it can be a string key of anything (ie. name, age, height, humidity). Out of these keys, one may consider "humidity" shouldn't be one of the string-keys for this dict, but there isn't a way to check, or enforce that until some error occurs down the road (hence, it is "arbitrary"; no rules to govern what are "allowed" string-keys of this dict).

Therefore, per the documentation, specifying this class (derived from TypedDict):

class Movie(TypedDict):
    name: str
    year: int

will specifically limit users to create a new kind of dict (a TypedDict) with string-keys name and year (with respective values typed str and int). Users will not be able to "arbitrarily" add a new key (ie. humidity) to this "Movie" TypedDict, or otherwise assign a non-int value to Movie["year"].

Use a generator together with any, which short-circuits on the first True:

if any(ext in url_string for ext in extensionsToCheck):
    print(url_string)

EDIT: I see this answer has been accepted by OP. Though my solution may be "good enough" solution to his particular problem, and is a good general way to check if any strings in a list are found in another string, keep in mind that this is all that this solution does. It does not care WHERE the string is found e.g. in the ending of the string. If this is important, as is often the case with urls, you should look to the answer of @Wladimir Palant, or you risk getting false positives.

all() stops at the first item evaluates to False. Basically:

if all(isinstance(x, (int, float)) for x in my_list):
    print("all numbers!")
else:
    print("not all number!")

And using these C-level functions instead of comprehensions should be more performant:

from itertools import repeat
if all(map(isinstance, my_list, repeat((int, float)))):
    print("all numbers!")
else:
    print("not all number!")