import datetime ymdstr = datetime.date.today().strftime("%y-%m-%d")

import datetime current_date: str = datetime.date.today().strftime("%y-%m-%d")

def get_user_info(): pass def get_client_data(): pass def get_customer_record(): pass

def get_user_info(): pass def get_user_data(): pass def get_user_record(): pass

from typing import Union, Dict class Record: pass class User: info : str @property def data(self) -> Dict[str, str]: return {} def get_record(self) -> Union[Record, None]: return Record()

import time # What is the number 86400 for again? time.sleep(86400)

import time # Declare them in the global namespace for the module. SECONDS_IN_A_DAY = 60 * 60 * 24 time.sleep(SECONDS_IN_A_DAY)

import re address = "One Infinite Loop, Cupertino 95014" city_zip_code_regex = r"^[^,\\]+[,\\\s]+(.+?)\s*(\d{5})?$" matches = re.match(city_zip_code_regex, address) if matches: print(f"{matches[1]}: {matches[2]}")

import re address = "One Infinite Loop, Cupertino 95014" city_zip_code_regex = r"^[^,\\]+[,\\\s]+(.+?)\s*(\d{5})?$" matches = re.match(city_zip_code_regex, address) if matches: city, zip_code = matches.groups() print(f"{city}: {zip_code}")

import re address = "One Infinite Loop, Cupertino 95014" city_zip_code_regex = r"^[^,\\]+[,\\\s]+(?P<city>.+?)\s*(?P<zip_code>\d{5})?$" matches = re.match(city_zip_code_regex, address) if matches: print(f"{matches['city']}, {matches['zip_code']}")

seq = ("Austin", "New York", "San Francisco") for item in seq: #do_stuff() #do_some_other_stuff() # Wait, what's `item` again? print(item)

locations = ("Austin", "New York", "San Francisco") for location in locations: #do_stuff() #do_some_other_stuff() # ... print(location)

class Car: car_make: str car_model: str car_color: str

class Car: make: str model: str color: str

import hashlib def create_micro_brewery(name): name = "Hipster Brew Co." if name is None else name slug = hashlib.sha1(name.encode()).hexdigest() # etc.

import hashlib def create_micro_brewery(name: str = "Hipster Brew Co."): slug = hashlib.sha1(name.encode()).hexdigest() # etc.

def create_menu(title, body, button_text, cancellable): pass

class Menu: def __init__(self, config: dict): self.title = config["title"] self.body = config["body"] # ... menu = Menu( { "title": "My Menu", "body": "Something about my menu", "button_text": "OK", "cancellable": False } )

class MenuConfig: """A configuration for the Menu.   Attributes:  title: The title of the Menu.  body: The body of the Menu.  button_text: The text for the button label.  cancellable: Can it be cancelled?  """ title: str body: str button_text: str cancellable: bool = False def create_menu(config: MenuConfig) -> None: title = config.title body = config.body # ... config = MenuConfig() config.title = "My delicious menu" config.body = "A description of the various items on the menu" config.button_text = "Order now!" # The instance attribute overrides the default class attribute. config.cancellable = True create_menu(config)

from typing import NamedTuple class MenuConfig(NamedTuple): """A configuration for the Menu.   Attributes:  title: The title of the Menu.  body: The body of the Menu.  button_text: The text for the button label.  cancellable: Can it be cancelled?  """ title: str body: str button_text: str cancellable: bool = False def create_menu(config: MenuConfig): title, body, button_text, cancellable = config # ... create_menu( MenuConfig( title="My delicious menu", body="A description of the various items on the menu", button_text="Order now!" ) )

from dataclasses import astuple, dataclass @dataclass class MenuConfig: """A configuration for the Menu.   Attributes:  title: The title of the Menu.  body: The body of the Menu.  button_text: The text for the button label.  cancellable: Can it be cancelled?  """ title: str body: str button_text: str cancellable: bool = False def create_menu(config: MenuConfig): title, body, button_text, cancellable = astuple(config) # ... create_menu( MenuConfig( title="My delicious menu", body="A description of the various items on the menu", button_text="Order now!" ) )

from typing import TypedDict class MenuConfig(TypedDict): """A configuration for the Menu.   Attributes:  title: The title of the Menu.  body: The body of the Menu.  button_text: The text for the button label.  cancellable: Can it be cancelled?  """ title: str body: str button_text: str cancellable: bool def create_menu(config: MenuConfig): title = config["title"] # ... create_menu( # You need to supply all the parameters MenuConfig( title="My delicious menu", body="A description of the various items on the menu", button_text="Order now!", cancellable=True ) )

from typing import List class Client: active: bool def email(client: Client) -> None: pass def email_clients(clients: List[Client]) -> None: """Filter active clients and send them an email.  """ for client in clients: if client.active: email(client)

from typing import List class Client: active: bool def email(client: Client) -> None: pass def get_active_clients(clients: List[Client]) -> List[Client]: """Filter active clients.  """ return [client for client in clients if client.active] def email_clients(clients: List[Client]) -> None: """Send an email to a given list of clients.  """ for client in get_active_clients(clients): email(client)

from typing import Generator, Iterator class Client: active: bool def email(client: Client): pass def active_clients(clients: Iterator[Client]) -> Generator[Client, None, None]: """Only active clients""" return (client for client in clients if client.active) def email_client(clients: Iterator[Client]) -> None: """Send an email to a given list of clients.  """ for client in active_clients(clients): email(client)

class Email: def handle(self) -> None: pass message = Email() # What is this supposed to do again? message.handle()

class Email: def send(self) -> None: """Send this message""" message = Email() message.send()

# type: ignore def parse_better_js_alternative(code: str) -> None: regexes = [ # ... ] statements = code.split('\n') tokens = [] for regex in regexes: for statement in statements: pass ast = [] for token in tokens: pass for node in ast: pass

from typing import Tuple, List, Dict REGEXES: Tuple = ( # ... ) def parse_better_js_alternative(code: str) -> None: tokens: List = tokenize(code) syntax_tree: List = parse(tokens) for node in syntax_tree: pass def tokenize(code: str) -> List: statements = code.split() tokens: List[Dict] = [] for regex in REGEXES: for statement in statements: pass return tokens def parse(tokens: List) -> List: syntax_tree: List[Dict] = [] for token in tokens: pass return syntax_tree

from tempfile import gettempdir from pathlib import Path def create_file(name: str, temp: bool) -> None: if temp: (Path(gettempdir()) / name).touch() else: Path(name).touch()

from tempfile import gettempdir from pathlib import Path def create_file(name: str) -> None: Path(name).touch() def create_temp_file(name: str) -> None: (Path(gettempdir()) / name).touch()

# type: ignore # This is a module-level name. # It's good practice to define these as immutable values, such as a string. # However... fullname = "Ryan McDermott" def split_into_first_and_last_name() -> None: # The use of the global keyword here is changing the meaning of the # the following line. This function is now mutating the module-level # state and introducing a side-effect! global fullname fullname = fullname.split() split_into_first_and_last_name() # MyPy will spot the problem, complaining about 'Incompatible types in # assignment: (expression has type "List[str]", variable has type "str")' print(fullname) # ["Ryan", "McDermott"] # OK. It worked the first time, but what will happen if we call the # function again?

from typing import List, AnyStr def split_into_first_and_last_name(name: AnyStr) -> List[AnyStr]: return name.split() fullname = "Ryan McDermott" name, surname = split_into_first_and_last_name(fullname) print(name, surname) # => Ryan McDermott

from dataclasses import dataclass @dataclass class Person: name: str @property def name_as_first_and_last(self) -> list: return self.name.split() # The reason why we create instances of classes is to manage state! person = Person("Ryan McDermott") print(person.name) # => "Ryan McDermott" print(person.name_as_first_and_last) # => ["Ryan", "McDermott"]

from importlib import metadata class VersionCommentElement: """An element that renders an HTML comment with the program's version number  """ def get_version(self) -> str: """Get the package version""" return metadata.version("pip") def render(self) -> None: print(f'<!-- Version: {self.get_version()} -->') VersionCommentElement().render()

from importlib import metadata def get_version(pkg_name:str) -> str: """Retrieve the version of a given package""" return metadata.version(pkg_name) class VersionCommentElement: """An element that renders an HTML comment with the program's version number  """ def __init__(self, version: str): self.version = version def render(self) -> None: print(f'<!-- Version: {self.version} -->') VersionCommentElement(get_version("pip")).render()

from dataclasses import dataclass @dataclass class Response: """An HTTP response""" status: int content_type: str body: str class View: """A simple view that returns plain text responses""" def get(self, request) -> Response: """Handle a GET request and return a message in the response""" return Response( status=200, content_type='text/plain', body="Welcome to my web site" ) class TemplateView(View): """A view that returns HTML responses based on a template file.""" def get(self, request) -> Response: """Handle a GET request and return an HTML document in the response""" with open("index.html") as fd: return Response( status=200, content_type='text/html', body=fd.read() )

from dataclasses import dataclass @dataclass class Response: """An HTTP response""" status: int content_type: str body: str class View: """A simple view that returns plain text responses""" content_type = "text/plain" def render_body(self) -> str: """Render the message body of the response""" return "Welcome to my web site" def get(self, request) -> Response: """Handle a GET request and return a message in the response""" return Response( status=200, content_type=self.content_type, body=self.render_body() ) class TemplateView(View): """A view that returns HTML responses based on a template file.""" content_type = "text/html" template_file = "index.html" def render_body(self) -> str: """Render the message body as HTML""" with open(self.template_file) as fd: return fd.read() 

from dataclasses import dataclass, field from typing import Protocol @dataclass class Response: """An HTTP response""" status: int content_type: str body: str headers: dict = field(default_factory=dict) class View: """A simple view that returns plain text responses""" content_type = "text/plain" def render_body(self) -> str: """Render the message body of the response""" return "Welcome to my web site" def get(self, request) -> Response: """Handle a GET request and return a message in the response""" return Response( status=200, content_type=self.content_type, body=self.render_body() ) class TemplateRenderMixin: """A mixin class for views that render HTML documents using a template file   Not to be used by itself!  """ template_file: str = "" def render_body(self) -> str: """Render the message body as HTML""" if not self.template_file: raise ValueError("The path to a template file must be given.") with open(self.template_file) as fd: return fd.read() class ContentLengthMixin: """A mixin class for views that injects a Content-Length header in the  response   Not to be used by itself!  """ def get(self, request) -> Response: """Introspect and amend the response to inject the new header""" response = super().get(request) # type: ignore response.headers['Content-Length'] = len(response.body) return response class TemplateView(TemplateRenderMixin, ContentLengthMixin, View): """A view that returns HTML responses based on a template file.""" content_type = "text/html" template_file = "index.html"

from dataclasses import dataclass @dataclass class Response: """An HTTP response""" status: int content_type: str body: str class View: """A simple view that returns plain text responses""" content_type = "text/plain" def render_body(self) -> str: """Render the message body of the response""" return "Welcome to my web site" def get(self, request) -> Response: """Handle a GET request and return a message in the response""" return Response( status=200, content_type=self.content_type, body=self.render_body() ) class TemplateView(View): """A view that returns HTML responses based on a template file.""" content_type = "text/html" def get(self, request, template_file: str) -> Response: # type: ignore """Render the message body as HTML""" with open(template_file) as fd: return Response( status=200, content_type=self.content_type, body=fd.read() ) def render(view: View, request) -> Response: """Render a View""" return view.get(request)

from abc import ABCMeta, abstractmethod # Define the Abstract Class for a generic Greeter object class Greeter(metaclass=ABCMeta): """An object that can perform a greeting action.""" @staticmethod @abstractmethod def greet(name: str) -> None: """Display a greeting for the user with the given name""" class FriendlyActor(Greeter): """An actor that greets the user with a friendly salutation""" @staticmethod def greet(name: str) -> None: """Greet a person by name""" print(f"Hello {name}!") def welcome_user(user_name: str, actor: Greeter): """Welcome a user with a given name using the provided actor""" actor.greet(user_name) welcome_user("Barbara", FriendlyActor())

import abc class Persistable(metaclass=abc.ABCMeta): """Serialize a file to data and back""" @property @abc.abstractmethod def data(self) -> bytes: """The raw data of the file""" @classmethod @abc.abstractmethod def load(cls, name: str): """Load the file from disk""" @abc.abstractmethod def save(self) -> None: """Save the file to disk""" # We just want to serve the documents, so our concrete PDF document # implementation just needs to implement the `.load()` method and have # a public attribute named `data`. class PDFDocument(Persistable): """A PDF document""" @property def data(self) -> bytes: """The raw bytes of the PDF document""" ... # Code goes here - omitted for brevity @classmethod def load(cls, name: str): """Load the file from the local filesystem""" ... # Code goes here - omitted for brevity def view(request): """A web view that handles a GET request for a document""" requested_name = request.qs['name'] # We want to validate this! return PDFDocument.load(requested_name).data

import abc class DataCarrier(metaclass=abc.ABCMeta): """Carries a data payload""" @property def data(self): ... class Loadable(DataCarrier): """Can load data from storage by name""" @classmethod @abc.abstractmethod def load(cls, name: str): ... class Saveable(DataCarrier): """Can save data to storage""" @abc.abstractmethod def save(self) -> None: ... class PDFDocument(Loadable): """A PDF document""" @property def data(self) -> bytes: """The raw bytes of the PDF document""" ... # Code goes here - omitted for brevity @classmethod def load(cls, name: str): """Load the file from the local filesystem""" ... # Code goes here - omitted for brevity def view(request): """A web view that handles a GET request for a document""" requested_name = request.qs['name'] # We want to validate this! return PDFDocument.load(requested_name).data

import csv from io import StringIO class StreamingHttpResponse: """A streaming HTTP response""" ... # implementation code goes here def some_view(request): rows = ( ['First row', 'Foo', 'Bar', 'Baz'], ['Second row', 'A', 'B', 'C', '"Testing"', "Here's a quote"] ) # Define a generator to stream data directly to the client def stream(): buffer_ = StringIO() writer = csv.writer(buffer_, delimiter=';', quotechar='"') for row in rows: writer.writerow(row) buffer_.seek(0) data = buffer_.read() buffer_.seek(0) buffer_.truncate() yield data # Create the streaming response object with the appropriate CSV header. response = StreamingHttpResponse(stream(), content_type='text/csv') response['Content-Disposition'] = 'attachment; filename="somefilename.csv"' return response

import csv class Echo: """An object that implements just the write method of the file-like  interface.  """ def write(self, value): """Write the value by returning it, instead of storing in a buffer.""" return value def some_streaming_csv_view(request): """A view that streams a large CSV file.""" rows = ( ['First row', 'Foo', 'Bar', 'Baz'], ['Second row', 'A', 'B', 'C', '"Testing"', "Here's a quote"] ) writer = csv.writer(Echo(), delimiter=';', quotechar='"') return StreamingHttpResponse( (writer.writerow(row) for row in rows), content_type="text/csv", headers={'Content-Disposition': 'attachment; filename="somefilename.csv"'}, )

from typing import List, Dict from dataclasses import dataclass @dataclass class Developer: def __init__(self, experience: float, github_link: str) -> None: self._experience = experience self._github_link = github_link @property def experience(self) -> float: return self._experience @property def github_link(self) -> str: return self._github_link @dataclass class Manager: def __init__(self, experience: float, github_link: str) -> None: self._experience = experience self._github_link = github_link @property def experience(self) -> float: return self._experience @property def github_link(self) -> str: return self._github_link def get_developer_list(developers: List[Developer]) -> List[Dict]: developers_list = [] for developer in developers: developers_list.append({ 'experience' : developer.experience, 'github_link' : developer.github_link }) return developers_list def get_manager_list(managers: List[Manager]) -> List[Dict]: managers_list = [] for manager in managers: managers_list.append({ 'experience' : manager.experience, 'github_link' : manager.github_link }) return managers_list ## create list objects of developers company_developers = [ Developer(experience=2.5, github_link='https://github.com/1'), Developer(experience=1.5, github_link='https://github.com/2') ] company_developers_list = get_developer_list(developers=company_developers) ## create list objects of managers company_managers = [ Manager(experience=4.5, github_link='https://github.com/3'), Manager(experience=5.7, github_link='https://github.com/4') ] company_managers_list = get_manager_list(managers=company_managers)

from typing import List, Dict from dataclasses import dataclass @dataclass class Employee: def __init__(self, experience: float, github_link: str) -> None: self._experience = experience self._github_link = github_link @property def experience(self) -> float: return self._experience @property def github_link(self) -> str: return self._github_link def get_employee_list(employees: List[Employee]) -> List[Dict]: employees_list = [] for employee in employees: employees_list.append({ 'experience' : employee.experience, 'github_link' : employee.github_link }) return employees_list ## create list objects of developers company_developers = [ Employee(experience=2.5, github_link='https://github.com/1'), Employee(experience=1.5, github_link='https://github.com/2') ] company_developers_list = get_employee_list(employees=company_developers) ## create list objects of managers company_managers = [ Employee(experience=4.5, github_link='https://github.com/3'), Employee(experience=5.7, github_link='https://github.com/4') ] company_managers_list = get_employee_list(employees=company_managers)