pyproject.toml

[project]
  authors = [
    { name = "Waldemar Villamayor-Venialbo", email = "wvenialbo@fpuna.edu.py" },
  ]
  classifiers = [
    "Development Status :: 4 - Beta",
    "Development Status :: 5 - Production/Stable",
    "Environment :: Console",
    "Framework :: Flake8",
    "Framework :: MkDocs",
    "Framework :: Sphinx :: Extension",
    "Framework :: Sphinx :: Theme",
    "Framework :: Sphinx",
    "Intended Audience :: Developers",
    "Intended Audience :: Education",
    "Intended Audience :: End Users/Desktop",
    "Intended Audience :: Science/Research",
    "License :: OSI Approved :: MIT License",
    "Natural Language :: English",
    "Operating System :: OS Independent",
    "Programming Language :: Python :: 3.12",
    "Topic :: Education",
    "Topic :: Internet :: WWW/HTTP :: Indexing/Search",
    "Topic :: Scientific/Engineering :: Atmospheric Science",
    "Topic :: Scientific/Engineering :: GIS",
    "Topic :: Scientific/Engineering :: Information Analysis",
    "Topic :: Utilities",
  ]
  dependencies = [
    "boto3~=1.35.42",
    "requests~=2.32.3",
  ]
  description = "Satellite imagery downloader for GOES and GridSat datasets"
  dynamic = [
    "version",
  ]
  keywords = [
    "GOES",
    "GOES-R",
    "GridSat",
    "GridSat-B1",
    "GridSat-GOES/CONUS",
    "atmospheric science",
    "dataset",
    "downloader",
    "environmental data",
    "meteorology",
    "multi-source",
    "satellite imagery",
    "severe weather",
  ]
  license = { file = "LICENSE" }
  name = "goes-dl"
  readme = { file = "README.md", content-type = "text/markdown" }
  requires-python = ">=3.9"

  [project.urls]
    # Homepage = "https://example.com"
    # Documentation = "https://readthedocs.org"
    Issues     = "https://github.com/wvenialbo/GOES-DL/issues"
    Repository = "https://github.com/wvenialbo/GOES-DL"
    # Changelog = "https://github.com/me/spam/blob/master/CHANGELOG.md"

[tool]

  [tool.setuptools]
    include-package-data = true

    [tool.setuptools.dynamic]
      version = { attr = "goesdl.__version__" }

    [tool.setuptools.package-data]
      goesdl = [
        "py.typed",
      ]
      config = [
        "settings.json",
      ]

    [tool.setuptools.packages.find]
      where = ["src"]

  [tool.poetry]
    authors     = [
      "Waldemar Villamayor-Venialbo <wvenialbo@fpuna.edu.py>",
    ]
    description = "Satellite imagery downloader for GOES and GridSat datasets"
    license     = "MIT"
    name        = "goes-dl"
    packages    = [
      { include = "goesdl" },
      { include = "goesdl/py.typed" },
    ]
    readme      = "README.md"
    version     = "0.1.0"

    [tool.poetry.dependencies]
      boto3    = "~1.35.42"
      python   = "^3.9"
      requests = "~2.32.3"

  [tool.black]
    line-length = 79

  [tool.coverage]

    [tool.coverage.run]
      omit = [
        ".ipynb_checkpoints/*",
        ".venv/*",
        ".vscode/*",
        "htmlcov/*",
        "var/*",
      ]

    [tool.coverage.report]
      show_missing = true

  [tool.isort]
    profile = "black"

  [tool.flake8]
    # darglint, darglint2
    docstring_style      = "numpy"
    # flake8-docstrings
    docstring-convention = "numpy"
    extend-ignore        = [
      "ANN101",
    ]
    max-line-length      = 79
    per-file-ignores     = [
      "__init__.py:F401",
      "./src/goesdl/utils/headers.py:DAR201",
    ]
    strictness           = "full"
    allow-init-docstring = true

  [tool.pylint]

    [tool.pylint.main]
      # Analyse import fallback blocks. This can be used to support both Python 2 and 3
      # compatible code, which means that the block might have code that exists only in
      # one or another interpreter, leading to false positives when analysed.
      # analyse-fallback-blocks =

      # Clear in-memory caches upon conclusion of linting. Useful if running pylint in
      # a server-like mode.
      # clear-cache-post-run =

      # Always return a 0 (non-error) status code, even if lint errors are found. This
      # is primarily useful in continuous integration scripts.
      # exit-zero =

      # A comma-separated list of package or module names from where C extensions may
      # be loaded. Extensions are loading into the active Python interpreter and may
      # run arbitrary code.
      # extension-pkg-allow-list =

      # A comma-separated list of package or module names from where C extensions may
      # be loaded. Extensions are loading into the active Python interpreter and may
      # run arbitrary code. (This is an alternative name to extension-pkg-allow-list
      # for backward compatibility.)
      # extension-pkg-whitelist =

      # Return non-zero exit code if any of these messages/categories are detected,
      # even if score is above --fail-under value. Syntax same as enable. Messages
      # specified are enabled, while categories only check already-enabled messages.
      # fail-on =

      # Specify a score threshold under which the program will exit with error.
      fail-under = 10.0

      # Interpret the stdin as a python script, whose filename needs to be passed as
      # the module_or_package argument.
      # from-stdin =

      # Files or directories to be skipped. They should be base names, not paths.
      ignore = ["CVS"]

      # Add files or directories matching the regular expressions patterns to the
      # ignore-list. The regex matches against paths and can be in Posix or Windows
      # format. Because '\\' represents the directory delimiter on Windows systems, it
      # can't be used as an escape character.
      # ignore-paths =

      # Files or directories matching the regular expression patterns are skipped. The
      # regex matches against base names, not paths. The default value ignores Emacs
      # file locks
      ignore-patterns = ["^\\.#"]

      # List of module names for which member attributes should not be checked and will
      # not be imported (useful for modules/projects where namespaces are manipulated
      # during runtime and thus existing member attributes cannot be deduced by static
      # analysis). It supports qualified module names, as well as Unix pattern
      # matching.
      # ignored-modules =

      # Python code to execute, usually for sys.path manipulation such as
      # pygtk.require().
      # init-hook =

      # Use multiple processes to speed up Pylint. Specifying 0 will auto-detect the
      # number of processors available to use, and will cap the count on Windows to
      # avoid hangs.
      jobs = 0

      # Control the amount of potential inferred values when inferring a single object.
      # This can help the performance when dealing with large functions or complex,
      # nested conditions.
      limit-inference-results = 100

      # List of plugins (as comma separated values of python module names) to load,
      # usually to register additional checkers.
      load-plugins = [
        "pylint.extensions.docparams",
        "pylint.extensions.magic_value",
        "pylint.extensions.no_self_use",
      ]

      # Pickle collected data for later comparisons.
      persistent = true

      # Resolve imports to .pyi stubs if available. May reduce no-member messages and
      # increase not-an-iterable messages.
      # prefer-stubs =

      # Minimum Python version to use for version dependent checks. Will default to the
      # version used to run pylint.
      py-version = "3.12"

      # Discover python modules and packages in the file system subtree.
      # recursive =

      # Add paths to the list of the source roots. Supports globbing patterns. The
      # source root is an absolute path or a path relative to the current working
      # directory used to determine a package namespace for modules located under the
      # source root.
      # source-roots =

      # When enabled, pylint would attempt to guess common misconfiguration and emit
      # user-friendly hints instead of false-positive error messages.
      suggestion-mode = true

      # Allow loading of arbitrary C extensions. Extensions are imported into the
      # active Python interpreter and may run arbitrary code.
      # unsafe-load-any-extension =

    [tool.pylint.basic]
      # Naming style matching correct argument names.
      argument-naming-style = "snake_case"

      # Regular expression matching correct argument names. Overrides argument-naming-
      # style. If left empty, argument names will be checked with the set naming style.
      # argument-rgx =

      # Naming style matching correct attribute names.
      attr-naming-style = "snake_case"

      # Regular expression matching correct attribute names. Overrides attr-naming-
      # style. If left empty, attribute names will be checked with the set naming
      # style.
      # attr-rgx =

      # Bad variable names which should always be refused, separated by a comma.
      bad-names = ["bar", "baz", "foo", "tata", "toto", "tutu"]

      # Bad variable names regexes, separated by a comma. If names match any regex,
      # they will always be refused
      # bad-names-rgxs =

      # Naming style matching correct class attribute names.
      class-attribute-naming-style = "any"

      # Regular expression matching correct class attribute names. Overrides class-
      # attribute-naming-style. If left empty, class attribute names will be checked
      # with the set naming style.
      # class-attribute-rgx =

      # Naming style matching correct class constant names.
      class-const-naming-style = "UPPER_CASE"

      # Regular expression matching correct class constant names. Overrides class-
      # const-naming-style. If left empty, class constant names will be checked with
      # the set naming style.
      # class-const-rgx =

      # Naming style matching correct class names.
      class-naming-style = "PascalCase"

      # Regular expression matching correct class names. Overrides class-naming-style.
      # If left empty, class names will be checked with the set naming style.
      # class-rgx =

      # Naming style matching correct constant names.
      const-naming-style = "UPPER_CASE"

      # Regular expression matching correct constant names. Overrides const-naming-
      # style. If left empty, constant names will be checked with the set naming style.
      # const-rgx =

      # Minimum line length for functions/classes that require docstrings, shorter ones
      # are exempt.
      docstring-min-length = -1

      # Naming style matching correct function names.
      function-naming-style = "snake_case"

      # Regular expression matching correct function names. Overrides function-naming-
      # style. If left empty, function names will be checked with the set naming style.
      # function-rgx =

      # Good variable names which should always be accepted, separated by a comma.
      good-names = ["i", "j", "k", "ex", "Run", "_"]

      # Good variable names regexes, separated by a comma. If names match any regex,
      # they will always be accepted
      # good-names-rgxs =

      # Include a hint for the correct naming format with invalid-name.
      # include-naming-hint =

      # Naming style matching correct inline iteration names.
      inlinevar-naming-style = "any"

      # Regular expression matching correct inline iteration names. Overrides
      # inlinevar-naming-style. If left empty, inline iteration names will be checked
      # with the set naming style.
      # inlinevar-rgx =

      # Naming style matching correct method names.
      method-naming-style = "snake_case"

      # Regular expression matching correct method names. Overrides method-naming-
      # style. If left empty, method names will be checked with the set naming style.
      # method-rgx =

      # Naming style matching correct module names.
      module-naming-style = "snake_case"

      # Regular expression matching correct module names. Overrides module-naming-
      # style. If left empty, module names will be checked with the set naming style.
      # module-rgx =

      # Colon-delimited sets of names that determine each other's naming style when the
      # name regexes allow several styles.
      # name-group =

      # Regular expression which should only match function or class names that do not
      # require a docstring.
      no-docstring-rgx = "^_"

      # List of decorators that produce properties, such as abc.abstractproperty. Add
      # to this list to register other decorators that produce valid properties. These
      # decorators are taken in consideration only for invalid-name.
      property-classes = ["abc.abstractproperty"]

      # Regular expression matching correct type alias names. If left empty, type alias
      # names will be checked with the set naming style.
      # typealias-rgx =

      # Regular expression matching correct type variable names. If left empty, type
      # variable names will be checked with the set naming style.
      # typevar-rgx =

      # Naming style matching correct variable names.
      variable-naming-style = "snake_case"

      # Regular expression matching correct variable names. Overrides variable-naming-
      # style. If left empty, variable names will be checked with the set naming style.
      # variable-rgx =

    [tool.pylint.classes]
      # Warn about protected attribute access inside special methods
      # check-protected-access-in-special-methods =

      # List of method names used to declare (i.e. assign) instance attributes.
      defining-attr-methods = [
        "__init__",
        "__new__",
        "__post_init__",
        "asyncSetUp",
        "setUp",
      ]

      # List of member names, which should be excluded from the protected access
      # warning.
      exclude-protected = [
        "_asdict",
        "_fields",
        "_make",
        "_replace",
        "_source",
        "os._exit",
      ]

      # List of valid names for the first argument in a class method.
      valid-classmethod-first-arg = ["cls"]

      # List of valid names for the first argument in a metaclass class method.
      valid-metaclass-classmethod-first-arg = ["mcs"]

    [tool.pylint.design]
      # List of regular expressions of class ancestor names to ignore when counting
      # public methods (see R0903)
      # exclude-too-few-public-methods =

      # List of qualified class names to ignore when counting class parents (see R0901)
      # ignored-parents =

      # Maximum number of arguments for function / method.
      # TODO: Restore this to its default value: 5. Increased this limit 8.
      max-args = 8

      # Maximum number of attributes for a class (see R0902).
      # TODO: Restore this to its default value: 7. Increased this limit 8.
      max-attributes = 8

      # Maximum number of boolean expressions in an if statement (see R0916).
      max-bool-expr = 5

      # Maximum number of branch for function / method body.
      max-branches = 12

      # Maximum number of locals for function / method body.
      max-locals = 15

      # Maximum number of parents for a class (see R0901).
      max-parents = 7

      # Maximum number of positional arguments for function / method.
      # TODO: Restore this to its default value: 5. Increased this limit 8.
      max-positional-arguments = 8

      # Maximum number of public methods for a class (see R0904).
      max-public-methods = 20

      # Maximum number of return / yield for function / method body.
      max-returns = 6

      # Maximum number of statements in function / method body.
      max-statements = 50

      # Minimum number of public methods for a class (see R0903).
      min-public-methods = 2

    [tool.pylint.exceptions]
      # Exceptions that will emit a warning when caught.
      overgeneral-exceptions = ["builtins.BaseException", "builtins.Exception"]

    [tool.pylint.format]
      # Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
      expected-line-ending-format = "LF"

      # Regexp for a line that is allowed to be longer than the limit.
      ignore-long-lines = "^\\s*(# )?<?https?://\\S+>?$"

      # Number of spaces of indent required inside a hanging or continued line.
      indent-after-paren = 4

      # String used as indentation unit. This is usually "    " (4 spaces) or "\t" (1
      # tab).
      indent-string = "    "

      # Maximum number of characters on a single line.
      max-line-length = 79

      # Maximum number of lines in a module.
      max-module-lines = 1000

      # Allow the body of a class to be on the same line as the declaration if body
      # contains single statement.
      # single-line-class-stmt =

      # Allow the body of an if to be on the same line as the test if there is no else.
      # single-line-if-stmt =

    [tool.pylint.imports]
      # List of modules that can be imported at any level, not just the top level one.
      # allow-any-import-level =

      # Allow explicit reexports by alias from a package __init__.
      allow-reexport-from-package = true

      # Allow wildcard imports from modules that define __all__.
      # allow-wildcard-with-all =

      # Deprecated modules which should not be used, separated by a comma.
      # deprecated-modules =

      # Output a graph (.gv or any supported image format) of external dependencies to
      # the given file (report RP0402 must not be disabled).
      # ext-import-graph =

      # Output a graph (.gv or any supported image format) of all (i.e. internal and
      # external) dependencies to the given file (report RP0402 must not be disabled).
      # import-graph =

      # Output a graph (.gv or any supported image format) of internal dependencies to
      # the given file (report RP0402 must not be disabled).
      # int-import-graph =

      # Force import order to recognize a module as part of the standard compatibility
      # libraries.
      # known-standard-library =

      # Force import order to recognize a module as part of a third party library.
      known-third-party = ["enchant"]

      # Couples of modules and preferred modules, separated by a comma.
      # preferred-modules =

    [tool.pylint.logging]
      # The type of string formatting that logging methods do. `old` means using %
      # formatting, `new` is for `{}` formatting.
      logging-format-style = "old"

      # Logging modules to check that the string format arguments are in logging
      # function parameter format.
      logging-modules = ["logging"]

    [tool.pylint.magic-value]
      # List of valid magic values that `magic-value-compare` will not detect. Supports
      # integers, floats, negative numbers, for empty string enter ``''``, for
      # backslash values just use one backslash e.g \n.
      valid-magic-values = ["", "__main__", -1, 0, 1]

    [tool.pylint."messages control"]
      # Only show warnings with the listed confidence levels. Leave empty to show all.
      # Valid levels: HIGH, CONTROL_FLOW, INFERENCE, INFERENCE_FAILURE, UNDEFINED.
      confidence = [
        "CONTROL_FLOW",
        "HIGH",
        "INFERENCE",
        "INFERENCE_FAILURE",
        "UNDEFINED",
      ]

      # Disable the message, report, category or checker with the given id(s). You can
      # either give multiple identifiers separated by comma (,) or put this option
      # multiple times (only on the command line, not in the configuration file where
      # it should appear only once). You can also use "--disable=all" to disable
      # everything first and then re-enable specific checks. For example, if you want
      # to run only the similarities checker, you can use "--disable=all
      # --enable=similarities". If you want to run only the classes checker, but have
      # no Warning level messages displayed, use "--disable=all --enable=classes
      # --disable=W".
      disable = [
        "bad-inline-option",
        "deprecated-pragma",
        "file-ignored",
        "locally-disabled",
        "raw-checker-failed",
        "suppressed-message",
        "use-implicit-booleaness-not-comparison-to-string",
        "use-implicit-booleaness-not-comparison-to-zero",
        "use-symbolic-message-instead",
        "useless-suppression",
        # temporary disable (avoid complaint about TODOs)
        "fixme",
      ]

      # Enable the message, report, category or checker with the given id(s). You can
      # either give multiple identifier separated by comma (,) or put this option
      # multiple time (only on the command line, not in the configuration file where it
      # should appear only once). See also the "--disable" option for examples.
      # enable =

    [tool.pylint.method_args]
      # List of qualified names (i.e., library.method) which require a timeout
      # parameter e.g. 'requests.api.get,requests.api.post'
      timeout-methods = [
        "requests.api.delete",
        "requests.api.get",
        "requests.api.head",
        "requests.api.options",
        "requests.api.patch",
        "requests.api.post",
        "requests.api.put",
        "requests.api.request",
      ]

    [tool.pylint.miscellaneous]
      # List of note tags to take in consideration, separated by a comma.
      notes = ["FIXME", "TODO", "XXX"]

      # Regular expression of note tags to take in consideration.
      # notes-rgx =

    [tool.pylint.parameter_documentation]
      # Whether to accept totally missing parameter documentation in the docstring of a
      # function that has parameters.
      accept-no-param-doc = false

      # Whether to accept totally missing raises documentation in the docstring of a
      # function that raises an exception.
      accept-no-raise-doc = false

      # Whether to accept totally missing return documentation in the docstring of a
      # function that returns a statement.
      accept-no-return-doc = false

      # Whether to accept totally missing yields documentation in the docstring of a
      # generator.
      accept-no-yields-doc = false

      # If the docstring type cannot be guessed the specified docstring type will be
      # used.
      default-docstring-type = "numpy"

    [tool.pylint.refactoring]
      # Maximum number of nested blocks for function / method body
      max-nested-blocks = 5

      # Complete name of functions that never returns. When checking for inconsistent-
      # return-statements if a never returning function is called then it will be
      # considered as an explicit return statement and no message will be printed.
      never-returning-functions = ["argparse.parse_error", "sys.exit"]

      # Let 'consider-using-join' be raised when the separator to join on would be non-
      # empty (resulting in expected fixes of the type: ``"- " + " - ".join(items)``)
      suggest-join-with-non-empty-separator = true

    [tool.pylint.reports]
      # Python expression which should return a score less than or equal to 10. You
      # have access to the variables 'fatal', 'error', 'warning', 'refactor',
      # 'convention', and 'info' which contain the number of messages in each category,
      # as well as 'statement' which is the total number of statements analyzed. This
      # score is used by the global evaluation report (RP0004).
      evaluation = "max(0, 0 if fatal else 10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10))"

      # Template used to display messages. This is a python new-style format string
      # used to format the message information. See doc for all details.
      # msg-template =

      # Set the output format. Available formats are: text, parseable, colorized, json2
      # (improved json format), json (old json format) and msvs (visual studio). You
      # can also give a reporter class, e.g. mypackage.mymodule.MyReporterClass.
      # output-format =

      # Tells whether to display a full report or only the messages.
      # reports =

      # Activate the evaluation score.
      score = true

    [tool.pylint.similarities]
      # Comments are removed from the similarity computation
      ignore-comments = true

      # Docstrings are removed from the similarity computation
      ignore-docstrings = true

      # Imports are removed from the similarity computation
      ignore-imports = true

      # Signatures are removed from the similarity computation
      ignore-signatures = true

      # Minimum lines number of a similarity.
      min-similarity-lines = 4

    [tool.pylint.spelling]
      # Limits count of emitted suggestions for spelling mistakes.
      max-spelling-suggestions = 4

      # Spelling dictionary name. No available dictionaries : You need to install both
      # the python package and the system dependency for enchant to work.
      # spelling-dict =

      # List of comma separated words that should be considered directives if they
      # appear at the beginning of a comment and should not be checked.
      spelling-ignore-comment-directives = "fmt: on,fmt: off,noqa:,noqa,nosec,isort:skip,mypy:"

      # List of comma separated words that should not be checked.
      # spelling-ignore-words =

      # A path to a file that contains the private dictionary; one word per line.
      # spelling-private-dict-file =

      # Tells whether to store unknown words to the private dictionary (see the
      # --spelling-private-dict-file option) instead of raising a message.
      # spelling-store-unknown-words =

    [tool.pylint.typecheck]
      # List of decorators that produce context managers, such as
      # contextlib.contextmanager. Add to this list to register other decorators that
      # produce valid context managers.
      contextmanager-decorators = ["contextlib.contextmanager"]

      # List of members which are set dynamically and missed by pylint inference
      # system, and so shouldn't trigger E1101 when accessed. Python regular
      # expressions are accepted.
      generated-members = "cv.*"

      # Tells whether missing members accessed in mixin class should be ignored. A
      # class is considered mixin if its name matches the mixin-class-rgx option.
      # Tells whether to warn about missing members when the owner of the attribute is
      # inferred to be None.
      ignore-none = true

      # This flag controls whether pylint should warn about no-member and similar
      # checks whenever an opaque object is returned when inferring. The inference can
      # return multiple potential results while evaluating a Python object, but some
      # branches might not be evaluated, which results in partial inference. In that
      # case, it might be useful to still emit no-member and other checks for the rest
      # of the inferred objects.
      ignore-on-opaque-inference = true

      # List of symbolic message names to ignore for Mixin members.
      ignored-checks-for-mixins = [
        "attribute-defined-outside-init",
        "no-member",
        "not-async-context-manager",
        "not-context-manager",
      ]

      # List of class names for which member attributes should not be checked (useful
      # for classes with dynamically set attributes). This supports the use of
      # qualified names.
      ignored-classes = [
        "_thread._local",
        "argparse.Namespace",
        "optparse.Values",
        "thread._local",
      ]

      # Show a hint with possible names when a member name was not found. The aspect of
      # finding the hint is based on edit distance.
      missing-member-hint = true

      # The minimum edit distance a name should have in order to be considered a
      # similar match for a missing member name.
      missing-member-hint-distance = 1

      # The total number of similar names that should be taken in consideration when
      # showing a hint for a missing member.
      missing-member-max-choices = 1

      # Regex pattern to define which classes are considered mixins.
      mixin-class-rgx = ".*[Mm]ixin"

      # List of decorators that change the signature of a decorated function.
      # signature-mutators =

    [tool.pylint.variables]
      # List of additional names supposed to be defined in builtins. Remember that you
      # should avoid defining new builtins when possible.
      # additional-builtins =

      # Tells whether unused global variables should be treated as a violation.
      allow-global-unused-variables = true

      # List of names allowed to shadow builtins
      # allowed-redefined-builtins =

      # List of strings which can identify a callback function by name. A callback name
      # must start or end with one of those strings.
      callbacks = ["_cb", "cb_"]

      # A regular expression matching the name of dummy variables (i.e. expected to not
      # be used).
      dummy-variables-rgx = "_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_"

      # Argument names that match this expression will be ignored.
      ignored-argument-names = "_.*|^ignored_|^unused_"

      # Tells whether we should check for unused import in __init__ files.
      # init-import =

      # List of qualified module names which can have objects that can redefine
      # builtins.
      redefining-builtins-modules = [
        "builtins",
        "future.builtins",
        "io",
        "past.builtins",
        "six.moves",
      ]

  [tool.mypy]
    # Introduce stricter options
    strict = true

    # Start off with these
    warn_redundant_casts = true
    warn_unused_configs  = true
    warn_unused_ignores  = true

    # Getting these passing should be easy
    strict_concatenate = true
    strict_equality    = true

    # Strongly recommend enabling this one as soon as you can
    check_untyped_defs = true

    # These shouldn't be too much additional work, but may be tricky to
    # get passing if you use a lot of untyped libraries
    disallow_any_generics       = true
    disallow_subclassing_any    = true
    disallow_untyped_decorators = true

    # These next few are various gradations of forcing use of type annotations
    disallow_incomplete_defs = true
    disallow_untyped_calls   = true
    disallow_untyped_defs    = true

    # This one isn't too hard to get passing, but return on investment is lower
    no_implicit_reexport = true

    # This one can be tricky to get passing if you use a lot of untyped libraries
    warn_return_any = true

  [tool.pydoclint]
    style = 'numpy'
    allow-init-docstring = true

  [tool.pydocstyle]
    convention = 'numpy'

[build-system]
  build-backend = "setuptools.build_meta"
  requires      = [
    "setuptools-scm",
    "setuptools>=75.2.0",
  ]

  # build-backend = "poetry.core.masonry.api"
  # requires      = [
  #   "poetry-core"
  # ]