PythonTutorial | Code files

I don't know anything about what system will be reading your file, so I can't say anything about how you should write it to a file. It really depends on how the Model Server expects to read it.

That said, I don't see anything wrong with how you're creating the message, or any of the serialization methods you've shown.

• The print method shows a "text format" proto, which is good for debugging and is sometimes used for storing configuration files. It's not very compact (field names are present in the file) and doesn't have all the backwards- and forwards-compatible features of the binary representation. It's actually funcionally the same as what you've said it "should look like": the colons and commas are actually optional.
• The SerializeToString() method uses the binary serialization format. This is arguably what Protocol Buffers were built to do. It's a compact representation and provides backwards and forwards compatibility, but it's not very human-readable.
• As the name suggests, the json_format module provides a JSON representation of the message. That's perfectly good if the system you're interacting with expects a JSON, but it's not exactly common.

Appendix: instead of using print(), the google.protobuf.text_format module has utilities better suited to using the text format programmatically. To write to a file, you could use:

protoc contains just logic for protocol buffers. That is, it will generate serialization/deserialization code for many languages. It does not, however, generate code for stubs and servers by default. This is left up to separate RPC systems through a system called protoc plugins.

Protoc plugins offer a simple interface by which an executable takes a description of a Protocol Buffer on stdin and outputs the corresponding generated code on stdout. Internal to Google, this system is used to generate code for Stubby. Externally, it is used to generate code for gRPC (or any other RPC system that wants to use protocol buffers).

Plugins get to register a command line flag for themselves to indicate where protoc should output the generated code. So, in your example above, --python_out indicates where the generated serialization/deserialization code should go, while --grpc_python_out is the flag registered by the gRPC Python code generator, indicating where Python stub and server code should be placed on the filesystem.

grpc_tools is a C extension bundling both protoc and the gRPC Python protoc plugin together so that the user doesn't have to deal with downloading protoc, downloading the gRPC Python code generator, and getting the necessary configuration set up to make them work together properly. However, in theory, you should be able to put all these pieces together to make them work just like grpc_tools (though I haven't tried).

I solved my problem. Apparently, pylint has (had?) problems with protobuf compiled python classes. There's a package available that solves this issue.

• installed pylint-protobuf package (pip install pylint-protobuf)
• added "python.linting.pylintArgs": ["--load-plugins", "pylint_protobuf"] to User Settings in VS Code

No errors!

For more information, see the VS Code linting Docs

use the -k option to specify substring matching.

using the following code I was able to parse a config file.

This probably is a path error. As I have encountered in the past VS Code doesn't allow you to run python commands from its terminal unless its paths are also set in the system variables. Do recheck these.

protobuf3 you were using is an archived project https://github.com/Pr0Ger/protobuf3. Please use pypi.org/project/protobuf.

Any traditional build system should be able to do this.

For example, Makefiles, scons, cmake or similar. The process is the same you would use to compile multiple .c files to multiple .o files with a C compiler, and there are plenty of examples for that.

I found the project called pyprotobuf (http://pyprotobuf.readthedocs.io) that can generate a module with protorpc classes starting from the proto file.

According to the documentation (http://pyprotobuf.readthedocs.io/topics/languages/protorpc.html) you need to execute:

protopy --format python example.proto