Data Algorithms with Spark: Recipes and Design

Patterns for Scaling Up using PySpark (Early

Release) 1 / 2021-09-10 Fourth Early Release
Edition Mahmoud Parsian install download
https://ebookmeta.com/product/data-algorithms-with-spark-recipes-
and-design-patterns-for-scaling-up-using-pyspark-early-
release-1-2021-09-10-fourth-early-release-edition-mahmoud-
parsian/

Download more ebook from https://ebookmeta.com

 Data Algorithms with Spark
With Early Release ebooks, you get books in their earliest form—
the author’s raw and unedited content as they write—so you can
take advantage of these technologies long before the official
release of these titles.

Recipes and Design Patterns for Scaling Up using

PySpark

Mahmoud Parsian
Data Algorithms with Spark
by Mahmoud Parsian
Copyright © 2021 Mahomoud Parsian. All rights reserved.
Printed in the United States of America.
Published by O’Reilly Media, Inc., 1005 Gravenstein Highway North,
Sebastopol, CA 95472.
O’Reilly books may be purchased for educational, business, or sales
promotional use. Online editions are also available for most titles
(http://oreilly.com). For more information, contact our
corporate/institutional sales department: 800-998-9938 or
[email protected].

Editors: Melissa Potter and Jessica Haberman

Production Editor: Katherine Tozer

Interior Designer: David Futato

Cover Designer: Karen Montgomery

Illustrator: Kate Dullea

December 2021: First Edition

Revision History for the Early Release

2020-08-26: First Release
2021-01-20: Second Release
2021-05-24: Third Release
2021-09-10: Fourth Release

See http://oreilly.com/catalog/errata.csp?isbn=9781492082385 for

release details.
The O’Reilly logo is a registered trademark of O’Reilly Media, Inc.
Data Algorithms with Spark, the cover image, and related trade
dress are trademarks of O’Reilly Media, Inc.
The views expressed in this work are those of the author, and do not
represent the publisher’s views. While the publisher and the author
have used good faith efforts to ensure that the information and
instructions contained in this work are accurate, the publisher and
the author disclaim all responsibility for errors or omissions,
including without limitation responsibility for damages resulting from
the use of or reliance on this work. Use of the information and
instructions contained in this work is at your own risk. If any code
samples or other technology this work contains or describes is
subject to open source licenses or the intellectual property rights of
others, it is your responsibility to ensure that your use thereof
complies with such licenses and/or rights.
978-1-492-08231-6
Chapter 1. Introduction to
Data Algorithms

A NOTE FOR EARLY RELEASE READERS

With Early Release ebooks, you get books in their earliest form—
the author’s raw and unedited content as they write—so you can
take advantage of these technologies long before the official
release of these titles.
This will be the 1st chapter of the final book. Please note that
the GitHub repo will be made active later on.
If you have comments about how we might improve the content
and/or examples in this book, or if you notice missing material
within this chapter, please reach out to the editor at
[email protected].

Spark is a powerful analytics engine for large-scale data processing.

Spark aims at light speed, ease of use, extensibility in big data.
Spark has introduced high-level APIs in Java, Scala, Python, and R.
In this book, I use PySpark (Python API for Spark) for the simplicity.
The purpose of this chapter is to introduce PySpark as a main
component of Spark echo system and show that it can effectively be
used to solve big data problems such as ETL, indexing billions of
documents, ingesting millions of genomes, machine learning
algorithms, graph data analysis, DNA data analysis, and much more.
To understand PySpark , we will review Spark and PySpark
architectures and provide examples to show the expressive power of
PySpark. The reason I chose Spark is very simple: Spark is a proven
and well-adopted technology at many high tech industries, who
handle big data every day. Spark is an analytics engine designed for
large-scale distributed data processing, in the cloud or private data
centers.
This chapter covers

Why Spark for data analytics?

What is PySpark API?
What problems does PySpark solve?
PySpark with examples
Interactive PySpark Shell
Running a PySpark application

This book provides a practical introduction to data algorithms

(practical and pragmatic big data transformations) using PySpark
(Python API for Spark). To get the most out of this book, you should
be comfortable reading and writing very basic Python code, and
have some familiarity with fundamentals of algorithms (how to solve
computational problems in simple steps). By data algorithms, I mean
solving big data problems by using a set of scalable and efficient
data transformations (such as mappers, reducers, filters, …).
In this book, I explore and teach the following basic concepts:

How to design and develop data algorithms by using

PySpark
How to solve big data problems by using Spark’s data
abstractions (RDDs, DataFrames, and GraphFrames)
How to partition big data in such a way to achieve maximum
performance of ETL and data transformations such as
summary data patterns
 How to integrate fundamental data design patterns (such as
Top-10, MinMax, InMapper Combiners, …) with a useful and
practical Spark transformations by using PySpark

In this book, I will provide simple working examples in PySpark so

that you can adapt (cut-and-past-and-modify) them to solve your big
data problems. All of the source code in this book is hosted at the
GitHub Data Algorithms with Spark.
My focus in this book is on PySpark rather than Spark. This means
that the provided examples will focus on solving big data problems
using PySpark and on getting effective by using PySpark and not an
exhaustive reference on Spark’s features.
This chapter will present an introduction to Spark, PySpark, and data
analytics with PySpark. We will present the core architecture of
Spark, PySpark, Spark Application, and Spark’s Structured APIs using
RDDs (Resilient Distributed Dataset), DataFrames, and SQL. We will
touch on Spark’s core functions (transformations and actions) and
concepts so that you are empowered to start using Spark and
PySpark right away. Spark’s data abstractions are RDDs,
DataFrames, and DataSets. This means that you can represent your
data (stored as Hadoop files, Amazon S3 objects, Linux files,
collection data structures, relational database tables, …) in any
combinations of RDDs and DataFrames.
Once your data is represented in a Spark data abstraction (such as
an RDD or a DataFrame), then you may apply transformations on
them and create new data abstractions until you come up with final
desired data. Spark’s transformations (such as map() and
reduceBykey()) can be used to convert your data from one form
into another one until you get your desired result. I will explain
these data abstractions shortly.
 SOURCE CODE

NOTE
Complete programs for this chapter are presented in GitHub
Chapter 1.

Why Spark for Data Analytics

Why should we use Spark? Spark is a powerful analytics engine for
large scale data processing. The most important reasons for using
Spark are listed:
Spark is simple, powerful, and fast (uses RAM rather than
disk — Spark runs workloads 100x faster.)
Spark is open-source, free, and can solve any big data
problem
Spark runs everywhere (Hadoop, Mesos, Kubernetes,
standalone, or in the cloud).
Spark can read/write data from/to many data sources
Spark can read/write data in row-based and column-based
(such as Parquet and ORC) formats

Spark’s high level architecture is illustrated by Figure 1.1.

 Figure 1-1. Spark’s high level architecture

Spark architecture (Figure 1.1) shows that it can read/write data

from any data source (Amazon S3, Hadoop HDFS, relational
databases, …) and can be integrated with almost any data
applications. Spark has a rich but simple set of API in any kind of
ETL, streaming, graph data analysis, machine learning and SQL. In
the past 5 years Spark has progressed in such a way to solve any big
data problem. This is proven by the fact that all big data companies
(FaceBook, Illumina, IBM, Google, …) use Spark every day in
production systems.
In a nutshell, Spark unlocks the power of data by handling big data
with power, ease of use, and speed. Spark is one of the best choices
for large-scale data processing and for solving MapReduce problems
and beyond. Spark unlocks the power of data by handling big data
with powerful APIs and speed. Using MapReduce/Hadoop to solve
big data problems is complex and you have to write ton of low level
code to solve primitive problems — this is where he power and
simplicity of Spark comes in to solve complex big data problems.
Apache Spark is much faster than Apache Hadoop because it uses
in-memory caching and optimized execution for fast performance,
and it supports general batch processing, streaming analytics,
machine learning, graph algorithms, and SQL queries.
Spark’s “native” language is Scala, but you can use language APIs to
run Spark code from other programming languages (for example,
Java, R, and Python). In this book, I teach you how to use PySpark
to solve big data problems in Spark.
In this book, you will learn how to solve your big data problems in
Spark by expressing your solution in PySpark. You will lean how to
read your data and represent it as an RDD and DataFrame. RDD is a
fundamental data abstraction of Spark. DataFrame (a distributed
table of rows with named columns) in Spark allows developers to
impose a structure onto a distributed collection of data, allowing
higher-level abstraction. Once your data is represented as an RDD or
a DataFrame, then you may apply transformation functions (such as
mappers, filters, reducers) on them to transform your data to your
desired form. I have presented many Spark transformations, which
can be used to solve your ETL, analysis, and data intensive
computations.
Some simple RDD transformations are represented by the following
Figure 1.1.

Figure 1-2. Simple RDD Transformation

The following transformations were performed (see Figure 1.1):

First we read our input data (represented as a text file of
sample.txt — here, I only show the first two rows/records
of input data) by an instance of SparkSession, which is
the entry point to programming Spark. Here,
SparkSession instance is represented as a spark object.
Reading input creates a new RDD as RDD[String]: each
input record is converted to an RDD element of a String
object (if your input path has N records, then the number of
RDD elements is N). This is accomplished by

# spark : an instance of SparkSession

# creat an RDD[String], which represents all input
# records; each record becomes an RDD element
spark.sparkContext.textFile("sample.txt")

Next, we convert all characters to lower case letters: this is

accomplished by the map() transformation, which is a one-
 to-one transformation:

# convert each element of RDD to a lowercase

.map(lambda x: x.lower())

Next, we use a flatMap() transformation (which is a one-

to-many transformation) to convert each element
(representing a single record) into a sequence of target
elements (representing a word). The flatMap()
transformation returns a new RDD by first applying a
function (here the split(",")) to all elements of the
source RDD, and then flattening the results. This is done as:

# split each record into a list of words

.flatMap(lambda x: x.split(","))

Finally, we drop non-needed word elements, where the

length of elements are less than or equal 2. The following
filter() keep words if and only if the length of word is
greater than 2.

# keep words if its length is greater than 2

.filter(lambda x: len(x) > 2)

As you can observe: Spark transformations are distributed, parallel,

high-level, powerful, and simple.

Spark’s ecosystem
Spark’s eco-system is presented in Figure 1.4 which has three main
components:

Environments:
can run anywhere and integrate well with other
environments
 Applications:
it integrates well with big data platforms and applications
Data Sources:
can read/write data from/to many data sources

Figure 1-3. Spark Eco-System (source Databricks)

What can I do with PySpark? Spark’s expansive echo system makes

PySpark as a great tool for ETL, data analysis, and much more. With
PySpark, you can read a ton of data from many different data
sources (Linux file system, Amazon S3, Hadoop distributed file
system, relational tables, MongoDB, ElasticSearch, Parquet files, …)
and represent your data as an Spark data abstraction. Once your
data is in Spark data abstraction (such as RDDs and DataFrames —
to be discussed shortly) then you can use a series of simple and
powerful Spark transformations to transform your data into your
desired content and format. For example, you may use the
filter() transformation to drop unwanted records, use
groupByKey() to group your data by your desired key, and finally
use the mapValues() transformation to perform final aggregation
(such as finding average, median, and standard deviation of
numbers) on the grouped data. All of these transformations are very
possible by using the simple but powerful PySpark API.

Spark Architecture
Spark is an open-source cluster computing tool for data-intensive
computations, managing and coordinating the execution of tasks on
data across a cluster of computers. When you have small data, it is
possible to analyze it with a single computer in a reasonable amount
of time. When data is huge, using a single computer to store and
analyze that data might take a long time and might be even
impossible to analyze and process it. For big data, we may use
Spark. Spark is a tool for analyzing, processing, managing and
coordinating the execution of tasks on big data across a cluster of
computers.
A high-level Spark architecture is presented by the Figure 1.7.
Informally, a Spark cluster is comprised of a master node (denoted
by a “cluster manager”) and a set of “worker” nodes, which are
responsible for executing tasks submitted by the Spark application
(your application which you want to run on the Spark cluster) and
the cluster manager (which is responsible in managing your
application).
 Figure 1-4. Spark Architecture

Spark uses the cluster of servers (comprised of a master node and a

set of worker nodes) to analyze your big data. The cluster of servers
that Spark will use to execute tasks will be managed by a cluster
manager like Spark’s Standalone cluster manager, Hadoop YARN, or
Mesos. When Spark cluster is ready and running, then we can
submit Spark applications to these cluster managers which will grant
resources to our application so that we can complete our data
analysis.
Spark has a core library and a set of built-in libraries (SQL, GraphX,
Streaming, MLlib). This relationship is illustrated by the Figure 1.8.
As you can observe, Spark can interact (using Data Access API) with
many data sources such as Hadoop, HBase, Amazon S3,
ElasticSearch, and MySQL to mention a few.
 Figure 1-5. Spark Libraries

Figure 1.8 shows the real power of Spark: You may use several
langauges (Python, Scala, Java, R) to write your Spark applications
and then you may use rich libraries (such as Spark SQL, Streaming,
machine library, GraphX, GraphFrames, …) for solving any big data
problems and meanwhile you may read/write data from any data
sources.
In this book, you’ll interface Spark with Python through PySpark, the
Spark Python API that exposes the Spark programming model to
Python. PySpark has a comprehensive API (comprised of packages,
modules, classes, and methods) to access Spark API. It is important
to note that, for this book, all Spark API, packages, modules,
classes, and methods are PySpark specific. For example, when I
refer to the SparkContext class, I am referring to the
pyspark.SparkContext (Python class, defined in the pyspark
package) and when referring to the SparkSession, I am referring
to the pyspark.sql.SparkSession (Python class, in
pyspark.sql module).
To understand PySpark better, we do need to understand Spark,
since PySpark is a Python API for Spark. The Spark architecture is
based on a master/worker architecture. Typically, a Spark cluster has
a “master” (controller and manager) node and a set of “worker”
(executor) nodes. The number of worker nodes can be from 1 to
tens, hundreds, and thousands (based on the need of your business
and project requirements). You may also, run Spark on a standalone
server (such as MacBook, Linux, or Windows — typically, for
production environment, Spark is run on cluster of Linux servers). To
run a Spark program, you need to have an access to a Spark cluster
(comprised of one or many nodes) and have a “driver program”,
which talks to a single coordinator called master (also called a
“cluster manager”) that manages workers in which executors run.
For this book, all driver programs will be in PySpark.
To understand Spark architecture, you’ll need to understand the
following two classes: SparkSession and SparkContext. In
order to do something useful with the Spark cluster, the first thing
we have to do is to create an instance of SparkSession and from
the SparkSession we can access the SparkContext object
as an attribute. Once you create an instance of a
`SparkSession, then SparkContext becomes available inside
your SparkSession, in other words, SparkSession contains an
instance of a SparkContext as SparkSession.sparkContext.
PySpark defines SparkSession as:

pyspark.sql.SparkSession (Python class, in pyspark.sql

module)
class
pyspark.sql.SparkSession(sparkContext,jsparkSession=None)

SparkSession: the entry point to programming Spark

with the RDD and DataFrame API.

When you start a PySpark shell, you automatically get an instance of

a SparkSession (denoted by the spark variable). If you write a
self-contained PySpark application (a Python driver, which uses
PySpark API), then you have to explicitly create an instance of a
SparkSession by using the “builder pattern” (see Listing 1.1).
SparkSession can be used to

Create RDDs (a main data abstraction in Spark)

Create DataFrames (a high-level data abstraction in Spark,
which will be explained shortly)
Register DataFrames as tables
Execute SQL over tables, cache tables
Read text, CSV, JSON, and parquet files
To create a SparkSession in Python, use the following builder
pattern (Listing 1.1). Note that when we use PySpark shell — an
interactive tool for running PySpark — an instance of
SparkSession is automatically created and provided as the spark
variable — no need to create the SparkSession inside the PySpark
shell, it will be already created on your behalf.

# import required Spark class

from pyspark.sql import SparkSession

# create an instance of SparkSession as spark

spark = SparkSession.builder \
.master("local") \
.appName("my-application-name") \
.config("spark.some.config.option", "some-value") \
.getOrCreate()

# to debug SparkSession
print(spark)

# create a reference to SparkContext as sc

# SparkContext is used to create new RDDs
sc = spark.sparkContext

# to debug SparkContext
print(sc)

Import the SparkSession class from the pyspark.sql

module

A class attribute having a Builder to construct SparkSession

instances

Sets a config option. Options set using this method are

automatically propagated to both SparkConf and
SparkSession’s own configuration. When creating a
 SparkSession object, you can define any number of
config(key, value) options.

Gets an existing SparkSession or, if there is no existing one,

creates a new one based on the options set in this builder

For debugging purposes only

SparkContext can be referenced from an instance of a

SparkSession

PySpark defines SparkContext (a class defined in the pyspark

module) as:

class pyspark.SparkContext(master=None, appName=None, ...)

SparkContext: the main entry point for Spark functionality.

A SparkContext represents the connection to a Spark
cluster,
and can be used to create RDD (the main data abstraction
for
Spark) and broadcast variables (such as collections and
data
structures) on that cluster.

SparkContext is the main entry point for Spark functionality. A

shell (such as PySpark shell) or PySpark driver program cannot
create more than one instance of SparkContext. A
SparkContext represents the connection to a Spark cluster, and
can be used to create new RDDs and broadcast variables (shared
data structures and collections — kind of a read-only global
variables) on that cluster. Spark’s RDDs and DataFrames are used to
represent your big data and transform them to your desired state.
The Figure 1.9 shows SparkContext usage for creation of a new
RDD from an input text file (labeled as records_rdd) and then
transforms it into another RDD by using the flatMap()
transformation (labeled as words_rdd).

Figure 1-6. Creation of RDDs by SparkContext

To create a SparkContext object, use the following pattern:

# create an instance of SparkSession

spark_session = SparkSession.builder...

# use SparkSession to access SparkContext

spark_context = spark_session.sparkContext

Spark Architecture is illustrated below.

 Figure 1-7. Spark Architecture

The following key terms used in Spark architecture:

SparkSession:
It is a class defined in the pyspark.sql package. This
class is the entry point to programming Spark with the
DataSet and DataFrame API. From this class, you may
access to an instance of SparkContext. A SparkSession
can be used create DataFrame, register DataFrame as
tables, execute SQL over tables, cache tables, and read
parquet files.
SparkContext:
It is a class defined in the pyspark package and represents
the connection to a Spark cluster. It is the main entry point
for Spark functionality. It holds a connection with Spark
“cluster manager” (also known as a master node) and can
be used to create RDD and broadcast variables on that
cluster. All Spark applications (including PySpark shell and
standalone Python programs) run as an independent set of
processes. These processes are coordinated by a
SparkContext in a driver program.
Driver:
To submit a standalone Python program to Spark, you need
to write a driver program with PySpark API (or Java or
Scala). A driver program is in charge of the process of
running the main() function of an application and creating
the SparkContext. Also, the driver program is in charge of
creating Spark’s RDDs and DataFrames.
Worker:
In Spark cluster environment, there are two type of nodes:
one (or two — for high availability) master and a set of
workers. A worker, is any node that can run program in the
 cluster. If a process is launched for an application, then this
application acquires executors at worker nodes, which carry
out executing Spark’s application tasks.
Cluster Manager:
The “master” node is known as the “cluster manager”. The
main function of a Cluster Manager is to manage the cluster
environment. The cluster of servers that Spark will leverage
to execute tasks will be managed by a cluster manager.
Cluster manager allocates resources to each application in
driver program. Spark runs everywhere: there are 5 types of
cluster managers supported by Spark:
1. Standalone: this is Spark’s own built-in clustered
environment
2. Mesos: a distributed systems kernel
3. Hadoop YARN
4. Kubernetes
5. Amazon EC2

Spark Usage
Is Spark used by many notable companies? Here are some examples
of how big companies use Spark.
FaceBook processes 60 TB of data on a daily basis. Spark
and MapReduce are at the heart of their algorithms and
processing production data
Viacom, with its 170 cable, broadcast, and online networks
in around 160 countries, is transforming itself into a data-
driven enterprise — collecting and analyzing petabytes of
network data to increase viewer loyalty and revenue.
 Illumina 1 ingests thousands of genomes (big data — by big
data we mean that data can not fit and processed in one
server) using Spark, PySpark, MapReduce, and distributed
algorithms.
IBM and many social network and search engine companies
(such use Google, Twitter and Facebook) use Spark,
MapReduce, and distributed algorithms on a daily basis to
scale out their computations and operations.

Spark in a Nutshell
There are four main reasons (as noted on Spark’s website) to choose
Spark:
1. Speed
Spark programs can run up to 100x faster than Hadoop
MapReduce in memory, or 10x faster on disk. Spark has an
advanced DAG execution engine that supports acyclic data
flow and in-memory computing (using memory is much
faster using Disk for intensive calculations and I/O). DAG
(Directed Acyclic Graph) in Spark is a set of Nodes and
Edges, where Nodes represent the RDDs and the edges
represent the Operation (transformation or action) to be
applied on RDD. On the calling of an Action, the created
DAG submits to DAG Scheduler which further splits the
graph into the stages of the task. Spark’s DAG Visualization
is presented as Figure 1.2.
 Figure 1-8. Spark DAG Visualization

1. Ease of Use
You can write Spark applications quickly in Java, Scala,
Python, R, and SQL.
2. Generality
Spark is a general compute engine and it can be used for
solving any type of problems. Spark provides combination of
SQL, streaming, and complex analytics. Spark powers a set
 of libraries including SQL and DataFrames, MLlib for machine
learning, GraphX, and Spark Streaming. You can combine all
of these libraries seamlessly in the same application. Also,
there are a lot of external libraries for Spark, which can
make data and graph processing (such as GraphFrames) like
a breeze.
3. Runs Everywhere
Spark runs on Hadoop, Mesos, standalone, or in the
cloud (such as Amazon Glue and Google Cloud).
Spark stack is presented by Figure 1-9
It can access diverse data sources including Text
files, relational databases, HDFS, Cassandra, HBase,
and S3.

Figure 1-9. Spark Stack

What is PySpark?
In a nutshell, PySpark is the collaboration of Apache Spark and
Python Programming Language.
 Figure 1-10. What is PySpark

Python is a popular programming language that you can use to work

quickly and integrate systems more effectively. PySpark is a Python
API for Spark. PySpark usage has increased in the past few years
(see Figure 1.4). Since PySpark applications and analytics run on
Spark clusters, we need to understand the basics of Spark echo
system.
SQL (Structured Query Language) is the most widely used query
language used to communicate with relational databases. Spark
enables us to to represent structured data as a DataFrame (a table
with named columns) and then query data by using SQL — SQL
queries are converted into a set of map(), filter(),
groupByKey() … transformations, and then executed by the Spark
engine.
 Figure 1-11. Languages Used for Developing Spark Applications

Python for PySpark

Python is simple and powerful programming language and integrates
very well with Spark analytics engine. Overall, no general
programming language alone can handle big data processing
efficiently. There is always a need for a distributed computing
framework like Spark, which is the defacto standard for big data
analysis. PySpark is the Python programming language bindings
(Python API) for Spark. Spark is an open-source distributed
processing system commonly used for big data workloads and
intensive computations. Since most data scientists already know
Python, PySpark eases their ability to write short but concise code
for distributed computing using Spark. I am assuming that you have
access to a Spark cluster or you have already installed it on your
laptop. In a nutshell, PySpark is an all-in-one ecosystem which can
handle the complex data requirements with its RDDs, DataFrames,
GraphFrames, MLlib, SQL, and Structured data processing API.

Power of PySpark
I’ll show the amazing power of PySpark with a simple example. Let’s
say that we have lots of data records measuring the URL visits by
users (cellected by a search engine from many web servers) in the
following format:

<URL-address><,><frequency>

Sample records are given here:

http://mapreduce4hackers.com,19779
http://mapreduce4hackers.com,31230
http://mapreduce4hackers.com,15708
...
https://www.illumina.com,87000
https://www.illumina.com,58086
...

Let’s say we want to find out average, median, and the standard
deviation of visiting numbers per key (as a URL-address). Assume
that another requirement is that to drop records, if the length of any
record is less than 5 (may be as a malformed URL). It is easy to
express an elegant solution for this in PySpark. This workflow can be
expressed by Figure 1.6.
 Figure 1-12. Simple Workflow to Compute Mean, Median, Standard Deviation

First, let’s create some basic Python functions, which will help us in
solving our simple problem. since we are going to work with (key,
value) pairs, the first function, create_pair() accepts a single
record of <URL-address><,><frequency> and returns a (key,
value) as a pair (which will enable us to do “group by” on the key
field later on), where key is a URL-address and value is the
associated frequency.
The create_pair() function is illustrated below:

# create a pair of (URL-address, frequency)

# where URL-address is a key and frequency is a value
# record: <url-address><,><frequency>
def create_pair(record):
tokens = record.split(',')
url_address = tokens[0]
frequency = tokens[1]
return (url_address, frequency)
#end-def

Accept a record of the form “URL-address,frequency”

 Tokenize input record, tokens[0]: URL-address as a key,
tokens[1]: frequency as a value

Return a pair of (URL-address, frequency)

The next function accepts a list of frequencies (as numbers) and

computes three values: average, median, and standard deviation:

# Compute average, median, and standard

# deviation for a given set of numbers
import statistics
# frequencies = [number1, number2, ...]
def compute_stats(frequencies):
average = statistics.mean(frequencies)
median = statistics.median(frequencies)
standard_deviation = statistics.stdev(frequencies)

return (average, median, standard_deviation)

#end-def

This module provides functions for calculating mathematical

statistics of numeric data

Accept a list of frequencies

Compute average of frequencies

Compute median of frequencies

Compute standard deviation of frequencies

Return the result as a triplet

Next, we show the amazing power of PySpark in just few lines of
code using Spark transformations and our custom Python defined
functions:

# input_path = "s3://<bucket>/key"
input_path = "/tmp/myinput.txt"
results = spark
.sparkContext
.textFile(input_path)
.filter(lambda record: len(record) > 5)
.map(create_pair)
.groupByKey()
.mapValues(compute_stats)

spark denotes an instance of a SparkSession`, the entry

point to programming Spark

sparkContext (is an attribute of SparkSession), main entry

point for Spark functionality

Read data as distributed set of string records (creates an

RDD[String])

Drop out records, where record size is less than or equal 5 (keep
records if their length is greater than 5)

Create (URL-address, frequency) pairs from a given input record

Group your data by keys (each key — as a URL-address — will be

associated with a list of frequencies)

Apply the compute_stats() function to list of frequencies

The results will represent a set of (key, value) pairs as:

(URL-address, (average, median, standard_deviation))

where URL-address is a key and (average, median,

standard_deviation) is the value.
The most important thing about Spark is that it maximizes
concurrency of functions and operations by means of partitioning
data. For example if your input data has 600 billion rows and you are
using a cluster of 10 nodes, your input data will be partitioned in to
N ( > 1) chuncks and then chunks are processed independently and
in parallel. For example, if N = 20,000 (the numer of chunks or
partitions), then each chunk will have a bout 30 million
records/elements where:

600,000,000,000 = 20,000 x 30,000,000

For example, if you have a big cluster then all of your 20,000 chunks
(called a partition) might be processed in one shot. But, If you have
a smaller cluster, then may be every 100 chunks can be processed
independently and in parallel. This process will continue until all of
your 20,000 partitions are processed. Spark is an analytic and
compute engine for parallel processing of data on a cluster.
Parallelism in Spark allows developers to perform tasks on hundreds
of computer servers in a cluster in parallel and independently.
Spark’s data abastractions (RDD and DataFrame) operate on
partitioned data. Therefore, we can say that partition is the main
unit of parallelism in Spark.

PySpark Architecture
The PySpark API is defined here: PySpark Documentation. Spark has
APIs for Java, Python (PySpark), Scala, and R. Spark is built for
cluster computing: having a “master” server and a set of “worker”
servers working together to enable big data computing. Typically, a
Spark-based distributed algorithm will run on a cluster of connected
computers. Spark, MapReduce paradigm, and distributed computing
enables high performance computing by using a set of commodity
servers.
PySpark is built on top of Spark’s Java API. Data is processed in
Python and cached / shuffled in the Java Virtual Machine (JVM). I
will cover “shuffling” concept in chapter 2. PySpark’s high-level
architecture is presented by the Figure 1.11.
Figure 1-13. PySpark High-Level Architecture
PySpark’s High-Level Architecture and data flow is illustrated by the
Figure 1.12.

Figure 1-14. PySpark High-Level Architecture and Data Flow

According to the Spark documentation: In the Python driver program

(which is your Spark application in Python), SparkContext uses Py4J
software — A Bridge between Python and Java to launch a JVM and
create a JavaSparkContext. Py4J is only used on the driver for local
communication between the Python and Java SparkContext objects;
large data transfers are performed through a different mechanism.
RDD transformations in Python are mapped to transformations on
PythonRDD objects in Java. On remote worker machines,
PythonRDD objects launch Python subprocesses and communicate
with them using pipes, sending the user’s code and the data to be
processed.
SparkContext uses Py4J software, which enables Python programs
running in a Python interpreter to dynamically access Java objects in
a JVM. Methods are called as if the Java objects resided in the
Python interpreter and Java collections can be accessed through
standard Python collection methods. Py4J also enables Java
programs to call back Python objects.

Spark Data Abstractions

To manipulate data in Python programming language, you use
integers, strings, lists, and dictionaries. To manipulate and analyze
data in Spark, you have to represent it as a Spark “data set”. Spark
supports 3 types of data set abstractions:
RDD (Resilient Distributed Dataset):
Low level API
Denoted by RDD[T] (each element has type T)

DataFrame (similar to relational tables):

High level API
Denoted by Table(column_name_1,
column_name_2, ...)

Dataset (similar to relational tables):

High level API (not available in PySpark)

Dataset data abstraction is used in a very strongly typed languages
such as Java and not supported in PySpark. RDDs and DataFrames
will be discussed in detail in the following chapters.
RDD Example
Basically, RDD represents your data as a collection of elements. In a
nutshell, RDD is an immutable set of distributed elements of type T,
denoted as RDD[T].
Table 1.1 denotes 3 simple RDDs:
RDD[Integer]: each element is an Integer
RDD[String]: each element is a String
RDD[(String, Integer)]: each element is a pair of
(String, Integer)
T
a
bl
e
1
-
1
.
Si
m
pl
e
R
D
D
s

RDD[Integer] RDD[String] RDD[(String, Integer)]

2 "abc" ('A', 4)

-730 "fox is red" ('B', 7)

320 "Python is cool" ('ZZ', 9)

… … …

Table 1.2 denotes an RDD, where each element is a pair of (key,

value), where key is a String and value is a triplet of (Integer,
Integer, Double).
T
a
bl
e
1
-
2
.
R
D
D
s
o
f
D
if
fe
r
e
n
t
El
e
m
e
n
t
T
y
p
e
s
(
C
o
m
pl
e
x
R
D
D
)

RDD[(String, (Integer, Integer, Double))]

("cat", (20, 40, 1.8))

("cat", (30, 10, 3.9))

("lion king", (27, 32, 4.5))

("python is fun", (2, 3, 0.6))

DataFrame Example
Similar to an RDD, Spark’s DataFrame is an immutable distributed
collection of data. Unlike an RDD, data is organized into named
columns, like a table in a relational database. Spark’s DataFrame is
designed to make large data sets processing even easier by using
named columns. DataFrame allows programmers to impose a
structure onto a distributed collection of data, allowing higher-level
abstraction. Spark’s DataFrame enables to process CSV and JSON
files much easier than RDDs.
A DataFrame example is provided below: this DataFrame has 3
columns:
DataFrame[name, age, salary]

name: String
age: Integer
salary: Integer

+-----+----+---------+
| name| age| salary|
+-----+----+---------+
| bob| 33| 45000|
| jeff| 44| 78000|
| mary| 40| 67000|
| ...| ...| ...|
+-----+----+---------+

A DataFrame can be created from many different sources such as

Hive tables, Structured Data files, external databases, or existing
RDDs. The DataFrames API was designed for modern Big Data and
data science applications taking inspiration from DataFrame in R
Programming and Pandas in Python. As we will see in other
chapters, we can use SQL queries against DataFrames.
Spark SQL comes with a set of DataFrame operations The list of
operations is powerful and quite extensive and includes:
Aggregate functions (min, max, sum, average, …)
Collection functions
Math functions
Sorting functions
String functions
User defined functions (UDF)
For example, you can easily read a CSV files(s) and create a
DataFrame:

# define input path

virus_input_path = "s3://mybucket/projects/cases/case.csv"

# read CSV file and create a DataFrame

cases_dataframe =
spark.read.load(virus_input_path,format="csv",
sep=",", inferSchema="true", header="true")

# show the first 3 rows of created dataframe

cases_dataframe.show(3)
+-------+-------+-----------+--------------+---------+
|case_id|country| city|infection_case|confirmed|
+-------+-------+-----------+--------------+---------+
| C0001| USA| New York| contact| 175|
+-------+-------+-----------+--------------+---------+
| C0008| USA| New Jersey| unknown| 25|
+-------+-------+-----------+--------------+---------+
| C0009| USA| Cupertino| contact| 100|
+-------+-------+-----------+--------------+---------+

To see the most cases at the top (use descending Sort), we use the
sort() function:

# We can do this using the F.desc function:

from pyspark.sql import functions as F
cases_dataframe.sort(F.desc("confirmed")).show()
+-------+-------+-----------+--------------+---------+
|case_id|country| city|infection_case|confirmed|
+-------+-------+-----------+--------------+---------+
| C0001| USA| New York| contact| 175|
+-------+-------+-----------+--------------+---------+
| C0009| USA| Cupertino| contact| 100|
+-------+-------+-----------+--------------+---------+
| C0008| USA| New Jersey| unknown| 25|
+-------+-------+-----------+--------------+---------+

You can easily filter rows:

 cases_dataframe.filter((cases_dataframe.confirmed > 100) &
(cases_dataframe.country ==
'USA')).show()

+-------+-------+-----------+--------------+---------+
|case_id|country| city|infection_case|confirmed|
+-------+-------+-----------+--------------+---------+
| C0001| USA| New York| contact| 175|
+-------+-------+-----------+--------------+---------+
...

The power of Spark’s DataFrame is expressed by an example: we

will create a DataFrame and find average and sum of hours per dept
of employees:

# Import required libraries

from pyspark.sql import SparkSession
from pyspark.sql.functions import avg, sum

# Create a DataFrame using SparkSession

spark = SparkSession.builder.appName("demo").getOrCreate()
dept_emps = [("Sales", "Barb", 40), ("Sales", "Dan", 20),
("IT", "Alex", 22), ("IT", "Jane", 24),
("HR", "Alex", 20), ("HR", "Mary", 30)]
df = spark.createDataFrame(dept_emps, ["dept", "name",
"hours"])

# Group the same depts together, aggregate their hours, and

compute an average
averages = df.groupBy("dept")
.agg(avg("hours").alias('average'),
sum("hours").alias('total'))

# Show the results of the final execution

averages.show()
+-----+--------+------+
| dept| average| total|
+-----+--------+------+
|Sales| 30.0| 60.0|
| IT| 23.0| 46.0|
Random documents with unrelated
content Scribd suggests to you:
surullisia kasvoja, jotka tuntuivat aina moittivan hänen huoletonta ja
toimetonta elintapaansa.

— Käyköön siis niinkuin tahdot, lapseni, — sanoi siis kuningas. —

Mutta ota edes siunaus isältäsi, jolle sinä aina olet tuottanut pelkkää
iloa.

— Antakaa ainoastaan kätenne suudellakseni, mutta suokaa tuo

kallis siunaus minulle ajatuksissanne.

Henkilöistä, jotka olivat saaneet tiedon prinsessan päätöksestä,

tämä oli ylevä ja juhlallinen näytelmä, tuo tuokio, jolloin jalo neito
läheni nyt jokaisella askeleellaan esi-isiään, noita kuninkaita, jotka
näyttivät kultakehyksistään häntä kiittävän siitä, että hän lähti täten
elävänä yhtymään heidän kanssaan heidän hautoihinsa.

Ovella hyvästeli kuningas vielä tytärtään ja poistui virkkamatta

sanaakaan.

Hovi seurasi häntä, niinkuin etiketti vaati.

28.

Riepu, Rääsy ja Varis.

Kuningas lähti varushuoneeseen päin, jossa hänellä oli tapana

viettää ennen metsästys- ja ajeluretkiään joku hetki jaellen
erikoismääräyksiä palvelukseen nähden, mitä hän sinä päivänä vielä
tarvitsi.
 Gallerian toisessa päässä hän hyvästeli hovimiehiään ilmaisten
kättään heilauttamalla, että hän halusi olla yksin.

Yksin jäätyään jatkoi Ludvig XV menoaan läpi erään käytävän,

joka vei kuninkaallisten naisten huoneustoihin. Kun hän tuli niiden
pääovelle, jota peitti verho, pysähtyi hän hetkeksi ja pudisti päätään.

— Niissä ei ollut muuta kuin yksi hyvä, — mutisi hän hampaittensa

välistä, — ja hänkin lähtee pois!

Kova huuto oli vastauksena tähän totuuteen, joka oli tosiaan

melkoisen epäkohtelias muille kotiin jääneille tyttärille. Oviverho
aukesi, ja Ludvig XV:ttä tervehdittiin yhteen ääneen kolmesta
vimmastuneesta suusta näillä sanoilla:

— Kiitos kunniasta, isä!

Kuningas seisoi nyt kolmen muun tyttärensä keskellä.

— Ah, sinäkö se olet, Riepu, — sanoi hän kääntyen vanhimman

tyttären puoleen, nimittäin madame Adelaiden. — Ah, ma foi, suutu
tai ole suuttumatta, minä puhuin totta.

— Oh, te ette puhunut meille mitään uutta, — keskeytti prinsessa

Viktoria, — me tiedämme, että te olette aina pitänyt enemmän
Louisesta.

— Ma foi, sinä lausut suuren totuuden, Rääsy.

— Mutta miksi te pidätte Louisea meitä parempana? — kysyi

prinsessa
Sofia pistävällä äänellä.
 — Siksi, että Louise ei kiusaa minua, — vastasi Ludvig XV
leppoisuudella, josta hän oli itsekkäillä hetkillään oivallinen tyyppi.

— Oh, kyllä hän teitä kiusaakin, odottakaahan, isä, — vastasi

prinsessa Sofia.

Ja hänen äänessään oli katkera sävy, joka käänsi kuninkaan

huomion erikoisesti häneen.

— Mistä sinä sitä päättelet, Varis? — kysyi kuningas. — Vai uskoiko

Louise lähtiessään asiansa sinulle? Ihmettelisinpä sitä, sillä hän ei
suurestikaan pitänyt sinusta.

— Vai niin, ma foi! No, joka tapauksessa maksan hänelle samalla

mitalla, — vastasi prinsessa Sofia.

— Erinomaista, — sanoi Ludvig XV, — vihatkaa, inhotkaa

toisianne, panetelkaa toisianne, se on teidän oma asianne; kunhan
ette vaan vaadi minua palauttamaan järjestystä amatsoonien
valtakunnassa, on se minusta yhdentekevää. Mutta tahtoisinpa
tietää, millä tavalla Louise-parka minua muka kiusaa?

— Louise-parka! — huudahtivat prinsessat Viktoria ja Adelaide

yhtaikaa, työntäen huuliansa kumpikin eri tavalla töröön.

— Ettäkö millä tavalla hän teitä kiusaa? No hyvä, sanonpa sen

teille, isäni.

Ludvig heittäytyi suureen nojatuoliin niin lähelle ovea, että pakotie

oli hänelle aina auki.

— Sillä tavalla, — jatkoi prinsessa Sofia, — että Madame Louisea

kiusaa hiukan samanlainen paholainen kuin aikoinaan Chelles'n
abbedissaakin ja että hän menee nyt luostariin tekemään kokeita.

— No, no, — sanoi Ludvig XV, — ei kaksimielisyyksiä, pyydän,

sisaresi kunniasta; siitä ei ole kenelläkään ollut vielä mitään
sanomista, vaikka ihmiset yleensä niin paljon lörpöttelevät pahaa
toisistaan. Älä sinä siis koetakaan.

— Minäkö?

— Niin, sinä.

— Oh, en minä hänen kunniastaan puhukaan, — vastasi prinsessa

Viktoria kovin loukkaantuneena äänen sävystä, jolla isä oli erikoisesti
korostanut sanan sinä ja vielä tuon sanan nimenomaisesti
uudistanutkin. — Minä vain sanoin, että hän tekee kokeita, siinä
kaikki.

— No niin, vaikka hän tekisi kokeita, tutkisi kemiaa, harjoittaisi

miekkailua, sorvaisi nojatuolin jalkakiekkoja, vaikka hän soittaisi
huilua, löisi rumpua ja rääkkäisi klaveeria, hankaisi viulua, mitä
pahaa sinusta siinä on?

— Minä sanon, että hän lähtee tekemään poliittisia kokeita. Ludvig

XV hätkähti.

— Tutkimaan filosofiaa, teologiaa ja jatkamaan Unigenitus-bullan

selityksiä; niin että me näytämme hänen hallintoteoriainsa,
metafyysillisten järjestelmiinsä ja teologiansa keskellä hyödyttömiltä
perheessä, me…

— Jos sisaresi sillä saa autuutensa, mitä pahaa sinä olet siinä
näkevinäsi? — toisti Ludvig XV, kuitenkin melkoisen hämmästyneenä,
miten samanlaiset Variksen syytös ja se poliittinen esitelmä, jonka
Madame Louise oli äsken niin hartaasti hänelle pitänyt lähtiäisiksi,
olivat keskenään. — Kadehdittako jo hänen autuuttaan? Silloinpa
olisitte huonotapaisia kristittyjä.

— Ma foi, emme suinkaan, — vastasi prinsessa Viktoria, —

menköön minne tahtoo, kunhan minun vaan ei tarvitse mennä
hänen kanssaan.

— Eikä minun, — jatkoi prinsessa Adelaide.

— Eikä minun, — jatkoi prinsessa Sofia.

— Muuten, hän inhosi meitä, — virkkoi prinsessa Viktoria.

— Teitäkö? — kysyi Ludvig XV.

— Niin, niin, juuri meitä, — vastasivat toiset kaksi sisarta yhtaikaa.

— Näette, että hän valitsi taivaan päästäkseen kerran kohtaamasta

sukuansa, Louise-rukka, — sanoi Ludvig XV.

Tämä sutkaus ei liioin viehättänyt sisaruksia. Prinsessa Adelaide,

vanhin heistä, ponnisti kaiken keksintökykynsä, antaakseen
kuninkaalle vielä sitäkin ankaramman iskun, joka oli ponnahtanut
pystymättä hänen panssaristaan.

— Mesdames, — huudahti prinsessa Adelaide pisteliäällä äänellä,

joka oli hänelle ominainen aina milloin hän heräsi
velttoudentilastaan, jonka vuoksi hänen isänsä oli antanut hänelle
nimen Riepu. — Mesdames, te ette ole keksinyt tai uskaltanut sanoa
kuninkaalle Madame Louisen lähdön oikeaa syytä.
 — Ahaa, taas jotain mustaamista, — virkkoi kuningas. — Anna
tulla vaan, Riepu, anna tulla!

— Oh, sire, — vastasi tytär, tiedänpä, etteivät sanani ole teille

oikein mieleen.

— Sano, ettet niiden toivo olevan; se sopii paremmin.

Madame Adelaide puraisi huultaan.

— Mutta minä puhun vaan totta.

— Oho, sepä on kumma! Totta! Lakatkaa jo käyttämästä sellaista

sanaa. Puhunko minä milloinkaan totta? Ja, kuten näet, minä voin
silti koko hyvin, Jumalan kiitos.

Ja Ludvig XV kohautti hartioitaan.

— No, puhu, sisko, puhu, — sanoivat toiset kaksi sisarta kilvan,

palaen halusta kuulla moisen kuninkaaseen sattuvan syyn.

— Kas sellaisia jalomielisiä olentoja, — murisi Ludvig XV, — kas

sillä tavalla te rakastatte isäänne!

Mutta samalla lohdutti häntä ajatus, että hän maksoi heille samalla
mitalla.

— Niin, — jatkoi prinsessa Adelaide, — seikka, jota Louise-

siskomme pelkäsi enimmin maailmassa, hän, joka noudatti niin
tarkasti etikettiä, oli, että…

— Että?… — toisti Ludvig XV. — No, sano nyt, koska kerran olet
alkanut.
 — No niin, sire, se oli se, että tänne tunkeutuu uusia ihmisiä…

— Tunkeutuu, mitä sanoit? — vastasi kuningas tyytymättömänä jo

tähän alkuun, sillä hän aavisti, mitä sillä tarkoitettiin.

— Tunkeutuu! Tuleeko minun luokseni tungettelijoita!

Pakoitetaanko minut ottamaan vastaan joitakin vasten tahtoani?

Tämä oli mukava keino muuttaa pakinan tarkoitus.

Mutta prinsessa Adelaide oli liian tottunut ilkeyksiin salliakseen

johtaa itsensä tällä tavoin harhaan, kun oli päässyt tolalle
antaakseen jonkun letkauksen.

— Minä erehdyin, se ei ollut oikea sana. Minun ei olisi pitänyt

puhua tunkeutumisesta, vaan esittämisestä.

— Ahaa, — sanoi kuningas, — tämä on jo parannus; tunnustan,

että tuo ensimäinen sana oli minusta vastenmielinen: pidän
enemmän esittämisestä.

— Ja kuitenkaan, sire, en luule vielä tätäkään oikeaksi sanaksi, —

jatkoi prinsessa Viktoria.

— No mikä se oikea sitten on, annapas kuulua?

— Se on esittely.

— Niin, niin, — huudahtivat toiset kaksi yhtyen vanhimman

väitteeseen, — nyt löytyi varmaan se oikea sana.

Kuningas pureskeli huuliaan.

— Ahaa, vai luulette? — sanoi hän.

 — Kyllä, — jatkoi prinsessa Adelaide. — Minä siis tarkoitin, että
Louise-sisareni pelkäsi pahoin uusia esittelyitä.

— No niin, — sanoi kuningas haluten päästä koko pakinasta, —

entä sitten?

— Niin, isä, hän pelkäsi tietysti nähdä kreivitär Dubarryn tulevan

esitellyksi hovissa.

— Kas niin muka! — huusi kuningas antaen harminsa purkautua

hillittömästi; — antakaa tulla vaan, älkää kierrelkö ja kaarrelko asiaa!
Cordieu, miten te tuhlaatte aikaamme, hyvä neiti Totuus.

— Sire, — vastasi prinsessa Adelaide, — jos äsken epäröin puhua

näin teidän Majesteetillenne, johtui se siitä, että kunnioitus esti
minua sitä tekemästä ja että ainoastaan teidän Majesteettinne käsky
saattoi avata suuni sellaisessa asiassa.

— Niin kai, tietysti! Niinkuin sinä osaisit pitää kiinni tuon suusi!
Niinkuin se ei aina joko haukottelisi, puhuisi tai pureskelisi!…

— Siitä huolimatta on kuitenkin totta, sire, — jatkoi prinsessa

Adelaide, — että luulen löytäneeni oikean syyn sisareni
poistumiseen.

— No niin, mutta siinä sinä erehdyt.

— Oh, sire, — vastasivat yhtaikaa painokkaasti päätään pudistaen

prinsessat Viktoria ja Sofia; — oh, sire, me olemme siitä asiasta
varsin varmat.

— Mitä tämä on! — keskeytti Ludvig XV, aivan kuin isä Molièren
näytelmissä. — Ahaa, nyt yhdytään samaan mielipiteeseen, vai niitä?
Näyttääpä siltä kuin olisi salaliitto perheessäni. Senkö tähden siis tuo
esittely ei saisi tapahtua; senkö tähden siis mesdames ovat poissa
kotoa, kun heidän luokseen aiotaan tulla vieraisille; sentähden siis he
eivät vastaa audienssianomuksiin ja hakemuksiin.

— Mihinkä anomuksiin ja hakemuksiin? — kysyi prinsessa

Adelaide.

— Oh, tiedäthän nyt sen; — virkkoi prinsessa Sofia; — neiti

Jeanne
Vaubernierin hakemuksiin.

— Ei, vaan neiti Langen audienssianomuksiinpas, — jatkoi

prinsessa
Viktoria.

Kuningas kavahti vimmoissaan ylös. Hänen silmissään, jotka olivat

tavallisesti niin tyynet ja lempeät, välkähti salama, joka ei luvannut
sisaruksille hyvää.

Ja kun tuossa kolmikossa ei ollut ainoatakaan sankaritarta, joka

olisi kestänyt isällisen vihan puuskan, niin vaipuivat heidän kaikkien
päänsä myrskyn edessä.

— Kas niin, — sanoi kuningas, — näin te todistatte minun muka

erehtyneen, kun väitin, että parhain teistä neljästä lähtee luotani.

— Sire, — sanoi prinsessa Adelaide, — teidän Majesteettinne

kohtelee meitä pahoin, pahemmin kuin koiriaan.

— Sen minä uskon; minun koirani ovat minulle hyviä, kun menen
niiden luokse; koirani ovat minun oikeita ystäviäni! Ja hyvästi siis
nyt, mesdames. Minä menen Charlotten, Belle-fillen ja Gredinetin
luokse. Elukka-raukat, niin, minä pidän niistä, pidän varsinkin
sentähden, että niillä on hyvänä puolena se, etteivät ne aina hauku
minulle totuuksia.

Kuningas läksi vimmoissaan pois. Mutta hän ei ollut vielä ehtinyt

eteisessä neljää askelta, kun hän kuuli tyttäriensä laulavan takanaan
kuorossa:

Pariisin suuren naiset

ja immet, nuorukaiset
on lempeen riutuvaiset
ja huokaa, vaikertaa! Oijoi, oijoi!
Se myöskin Blaisen heilun
vie hautaan, armastellun
reilun
lellun,
heilun
jo sängyn omaks saa, Hohoi!

Se oli ensimäinen värssy erästä rouva Dubarrytä vastaan

sepitettyä laulua, jota laulettiin kaduilla nimellä La Belle
Bourbonnaise.

Kuningas aikoi jo melkein kääntyä takaisin, ja ehkäpä eivät

prinsessat olisi olleet liioin tyytyväiset häneen palaamiseensa, mutta
hän malttoi kuitenkin mielensä ja huusi päästäkseen kuulemasta:

— Herra koirakapteeni hoi, herra koirakapteeni!

Upseeri, jolla oli tämä merkillinen arvonimi, kiiruhti hänen

luokseen.
 — Avatkaa koirakamari, — sanoi kuningas.

— Oh, sire, — huudahti upseeri syöksähtäen kuninkaan eteen,

estämään hänen kulkuaan, — älköön teidän Majesteettinne menkö
enää askeltakaan.

— No mikä nyt sitten on, sanokaa? — virkkoi kuningas pysähtyen

koirahuoneen ovelle, jonka takaa kuului koirain uikutus, kun he
vainusivat isäntänsä olevan lähellä.

— Sire, — vastasi upseeri, — antakaa intoni anteeksi, mutta minä

en voi sallia nyt kuninkaan mennä koirien luokse.

— Ahaa, — sanoi kuningas, — ymmärrän, kamari ei ole

järjestyksessä… No niin, päästäkää Gredinet tänne.

— Sire, — jupisi upseeri kasvot tyrmistyneinä, — Gredinet ei ole

huolinut ruokaa eikä juomaa kahteen päivään ja peljätään, että sillä
on vesikauhu.

— Oh, toden totta, — huudahti Ludvig XV, — minä olen

onnettomin ihminen maailmassa! Gredinetillä vesikauhu, se nyt
kaiken surun lisäksi.

Koiraupseeri arveli velvollisuudekseen vuodattaa pari kyyneltä,

tehdäkseen kohtauksen elävämmäksi.

Kuningas kiepahti kannoillaan ja meni työhuoneeseensa, jossa

hänen kamaripalvelijansa häntä odotti.

Kun hän näki kuninkaan tyrmistyneet kasvot, vetäytyi hän

ikkunasyvennykseen kätköön.
 — Ah, kyllä minä huomaan hyvin, — mutisi Ludvig XV välittämättä
vähääkään tuon uskollisen palvelijan läsnäolosta, sillä hän ei ollut
kuninkaasta edes ihminenkään, ja kävellen edestakaisin
huoneessaan, — ah, kyllä minä huomaan, että hra de Choiseul
kohtelee minua narrina. Dauphin pitää jo itseään täällä puolittain
isäntänä ja luulee pääsevänsä kokonaan herraksi, saatuaan pikku
Itävallattarensa valtaistuimelle. Louise kyllä rakastaa minua, mutta
sangen kovalla tavalla, koska hän saarnaa minulle moraalia ja hylkää
minut. Muut kolme tytärtäni laulavat renkutuksia, joissa minua
kutsutaan Blaiseksi. Provencen kreivi kääntää Lucretiusta. Artois'n
kreivi juoksee tyttöjen perästä. Koirillani on vesikauhu ja tahtovat
minua purra. Ei ole tosiaan muita kuin tuo kreivitär-parka, joka
minua rakastaa. Hiiteen kaikki, jotka tahtovat häntä kiusata!

Epätoivon vimmalla istahti Ludvig XV senjälkeen pöydän eteen,

saman, jonka ääressä Ludvig XIV oli kirjoittanut nimiään valtion
papereihin ja joka oli kantanut hänen viimeisten sopimuskirjainsa ja
ylpeäin kirjelmäinsä taakkaa.

— Nyt minä ymmärrän, miksi kaikki ihmiset ympärilläni koettavat

saada madame la dauphinea kiireesti tänne. Luullaan, että hänen
tarvitsee täällä ainoastaan näyttäytyä, niin minä joudun hänen
orjakseen tai annan hänen sukunsa itseäni vallita. Ma foi, kylläpä
tosiaan ennätän vielä tavata tuon rakkaan pojanpoikani nuorikon,
varsinkin jos hänen saapumisensa tuo minulle yhä uusia rettelöltä.
Eläkäämme siis rauhassa, rauhassa niin kauan kuin on mahdollista
vielä. Ja että se olisi mahdollista, viivytelkäämme häntä matkalla.
Hän aikoi, — jatkoi kuningas, — kulkea Reimsin ja Noyonin kautta
pysäyttämättä ja saapua nyt kohta Compiègneen. Mutta
noudattakaamme nyt aikaisemmin aiottua seremoniaa. Kolme päivää
vastaanottoja Reimsissä ja yksi… ei, kaksi… pyh, miksikä ei kolme
päivää juhlia Noyonissa! Siten voitan toki aikaa kuusi päivää, kuusi
onnellista päivää!

Kuningas tarttui kynään ja kirjoitti itse hra de Stainvillelle käskyn

pysähtyä kolmeksi päiväksi Reimsiin ja kolmeksi Noyoniin.

Sitten lähetti hän noutamaan häntä palvelemaan määrätyn

kuriirin.

— Tulista vauhtia, kunnes tämä käsky on asianomaisen käsissä, —

sanoi hän tälle.

Sitten kirjoitti hän samassa rupeamassa:

'Rakas kreivitär, me asetamme tänään Zamoren

kuvernöörinpaikkaansa. Minä lähden Marly'hin. Tänä iltana
tulen Luciennesiin ja kerron teille kaikki, mitä nykyään
ajattelen.

Ranska.'

— Kas tässä, Lebel, — sanoi hän, — vie tämä kirje kreivittärelle, ja

ole hänen kanssaan hyvissä väleissä, sen neuvon sinulle annan.

Kamaripalvelija kumarsi ja poistui.

29.

Kreivitär de Béarn.
 Kaikkien kerrottujen katkerain kohtausten päävaikute, kaikkien
näiden hovissa toivottujen tai peljättyjen häpeäjuttujen
kompastuskivi, Béarnin kreivitär, matkusti, kuten Chon oli veljelleen
sanonut, nopeaa vauhtia Pariisia kohti.

Tämä matka oli erään tuollaisen kekseliään päähänpiston tulos,

jollaisilla varakreivi Jean tarpeen vaatiessa päästi itsensä pulasta.

Kun hän ei ollut saanut hovin vallasnaisista tuota niin hartaasti

toivottua ja välttämätöntä kummitätiä, jota ilman rouva Dubarryn
esittely ei voinut tapahtua, oli hän kääntynyt maaseudun puoleen ja
tutkinut siellä kaikki mahdolliset asemat ja olosuhteet ja nuuskinut
kaupungin toisensa jälkeen. Ja viimein oli hän löytänyt Maas-joen
rannalta eräästä aivan keskiaikaisesta, mutta melkoisen hyvin
hoidetusta talosta ne seikat, joita hän tarvitsi.

Varakreivi Jeanin tarvitsemat seikat olivat joku vanha käräjöitsijä

ja vanha oikeusjuttu.

Vanha käräjöitsijä oli Béarnin kreivitär.

Vanha oikeusjuttu jälleen oli selkkaus, josta kreivittären koko

omaisuus riippui, ja oikeusjuttu taas riippui hra de Maupeousta, joka
oli aivan äskettäin saatu rouva Dubarryn liittolaiseksi. Tämän kanssa
oli hra de Maupeou nyt huomannut olevansa sukulaisuussuhteissa,
jotka olivat tähän saakka olleet aivan tuntemattomat, ja niinpä kutsui
hän nyt rouva Dubarrytä serkukseen ja oli avulias ja palvelevainen
kuninkaan lemmikille koko äsken syntyneen ystävyyden ja
tulevaisten etujensa voimalla, sillä hän toivoi kanslerin paikkaa.
Moinen ystävyys ja tulevainen harrastus olivatkin jo saaneet
kuninkaan nimittämään hänet vice-chancelieriksi, varakansleriksi;
mutta ihmiset kutsuivat häntä lyhyyden vuoksi vain arvonimellä le
vice.[52]

Rouva de Béarn oli tosiaan oikein kunnon käräjätäti, joka muistutti

suuresti kreivitär d'Escarbagnasia tai rouva Pimbecheä, noita kahta
tämän aikakauden erinomaista tyyppiä, ja jolla muuten oli, kuten
näkee, sangen kunniakas nimikin.

Béarnin kreivitär oli vilkasliikkeinen, laiha ja kulmikas vanhus, aina

valpas ja varuillaan, ja hänen silmänsä pälyivät harmaiden
kulmakarvain alta aina kuin peljästyneen kissan. Hän käytti yhä
nuoruutensa ajan pukua, ja koska muoti, niin oikullinen kuin se
onkin, joskus suvaitsee olla järkeväkin, niin sattui vuonna 1740
eläneitten tyttöjen puku olemaan samanlainen kuin se, jota vanhat
naiset käyttivät kertomuksemme aikana, vuonna 1770.

Runsaasti pitsejä, pieni pykäläreunainen vaippa hartioilla,

suunnattoman suuri myssy päässä ja valtavilla taskuilla varustettu
hame yllä ja kukikas silkkinen kaulaliina kaulassa, tällainen oli puku,
jossa Chon, rouva Dubarryn rakas käly ja luotettava uskottu, tapasi
kreivitär de Béarnin silloin kun hän oli tullut hänen luoksensa neiti
Flageot'na, nimittäin kreivittären asianajajan tyttärenä.

Vanha kreivitär käytti sitä, pukua nimittäin, yhtä paljon

mieltymyksen kuin säästäväisyydenkin vuoksi. Hän ei ollut niitä
ihmisiä, jotka punastelevat köyhyyttään, sillä hän ei ollut syynä
tuohon köyhyyteensä. Sitä, ettei hän ollut rikas, suri hän ainoastaan
sentähden, ettei hän voinut jättää nimensä arvoista omaisuutta
perinnöksi pojalleen, joka oli sangen maalaismainen nuorukainen,
kaino kuin nuori tyttö ja muuten paljon enemmän aineellista
hyvinvointia kuin kunnian loistoa haluava olento.
 Vanhalla käräjätädillä oli kyllä yksi rikkaus, nimittäin se, että hän
saattoi kutsua omikseen maita, joista hänen asianajajansa riiteli
Saluces-suvun kanssa. Mutta koska hän oli sangen älykäs nainen,
niin tiesi hän hyvin, että jos hän olisi halunnut saada lainaa noita
maita vastaan, ei olisi löytynyt ainoatakaan koronkiskuria, — vaikka
sillä ammattialalla oli Ranskassa siihen aikaan varsin rohkeita miehiä,
— eikä ainoatakaan prokuraattoria, — ja periaatteettomia
prokuraattoreita on löytynyt aina, — joka olisi lainannut hänelle
mitään tuollaisia takeita vastaan tai antanut hänelle pienintäkään
summaa etukäteen toivossa, että nämä maat luovutettaisiin takaisin
entiselle omistajattarelleen.

Siitä syystä oli kreivitär de Béarnin pakko tyytyä pelkästään niiden

maittensa tuottoon ja vuokraan, joita tämä oikeudenkäynti ei
koskenut, nimittäin suunnilleen tuhannen écun korkoihin vuosittain,
ja siitä syystä hän karttoi nykyään hovia, sillä siellä oli mennyt
kaksitoista livreä päivässä jo pelkästään niiden vaunujen vuokraan,
joilla käräjätäti oli ajellut herrain tuomarien ja asianajajien puheilla.

Ennen kaikkea oli hän väistynyt syrjään maaseudulle siksi, ettei

hän toivonut neljään, viiteen vuoteen oikeudenpöytäkirjainsa
pääsevän alas hyllyltä, johon ne oli pantu odottamaan vuoroaan.
Nykyäänkin käyvät oikeusjutut hitaasti, ja kuitenkin saattaa
oikeudenkävijä toivoa näkevänsä juttunsa kerran loppuvan
tarvitsematta elää aivan muinaisten patriarkkain ikään, mutta siihen
aikaan sitävastoin kesti oikeudenkäyntiä usein kaksi, kolme
sukupolvea ja ne olivat aivan kuin nuo "Tuhannen ja yhden yön"
ihmeelliset kasvit, jotka kantavat hedelmää vasta parin sadan
vuoden päästä.
 Rouva de Béarn ei tahtonut hukata isiensä perinnön viimeisiäkin
tähteitä koettaessaan hankkia itselleen takaisin riidanalaisia
kymmentä kahdestoista-osaa niistä; sillä hän oli, kuten olemme
sanoneet, tuollainen nainen, jota kaikkina aikoina kutsutaan vanhan
kansan ihmiseksi, nimittäin viisaan varova, itsepäinen ja ahnas.

Hän olisi luultavastikin ajanut itse koko perintöjuttunsa,

haastattanut vastustajansa oikeuteen, puolustanut asiansa ja
toimittanut tuomion nopsemmin kuin mikään prokuraattori,
asianajaja tai oikeudenpalvelija; mutta hänen nimensä oli Béarn,[53]
ja se nimi tuotti haittaa monessa kohden. Ja siitä johtui, että rouva
de Béarn vietti aikansa nykyään surun ja huolen kalvamana, aivan
kuin mikä jumalainen Akilles telttaansa vetäytyneenä ja kärsien kuin
sama sankari tuhannet kuolemantuskat kuullessaan tuon
taistelutorven äänen, jolle hän oli olevinaan kuuro, tutkiskellen
päivisin silmälasit nenällä vanhoja pergamentteja ja puolustaen yöt
asiaansa korvatyynylleen, verhoutuneena persialaiseen yömekkoon
ja harmaat hapset epäjärjestyksessä. Niinhän ajoi perimisjuttuaan,
josta hän riiteli Saluces-suvun kanssa, ja itsekseen voitti hän aina
sen niin kaunopuheisesti, että hän iloissaan menestyksestään toivoi
asianajajalleenko yhtä hyvää puheenlahjaa kuin hänellä itsellään oli.

Nyt ymmärrämme, että Chonin tiedot, kun hän ilmestyi neiti

Flageot'na vanhan kreivittären luokse, olivat tälle melkoisen
miellyttävä yllätys.

Nuori kreivi palveli armeijassa ja oli siis poissa kotoa.

Ihminen uskoo aina sitä, mitä hän toivoo. Ja niinpä antoi myöskin
rouva de Béarn tuon nuoren naikkosen puijata itsensä helposti
kertomuksellaan.
 Pieni epäilyksen varjo hänessä kuitenkin oli huomattavissa; hän oli
tuntenut mestari Flageot'n jo kaksikymmentä vuotta; hän oli käynyt
ainakin pari sataa kertaa hänen asunnossaan Rue du Petit-Lion-
Saint-Sauveurin varrella, mutta koskaan hän ei ollut nähnyt siellä,
neliskulmaisella lattiamatolla, joka tuntui hänestä varsin pieneltä
asianajajan aution suureen huoneeseen verrattuna, koskaan ei hän
ollut nähnyt siellä lasta tulevan kärkkäästi anelemaan namusia
miesten tai naisten taskuista, joiden asioita mestari Flageot ajoi.

Mutta turha oli nyt ajatella asianajajan mattoa ja turha miettiä

lasta, joka sillä matolla olisi saattanut leikkiä, tai vaivata päätänsä
kaivamalla todistuskappaleita muistostaan: neiti Flageot oli neiti
Flageot, siinä ei mikään auttanut.

Sitäpaitsi oli vieras naimisissa eikä tullut suinkaan Verduniin

vakituisesti tälle asialle, vaan aikoi mennä edelleen Strassburgiin
miehensä luokse. Ja tämä viimeinen seikka oli vahva varustus kaikkia
pahoja epäilyksiä vastaan.

Ehkäpä olisi rouva de Béarnin pitänyt pyytää neiti Flageot'lta

kirjettä, jolla hän olisi voinut saada häneltä täyden luottamuksen.
Mutta ellei isä voi lähettää omaa tytärtään varustamatta häntä
moisella kirjelmällä, kenelle hän sitten saattaa uskoa minkään
luottamusasian?

Ja miksikä peljätä sellaista? Mitä arvoa moisilla epäilyksillä oli?

Mitä varten kukaan olisi matkustanut kolmenkymmenen peninkulman
matkan esittämään kreivitär de Béarniile pelkkiä sepustuksia? Jos
rouva de Béarn olisi ollut rikas, jos hän olisi ollut jonkun pankkiirin,
yleisvuokraajan tai veronkantajan vaimo, jos hän olisi saattanut
lähteä Pariisiin komeilla vaunuilla ja kuljettaa mukanaan
pöytähopeita ja jalokiviä, olisi hän voinut ajatella, että tämä oli
varkaiden keksimää salajuonta. Mutta rouva de Béarn vaan nauroi
sattuessaan ajattelemaan, miten ankarasti ne varkaat pettyisivät,
jotka olisivat niin vähän perillä asioista, että häntä muistaisivat.

Heti kun Chon oli lähtenyt hänen luotaan tavallisessa

porvarisnaisen puvussaan ja yhden ainoan hevosen vetämillä pienillä
kääseillä, jotka hän oli vuokrannut viimeisen edellisestä kyytipaikasta
jättäen sinne vaununsa, nousi kreivitär de Béarn nyt vuorostaan
huonoihin vaunuihin, ajatellen, että nyt oli aika tehdä jokin uhraus.
Ja hän kiiruhti kyytimiehiä siinä määrin, että joutuikin Chausséen
kylän ohi jo tuntia ennen dauphinea ja että saapui Saint-Denis'n
tulliportille jo viisi kuusi tuntia ennen kuin neiti Chon.

Kun matkustavalla vanhalla rouvalla oli sangen vähän

matkatavaroita mukanaan ja koska hänen ensimäinen asiansa oli nyt
saada lähempiä tietoja, niin pysäytti hän vaunut Petit-Lion-kadun
varrella, mestari Flageot'n talon portilla.

Kuten ymmärretään, ei tuo pysähdys voinut tapahtua kokoamatta

joukon uteliaita, ja pariisilaiset ovat kaikki uteliaita, noiden
kunnianarvoisain ajoneuvojen ympärille, jotka näyttivät olevan
peräisin Henrik IV:nnen ajoilta, muistuttaen vankan ja
momumentaalisen rakenteensa sekä käpertyneiden nahkauudintensa
puolesta, jotka kauheasti vinkuen soluivat vihertävällä vaskipuikolla,
juuri tuon ruhtinaan mieliajoneuvoja.

Petit-Lion-katu ei ole leveä. Rouva de Béarn tukki sen täydellisesti

majesteettisilla vaunuillaan, ja kun hän oli maksanut kyytimiehille,
niin käski hän heidän viedä vaunut majataloon, jossa hänen oli tapa
asua Pariisissa käydessään, nimittäin Kiekuvaan Kukkoon, joka oli
Saint-Germain-des-Prés-kadun varrella.
 Sitten nousi kreivitär de Béarn ylös hra de Flageot'n pimeitä
portaita rasvaisen kaidenuoran johdolla; portaissa vallitsi viileys, joka
ei ollut muorista lainkaan epämiellyttävä, sillä hän oli uupunut
kiivaasta ajosta ja maantien helteestä.

Kun Marketta-palvelijatar oli ilmoittanut mestari Flageot'lle rouva

kreivitär de Béarnin tulon, kohotti asianajaja ylös housunsa, joiden
hän oli antanut kuumuuden tähden valua alas, painoi päähänsä
peruukin, joka aina oli hänen ulottumissaan, ja pisti ylleen
kuvikkaasta pumpulista valmistetun yönutun.

Tällaisessa juhlallisessa asussa meni hän sitten hymyillen ovelle.

Mutta hänen hymyssään oli niin selvä hämmästyksen vivahdus, että
kreivittärellä oli täysi syy hänelle sanoa:

— No, tässä minä olen, hra Flageot, minä!

— Kyllä, — vastasi Flageot, — sen näen, kreivitär.

Sitten sulki asianajaja häveliäästi yötakkinsa ja vei kreivittären

nahkaiseen nojatuoliin työhuoneensa valoisimpaan nurkkaan, ja
toimitti hänet sillä tavoin tarpeeksi loitolle kirjoituspöytänsä luota,
sillä hän tiesi tulijan sangen uteliaaksi.

— Kas niin, madame, — sanoi mestari Flageot kohteliaasti, —

sallinette nyt minun ilmaista teille iloani näin odottamattomasta
tulosta?

Rouva de Béarn kohotti paraikaa syvässä nojatuolissa jalkojaan

sen verran permannosta, että Marketta saattoi panna sen ja hänen
kirjattujen silkkikenkiänsä väliin tuomansa nahkatyynyn, ja
suoristautui nyt yhtäkkiä.
 — Kuinka, odottamattomastako? — vastasi hän ja pisti nenälleen
silmälasinsa, jotka hän oli jo vetänyt kotelosta, voidakseen paremmin
tarkastaa varakansleria.

— Tiettävästi; minä luulin, että te olisitte siellä tiluksillanne,

madame, — vastasi asianajaja, antaen herttaisesti tilusten
imartelevan nimen rouva de Béarnin kolmelle auranalalle
vihannestarhaa.

— Kuten huomaatte, olen siellä ollutkin; mutta ensimäisen merkin

teiltä saatuani kiiruhdin tänne.

— Ensimäisen merkin minulta? — matki asianajaja

hämmästyneenä.

— Ensimäisen sanan, ensimäisen tiedon tai neuvon teiltä tultua,

miten vaan haluatte sitä nimittää.

Asianajajan silmät tulivat suuriksi kuin kreivittären silmälasit.

— Toivoakseni olen tarpeeksi kiiruhtanut, — jatkoi kreivitär, — että

voitte olla minuun tyytyväinen.

— Suorastaan hurmaantunut, madame, kuten aina teihin; mutta

sallikaa minun teille sanoa, että minä en jaksa ymmärtää, mitä
minulla tässä tulossanne on tekemistä.

— Kuinka! — huudahti kreivitär; — mitäkö teillä on siinä

tekemistä?… Kaikki, tai paremminkin sanoen, tehän siihen olette
syynäkin.

— Minä?
 — Niin juuri, te… No niin, täällä on siis uutisia?

— Kyllä, madame, väitetään, että kuningas suunnittelee

valtiokeikausta parlamenttia vastaan. Mutta saanko luvan teille jotain
tarjota?

— Vai niin, siis muka kysymys kuninkaasta ja valtiokeikauksista!

— Mutta mistäs sitten, madame?

— Minun oikeusjutustani. Siitähän minä kysyin, mitä uutta siinä on

tapahtunut.

— Oh, — vastasi hra Flageot pudistaen surullisesti päätään, —

mitä siihen asiaan tulee, ei mitään, ei kerrassaan mitään.

— Ettäkö ei mitään…

— Ei, ei mitään…

— Siitä saakka nimittäin, kun teidän tyttärenne kävi minulle

asiasta puhumassa. Ja koska hän teki sen vasta toissapäivänä, niin
ymmärrän, ettei siitä saakka olekaan ehtinyt mitään uutta tapahtua.

— Minun tyttäreni, madame?

— Niin.

— Sanotteko: minun tyttäreni?

— Epäilemättäkin, teidän tyttärenne, jonka lähetitte luokseni.

— Anteeksi, madame, — vastasi Flageot, — mutta on aivan

mahdotonta, että olisin lähettänyt luoksenne tyttäreni.
 — Mahdotonta?

— Niin, siitä hyvin yksinkertaisesta syystä, että minulla ei ole

tytärtä.

— Oletteko varma siitä? — kysyi kreivitär.

— Madame, — huomautti Flageot, — minulla on kunnia olla

vanhapoika.

— Älkää nyt! — epäsi kreivitär.

Flageot tuli rauhattomaksi; hän huusi Markettaa tuomaan

kreivittärelle virvoitusjuomaa ja varsinkin antaakseen hänen pitää
vierasta silmällä.

"Nais-parka", ajatteli asianajaja, "hänen älynsä on mennyt

sekaisin".

— Kuinka, — jatkoi kreivitär, — eikö teillä ole tytärtä?

— Ei, madame.

— Naitua tytärtä, joka asuu Strassburgissa?

— Ei, madame, tuhannen kertaa ei!

— Ja te ette ole antanut tyttärenne tehtäväksi, — jatkoi kreivitär

seuraten yhä ajatustaan, — ette ole antanut tuon tyttären tehtäväksi
ilmoittaa minulle ohitse matkustaessaan, että minun oikeusjuttuni on
nyt listalla?

— En.
 Kreivitär hypähti koholle nojatuolissa ja löi kaksin käsin polviinsa.

— Maistakaa hiukan, kreivitär, — kehoitti Flageot, — se tekee teille

hyvää.

Ja samassa hän antoi salaisen merkin Marketalle, joka toi sisään

tarjottimen ja sillä kaksi lasia olutta. Mutta vanhalla rouvalla ei enää
ollut jano; hän sysäsi tarjottimen ja lasit niin kiireesti luotaan pois,
että mamselli Marketta, joka näytti olevan talossa jollakin tavoin
etuoikeutetussa asemassa, siitä suorastaan loukkaantui.

— Kuulkaahan nyt, — sanoi kreivitär katsellen lakimiestä

silmälasiensa lävitse, — selvittäkäämme nyt toisillemme tätä asiaa.

— Kyllä, mielelläni, — vastasi Flageot. — Jää sinä tänne,

Marketta; ehkäpä madame tahtoo hiukan myöhemmin. Selvitetään
nyt.

— Niin, tehkäämme se, olkaa niin hyvä, sillä te olette aivan

käsittämätön tänään, hyvä hra Flageot; luulisi toden totta, että helle
on pannut aivonne aivan sekaisin.

— Älkää kiihtykö, — vastasi asianajaja ja lykkäsi jaloillaan tuoliaan

taaksepäin, päästäkseen kreivittärestä loitommalle, — älkää kiihtykö,
vaan puhutaan rauhassa.

— Niin, puhutaan vaan. Te siis sanoitte, että teillä ei ole tytärtä,

hra Flageot?

— Ei, madame, ja minä valitan sitä mitä syvimmin, koska se ei näy

olevan teistä mieleen, joskin…

— Joskin? — toisti kreivitär.

 — Joskin minä puolestani olisin mieluummin toivonut poikaa.
Poikain on helpompi tulla maailmassa toimeen, tai he eivät ainakaan
joudu niin huonoille jäljille kuin tytöt nykyaikaan.

Kreivitär liitti ylen rauhattomana kätensä ristiin.

— Kuinka, — kysyi hän; — ettekö te lähettänyt jotakin sisartanne,

veljentytärtänne tai serkkuanne pyytämään minua tulemaan
Pariisiin?

— Sitä en ole koskaan uneksinutkaan, madame, tietäen kuinka

kalliiksi elanto Pariisissa tulee.

— Mutta minun juttuni?

— Lupaan ilmoittaa heti siitä teille, kun se otetaan esille.

— Kuinka, kun se otetaan esille?

— Niin.

— Eikö se sitten nyt ole esillä?

— Ei minun tietääkseni, madame.

— Minun juttuani ei ole siis otettu tutkittavaksi?

— Ei.

— Eikä sitä aiotakaan piakkoin ottaa?

— Ei, madame, Jumala paratkoon, ei!

 — Siinä tapauksessa, — huudahti vanhus nousten ylös, — on
minua petetty, hävyttömästi pidetty pilkkana.

Flageot sysäsi peruukin ylös otsalleen ja mutisi:

— Niin pelkään, madame.

— Mestari Flageot!… — huusi kreivitär.

Asianajaja ponnahti tuolillaan pelosta ja antoi merkin Marketalle,

joka oli jo valmiina isäntäänsä auttamaan.

— Mestari Flageot, — jatkoi kreivitär, — minä en aio kärsiä tätä

nöyryytystä ja minä turvaudun poliisipäällikköön saadakseni tietooni
tuon lepakon, joka on tällä tavoin minua loukannut.

— Hm, — hymähti Flageot; — sen tiedon saamisen taitaa olla niin

ja näin.

— Ja kun saan hänet käsiini, — jatkoi kreivitär vihan vimmassa, —

haastatan hänet oikeuteen.

— Taas oikeusjuttu! — sanoi asianajaja alakuloiseksi tullen. Nämä

sanat pudottivat käräjöitsijän alas hänen vimmansa korkeudesta, ja
kolaus oli ankara.

— Oi, — sanoi hän, — minä tulin tänne niin onnellisena!

— Mutta mitä tuo nainen sitten teille sanoi?

— Ensinnäkin, että te olitte hänet lähettänyt.

— Mikä hävytön vehkeilijä!

 — Ja teidän puolestanne hän ilmoitti minulle, että juttuni otetaan
tutkittavaksi aivan kohta; minun ei mitenkään pitänyt viivytellä, tai
olisin muka saapunut liian myöhään.

— Oi, kaukana siitä, että juttunne tulisi tutkittavaksi, — vahvisti

Flageot jälleen.

— Meidät on unohdettu, eikö niin?

— Unohdettu, haudattu, kuopattu, madame; ja ellei tapahdu

ihmettä, mutta tehän tiedätte, että ihmeet ovat nykyään
harvinaisia…

— Oi, se on totta, — mutisi kreivitär huokaisten.

Flageot vastasi toisella huokauksella tilaisuuden vaatimuksen

mukaan.

— Kuulkaahan, hra Flageot, — jatkoi rouva de Béarn, —

tahdotteko tietää erään asian?

— Sanokaa pois, madame.

— Minä en elä tämän ohi.

— Oh, mitä siihen tulee, se olisi sangen väärin.

— Hyvä Jumala, — jatkoi kreivitär-parka, — minun voimani ovat

aivan lopussa.

— Rohkeutta, madame, rohkeutta, — sanoi Flageot.

— Mutta eikö teillä ole minulle mitään neuvoa?

 — Kyllä; neuvon teitä matkustamaan takaisin tiluksillenne ja
olemaan vasta uskomatta henkilöitä, jotka tulevat luoksenne
tuomatta minulta kirjettä.

— Ah, niin, kai minun sinne täytyy palata.

— Se olisi viisainta.

— Mutta uskokaa minua, hra Flageot, — vaikeroi kreivitär, — me

emme toisiamme enää näe, emme ainakaan tässä maailmassa.

— Mikä konnamaisuus!

— Mutta ovatpa vihamieheni siis kovin häikäilemättömiä?

— Se on Saluces-suvun ilkeyttä, sen vannon.

— Kaikessa tapauksessa se on hyvin raukkamainen keksintö.

— Niin, suorastaan kehno, — myönsi Flageot.

— Haa, oikeus, oikeus, — huusi kreivitär, — se on Kakuksen luola,

hyvä hra Flageot.

— Ja miksikä? — sanoi asianajaja. — Siksi, ettei oikeus ole enää

ennallaan, siksi että parlamenttia lahjotaan, että hra de Maupeou on
tahtonut päästä kansleriksi tyytymättä olemaan presidenttinä.

— Hra Flageot, nyt minun tekisi mieleni vähän juoda.

— Marketta! — huusi asianajaja.

Marketta, joka oli hetkeksi poistunut nähdessään keskustelun

sujuvan rauhallisesti, tuli sisään.
 Hän tuli sisään, sanoimme, tuoden takaisin poisviemänsä
tarjottimen ja kaksi lasia olutta. Rouva de Béarn tyhjensi verkalleen
lasinsa ja soi asianajajalleen kunnian kilistää kanssaan. Sitten hän
meni ulos eteiseen, kumarrettuaan surullisesti ja hyvästeltyään vielä
surullisemmin.

Flageot saattoi häntä ulos peruukki kädessä.

Kreivitär seisoi jo porrassillakkeella tavoitellen köyttä, joka siellä

toimitti kaiteen virkaa, kun yhtäkkiä jokin käsi sattui hänen kätensä
päälle ja jonkun pää puski häntä rintaan.

Käsi ja pää olivat kirjurin, joka harppasi portaita ylös neljä

askelmaa kerrallaan.

Vanha kreivitär suututtelihe ja motkotti, järjesteli helmuksiaan ja

jatkoi menoaan ulos, mutta kirjuri jälleen juoksi eteiseen, lykkäsi sen
oven auki ja huusi kaikkien aikain kirjureille ominaisella iloisella ja
reippaalla äänellä:

— Tässä on, mestari Flageot, se koskee Béarnin juttua! Ja hän

ojensi asianajajalle erään paperin.

Juosta takaisin ylös, työntää kirjuri syrjään, karata mestari

Flageot'n kimppuun, temmaista paperi hänen kädestään, sulkea
hänet auttamattomasti työhuoneeseen, tämän kaiken ehti vanha
kreivitär tehdä ennenkuin kirjuri ennätti saada kaksi korvapuustia,
jotka Marketta hänelle antoi tai oli antavinaan vastaukseksi kahdesta
muiskusta.

— Hei, — huusi vanha kreivitär, — mitä siinä paperissa sanotaan,

mestari Flageot?
 — Ma foi, sitä en vielä tiedä, kreivitär; mutta jos suvaitsette antaa
minulle paperin, niin sen sanon.

— Se on totta, hyvä mestari Flageot; lukekaa, mutta nopeasti.

Asianajaja katsoi kirjeen allekirjoitusta.

— Tämän on lähettänyt mestari Guildou, meidän

prokuraattorimme, — sanoi asianajaja.

— Ah, hyvä Jumala!

— Hän käskee minua olemaan valmiina, — jatkoi mestari Flageot

yhä ällistyneempänä, — olemaan valmiina ajamaan oikeuden edessä
asiaamme, sillä juttumme on nyt otettu esityslistalle.

— Otettu esityslistalle! — huusi kreivitär ponnahtaen ylös

permannosta; — otettu esityslistalle! Ahaa, varokaa itseänne, hra
Flageot, älkäämme laskeko enää leikkiä, nyt minä en enää sitä
sietäisi.

— Madame, — vastasi mestari Flageot, joka oli aivan ymmällään

saamastansa tiedonannosta, — jos tässä joku laskee leikkiä, niin se
on kai pelkästään hra de Guildou, ja siinä tapauksessa tekee hän sen
ensi kertaa elämässään.

— Mutta onko tämä kirje tosiaan häneltä?

— Katsokaa itse, tuossa on allekirjoitus: Guildou.

— Se on totta… Otettu esityslistalle ja tulee käsiteltäväksi tiistaina.

Mutta kuulkaas, eihän tuo luonani käynyt nainen ollutkaan mikään
vehkeilijä, mestari Flageot?