FollowTheMoney

https://followthemoney.tech/
Admin
FollowTheMoney is a data model and toolset for financial crime investigations and document...
Tokens:58,031
Snippets:724
Trust Score:6.5
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install followthemoney and verify CLI

Source: https://followthemoney.tech/docs/cli

Install the package via pip and check the help menu to confirm installation.

```bash
pip install followthemoney
ftm --help
```

--------------------------------

### Install followthemoney-store with SQLite

Source: https://followthemoney.tech/docs/cli

Install the store package with default SQLite support.

```bash
pip install followthemoney-store
```

--------------------------------

### Install followthemoney-store with PostgreSQL

Source: https://followthemoney.tech/docs/cli

Install the store package with PostgreSQL support and configure the database URI.

```bash
pip install followthemoney-store[postgresql]
export FTM_STORE_URI=postgresql://localhost/followthemoney
```

--------------------------------

### Query Examples

Source: https://followthemoney.tech/docs/metadata

Various examples of dataset query structures.

```json
"us_ofac_sdn"
```

```json
["us_ofac_sdn", "eu_fsf", "gb_hmt_sanctions"]
```

```json
"#list.sanction"
```

```json
{"and": ["#issuer.eu", "#list.sanction"]}
```

```json
{"and": [
    {"or": ["#issuer.west", "#list.sanction", "#list.debarment"]},
    {"not": "lt_fiu_sanctions"},
    {"not": "#issuer.ru"}
]}
```

```json
{"and": [
    "#list.sanction",
    {"not": {"or": ["lt_fiu_sanctions", "ru_fedsfm"]}}
]}
```

--------------------------------

### Install TypeScript/JavaScript library

Source: https://followthemoney.tech/libraries

Use npm to install the FollowTheMoney package for TypeScript and JavaScript environments.

```bash
npm install @opensanctions/followthemoney
```

--------------------------------

### Advanced Property Mapping Hacks

Source: https://followthemoney.tech/docs/mappings

Examples for handling multiple columns, joining strings, setting constants, and formatting dates.

```yaml
# Setting multiple values for a property:
properties:
  name:
    columns:
    - person_name
    - maiden_name

# Merging values ad-hoc:
properties:
  name:
    columns:
    - first_name
    - last_name
    join: " "

# Setting a constant value:
properties:
  country:
    literal: "SS"

# Defining a date format:
properties:
  birthDate:
    column: dob
    format: "%d.%m.%Y"
```

--------------------------------

### Install ICU dependencies

Source: https://followthemoney.tech/docs/cli

Required for transliteration and fuzzy name comparison features.

```bash
apt install libicu-dev
pip install pyicu
```

--------------------------------

### Entity Key Collision Example

Source: https://followthemoney.tech/docs/mappings

An example of an insufficient key configuration that leads to entity collisions when names are not unique.

```yaml
entities:
  person:
    schema: Person
    keys:
      - FirstName
      - LastName
    properties:
      firstName:
        column: FirstName
      lastName:
        column: LastName
      birthDate:
        column: DoB
```

--------------------------------

### Example entity format

Source: https://followthemoney.tech/docs/cli

The standard newline-delimited JSON format for entities.

```json
{"id": "person-1", "schema": "Person", "properties": {"name": ["Jane Doe"]}}
```

--------------------------------

### Complex Mapping Configuration

Source: https://followthemoney.tech/docs/mappings

Example of mapping multiple CSV sources to Company entities with specific property assignments.

```yaml
- csv_url: http://assets.data.occrp.org/tools/aleph/fixtures/md_companies/licensed.csv
  entities:
    company:
      schema: Company
      keys:
        - Company_IDNO
        - Company_Name
      properties:
        sector:
          column: Denumire
- csv_url: http://assets.data.occrp.org/tools/aleph/fixtures/md_companies/unlicensed.csv
  entities:
    company:
      schema: Company
      keys:
        - Company_IDNO
        - Company_Name
      properties:
        sector:
          column: Denumire
        caemCode:
          column: Cod_CAEM
```

--------------------------------

### Define SQL database mapping

Source: https://followthemoney.tech/docs/mappings

Configures a PostgreSQL database connection with table aliases and join conditions. Ensure required Python drivers for the specific database backend are installed.

```yaml
za_cipc:
  queries:
    - database: postgresql://localhost/cipc
      tables:
        - table: za_cipc_companies
          alias: companies
        - table: za_cipc_directors
          alias: directors
      joins:
        - left: companies.regno
          right: directors.company_regno
```

--------------------------------

### Get entity caption

Source: https://followthemoney.tech/python/statements

Calculates the user-facing label for the entity based on schema caption properties.

```python
@property
def caption(self) -> str:
    """The user-facing label to be used for this entity. This checks a list
    of properties defined by the schema (caption) and returns the first
    available value. If no caption is available, return the schema label.

    This implementation prefers statements where the language property is that
    of the preferred system language."""
    if self._caption is None:
        for prop_ in self.schema.caption:
            stmts = self._statements.get(prop_)
            if stmts is None:
                continue
            prop = self.schema.properties[prop_]
            if prop.type == registry.name and len(stmts) > 1:
                values = [LangStr(s.value, lang=s.lang) for s in stmts]
                name = pick_lang_name(values)
                if name is not None:
                    self._caption = name
                    return self._caption

            for stmt in sorted(stmts):
                self._caption = stmt.value
                return self._caption
        if self._caption is None:
            self._caption = self.schema.label
    return self._caption
```

--------------------------------

### Get Entity Length

Source: https://followthemoney.tech/python/statements

Returns the count of statements plus one.

```python
def __len__(self) -> int:
    return len(list(self._iter_stmt())) + 1
```

--------------------------------

### Interact with Schemas and Entities

Source: https://followthemoney.tech/python

Demonstrates loading the model, creating entity proxies, assigning properties, and serializing data.

```python
# Load the standard instance of the model
from followthemoney import model

## Schema metadata
# Access a schema metadata object
schema = model.get('Person')

# Access a property metadata object
prop = schema.get('birthDate')

## Working with entities and entity proxies
# Next, let's instantiate a proxy object for a new Person entity:
entity = model.make_entity(schema)

# First, you'll want to assign an ID to the entity. You can do this directly:
entity.id = 'john-smith'

# Or you can use a hashing function to make a safe ID:
entity.make_id('John Smith', '1979')

# Now, let's assign this entity a birthDate property (see above):
entity.add(prop, '1979-08-23')

# You can also assign properties by name:
entity.add('firstName', 'John')
entity.add('lastName', 'Smith')
entity.add('name', 'John Smith')

# Adding a property value will perform some data normalisation and validation:
entity.add('nationality', 'Atlantis')
assert not entity.has('nationality')
entity.add('nationality', 'Germani', fuzzy=True)
assert 'de' == entity.first('nationality')
enttiy.add('nationality', '阿拉伯聯合大公國')
assert 'ae' in entity.get('nationality')

# Lets make a second entity, this time for a passport:
passport_entity = model.make_entity('Passport')
passport_entity.make_id(entity.id, 'C716818')
passport_entity.add('number', 'C716818')

# Entities can link to other entities like this:
passport_entity.add('holder', entity)
# Which is the same as:
passport_entity.add('holder', entity.id)

# Finally, you can turn the contents of the entity proxy into a plain dictionary
# that is suitable for JSON serialization or storage in a database:
data = entity.to_dict()
assert data.get('id') == entity.id

# If you want to turn this back into an entity proxy:
entity2 = model.get_proxy(data)
assert entity2 == entity
```

--------------------------------

### Execute mapping via command-line

Source: https://followthemoney.tech/docs/mappings

Run the mapping file using the ftm command-line tool to output JSON entities.

```bash
ftm map brexitonians.yml
```

--------------------------------

### Aggregate datasets using the store CLI

Source: https://followthemoney.tech/docs/cli

Perform a write-then-iterate workflow to aggregate entities using the store command.

```bash
cat us_ofac.ijson | ftm store write -d us_ofac
ftm store iterate -d us_ofac > aggregated.ijson
ftm store delete -d us_ofac
```

--------------------------------

### Accessing and using property types via registry

Source: https://followthemoney.tech/python/registry

Demonstrates cleaning values, comparing entities, and iterating over matchable types using the registry singleton.

```python
from followthemoney.types import registry

# Clean a value
phone = registry.phone.clean("+1 (415) 555-0100")

# Compare two values
score = registry.name.compare("Jane Doe", "J. Doe")

# Iterate all types that support comparison
for t in registry.matchable:
    print(t.name, t.label)
```

--------------------------------

### Configure Java Maven dependency

Source: https://followthemoney.tech/libraries

Add the followthemoney dependency to your project's pom.xml file.

```xml
<dependency>
    <groupId>tech.followthemoney</groupId>
    <artifactId>followthemoney</artifactId>
    <version>4.10.1</version>
</dependency>
```

--------------------------------

### Aggregate entities using Python

Source: https://followthemoney.tech/docs/fragments

Using the ftmstore library to bulk load fragments and iterate over combined entities or partials.

```python
import os
from ftmstore import get_dataset
# Assume a function that will emit fragments:
from myapp.data import generate_fragments

# If no `database_uri` is given, ftmstore will read connection from
# $FTM_STORE_URI, or create a file called `followthemoney.sqlite` in
# the current directory.
database_uri = os.environ.get('DATABASE_URI')
dataset = get_dataset('myapp_dataset', database_uri=database_uri)
bulk = dataset.bulk()
for idx, proxy in enumerate(generate_fragments()):
    bulk.put(proxy, fragment=idx)
bulk.flush()

# This will print the number of combined entities (ie. DISTINCT id):
print(len(dataset))

# This will return combined entities:
for entity in dataset.iterate():
    print(entity.caption)

# You could also iterate the underlying fragments:
for proxy in dataset.partials():
    print(proxy)

# Note: `dataset.partials()` returns `EntityProxy` objects. The method
# `dataset.fragments()` would return raw Python dictionaries instead.

# All three methods also support the `entity_id` filter, which can also be
# shortened to `get`:
entity = dataset.get(entity_id)
```

--------------------------------

### Execute a mapping from a YAML file

Source: https://followthemoney.tech/docs/cli

Downloads a mapping file and executes it to generate an ijson stream of entities.

```bash
curl -o md_companies.yml https://raw.githubusercontent.com/alephdata/aleph/main/mappings/md_companies.yml
ftm map md_companies.yml > moldova.ijson
```

--------------------------------

### Perform Neo4J bulk import

Source: https://followthemoney.tech/docs/cli

Generate CSV files and a shell script for high-performance Neo4J bulk loading.

```bash
cat us_ofac.ijson | ftm export-neo4j-bulk -o neo4j_import/ -e iban -e address
```

--------------------------------

### Sign an Ownership entity with a namespace

Source: https://followthemoney.tech/docs/namespace

Demonstrates the transformation of an Ownership entity's bare IDs into signed IDs using a specific namespace.

```json
{
  "id": "owner-ship-1",
  "schema": "Ownership",
  "properties": {
    "owner": ["person-1"],
    "asset": ["company-1"]
  }
}
```

```json
{
  "id": "owner-ship-1.a40a29300ac6bb79dd2f911e77bbda7a3b502126",
  "schema": "Ownership",
  "properties": {
    "owner": ["person-1.c2c1…"],
    "asset": ["company-1.8b3f…"]
  }
}
```

--------------------------------

### Aggregate entities using CLI

Source: https://followthemoney.tech/docs/fragments

Commands to map CSV data to fragments, store them in a database, and iterate over merged entities.

```bash
# Generate entities from a CSV file and a mapping:
cat company-registry.csv | ftm map-csv mapping_file.yml > fragments.ijson

# Write the fragments to a table `company_registry`:
cat fragments.ijson | ftm store write -d company_registry

# List the tables in the store:
ftm store list

# Output merged entities:
ftm store iterate -d company_registry
```

--------------------------------

### Pick a name from a set

Source: https://followthemoney.tech/explorer/types/name

Selects the most plausible user-facing name from a sequence of name strings.

```python
def pick(self, values: Sequence[str]) -> str | None:
    """From a set of names, pick the most plausible user-facing one."""
    return pick_name(list(values))
```

--------------------------------

### Export graph data to GEXF

Source: https://followthemoney.tech/docs/cli

Create GEXF files for quantitative analysis in tools like Gephi.

```bash
cat us_ofac.ijson | ftm validate | ftm export-gexf -e iban -o ofac.gexf
```

--------------------------------

### Pull and run Docker container

Source: https://followthemoney.tech/libraries

Commands to pull the latest FollowTheMoney Docker image and run it interactively.

```bash
docker pull ghcr.io/opensanctions/followthemoney:latest
docker run --rm -t -i ghcr.io/opensanctions/followthemoney:latest
```

--------------------------------

### Normalize phone numbers with country hints

Source: https://followthemoney.tech/explorer/types/phone

Demonstrates cleaning phone numbers and adding them to entities using the registry and entity proxy.

```python
from followthemoney import model
from followthemoney.types import registry

registry.phone.clean("020 8366 1177")               # None
registry.phone.clean("020 8366 1177", format="gb")  # '+442083661177'

entity = model.make_entity("Company")
entity.add("phone", "020 8366 1177", format="gb")
```

--------------------------------

### Explore schema model with ftm ref

Source: https://followthemoney.tech/docs/cli

Browse schema definitions, properties, and types. Outputs tables for terminals or JSON when piped.

```bash
ftm ref                       # model overview + the subcommand index
ftm ref schemata              # every schema, with matchable/abstract flags
ftm ref schemata --matchable  # only schemata that can be matched
ftm ref schema Person         # one schema, with all inherited properties
ftm ref types                 # every property type
ftm ref type country          # one type, including its enum values
ftm ref prop Person:nationality   # one property's full definition
```

--------------------------------

### Read and process FtM entities in Java

Source: https://followthemoney.tech/libraries

Demonstrates loading the default model and iterating through entity data from a JSON file.

```java
package tech.followthemoney;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

import tech.followthemoney.entity.ValueEntity;
import tech.followthemoney.exc.SchemaException;
import tech.followthemoney.model.Model;

public class FtMLibraryDemo {
    public static void main(String[] args) {
        String path = "entities.ftm.json";
        try {
            BufferedReader reader = new BufferedReader(new FileReader(path));
            Model model = Model.loadDefault();
            ObjectMapper mapper = new ObjectMapper();
            String line;
            while ((line = reader.readLine()) != null) {
                JsonNode node = mapper.readTree(line);
                ValueEntity entity = ValueEntity.fromJson(model, node);
                System.out.println("Processing entity: " + entity.getId());
                System.out.println(" -> Entity name: " + entity.getCaption());
                System.out.println(" -> Entity type: " + entity.getSchema().getLabel());
            }

        } catch (IOException | SchemaException e) {
            e.printStackTrace();
        } 
    }
}
```

--------------------------------

### followthemoney.compare.compare(left, right, weights=COMPARE_WEIGHTS)

Source: https://followthemoney.tech/python/lib

Compares two entity proxies and returns a float representing the match score based on provided weights.

```APIDOC
## followthemoney.compare.compare

### Description
Compares two entities and returns a match score as a float. If the entities have identical checksums and contain properties, it returns a perfect match score of 1.0.

### Signature
`compare(left: EntityProxy, right: EntityProxy, weights: Weights = COMPARE_WEIGHTS) -> float`

### Parameters
- **left** (EntityProxy) - Required - The first entity to compare.
- **right** (EntityProxy) - Required - The second entity to compare.
- **weights** (Weights) - Optional - The weighting configuration used for scoring, defaults to COMPARE_WEIGHTS.

### Returns
- **float** - The calculated match score.
```

--------------------------------

### Compare two entities using followthemoney.compare

Source: https://followthemoney.tech/python/lib

Calculates a match score between two EntityProxy objects based on provided weights. Returns a float representing the similarity score.

```python
def compare(
    left: EntityProxy,
    right: EntityProxy,
    weights: Weights = COMPARE_WEIGHTS,
) -> float:
    """Compare two entities and return a match score."""
    if left.checksum == right.checksum:
        # Check if there is any data at all (ie any basis for making a decision),
        # if so, return a perfect match. This avoids marking two empty entities
        # as matching. Bit ambiguous, but practical.
        if len(left.properties) > 0 and len(right.properties) > 0:
            return 1.0
    scores = compare_scores(left, right)
    return _compare(scores, weights)
```

--------------------------------

### Load and iterate a dataset catalog

Source: https://followthemoney.tech/python/dataset

Load a catalog from a YAML file and iterate through the resources of a specific dataset.

```python
from followthemoney.dataset import DataCatalog, Dataset

catalog = DataCatalog.from_path(Dataset, "catalog.yml")
ofac = catalog.require("us_ofac_sdn")
for resource in ofac.resources:
    print(resource.name, resource.url)
```

--------------------------------

### Apply filters to source data

Source: https://followthemoney.tech/docs/mappings

Demonstrates filtering imported data using equality conditions. Complex filtering logic should be handled during data cleaning before mapping execution.

```yaml
gb_parliament_57:
  queries:
    - csv_url: http://bit.ly/uk-mps-csv
      filters:
        group: 'Conservative'
      filters_not:
        gender: 'male'
      entities:
        member:
          schema: Person
          keys:
            - id
          properties:
            name:
              column: name
```

--------------------------------

### Create Statement instance from dictionary

Source: https://followthemoney.tech/python/statements

Instantiates a Statement object using a dictionary of statement attributes.

```python
@classmethod
def from_dict(cls, data: StatementDict) -> "Statement":
    return cls(
        entity_id=data["entity_id"],
        prop=data["prop"],
        schema=data["schema"],
        value=data["value"],
        dataset=data["dataset"],
        lang=data.get("lang", None),
        original_value=data.get("original_value", None),
        first_seen=data.get("first_seen", None),
        external=data.get("external", False),
        id=data.get("id", None),
        canonical_id=data.get("canonical_id", None),
        last_seen=data.get("last_seen", None),
        origin=data.get("origin", None),
    )
```

--------------------------------

### Process statement-based workflows

Source: https://followthemoney.tech/docs/cli

Convert between entity streams and statement tables for provenance-aware data handling.

```bash
# Entities → statements (CSV, attributed to dataset 'md_companies')
cat moldova.ijson | ftm statements -d md_companies > statements.csv

# Statements → entities, reconstructing full records
ftm aggregate-statements -i statements.csv > rebuilt.ijson
```

--------------------------------

### Model and Schema Access

Source: https://followthemoney.tech/python

Accessing schema and property metadata from the model singleton.

```APIDOC
## model.get(name)

### Description
Retrieves a schema metadata object by its name.

### Parameters
- **name** (string) - Required - The name of the schema (e.g., 'Person').

## schema.get(name)

### Description
Retrieves a property metadata object from a schema.

### Parameters
- **name** (string) - Required - The name of the property (e.g., 'birthDate').
```

--------------------------------

### Create Statement instance from database row

Source: https://followthemoney.tech/python/statements

Instantiates a Statement object from a database row object.

```python
@classmethod
def from_db_row(cls, row: Row[Any]) -> "Statement":
    return cls(
        id=row.id,
        canonical_id=row.canonical_id,
        entity_id=row.entity_id,
        prop=row.prop,
        schema=row.schema,
        value=row.value,
        dataset=row.dataset,
        lang=row.lang,
        original_value=row.original_value,
        first_seen=datetime_iso(row.first_seen),
        external=row.external,
        last_seen=datetime_iso(row.last_seen),
        origin=row.origin,
    )
```

--------------------------------

### Initialize StatementEntity

Source: https://followthemoney.tech/python/statements

Defines the StatementEntity class which links entities to their source datasets.

```python
class StatementEntity(EntityProxy):
    """An entity object that can link to a set of datasets that it is sourced from."""

    __slots__ = (
        "_caption",
        "_statements",
        "dataset",
        "extra_referents",
        "id",
        "last_change",
        "schema",
    )

    def __init__(
        self,
        dataset: Dataset,
        data: dict[str, Any],
        cleaned: bool = True,
    ) -> None:
        data = dict(data or {})
        schema = Model.instance().get(data.pop("schema", None))
        if schema is None:
            raise InvalidData(gettext("No schema for entity."))
        self.schema = schema
```

--------------------------------

### Standard Column Mapping

Source: https://followthemoney.tech/docs/mappings

Basic configuration for mapping a single column to a property.

```yaml
properties:
  name:
    column: person_name
```

--------------------------------

### followthemoney.types.Registry.get(name)

Source: https://followthemoney.tech/python/registry

Retrieves a specific property type object by its name.

```APIDOC
## get(name)

### Description
Retrieves the property type object associated with the provided name. This can also be accessed via attribute access on the registry instance (e.g., registry.phone).

### Parameters
- **name** (string) - Required - The name of the property type to retrieve.
```

--------------------------------

### Aggregate Entities from Multiple Files

Source: https://followthemoney.tech/docs/statements

Map multiple CSV files to statements, sort them, and aggregate them into a single entity file.

```bash
# Map several source files to FtM. Some of the source files may emit copies of
# the same entity.
ftm map-csv mapping.yml -i source1.csv | ftm statements -o source1.json
ftm map-csv mapping.yml -i source2.csv | ftm statements -o source2.json
ftm map-csv mapping.yml -i source3.csv | ftm statements -o source3.json

# Invoke a normal UNIX sort:
sort -o combined.json source1.json source2.json source3.json 

# Now, all statements representing one entity are grouped and can be turned
# into FtM entities:
ftm aggregate-statements -i combined.json -o entities.ftm.json
```

--------------------------------

### Statement Cloning and Key Generation

Source: https://followthemoney.tech/python/statements

Methods for creating deep copies of statements and generating unique keys for data identification.

```python
def clone(
    self: Self,
    *,
    entity_id: str | None = None,
    prop: str | None = None,
    schema: str | None = None,
    value: str | None = None,
    dataset: str | None = None,
    lang: str | None | object = UNSET,
    original_value: str | None | object = UNSET,
    first_seen: str | None | object = UNSET,
    external: bool | None = None,
    canonical_id: str | None = None,
    last_seen: str | None | object = UNSET,
    origin: str | None | object = UNSET,
) -> "Statement":
    """Make a deep copy of the given statement."""
    lang = lang if is_not_unset(lang) else self._lang
    ov = original_value if is_not_unset(original_value) else self.original_value
    first_seen = first_seen if is_not_unset(first_seen) else self.first_seen
    last_seen = last_seen if is_not_unset(last_seen) else self.last_seen
    origin = origin if is_not_unset(origin) else self.origin
    if external is None:
        external = self._external
    if canonical_id is None and self._entity_id != self.canonical_id:
        canonical_id = self.canonical_id

    # Decide if the statement ID can be kept the same:
    stmt_id = self.id
    if entity_id is not None and entity_id != self.entity_id:
        stmt_id = None
    if prop is not None and prop != self._prop:
        stmt_id = None
    if schema is not None and schema != self._schema:
        stmt_id = None
    if value is not None and value != self._value:
        stmt_id = None
    if dataset is not None and dataset != self._dataset:
        stmt_id = None
    if external != self._external:
        stmt_id = None
    if lang != self._lang:
        stmt_id = None
    return Statement(
        id=stmt_id,
        entity_id=entity_id or self._entity_id,
        prop=prop or self._prop,
        schema=schema or self._schema,
        value=value or self._value,
        dataset=dataset or self._dataset,
        lang=lang,
        original_value=ov,
        first_seen=first_seen,
        external=external,
        canonical_id=canonical_id,
        last_seen=last_seen,
        origin=origin,
    )
```

```python
def generate_key(self) -> str | None:
    return self.make_key(
        self._dataset,
        self._entity_id,
        self._prop,
        self._value,
        self._external,
        lang=self._lang,
    )
```

--------------------------------

### pick(values)

Source: https://followthemoney.tech/explorer/types/name

Selects the most plausible user-facing name from a set of names.

```APIDOC
## pick(values)

### Description
From a set of names, pick the most plausible user-facing one.

### Parameters
- **values** (Sequence[str]) - Required - A list of name strings.

### Returns
- **str | None** - The most plausible name or None.
```

--------------------------------

### Caption Method

Source: https://followthemoney.tech/explorer/types/country

Converts a country code into its corresponding short name.

```python
def caption(self, value: str, format: str | None = None) -> str:
    """Turn country codes into short names."""
    territory = get_territory(value)
    if territory is not None:
        return territory.name
    return value
```

--------------------------------

### Convert and Aggregate Statements

Source: https://followthemoney.tech/docs/statements

Convert entities to statement streams and perform the inverse aggregation operation.

```bash
# Convert "traditional" FtM entities to a statement stream
cat entities.ftm.json | ftm statements --format json -o statements.json
#. The inverse operation:
ftm aggregate-statements -i statements.json -o entities.ftm.json
```

--------------------------------

### Sign entity IDs with a namespace

Source: https://followthemoney.tech/docs/cli

Applies an HMAC signature to entity IDs in a stream using a specified namespace key.

```bash
cat entities.ijson | ftm sign -s md_companies > signed.ijson
```

--------------------------------

### apply(proxy, shallow=False)

Source: https://followthemoney.tech/docs/namespace

Rewrites an entity proxy so that all IDs mentioned are limited to the current namespace.

```APIDOC
## apply(proxy, shallow=False)

### Description
Rewrite an entity proxy so all IDs mentioned are limited to the namespace.

### Parameters
- **proxy** (object) - Required - The entity proxy to rewrite.
- **shallow** (bool) - Optional - Whether to perform a shallow rewrite.
```
Tokens:
Raw