Schemathesis VS yapf

I am not aware of any tools like that, but eventually, I plan to add support for gRPC fuzzing to Schemathesis. There were already some discussions and it is more or less clear how to move forward. See https://github.com/schemathesis/schemathesis/discussions/190...

Why is AI needed for this at all? Have you heard about Schemathesis (https://github.com/schemathesis/schemathesis)?

SchemaThesis is a powerful tool, especially when working with web APIs, and here's how it can enhance your testing capabilities:

I'm sorry, but you have completely misunderstood the purpose of Open API.

It is not a specification to define your business logic classes and objects -- either client or server side. Its goal is to define the interface of an API, and to provide a single source of truth that requests and responses can be validated against. It contains everything you need to know to make requests to an API; code generation is nice to have (and I use it myself, but mainly on the server side, for routing and validation), but not something required or expected from OpenAPI

For what it's worth, my personal preferred workflow to build an API is as follows:

1. Build the OpenAPI spec first. A smaller spec could easily be done by hand, but I prefer using a design tool like Stoplight [0]; it has the best Web-based OpenAPI (and JSON Schema) editor I have encountered, and integrates with git nearly flawlessly.

2. Use an automated tool to generate the API code implementation. Again, a static generation tool such as datamodel-code-generator [1] (which generates Pydantic models) would suffice, but for Python I prefer the dynamic request routing and validation provided by pyapi-server [2].

3. Finally, I use automated testing tools such as schemathesis [3] to test the implementation against the specification.

[0] https://stoplight.io/

[1] https://koxudaxi.github.io/datamodel-code-generator/

[2] https://pyapi-server.readthedocs.io

[3] https://schemathesis.readthedocs.io

Consolidating the API specification with OpenAPI was a turning point for the project. From that moment we were able to run mock servers to build and test the UI before integrating with the backend, and we were able to validate the backend implementation against the specification. We used prism to run mock servers, and Dredd to validate the server implementation (these days I’d rather use schemathesis).

In this approach, you produce an API specification first, then you build the API against the specification, and then you validate your implementation against the specification using automated API testing tools. This is the most reliable approach for building API servers, since it’s the only one that holds the server accountable and validates the implementation against the source of truth. Unfortunately, this approach isn’t as common as it should be. One of the reasons why it isn’t so common is because it requires you to produce the API specification first, which, as we saw earlier, puts off many developers who don’t know how to work with OpenAPI. However, like I said before, generating OpenAPI specifications doesn’t need to be painful since you can use tools for that. In this approach, you use automated API testing tools to validate your implementation. Tools like Dredd and schemathesis. These tools work by parsing your API specification and automatically generating tests that ensure your implementation complies with the specification. They look at every aspect of your API implementation, including use of headers, status codes, compliance with schemas, and so on. The most advanced of these tools at the moment is schemathesis, which I highly encourage you to check out.

Keep all API versions in the code Another strategy is to have all the different API versions in the same code. So you may have a folder structure that looks like this: api ├── v1 └── v2 Within the API folder, you have one folder for v1 and another one for v2. Each folder has its own schemas and routes as required by the API version they implement. If you use URL-based versioning, v1 is accessible through the example.com/v1 endpoint or the v1.example.com subdomain (whichever strategy you use), and same for v2. Deprecating a version is a simple as its corresponding folder. In any case, I'd recommend you also validate your API implementations in the CI using something like schemathesis. Schemathesis looks at the API documentation and automatically generates hundreds of tests to make sure you're using the right schemas, status codes, and so on. It works best if you design and document the API before implementing, which allows you to include OpenAPI links and other features.

schemathesis – Run generated test scenarios based on your OpenAPI specification

YAPF (Yet Another Python Formatter): YAPF takes a different approach in that it’s based off of ‘clang-format’, a popular formatter for C++ code. YAPF reformats Python code so that it conforms to the style guide and looks good.

I think I agree about the testing and labor of complicated translation rules.

But it doesn't appear that almost every pretty printer uses the Wadler pretty printing paper. It seems like MOST of them don't?

e.g. clang-format is one of the biggest and best, and it has a model that includes "unwrapped lines", a "layouter", a line break cost function, exhaustive search with memoization, and Dijikstra's algorithm:

https://llvm.org/devmtg/2013-04/jasper-slides.pdf

The YAPF Python formatter is based on this same algorithm - https://github.com/google/yapf

The Dart formatter used a model of "chunks, rules, and spans"

https://journal.stuffwithstuff.com/2015/09/08/the-hardest-pr...

It almost seems like there are 2 camps -- the functional algorithms for functional/expression-based languages, and other algorithms for more statement-based languages.

Though I guess Prettier/JavaScript falls on the functional side.

I just ran across this survey on lobste.rs and it seems to cover the functional pretty printing languages influenced by Wadler, but functional style, but not the other kind of formatter ("Google" formatters perhaps)

https://arxiv.org/pdf/2310.01530.pdf

To get all your code into a consistent format the next step is to run a formatter. I recommend black, the well-known uncompromising code formatter, which is the most popular choice. Alternatives to black are autoflake, prettier and yapf, if you do not agree with blacks constraints.

Use yapf to format code -> https://github.com/google/yapf

Google is surprisingly rigorous when it comes to code formatting. I have been a software engineer at Amazon and it was nothing like what the book says happens at Google. So the conventions you see for python docstring formatting are primarily designed to integrate with Google's internal tooling. By using docstrings following the Google conventions, you will ultimately end up with automated documentation and other fancy automated things (like type checking which they did in the docstring before there were type hints). Also notably, Google has an open source python formatting tool that they use internally called YAPF (which stands for "Yet Another Python Formatter". So if you really want to go all-in on Google python style, grab that, too.

https://github.com/google/yapf has configs, do ctrl+f SPLIT_COMPLEX_COMPREHENSION in the readme

Only as recommendation: If the lines of the source code (here: you C code you aim to document) are kept short, in manageable bytes (similar to entries parser.add_argument in Clark's "Tiny Python Projects", example seldomly pass beyond the frequently recommended threshold of 80 characters/line), reporting with listings becomes easier (equally, the reading of the difference logs/views by git and vimdiff), than with lines of say 120 characters per line. Though we no longer are constrained to 80 characters per line by terminals/screens and punch cards (when Fortran still was FORTRAN), this is a reason e.g., yapf for Python allows you to choose between 4 spaces/indentation (PEP8 style), or 2 spaces/indentation (Google style).

There is also a formatter for Python files called yapf that your team can use to avoid arguing over formatting conventions. Plus, Google also provides a settings file for Vim, noting that the default settings should be enough if you're using Emacs.