In the next chapter, we'll use persistence techniques to handle configuration files. A file that's editable by humans is the primary requirement for the configuration data. If we use a well-known persistence module, then our application can parse and validate the configuration data with less programming on our part.
- Title Page
- Copyright and Credits
- About Packt
- Contributors
- Preface
- Section 1: Tighter Integration Via Special Methods
- Preliminaries, Tools, and Techniques
- Technical requirements
- About the Blackjack game
- The Python runtime and special methods
- Interaction, scripting, and tools
- Selecting an IDE
- Consistency and style
- Type hints and the mypy program
- Performance – the timeit module
- Testing – unittest and doctest
- Documentation – sphinx and RST markup
- Installing components
- Summary
- The __init__() Method
- Technical requirements
- The implicit superclass – object
- The base class object __init__() method
- Implementing __init__() in a superclass
- Creating enumerated constants
- Leveraging __init__() via a factory function
- Implementing __init__() in each subclass
- Composite objects
- Complex composite objects
- Stateless objects without __init__()
- Some additional class definitions
- Multi-strategy __init__()
- Yet more __init__() techniques
- Summary
- Integrating Seamlessly - Basic Special Methods
- Attribute Access, Properties, and Descriptors
- The ABCs of Consistent Design
- Using Callables and Contexts
- Creating Containers and Collections
- Technical requirements
- ABCs of collections
- Examples of special methods
- Using the standard library extensions
- Creating new kinds of collections
- Narrowing a collection's type
- Defining a new kind of sequence
- Creating a new kind of mapping
- Creating a new kind of set
- Design considerations and tradeoffs
- Summary
- Creating Numbers
- Decorators and Mixins - Cross-Cutting Aspects
- Section 2: Object Serialization and Persistence
- Serializing and Saving - JSON, YAML, Pickle, CSV, and XML
- Technical requirements
- Understanding persistence, class, state, and representation
- Filesystem and network considerations
- Defining classes to support persistence
- Dumping and loading with JSON
- Dumping and loading with YAML
- Dumping and loading with pickle
- Dumping and loading with CSV
- Dumping and loading with XML
- Summary
- Storing and Retrieving Objects via Shelve
- Technical requirements
- Analyzing persistent object use cases
- Creating a shelf
- Designing shelvable objects
- Searching, scanning, and querying
- Designing an access layer for shelve
- Creating indexes to improve efficiency
- Adding yet more index maintenance
- The writeback alternative to index updates
- Summary
- Storing and Retrieving Objects via SQLite
- Technical requirements
- SQL databases, persistence, and objects
- Processing application data with SQL
- Mapping Python objects to SQLite BLOB columns
- Mapping Python objects to database rows manually
- Improving performance with indices
- Adding an ORM layer
- Querying posts that are given a tag
- Defining indices in the ORM layer
- Summary
- Transmitting and Sharing Objects
- Technical requirements
- Class, state, and representation
- Using HTTP and REST to transmit objects
- Using Flask to build a RESTful web service
- Handling stateful REST services
- Creating a secure REST service
- Implementing REST with a web application framework
- Using a message queue to transmit objects
- Summary
- Configuration Files and Persistence
- Technical requirements
- Configuration file use cases
- Representation, persistence, state, and usability
- Storing the configuration in INI files
- Handling more literals via the eval() variants
- Storing the configuration in PY files
- Why exec() is a non-problem
- Using ChainMap for defaults and overrides
- Storing the configuration in JSON or YAML files
- Storing the configuration in properties files
- Using XML files – PLIST and others
- Summary
- Section 3: Object-Oriented Testing and Debugging
- Design Principles and Patterns
- The Logging and Warning Modules
- Designing for Testability
- Coping with the Command Line
- Technical requirements
- The OS interface and the command line
- Using the pathlib module
- Parsing the command line with argparse
- Integrating command-line options and environment variables
- Customizing the help output
- Creating a top-level main() function
- Programming in the large
- Additional composite Command design patterns
- Integrating with other applications
- Summary
- Module and Package Design
- Quality and Documentation
- Technical requirements
- Writing docstrings for the help() function
- Using pydoc for documentation
- Better output via RST markup
- Writing effective docstrings
- Writing file-level docstrings, including modules and packages
- More sophisticated markup techniques
- Using Sphinx to produce the documentation
- Writing the documentation
- Literate programming
- Summary
- Other Books You May Enjoy
Looking forward
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.