ruff-config-generator 2.1.0__tar.gz

ruff_config_generator-2.1.0/.config/.coveragerc

@@ -0,0 +1,5 @@
+[report]
+exclude_lines =
+    pragma: no cover
+    if TYPE_CHECKING:
+    return NotImplemented

ruff_config_generator-2.1.0/.config/.editorconfig

@@ -0,0 +1,17 @@
+root = true
+
+[*]
+spelling_language = "en-US"
+trim_trailing_whitespace = true
+insert_final_newline = true
+charset = utf-8
+end_of_line = lf
+indent_style = space
+indent_size = 4
+
+[*.{json,yaml,yml,xml}]
+indent_size = 2
+
+[*.{md}]
+indent_size = 4
+trim_trailing_whitespace = false

ruff_config_generator-2.1.0/.config/.flake8

@@ -0,0 +1,25 @@
+[flake8]
+count = True
+extend-exclude =
+    .*/
+    tests/
+
+### Rules choice
+# DOC: We use flake8 just to run pydoclint, ruff takes care about the rest
+select=DOC
+# DOC5xx: Violations about “raise” and “assert” statements
+# DOC6xx: Violations about class attributes
+# DOC203: Return type(s) in the docstring not consistent with the return annotation
+# DOC404: The types in the docstring’s Yields section and the return annotation in the signature are not consistent
+ignore=DOC5,DOC6,DOC203,DOC404
+
+### pydoclint options
+style = sphinx
+arg-type-hints-in-docstring = False
+skip-checking-short-docstrings = False
+skip-checking-raises = True
+check-return-types = False
+check-yield-types = False
+check-class-attributes = False
+check-style-mismatch = True
+omit-stars-when-documenting-varargs = True

ruff_config_generator-2.1.0/.config/mypy.ini

@@ -0,0 +1,497 @@
+### Configuration created for mypy==2.3.0
+
+[mypy]
+
+### Import discovery
+# Specifies the paths to use, after trying the paths from MYPYPATH environment
+# variable.  Useful if you’d like to keep stubs in your repo, along with the config file.
+# Multiple paths are always separated with a : or , regardless of the platform.
+# User home directory and environment variables will be expanded.
+# Relative paths are treated relative to the working directory of the mypy command,
+# not the config file.
+# Use the MYPY_CONFIG_FILE_DIR environment variable to refer to paths relative to
+# the config file (e.g. mypy_path = $MYPY_CONFIG_FILE_DIR/src).
+# This option may only be set in the global section ([mypy]).
+# Note: On Windows, use UNC paths to avoid using : (e.g. \\127.0.0.1\X$\MyDir where X is the drive letter).
+#mypy_path =
+
+# A comma-separated list of paths which should be checked by mypy if none are given on the command
+# line. Supports recursive file globbing using glob, where * (e.g. *.py) matches
+# files in the current directory and **/ (e.g. **/*.py) matches files in any directories below
+# the current one. User home directory and environment variables will be expanded.
+# This option may only be set in the global section ([mypy]).
+files = .
+
+# A comma-separated list of packages which should be checked by mypy if none are given on the command
+# line. Mypy will not recursively type check any submodules of the provided
+# module.
+# This option may only be set in the global section ([mypy]).
+#modules =
+
+# A comma-separated list of packages which should be checked by mypy if none are given on the command
+# line.  Mypy will recursively type check any submodules of the provided
+# package. This flag is identical to modules apart from this
+# behavior.
+# This option may only be set in the global section ([mypy]).
+#packages =
+
+# A regular expression that matches file names, directory names and paths
+# which mypy should ignore while recursively discovering files to check.
+# Use forward slashes (/) as directory separators on all platforms.
+# Crafting a single regular expression that excludes multiple files while remaining
+# human-readable can be a challenge. The above example demonstrates one approach.
+# (?x) enables the VERBOSE flag for the subsequent regular expression, which
+# ignores most whitespace and supports comments.
+# The above is equivalent to: (^one\.py$|two\.pyi$|^three\.).
+# For more details, see --exclude.
+# This option may only be set in the global section ([mypy]).
+#exclude =
+
+# This flag will add everything that matches .gitignore file(s) to exclude.
+# This option may only be set in the global section ([mypy]).
+exclude_gitignore = False
+
+# Enables PEP 420 style namespace packages.  See the
+# corresponding flag --no-namespace-packages
+# for more information.
+# This option may only be set in the global section ([mypy]).
+namespace_packages = True
+
+# This flag tells mypy that top-level packages will be based in either the
+# current directory, or a member of the MYPYPATH environment variable or
+# mypy_path config option. This option is only useful in
+# the absence of __init__.py. See Mapping file
+# paths to modules for details.
+# This option may only be set in the global section ([mypy]).
+explicit_package_bases = False
+
+# Suppresses error messages about imports that cannot be resolved.
+# If this option is used in a per-module section, the module name should
+# match the name of the imported module, not the module containing the
+# import statement.
+ignore_missing_imports = False
+
+# Makes mypy analyze imports from installed packages even if missing a
+# py.typed marker or stubs.
+# If this option is used in a per-module section, the module name should
+# match the name of the imported module, not the module containing the
+# import statement.
+follow_untyped_imports = False
+
+# Directs what to do with imports when the imported module is found
+# as a .py file and not part of the files, modules and packages
+# provided on the command line.
+# The four possible values are normal, silent, skip and
+# error.  For explanations see the discussion for the
+# --follow-imports command line flag.
+# Using this option in a per-module section (potentially with a wildcard,
+# as described at the top of this page) is a good way to prevent mypy from
+# checking portions of your code.
+# If this option is used in a per-module section, the module name should
+# match the name of the imported module, not the module containing the
+# import statement.
+follow_imports = normal
+
+# Determines whether to respect the follow_imports setting even for
+# stub (.pyi) files.
+# Used in conjunction with follow_imports=skip, this can be used
+# to suppress the import of a module from typeshed, replacing it
+# with Any.
+# Used in conjunction with follow_imports=error, this can be used
+# to make any use of a particular typeshed module an error.
+follow_imports_for_stubs = False
+
+# Specifies the path to the Python executable to inspect to collect
+# a list of available PEP 561 packages. User
+# home directory and environment variables will be expanded. Defaults to
+# the executable used to run mypy.
+# This option may only be set in the global section ([mypy]).
+#python_executable =
+
+# Disables using type information in installed packages (see PEP 561).
+# This will also disable searching for a usable Python executable. This acts
+# the same as --no-site-packages command
+# line flag.
+no_site_packages = False
+
+# Enables reporting error messages generated within installed packages (see
+# PEP 561 for more details on distributing type information). Those error
+# messages are suppressed by default, since you are usually not able to
+# control errors in 3rd party code.
+# This option may only be set in the global section ([mypy]).
+no_silence_site_packages = False
+
+
+### Platform configuration
+# Specifies the Python version used to parse and check the target
+# program.  The string should be in the format MAJOR.MINOR –
+# for example 3.10.  The default is the version of the Python
+# interpreter used to run mypy.
+# This option may only be set in the global section ([mypy]).
+#python_version =
+
+# Specifies the OS platform for the target program, for example
+# darwin or win32 (meaning OS X or Windows, respectively).
+# The default is the current platform as revealed by Python’s
+# sys.platform variable.
+# This option may only be set in the global section ([mypy]).
+#platform =
+
+# Specifies a list of variables that mypy will treat as
+# compile-time constants that are always true.
+#always_true =
+
+# Specifies a list of variables that mypy will treat as
+# compile-time constants that are always false.
+#always_false =
+
+
+### Disallow dynamic typing
+# Disallows usage of types that come from unfollowed imports (anything imported from
+# an unfollowed import is automatically given a type of Any).
+disallow_any_unimported = False
+
+# Disallows all expressions in the module that have type Any.
+disallow_any_expr = False
+
+# Disallows functions that have Any in their signature after decorator transformation.
+disallow_any_decorated = False
+
+# Disallows explicit Any in type positions such as type annotations and generic
+# type parameters.
+disallow_any_explicit = False
+
+# Disallows usage of generic types that do not specify explicit type parameters.
+disallow_any_generics = True
+
+# Disallows subclassing a value of type Any.
+disallow_subclassing_any = True
+
+
+### Untyped definitions and calls
+# Disallows calling functions without type annotations from functions with type
+# annotations. Note that when used in per-module options, it enables/disables
+# this check inside the module(s) specified, not for functions that come
+# from that module(s), for example config like this:
+# will disable this check inside some.library, not for your code that
+# imports some.library. If you want to selectively disable this check for
+# all your code that imports some.library you should instead use
+# untyped_calls_exclude, for example:
+disallow_untyped_calls = True
+
+# Selectively excludes functions and methods defined in specific packages,
+# modules, and classes from action of disallow_untyped_calls.
+# This also applies to all submodules of packages (i.e. everything inside
+# a given prefix). Note, this option does not support per-file configuration,
+# the exclusions list is defined globally for all your code.
+#untyped_calls_exclude =
+
+# Disallows defining functions without type annotations or with incomplete type
+# annotations (a superset of disallow_incomplete_defs).
+# For example, it would report an error for def f(a, b) and def f(a: int, b).
+disallow_untyped_defs = True
+
+# Disallows defining functions with incomplete type annotations, while still
+# allowing entirely unannotated definitions.
+# For example, it would report an error for def f(a: int, b) but not def f(a, b).
+disallow_incomplete_defs = True
+
+# Type-checks the interior of functions without type annotations.
+check_untyped_defs = True
+
+# Reports an error whenever a function with type annotations is decorated with a
+# decorator without annotations.
+disallow_untyped_decorators = True
+
+
+### None and Optional handling
+# Causes mypy to treat parameters with a None
+# default value as having an implicit optional type (T | None).
+# Note: This was True by default in mypy versions 0.980 and earlier.
+implicit_optional = False
+
+# Effectively disables checking of optional
+# types and None values. With this option, mypy doesn’t
+# generally check the use of None values – it is treated
+# as compatible with every type.
+strict_optional = True
+
+
+### Configuring warnings
+# Warns about casting an expression to its inferred type.
+# This option may only be set in the global section ([mypy]).
+warn_redundant_casts = True
+
+# Warns about unneeded # type: ignore comments.
+warn_unused_ignores = True
+
+# Shows errors for missing return statements on some execution paths.
+warn_no_return = True
+
+# Shows a warning when returning a value with type Any from a function
+# declared with a non- Any return type.
+warn_return_any = True
+
+# Shows a warning when encountering any code inferred to be unreachable or
+# redundant after performing type analysis.
+warn_unreachable = True
+
+# Selectively excludes functions and methods defined in specific packages,
+# modules, and classes from the deprecated error code.
+# This also applies to all submodules of packages (i.e. everything inside
+# a given prefix). Note, this option does not support per-file configuration,
+# the exclusions list is defined globally for all your code.
+#deprecated_calls_exclude =
+
+
+### Suppressing errors
+# Ignores all non-fatal errors.
+ignore_errors = False
+
+
+### Miscellaneous strictness flags
+# Causes mypy to suppress errors caused by not being able to fully
+# infer the types of global and class variables.
+allow_untyped_globals = False
+
+# By default, mypy won’t allow a variable to be redefined with an
+# unrelated type. This flag enables the redefinition of unannotated
+# variables with an arbitrary type. This also requires
+# local_partial_types, which is enabled by default starting
+# from mypy 2.0. Example:
+# This also enables an unannotated variable to have different types in different
+# code locations:
+# Function arguments are special, changing their type within function body
+# is allowed even if they are annotated, but that annotation is used to infer
+# types of r.h.s. of all subsequent assignments. Such middle-ground semantics
+# provides good balance for majority of common use cases. For example:
+# Note: We are planning to turn this flag on by default in a future mypy
+# release.
+allow_redefinition = False
+
+# Deprecated alias for allow_redefinition.
+allow_redefinition_new = False
+
+# Allows variables to be redefined with an arbitrary type, as long as the redefinition
+# is in the same block and nesting level as the original definition.
+# Example where this can be useful:
+# The variable must be used before it can be redefined:
+allow_redefinition_old = False
+
+# This prevents inferring a variable type from an empty container (such as a list or
+# a dictionary) created at module top level or class body and updated in
+# a function. This must be enabled when using the mypy daemon.
+local_partial_types = True
+
+# Allows disabling one or multiple error codes globally.
+#disable_error_code =
+
+# Allows enabling one or multiple error codes globally.
+# Note: This option will override disabled error codes from the disable_error_code option.
+#enable_error_code =
+
+# This flag enables additional checks that are technically correct but may be impractical.
+# See mypy --extra-checks for more info.
+extra_checks = True
+
+# By default, imported values to a module are treated as exported and mypy allows
+# other modules to import them. When false, mypy will not re-export unless
+# the item is imported using from-as or is included in __all__. Note that mypy
+# treats stub files as if this is always disabled. For example:
+implicit_reexport = False
+
+# Prohibit equality checks, identity checks, and container checks between
+# non-overlapping types (except None).
+strict_equality = True
+
+# Include None in strict equality checks (requires strict_equality
+# to be activated).
+strict_equality_for_none = False
+
+# If disabled, mypy treats bytearray and memoryview as subtypes of bytes.
+# This has been enabled by default since mypy 2.0.
+strict_bytes = True
+
+# Enable all optional error checking flags.  You can see the list of
+# flags enabled by strict mode in the full mypy --help
+# output.
+# Note: the exact list of flags enabled by strict may
+# change over time.
+strict = True
+
+
+### Configuring error messages
+# Prefixes each error with the relevant context.
+show_error_context = False
+
+# Shows column numbers in error messages.
+show_column_numbers = False
+
+# Shows documentation link to corresponding error code.
+show_error_code_links = False
+
+# Hides error codes in error messages. See Error codes for more information.
+hide_error_codes = False
+
+# Use visually nicer output in error messages: use soft word wrap,
+# show source code snippets, and show error location markers.
+pretty = False
+
+# Shows error messages with color enabled.
+color_output = True
+
+# Shows a short summary line after error messages.
+error_summary = True
+
+# Show absolute paths to files.
+show_absolute_path = False
+
+
+### Incremental mode
+# Enables incremental mode.
+incremental = True
+
+# Specifies the location where mypy stores incremental cache info.
+# User home directory and environment variables will be expanded.
+# This setting will be overridden by the MYPY_CACHE_DIR environment
+# variable.
+# Note that the cache is only read when incremental mode is enabled
+# but is always written to, unless the value is set to /dev/null
+# (UNIX) or nul (Windows).
+cache_dir = .mypy_cache
+
+# Use an SQLite database to store the cache.
+sqlite_cache = True
+
+# Include fine-grained dependency information in the cache for the mypy daemon.
+cache_fine_grained = False
+
+# Makes mypy use incremental cache data even if it was generated by a
+# different version of mypy. (By default, mypy will perform a version
+# check and regenerate the cache if it was written by older versions of mypy.)
+skip_version_check = False
+
+# Skip cache internal consistency checks based on mtime.
+skip_cache_mtime_checks = False
+
+
+### Parallel type-checking configuration
+# Use specific number of parallel worker processes for type-checking, see
+# parallel type-checking for more details.
+# This setting will be overridden by the MYPY_NUM_WORKERS environment
+# variable.
+num_workers = 0
+
+
+### Advanced options
+# A comma-separated list of mypy plugins. See Extending mypy using plugins.
+#plugins =
+
+# Invokes pdb on fatal error.
+pdb = False
+
+# Shows traceback on fatal error.
+show_traceback = False
+
+# Raise exception on fatal error.
+raise_exceptions = False
+
+# Specifies a custom module to use as a substitute for the typing module.
+#custom_typing_module =
+
+# This specifies the directory where mypy looks for standard library typeshed
+# stubs, instead of the typeshed that ships with mypy.  This is
+# primarily intended to make it easier to test typeshed changes before
+# submitting them upstream, but also allows you to use a forked version of
+# typeshed.
+# User home directory and environment variables will be expanded.
+# Note that this doesn’t affect third-party library stubs. To test third-party stubs,
+# for example try MYPYPATH=stubs/six mypy ....
+#custom_typeshed_dir =
+
+# Warns about missing type annotations in typeshed.  This is only relevant
+# in combination with disallow_untyped_defs or disallow_incomplete_defs.
+warn_incomplete_stub = True
+
+# This enables fast Rust-based parser that parses directly to mypy AST.
+# It will become the default parser in one of the next mypy releases.
+native_parser = False
+
+
+### Report generation
+# Causes mypy to generate a text file report documenting how many
+# expressions of type Any are present within your codebase.
+#any_exprs_report =
+
+# Causes mypy to generate a Cobertura XML type checking coverage report.
+# To generate this report, you must either manually install the lxml
+# library or specify mypy installation with the setuptools extra
+# mypy[reports].
+#cobertura_xml_report =
+
+# Causes mypy to generate an HTML type checking coverage report.
+# To generate this report, you must either manually install the lxml
+# library or specify mypy installation with the setuptools extra
+# mypy[reports].
+#html_report / xslt_html_report =
+
+# Causes mypy to generate a text file report documenting the functions
+# and lines that are typed and untyped within your codebase.
+#linecount_report =
+
+# Causes mypy to generate a JSON file that maps each source file’s
+# absolute filename to a list of line numbers that belong to typed
+# functions in that file.
+#linecoverage_report =
+
+# Causes mypy to generate a flat text file report with per-module
+# statistics of how many lines are typechecked etc.
+#lineprecision_report =
+
+# Causes mypy to generate a text file type checking coverage report.
+# To generate this report, you must either manually install the lxml
+# library or specify mypy installation with the setuptools extra
+# mypy[reports].
+#txt_report / xslt_txt_report =
+
+# Causes mypy to generate an XML type checking coverage report.
+# To generate this report, you must either manually install the lxml
+# library or specify mypy installation with the setuptools extra
+# mypy[reports].
+#xml_report =
+
+
+### Miscellaneous
+# Causes mypy to generate a JUnit XML test result document with
+# type checking results. This can make it easier to integrate mypy
+# with continuous integration (CI) tools.
+#junit_xml =
+
+# If junit_xml is set, specifies format.
+# global (default): single test with all errors;
+# per_file: one test entry per file with failures.
+junit_format = global
+
+# Makes script x become module x instead of __main__.  This is
+# useful when checking multiple scripts in a single run.
+scripts_are_modules = False
+
+# Warns about per-module sections in the config file that do not
+# match any files processed when invoking mypy.
+# (This requires turning off incremental mode using incremental = False.)
+warn_unused_configs = True
+
+# Controls how much debug output will be generated.  Higher numbers are more verbose.
+verbosity = 0
+
+
+# This section should only define values that are different than in global section
+[mypy-tests.*]
+disallow_untyped_defs = False
+disallow_incomplete_defs = False
+
+
+# Conftests should be checked in the same manner as production code, so they revert `tests.*` overwrites
+[mypy-tests.*.conftest]
+disallow_untyped_defs = True
+disallow_incomplete_defs = True

ruff_config_generator-2.1.0/.config/pytest.ini

@@ -0,0 +1,15 @@
+[pytest]
+logot_capturer = logot.loguru.LoguruCapturer
+
+testpaths =
+    tests
+
+addopts =
+    --cov src
+    --cov-report html:coverage-report
+    --cov-report term:skip-covered
+    --cov-fail-under=0
+    --no-cov-on-fail
+    -Werror
+    -Wignore::ImportWarning
+    --strict-markers