text stringlengths 0 20k |
|---|
from functools import partial
import sys
import numpy as np
import pytest
import pandas._libs.window.aggregations as window_aggregations
from pandas import Series
import pandas._testing as tm
def _get_rolling_aggregations():
# list pairs of name and function
# each function has this signature:
# (const... |
import numpy as np
import pytest
from pandas.compat import is_platform_arm
from pandas.errors import NumbaUtilError
import pandas.util._test_decorators as td
from pandas import (
DataFrame,
Series,
option_context,
to_datetime,
)
import pandas._testing as tm
from pandas.util.version import Version
pyt... |
from datetime import (
datetime,
timedelta,
)
import numpy as np
import pytest
import pandas.util._test_decorators as td
from pandas import (
DataFrame,
Series,
bdate_range,
)
@pytest.fixture(params=[True, False])
def raw(request):
"""raw keyword argument for rolling.apply"""
return req... |
import numpy as np
import pytest
from pandas import (
DataFrame,
Index,
MultiIndex,
Series,
Timestamp,
concat,
date_range,
isna,
notna,
)
import pandas._testing as tm
from pandas.tseries import offsets
# suppress warnings about empty slices, as we are deliberately testing
# with a... |
import numpy as np
import pytest
from pandas import Series
import pandas._testing as tm
def no_nans(x):
return x.notna().all().all()
def all_na(x):
return x.isnull().all().all()
@pytest.fixture(params=[(1, 0), (5, 1)])
def rolling_consistency_cases(request):
"""window, min_periods"""
return reque... |
import itertools
import numpy as np
import pytest
from pandas import (
DataFrame,
Series,
notna,
)
def create_series():
return [
Series(dtype=np.float64, name="a"),
Series([np.nan] * 5),
Series([1.0] * 5),
Series(range(5, 0, -1)),
Series(range(5)),
Ser... |
import numpy as np
import pytest
from pandas import Series
import pandas._testing as tm
def no_nans(x):
return x.notna().all().all()
def all_na(x):
return x.isnull().all().all()
@pytest.mark.parametrize("f", [lambda v: Series(v).sum(), np.nansum, np.sum])
def test_expanding_apply_consistency_sum_nans(req... |
import numpy as np
import pytest
from pandas import (
DataFrame,
Series,
concat,
)
import pandas._testing as tm
def create_mock_weights(obj, com, adjust, ignore_na):
if isinstance(obj, DataFrame):
if not len(obj.columns):
return DataFrame(index=obj.index, columns=obj.columns)
... |
import numpy as np
import pytest
from pandas.errors import DataError
from pandas.core.dtypes.common import pandas_dtype
from pandas import (
NA,
DataFrame,
Series,
)
import pandas._testing as tm
# gh-12373 : rolling functions error on float32 data
# make sure rolling functions works for different dtypes... |
from datetime import datetime
from operator import methodcaller
import numpy as np
import pytest
import pandas as pd
from pandas import (
DataFrame,
Index,
Series,
Timestamp,
)
import pandas._testing as tm
from pandas.core.groupby.grouper import Grouper
from pandas.core.indexes.datetimes import date_r... |
from datetime import timedelta
import numpy as np
import pytest
import pandas.util._test_decorators as td
import pandas as pd
from pandas import (
DataFrame,
Series,
)
import pandas._testing as tm
from pandas.core.indexes.timedeltas import timedelta_range
def test_asfreq_bug():
df = DataFrame(data=[1, ... |
from datetime import datetime
import numpy as np
import pytest
from pandas import (
DataFrame,
Series,
)
# The various methods we support
downsample_methods = [
"min",
"max",
"first",
"last",
"sum",
"mean",
"sem",
"median",
"prod",
"var",
"std",
"ohlc",
"qu... |
from datetime import datetime
import numpy as np
import pytest
from pandas.core.dtypes.common import is_extension_array_dtype
import pandas as pd
from pandas import (
DataFrame,
DatetimeIndex,
MultiIndex,
NaT,
PeriodIndex,
Series,
TimedeltaIndex,
)
import pandas._testing as tm
from pandas... |
import re
import numpy as np
import pytest
from pandas.core.dtypes import generic as gt
import pandas as pd
import pandas._testing as tm
class TestABCClasses:
tuples = [[1, 2, 2], ["red", "blue", "red"]]
multi_index = pd.MultiIndex.from_arrays(tuples, names=("number", "color"))
datetime_index = pd.to_d... |
import pytest
import pandas.core.dtypes.concat as _concat
import pandas as pd
from pandas import Series
import pandas._testing as tm
def test_concat_mismatched_categoricals_with_empty():
# concat_compat behavior on series._values should match pd.concat on series
ser1 = Series(["a", "b", "c"], dtype="categor... |
from datetime import (
date,
datetime,
timedelta,
)
import numpy as np
import pytest
from pandas.core.dtypes.cast import (
infer_dtype_from,
infer_dtype_from_array,
infer_dtype_from_scalar,
)
from pandas.core.dtypes.common import is_dtype_equal
from pandas import (
Categorical,
Interv... |
import decimal
import numpy as np
import pytest
from pandas.core.dtypes.cast import maybe_downcast_to_dtype
from pandas import (
Series,
Timedelta,
)
import pandas._testing as tm
@pytest.mark.parametrize(
"arr,dtype,expected",
[
(
np.array([8.5, 8.6, 8.7, 8.8, 8.9999999999995]),... |
import numpy as np
from pandas.core.dtypes.cast import can_hold_element
def test_can_hold_element_range(any_int_numpy_dtype):
# GH#44261
dtype = np.dtype(any_int_numpy_dtype)
arr = np.array([], dtype=dtype)
rng = range(2, 127)
assert can_hold_element(arr, rng)
# negatives -> can't be held b... |
import numpy as np
import pytest
from pandas.core.dtypes.cast import construct_1d_arraylike_from_scalar
from pandas.core.dtypes.dtypes import CategoricalDtype
from pandas import (
Categorical,
Timedelta,
)
import pandas._testing as tm
def test_cast_1d_array_like_from_scalar_categorical():
# see gh-19565... |
import numpy as np
import pytest
from pandas import (
DataFrame,
NaT,
Series,
Timestamp,
)
@pytest.mark.parametrize(
"data,exp_size",
[
# see gh-16362.
([[NaT, "a", "b", 0], [NaT, "b", "c", 1]], 8),
([[NaT, "a", 0], [NaT, "b", 1]], 6),
],
)
def test_maybe_infer_to_... |
import numpy as np
import pytest
from pandas.core.dtypes.cast import find_common_type
from pandas.core.dtypes.common import pandas_dtype
from pandas.core.dtypes.dtypes import (
CategoricalDtype,
DatetimeTZDtype,
IntervalDtype,
PeriodDtype,
)
from pandas import (
Categorical,
Index,
)
@pytest... |
import numpy as np
from pandas.core.dtypes.cast import dict_compat
from pandas import Timestamp
def test_dict_compat():
data_datetime64 = {np.datetime64("1990-03-15"): 1, np.datetime64("2015-03-15"): 2}
data_unchanged = {1: 2, 3: 4, 5: 6}
expected = {Timestamp("1990-3-15"): 1, Timestamp("2015-03-15"): 2... |
import numpy as np
import pytest
import pandas as pd
import pandas._testing as tm
from pandas.core.construction import sanitize_array
@pytest.mark.parametrize(
"values, dtype, expected",
[
([1, 2, 3], None, np.array([1, 2, 3], dtype=np.int64)),
(np.array([1, 2, 3]), None, np.array([1, 2, 3]))... |
import pytest
from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike
@pytest.mark.parametrize("datum1", [1, 2.0, "3", (4, 5), [6, 7], None])
@pytest.mark.parametrize("datum2", [8, 9.0, "10", (11, 12), [13, 14], None])
def test_cast_1d_array(datum1, datum2):
data = [datum1, datum2]
result... |
from datetime import datetime
import numpy as np
import pytest
from pandas.core.dtypes.cast import maybe_box_native
from pandas import (
Interval,
Period,
Timedelta,
Timestamp,
)
@pytest.mark.parametrize(
"obj,expected_dtype",
[
(b"\x00\x10", bytes),
(int(4), int),
(... |
from itertools import chain
import operator
import numpy as np
import pytest
from pandas.core.dtypes.common import is_number
from pandas import (
DataFrame,
Series,
)
import pandas._testing as tm
from pandas.tests.apply.common import (
frame_transform_kernels,
series_transform_kernels,
)
@pytest.ma... |
import pandas as pd
import pandas._testing as tm
def test_relabel_no_duplicated_method():
# this is to test there is no duplicated method used in agg
df = pd.DataFrame({"A": [1, 2, 1, 2], "B": [1, 2, 3, 4]})
result = df["A"].agg(foo="sum")
expected = df["A"].agg({"foo": "sum"})
tm.assert_series_e... |
from pandas.core.groupby.base import transformation_kernels
# There is no Series.cumcount or DataFrame.cumcount
series_transform_kernels = [
x for x in sorted(transformation_kernels) if x != "cumcount"
]
frame_transform_kernels = [x for x in sorted(transformation_kernels) if x != "cumcount"]
|
# Tests specifically aimed at detecting bad arguments.
# This file is organized by reason for exception.
# 1. always invalid argument values
# 2. missing column(s)
# 3. incompatible ops/dtype/args/kwargs
# 4. invalid result shape/type
# If your test does not fit into one of these categories, add to this... |
import numpy as np
import pytest
from pandas import (
DataFrame,
MultiIndex,
Series,
)
import pandas._testing as tm
from pandas.tests.apply.common import frame_transform_kernels
from pandas.tests.frame.common import zip_frames
def unpack_obj(obj, klass, axis):
"""
Helper to ensure we have the rig... |
import numpy as np
import pytest
from pandas.compat import is_platform_arm
import pandas.util._test_decorators as td
import pandas as pd
from pandas import (
DataFrame,
Index,
)
import pandas._testing as tm
from pandas.util.version import Version
pytestmark = [td.skip_if_no("numba"), pytest.mark.single_cpu, ... |
import numpy as np
import pytest
from pandas import (
DataFrame,
MultiIndex,
Series,
concat,
)
import pandas._testing as tm
@pytest.mark.parametrize(
"args, kwargs, increment",
[((), {}, 0), ((), {"a": 1}, 1), ((2, 3), {}, 32), ((1,), {"c": 2}, 201)],
)
def test_agg_args(args, kwargs, increme... |
import numpy as np
import pytest
from pandas.compat.numpy import np_version_gte1p25
import pandas as pd
import pandas._testing as tm
def test_agg_relabel():
# GH 26513
df = pd.DataFrame({"A": [1, 2, 1, 2], "B": [1, 2, 3, 4], "C": [3, 4, 5, 6]})
# simplest case with one column, one func
result = df.... |
from collections.abc import Generator
import contextlib
import pytest
import pandas as pd
import pandas._testing as tm
from pandas.core import accessor
def test_dirname_mixin() -> None:
# GH37173
class X(accessor.DirNamesMixin):
x = 1
y: int
def __init__(self) -> None:
... |
__all__ = [
"dtypes",
"localize_pydatetime",
"NaT",
"NaTType",
"iNaT",
"nat_strings",
"OutOfBoundsDatetime",
"OutOfBoundsTimedelta",
"IncompatibleFrequency",
"Period",
"Resolution",
"Timedelta",
"normalize_i8_timestamps",
"is_date_array_normalized",
"dt64arr_t... |
__all__ = [
"NaT",
"NaTType",
"OutOfBoundsDatetime",
"Period",
"Timedelta",
"Timestamp",
"iNaT",
"Interval",
]
# Below imports needs to happen first to ensure pandas top level
# module gets monkeypatched with the pandas_datetime_CAPI
# see pandas_datetime_exec in pd_datetime.c
import p... |
from __future__ import annotations
import collections.abc as cabc
import textwrap
from contextlib import contextmanager
class TextWrapper(textwrap.TextWrapper):
def _handle_long_word(
self,
reversed_chunks: list[str],
cur_line: list[str],
cur_len: int,
width: int,
) ->... |
"""
This module started out as largely a copy paste from the stdlib's
optparse module with the features removed that we do not need from
optparse because we implement them in Click on a higher level (for
instance type handling, help formatting and a lot more).
The plan is to remove more and more from here over time.
... |
"""
Click is a simple Python module inspired by the stdlib optparse to make
writing command line scripts fun. Unlike other modules, it's based
around a simple API that does not come with too much magic and is
composable.
"""
from __future__ import annotations
from .core import Argument as Argument
from .core import C... |
from __future__ import annotations
import inspect
import typing as t
from functools import update_wrapper
from gettext import gettext as _
from .core import Argument
from .core import Command
from .core import Context
from .core import Group
from .core import Option
from .core import Parameter
from .globals import ge... |
from __future__ import annotations
import collections.abc as cabc
from contextlib import contextmanager
from gettext import gettext as _
from ._compat import term_len
from .parser import _split_opt
# Can force a width. This is used by the test system
FORCED_WIDTH: int | None = None
def measure_table(rows: cabc.It... |
from __future__ import annotations
import collections.abc as cabc
import typing as t
from gettext import gettext as _
from gettext import ngettext
from ._compat import get_text_stderr
from .globals import resolve_color_default
from .utils import echo
from .utils import format_filename
if t.TYPE_CHECKING:
from .c... |
from __future__ import annotations
import codecs
import collections.abc as cabc
import io
import os
import re
import sys
import typing as t
from types import TracebackType
from weakref import WeakKeyDictionary
CYGWIN = sys.platform.startswith("cygwin")
WIN = sys.platform.startswith("win")
auto_wrap_for_ansi: t.Callab... |
from __future__ import annotations
import collections.abc as cabc
import contextlib
import io
import os
import shlex
import sys
import tempfile
import typing as t
from types import TracebackType
from . import _compat
from . import formatting
from . import termui
from . import utils
from ._compat import _find_binary_r... |
from __future__ import annotations
import enum
import typing as t
class Sentinel(enum.Enum):
"""Enum used to define sentinel values.
.. seealso::
`PEP 661 - Sentinel Values <https://peps.python.org/pep-0661/>`_.
"""
UNSET = object()
FLAG_NEEDS_VALUE = object()
def __repr__(self) -... |
from __future__ import annotations
import typing as t
from threading import local
if t.TYPE_CHECKING:
from .core import Context
_local = local()
@t.overload
def get_current_context(silent: t.Literal[False] = False) -> Context: ...
@t.overload
def get_current_context(silent: bool = ...) -> Context | None: ...... |
# This module is based on the excellent work by Adam Bartoš who
# provided a lot of what went into the implementation here in
# the discussion to issue1602 in the Python bug tracker.
#
# There are some general differences in regards to how this works
# compared to the original patches as we do not need to patch
# the e... |
from __future__ import annotations
import contextlib
import typing
from .._models import (
URL,
Extensions,
HeaderTypes,
Origin,
Request,
Response,
enforce_bytes,
enforce_headers,
enforce_url,
include_request_headers,
)
class RequestInterface:
def request(
self,
... |
from __future__ import annotations
import itertools
import logging
import ssl
import types
import typing
from .._backends.sync import SyncBackend
from .._backends.base import SOCKET_OPTION, NetworkBackend, NetworkStream
from .._exceptions import ConnectError, ConnectTimeout
from .._models import Origin, Request, Resp... |
from __future__ import annotations
import ssl
import sys
import types
import typing
from .._backends.sync import SyncBackend
from .._backends.base import SOCKET_OPTION, NetworkBackend
from .._exceptions import ConnectionNotAvailable, UnsupportedProtocol
from .._models import Origin, Proxy, Request, Response
from .._s... |
from __future__ import annotations
import base64
import logging
import ssl
import typing
from .._backends.base import SOCKET_OPTION, NetworkBackend
from .._exceptions import ProxyError
from .._models import (
URL,
Origin,
Request,
Response,
enforce_bytes,
enforce_headers,
enforce_url,
)
fr... |
from .connection import HTTPConnection
from .connection_pool import ConnectionPool
from .http11 import HTTP11Connection
from .http_proxy import HTTPProxy
from .interfaces import ConnectionInterface
try:
from .http2 import HTTP2Connection
except ImportError: # pragma: nocover
class HTTP2Connection: # type: i... |
from __future__ import annotations
import logging
import ssl
import socksio
from .._backends.sync import SyncBackend
from .._backends.base import NetworkBackend, NetworkStream
from .._exceptions import ConnectionNotAvailable, ProxyError
from .._models import URL, Origin, Request, Response, enforce_bytes, enforce_url... |
from __future__ import annotations
import enum
import logging
import ssl
import time
import types
import typing
import h11
from .._backends.base import NetworkStream
from .._exceptions import (
ConnectionNotAvailable,
LocalProtocolError,
RemoteProtocolError,
WriteError,
map_exceptions,
)
from .._... |
from __future__ import annotations
import threading
import types
from ._exceptions import ExceptionMapping, PoolTimeout, map_exceptions
# Our async synchronization primatives use either 'anyio' or 'trio' depending
# on if they're running under asyncio or trio.
try:
import trio
except (ImportError, NotImplemente... |
from __future__ import annotations
import ssl
import typing
import anyio
from .._exceptions import (
ConnectError,
ConnectTimeout,
ReadError,
ReadTimeout,
WriteError,
WriteTimeout,
map_exceptions,
)
from .._utils import is_socket_readable
from .base import SOCKET_OPTION, AsyncNetworkBacke... |
from __future__ import annotations
import ssl
import time
import typing
SOCKET_OPTION = typing.Union[
typing.Tuple[int, int, int],
typing.Tuple[int, int, typing.Union[bytes, bytearray]],
typing.Tuple[int, int, None, int],
]
class NetworkStream:
def read(self, max_bytes: int, timeout: float | None = ... |
from __future__ import annotations
import typing
from .._synchronization import current_async_library
from .base import SOCKET_OPTION, AsyncNetworkBackend, AsyncNetworkStream
class AutoBackend(AsyncNetworkBackend):
async def _init_backend(self) -> None:
if not (hasattr(self, "_backend")):
ba... |
from __future__ import annotations
import ssl
import typing
import trio
from .._exceptions import (
ConnectError,
ConnectTimeout,
ExceptionMapping,
ReadError,
ReadTimeout,
WriteError,
WriteTimeout,
map_exceptions,
)
from .base import SOCKET_OPTION, AsyncNetworkBackend, AsyncNetworkStr... |
from __future__ import annotations
import functools
import socket
import ssl
import sys
import typing
from .._exceptions import (
ConnectError,
ConnectTimeout,
ExceptionMapping,
ReadError,
ReadTimeout,
WriteError,
WriteTimeout,
map_exceptions,
)
from .._utils import is_socket_readable
... |
from __future__ import annotations
import ssl
import typing
from .._exceptions import ReadError
from .base import (
SOCKET_OPTION,
AsyncNetworkBackend,
AsyncNetworkStream,
NetworkBackend,
NetworkStream,
)
class MockSSLObject:
def __init__(self, http2: bool):
self._http2 = http2
... |
from ._api import request, stream
from ._async import (
AsyncConnectionInterface,
AsyncConnectionPool,
AsyncHTTP2Connection,
AsyncHTTP11Connection,
AsyncHTTPConnection,
AsyncHTTPProxy,
AsyncSOCKSProxy,
)
from ._backends.base import (
SOCKET_OPTION,
AsyncNetworkBackend,
AsyncNetwo... |
from __future__ import annotations
import base64
import ssl
import typing
import urllib.parse
# Functions for typechecking...
ByteOrStr = typing.Union[bytes, str]
HeadersAsSequence = typing.Sequence[typing.Tuple[ByteOrStr, ByteOrStr]]
HeadersAsMapping = typing.Mapping[ByteOrStr, ByteOrStr]
HeaderTypes = typing.Unio... |
from __future__ import annotations
import contextlib
import typing
from .._models import (
URL,
Extensions,
HeaderTypes,
Origin,
Request,
Response,
enforce_bytes,
enforce_headers,
enforce_url,
include_request_headers,
)
class AsyncRequestInterface:
async def request(
... |
from __future__ import annotations
import itertools
import logging
import ssl
import types
import typing
from .._backends.auto import AutoBackend
from .._backends.base import SOCKET_OPTION, AsyncNetworkBackend, AsyncNetworkStream
from .._exceptions import ConnectError, ConnectTimeout
from .._models import Origin, Req... |
from __future__ import annotations
import ssl
import sys
import types
import typing
from .._backends.auto import AutoBackend
from .._backends.base import SOCKET_OPTION, AsyncNetworkBackend
from .._exceptions import ConnectionNotAvailable, UnsupportedProtocol
from .._models import Origin, Proxy, Request, Response
from... |
from __future__ import annotations
import base64
import logging
import ssl
import typing
from .._backends.base import SOCKET_OPTION, AsyncNetworkBackend
from .._exceptions import ProxyError
from .._models import (
URL,
Origin,
Request,
Response,
enforce_bytes,
enforce_headers,
enforce_url,... |
from .connection import AsyncHTTPConnection
from .connection_pool import AsyncConnectionPool
from .http11 import AsyncHTTP11Connection
from .http_proxy import AsyncHTTPProxy
from .interfaces import AsyncConnectionInterface
try:
from .http2 import AsyncHTTP2Connection
except ImportError: # pragma: nocover
cla... |
from __future__ import annotations
import logging
import ssl
import socksio
from .._backends.auto import AutoBackend
from .._backends.base import AsyncNetworkBackend, AsyncNetworkStream
from .._exceptions import ConnectionNotAvailable, ProxyError
from .._models import URL, Origin, Request, Response, enforce_bytes, e... |
from __future__ import annotations
import enum
import logging
import ssl
import time
import types
import typing
import h11
from .._backends.base import AsyncNetworkStream
from .._exceptions import (
ConnectionNotAvailable,
LocalProtocolError,
RemoteProtocolError,
WriteError,
map_exceptions,
)
fro... |
from __future__ import annotations
import select
import socket
import sys
def is_socket_readable(sock: socket.socket | None) -> bool:
"""
Return whether a socket, as identifed by its file descriptor, is readable.
"A socket is readable" means that the read buffer isn't empty, i.e. that calling
.recv()... |
import ssl
import certifi
def default_ssl_context() -> ssl.SSLContext:
context = ssl.create_default_context()
context.load_verify_locations(certifi.where())
return context
|
import contextlib
import typing
ExceptionMapping = typing.Mapping[typing.Type[Exception], typing.Type[Exception]]
@contextlib.contextmanager
def map_exceptions(map: ExceptionMapping) -> typing.Iterator[None]:
try:
yield
except Exception as exc: # noqa: PIE786
for from_exc, to_exc in map.item... |
from __future__ import annotations
import inspect
import logging
import types
import typing
from ._models import Request
class Trace:
def __init__(
self,
name: str,
logger: logging.Logger,
request: Request | None = None,
kwargs: dict[str, typing.Any] | None = None,
) ... |
from __future__ import annotations
import contextlib
import typing
from ._models import URL, Extensions, HeaderTypes, Response
from ._sync.connection_pool import ConnectionPool
def request(
method: bytes | str,
url: URL | bytes | str,
*,
headers: HeaderTypes = None,
content: bytes | typing.Itera... |
huggingface_hub
|
[console_scripts]
hf = huggingface_hub.cli.hf:main
tiny-agents = huggingface_hub.inference._mcp.cli:app
[fsspec.specs]
hf = huggingface_hub.HfFileSystem
|
"""Sub-package containing the matrix class and related functions.
"""
from . import defmatrix
from .defmatrix import *
__all__ = defmatrix.__all__
from numpy._pytesttester import PytestTester
test = PytestTester(__name__)
del PytestTester
|
import collections.abc
import numpy as np
from numpy import asmatrix, bmat, matrix
from numpy.linalg import matrix_power
from numpy.testing import (
assert_,
assert_almost_equal,
assert_array_almost_equal,
assert_array_equal,
assert_equal,
assert_raises,
)
class TestCtor:
def test_basic(s... |
import pickle
import numpy as np
from numpy.ma.core import (
MaskedArray,
MaskType,
add,
allequal,
divide,
getmask,
hypot,
log,
masked,
masked_array,
masked_values,
nomask,
)
from numpy.ma.extras import mr_
from numpy.ma.testutils import assert_, assert_array_equal, asse... |
import numpy as np
from numpy.testing import assert_equal
class TestDot:
def test_matscalar(self):
b1 = np.matrix(np.ones((3, 3), dtype=complex))
assert_equal(b1 * 1.0, b1)
def test_diagonal():
b1 = np.matrix([[1, 2], [3, 4]])
diag_b1 = np.matrix([[1, 4]])
array_b1 = np.array([1, 4])... |
import numpy as np
from numpy.testing import assert_, assert_array_equal, assert_equal
class TestView:
def test_type(self):
x = np.array([1, 2, 3])
assert_(isinstance(x.view(np.matrix), np.matrix))
def test_keywords(self):
x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])... |
"""Tests of interaction of matrix with other parts of numpy.
Note that tests with MaskedArray and linalg are done in separate files.
"""
import textwrap
import warnings
import pytest
import numpy as np
from numpy.testing import (
assert_,
assert_almost_equal,
assert_array_almost_equal,
assert_array_e... |
import numpy as np
from numpy.testing import assert_, assert_equal, assert_raises
class TestRegression:
def test_kron_matrix(self):
# Ticket #71
x = np.matrix('[1 0; 1 0]')
assert_equal(type(np.kron(x, x)), type(x))
def test_matrix_properties(self):
# Ticket #125
a = n... |
""" Test functions for linalg module using the matrix class."""
import numpy as np
from numpy.linalg.tests.test_linalg import (
CondCases,
DetCases,
EigCases,
EigvalsCases,
InvCases,
LinalgCase,
LinalgTestCase,
LstsqCases,
PinvCases,
SolveCases,
SVDCases,
_TestNorm2D,
... |
from numpy.version import version # noqa: F401
|
#!/usr/bin/env python3
import os
import sys
import tempfile
def run():
_path = os.getcwd()
os.chdir(tempfile.gettempdir())
print('------')
print(f'os.name={os.name!r}')
print('------')
print(f'sys.platform={sys.platform!r}')
print('------')
print('sys.version:')
print(sys.version)
... |
"""
Build F90 module support for f2py2e.
Copyright 1999 -- 2011 Pearu Peterson all rights reserved.
Copyright 2011 -- present NumPy Developers.
Permission to use, modify, and distribute this software is given under the
terms of the NumPy License.
NO WARRANTY IS EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
"""
__versi... |
import errno
import os
import re
import shutil
import subprocess
import sys
from itertools import chain
from pathlib import Path
from string import Template
from ._backend import Backend
class MesonTemplate:
"""Template meson build file generation class."""
def __init__(
self,
modulename: st... |
def f2py_build_generator(name):
if name == "meson":
from ._meson import MesonBackend
return MesonBackend
elif name == "distutils":
from ._distutils import DistutilsBackend
return DistutilsBackend
else:
raise ValueError(f"Unknown backend: {name}")
|
from abc import ABC, abstractmethod
class Backend(ABC):
def __init__(
self,
modulename,
sources,
extra_objects,
build_dir,
include_dirs,
library_dirs,
libraries,
define_macros,
undef_macros,
f2py_flags,
sysinfo_flags,
... |
import os
import shutil
import sys
import warnings
from numpy.distutils.core import Extension, setup
from numpy.distutils.misc_util import dict_append
from numpy.distutils.system_info import get_info
from numpy.exceptions import VisibleDeprecationWarning
from ._backend import Backend
class DistutilsBackend(Backend)... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.