Sidb

Sidb est l'accronyme de Sinamet Database. Il sert d'interface pour les requêtes sur la base de données, notamment pour y récupérer les différents objets à manipuler (Territoires, Acteurs, Flux...).

L'utilisation de l'interface Sidb doit se faire à travers un contexte with pour la connexion (voir code ci-dessous). Les objets ne sont pas persistants d'un contexte à l'autre.

with Sidb.connect() as sidb:
    mon_territoire = sidb.get_territory( ... )

Récupérer un objet

get_territory

get_territory(
    *args: str,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["object"] = "object",
    if_none: Literal["raise"],
    if_many: Literal["raise", "first", "warn_first"],
    verbose: bool = False,
    **kwargs: str
) -> Territory

get_territory(
    *args: str,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["object"] = "object",
    if_none: Literal["raise"],
    if_many: Literal["list", "warn_list"] = "warn_list",
    verbose: bool = False,
    **kwargs: str
) -> Territory | Sequence[Territory]

get_territory(
    *args: str,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["object"] = "object",
    if_none: Literal["warn", None] = None,
    if_many: Literal["raise", "first", "warn_first"],
    verbose: bool = False,
    **kwargs: str
) -> Territory | None

get_territory(
    *args: str,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["object"] = "object",
    if_none: Literal["warn", None] = None,
    if_many: Literal["list", "warn_list"] = "warn_list",
    verbose: bool = False,
    **kwargs: str
) -> Territory | Sequence[Territory] | None

get_territory(
    *args: str,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["id"],
    if_none: Literal["raise"],
    if_many: Literal["raise", "first", "warn_first"],
    verbose: bool = False,
    **kwargs: str
) -> int

get_territory(
    *args: str,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["id"],
    if_none: Literal["raise"],
    if_many: Literal["list", "warn_list"] = "warn_list",
    verbose: bool = False,
    **kwargs: str
) -> int | Sequence[int]

get_territory(
    *args: str,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["id"],
    if_none: Literal["warn", None] = None,
    if_many: Literal["raise", "first", "warn_first"],
    verbose: bool = False,
    **kwargs: str
) -> int | None

get_territory(
    *args: str,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["id"],
    if_none: Literal["warn", None] = None,
    if_many: Literal["list", "warn_list"] = "warn_list",
    verbose: bool = False,
    **kwargs: str
) -> int | Sequence[int] | None

get_territory(
    *args: str,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["query"],
    if_none: Literal["raise", "warn", None] = None,
    if_many: Literal[
        "raise", "first", "list", "warn_list", "warn_first"
    ] = "warn_list",
    verbose: bool = False,
    **kwargs: str
) -> Select[tuple[Territory]]

get_territory(
    *args: str,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["queryid", "qid"],
    if_none: Literal["raise", "warn", None] = None,
    if_many: Literal[
        "raise", "first", "list", "warn_list", "warn_first"
    ] = "warn_list",
    verbose: bool = False,
    **kwargs: str
) -> Select[tuple[int]]

get_territory(
    *args,
    match_pattern=False,
    ignore_case=False,
    ignore_accent=False,
    return_type="object",
    if_none=None,
    if_many="warn_list",
    verbose=False,
    **kwargs
)

Trouve un territoire.

Examples:

>>> territory = get_territory(code="16")
>>> territory = get_territory("Name", "Saint-%", match_pattern=True)

Parameters:

• *args (str, default: () ) –

  Duo d'arguments "NomDeProprieté", "Valeur", ou chaîne-objet "Territory(Code=xxxxx)", ou vide si kwargs renseignés

• **kwargs (str, default: {} ) –

  code=="xxxxx" ou code_insee="xxxxx" ou name="xxxxxx" ou name_fr="xxxxx"

• match_pattern (bool, default: False ) –

  Si True, la valeur est recherchée par motif plutôt que par valeur exacte, via l'instruction LIKE de SQL Se référer à la documentation de postgresql pour plus de détails. Les charactères spéciaux % et _ ne sont pas échappés.

• ignore_case (bool, default: False ) –

  Recherche ignorant la casse.

• ignore_accent (bool, default: False ) –

  Recherche ignorant l'accentuation.

• return_type (Literal['object', 'id', 'query', 'queryid', 'qid'], default: 'object' ) –

  Type de retour de la fonction. Valeurs possibles:

  • object: L'objet Territory.
  • id: L'identifiant de l'objet.
  • query: La requète de l'objet.
  • queryid ou qid: La requète de l'identifiant de l'object.
• if_none (Literal['raise', 'warn', None], default: None ) –

  Comportement en cas de propriété non trouvée: lève un erreur (raise), affiche un avertissement (warn) ou renvoie None (défaut).

• if_many (Literal['raise', 'first', 'list', 'warn_list', 'warn_first'], default: 'warn_list' ) –

  Action à prendre quand plusieurs éléments correspondents à la requète Les valeurs possibles sont:

  • warn_list: Affiche un avertissement et renvoie la liste des éléments.
  • warn_first: Affiche un avertissement et renvoie le premier élément.
  • raise: Lève une AssertionError.
  • list: Renvoie la liste des éléments correspondants.
  • first: Renvoie le premier élément correspondant.
• verbose (bool, default: False ) –

  Si True, est bavard.

Returns:

• Territory –

  L'object trouvé.

• int –

  L'identifiant de l'objet trouvé.

• Select –

  La requète de l'objet ou de l'identifiant

• None –

  Aucun object trouvé.

Raises:

• SidbNotFoundError –

  Si aucun territoire n'a pu être trouvé avec ces critères.

• ValueError –

  Si les critères de recherche sont mauvais.

get_actor

get_actor(
    *args: str,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["object"] = "object",
    if_none: Literal["raise"],
    if_many: Literal["raise", "first", "warn_first"],
    verbose: bool = False,
    **kwargs: str
) -> Actor

get_actor(
    *args: str,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["object"] = "object",
    if_none: Literal["raise"],
    if_many: Literal["list", "warn_list"] = "warn_list",
    verbose: bool = False,
    **kwargs: str
) -> Actor | Sequence[Actor]

get_actor(
    *args: str,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["object"] = "object",
    if_none: Literal["warn", None] = None,
    if_many: Literal["raise", "first", "warn_first"],
    verbose: bool = False,
    **kwargs: str
) -> Actor | None

get_actor(
    *args: str,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["object"] = "object",
    if_none: Literal["warn", None] = None,
    if_many: Literal["list", "warn_list"] = "warn_list",
    verbose: bool = False,
    **kwargs: str
) -> Actor | Sequence[Actor] | None

get_actor(
    *args: str,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["id"],
    if_none: Literal["raise"],
    if_many: Literal["raise", "first", "warn_first"],
    verbose: bool = False,
    **kwargs: str
) -> int

get_actor(
    *args: str,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["id"],
    if_none: Literal["raise"],
    if_many: Literal["list", "warn_list"] = "warn_list",
    verbose: bool = False,
    **kwargs: str
) -> int | Sequence[int]

get_actor(
    *args: str,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["id"],
    if_none: Literal["warn", None] = None,
    if_many: Literal["raise", "first", "warn_first"],
    verbose: bool = False,
    **kwargs: str
) -> int | None

get_actor(
    *args: str,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["id"],
    if_none: Literal["warn", None] = None,
    if_many: Literal["list", "warn_list"] = "warn_list",
    verbose: bool = False,
    **kwargs: str
) -> int | Sequence[int] | None

get_actor(
    *args: str,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["query"],
    if_none: Literal["raise", "warn", None] = None,
    if_many: Literal[
        "raise", "first", "list", "warn_list", "warn_first"
    ] = "warn_list",
    verbose: bool = False,
    **kwargs: str
) -> Select[tuple[Actor]]

get_actor(
    *args: str,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["queryid", "qid"],
    if_none: Literal["raise", "warn", None] = None,
    if_many: Literal[
        "raise", "first", "list", "warn_list", "warn_first"
    ] = "warn_list",
    verbose: bool = False,
    **kwargs: str
) -> Select[tuple[int]]

get_actor(
    *args,
    match_pattern=False,
    ignore_case=False,
    ignore_accent=False,
    return_type="object",
    if_none=None,
    if_many="warn_list",
    verbose=False,
    **kwargs
)

Trouve un acteur.

Examples:

>>> actor = get_actor(id=487)
>>> actor = get_actor("Id", 487)

Parameters:

• *args (str, default: () ) –

  Duo d'arguments "NomDeProprieté", "Valeur", ou chaîne-objet "Actor(Code=xxxxx)", ou vide si kwargs renseignés

• **kwargs (str, default: {} ) –

  code=="xxxxx" ou code_siret="xxxxx" ou name="xxxxxx" ou name_fr="xxxxx"

• match_pattern (bool, default: False ) –

  Si True, la valeur est recherchée par motif plutôt que par valeur exacte, via l'instruction LIKE de SQL Se référer à la documentation de postgresql pour plus de détails. Les charactères spéciaux % et _ ne sont pas échappés.

• ignore_case (bool, default: False ) –

  Recherche ignorant la casse.

• ignore_accent (bool, default: False ) –

  Recherche ignorant l'accentuation.

• return_type (Literal['object', 'id', 'query', 'queryid', 'qid'], default: 'object' ) –

  Type de retour de la fonction. Valeurs possibles:

  • object: L'objet Actor.
  • id: L'identifiant de l'objet.
  • query: La requète de l'objet.
  • queryid ou qid: La requète de l'identifiant de l'object.
• if_none (Literal['raise', 'warn', None], default: None ) –

  Comportement en cas de propriété non trouvée: lève un erreur (raise), affiche un avertissement (warn) ou renvoie None (défaut).

• if_many (Literal['raise', 'first', 'list', 'warn_list', 'warn_first'], default: 'warn_list' ) –

  Action à prendre quand plusieurs éléments correspondents à la requète Les valeurs possibles sont:

  • warn_list: Affiche un avertissement et renvoie la liste des éléments.
  • warn_first: Affiche un avertissement et renvoie le premier élément.
  • raise: Lève une AssertionError.
  • list: Renvoie la liste des éléments correspondants.
  • first: Renvoie le premier élément correspondant.
• verbose (bool, default: False ) –

  Si True, est bavard.

Returns:

• Actor –

  L'object trouvé.

• int –

  L'identifiant de l'objet trouvé.

• Select –

  La requète de l'objet ou de l'identifiant

• None –

  Aucun object trouvé.

Raises:

• SidbNotFoundError –

  Si aucun acteur n'a pu être trouvé avec ces critères.

• ValueError –

  Si les critères de recherche sont mauvais.

get_product

get_product(
    *args: str,
    nomenclature: str | None = None,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["object"] = "object",
    if_none: Literal["raise"],
    if_many: Literal["raise", "first", "warn_first"],
    verbose: bool = False,
    **kwargs: str
) -> Product

get_product(
    *args: str,
    nomenclature: str | None = None,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["object"] = "object",
    if_none: Literal["raise"],
    if_many: Literal["list", "warn_list"] = "warn_list",
    verbose: bool = False,
    **kwargs: str
) -> Product | Sequence[Product]

get_product(
    *args: str,
    nomenclature: str | None = None,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["object"] = "object",
    if_none: Literal["warn", None] = None,
    if_many: Literal["raise", "first", "warn_first"],
    verbose: bool = False,
    **kwargs: str
) -> Product | None

get_product(
    *args: str,
    nomenclature: str | None = None,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["object"] = "object",
    if_none: Literal["warn", None] = None,
    if_many: Literal["list", "warn_list"] = "warn_list",
    verbose: bool = False,
    **kwargs: str
) -> Product | Sequence[Product] | None

get_product(
    *args: str,
    nomenclature: str | None = None,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["id"],
    if_none: Literal["raise"],
    if_many: Literal["raise", "first", "warn_first"],
    verbose: bool = False,
    **kwargs: str
) -> int

get_product(
    *args: str,
    nomenclature: str | None = None,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["id"],
    if_none: Literal["raise"],
    if_many: Literal["list", "warn_list"] = "warn_list",
    verbose: bool = False,
    **kwargs: str
) -> int | Sequence[int]

get_product(
    *args: str,
    nomenclature: str | None = None,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["id"],
    if_none: Literal["warn", None] = None,
    if_many: Literal["raise", "first", "warn_first"],
    verbose: bool = False,
    **kwargs: str
) -> int | None

get_product(
    *args: str,
    nomenclature: str | None = None,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["id"],
    if_none: Literal["warn", None] = None,
    if_many: Literal["list", "warn_list"] = "warn_list",
    verbose: bool = False,
    **kwargs: str
) -> int | Sequence[int] | None

get_product(
    *args: str,
    nomenclature: str | None = None,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["query"],
    if_none: Literal["raise", "warn", None] = None,
    if_many: Literal[
        "raise", "first", "list", "warn_list", "warn_first"
    ] = "warn_list",
    verbose: bool = False,
    **kwargs: str
) -> Select[tuple[Product]]

get_product(
    *args: str,
    nomenclature: str | None = None,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    return_type: Literal["queryid", "qid"],
    if_none: Literal["raise", "warn", None] = None,
    if_many: Literal[
        "raise", "first", "list", "warn_list", "warn_first"
    ] = "warn_list",
    verbose: bool = False,
    **kwargs: str
) -> Select[tuple[int]]

get_product(
    *args,
    nomenclature=None,
    match_pattern=False,
    ignore_case=False,
    ignore_accent=False,
    return_type="object",
    if_none=None,
    if_many="warn_list",
    verbose=False,
    **kwargs
)

Trouve un produit.

Parameters:

• *args (str, default: () ) –

  Duo d'arguments "NomDeProprieté", "Valeur", ou chaîne-objet "Product(Code=xxxxx)", ou vide si kwargs renseignés

• **kwargs (str, default: {} ) –

  code=="xxxxx" ou name="xxxxxx" ou name_fr="xxxxx"

• nomenclature (str | None, default: None ) –

  Nom de la nomenclature du produit recherché.

• match_pattern (bool, default: False ) –

  Si True, la valeur est recherchée par motif plutôt que par valeur exacte, via l'instruction LIKE de SQL Se référer à la documentation de postgresql pour plus de détails. Les charactères spéciaux % et _ ne sont pas échappés.

• ignore_case (bool, default: False ) –

  Recherche ignorant la casse.

• ignore_accent (bool, default: False ) –

  Recherche ignorant l'accentuation.

• return_type (Literal['object', 'id', 'query', 'queryid', 'qid'], default: 'object' ) –

  Type de retour de la fonction. Valeurs possibles:

  • object: L'objet Product.
  • id: L'identifiant de l'objet.
  • query: La requète de l'objet.
  • queryid ou qid: La requète de l'identifiant de l'object.
• if_none (Literal['raise', 'warn', None], default: None ) –

  Comportement en cas de propriété non trouvée: lève un erreur (raise), affiche un avertissement (warn) ou renvoie None (défaut).

• if_many (Literal['raise', 'first', 'list', 'warn_list', 'warn_first'], default: 'warn_list' ) –

  Action à prendre quand plusieurs éléments correspondents à la requète Les valeurs possibles sont:

  • warn_list: Affiche un avertissement et renvoie la liste des éléments.
  • warn_first: Affiche un avertissement et renvoie le premier élément.
  • raise: Lève une AssertionError.
  • list: Renvoie la liste des éléments correspondants.
  • first: Renvoie le premier élément correspondant.
• verbose (bool, default: False ) –

  Si True, décrit le déroulement de la fonction dans le shell.

Returns:

• Product –

  L'object trouvé (ou une liste si if_many=list)

• int –

  L'identifiant de l'objet trouvé (ou une liste si if_many=list)

• Select –

  La requète de l'objet ou de l'identifiant

• None –

  Aucun object trouvé.

Raises:

• SidbNotFoundError –

  Aucun produit n'a pu être trouvé avec ces critères.

• ValueError –

  Si les critères de recherche sont mauvais.

Récupérer une liste d'objets

get_territories

get_territories(
    property_name: str | None = None,
    property_value: str | None = None,
    /,
    *,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["list", "object"] = "list",
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Sequence[Territory]

get_territories(
    property_name: str | None = None,
    property_value: str | None = None,
    /,
    *,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["id"],
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Sequence[int]

get_territories(
    property_name: str | None = None,
    property_value: str | None = None,
    /,
    *,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["count"],
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> int

get_territories(
    property_name: str | None = None,
    property_value: str | None = None,
    /,
    *,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["query"],
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Select[tuple[Territory]]

get_territories(
    property_name: str | None = None,
    property_value: str | None = None,
    /,
    *,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["queryid", "qid"],
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Select[tuple[int]]

get_territories(
    property_name=None,
    property_value=None,
    /,
    *,
    match_pattern=False,
    ignore_case=False,
    ignore_accent=False,
    filter_ids=None,
    return_type="list",
    cache_properties=[],
    verbose=False,
)

Trouve plusieurs territoires.

Parameters:

• *args –

  Duo d'arguments "NomDeProprieté", "Valeur"

• match_pattern (bool, default: False ) –

  Si True, la valeur est recherchée par motif plutôt que par valeur exacte, via l'instruction LIKE de SQL Se référer à la documentation de postgresql pour plus de détails. Les charactères spéciaux % et _ ne sont pas échappés.

• ignore_case (bool, default: False ) –

  Recherche ignorant la casse.

• ignore_accent (bool, default: False ) –

  Recherche ignorant l'accentuation.

• filter_ids (Iterable[int] | Select[tuple[int]] | None, default: None ) –

  Filtre d'identifiants des objets.

• return_type (Literal['list', 'object', 'id', 'query', 'queryid', 'qid', 'count'], default: 'list' ) –

  Type de retour de la fonction. Valeurs possibles:

  • list ou object: La liste des objets Territory.
  • id: La liste des identifiants des objets.
  • query: La requète des objets.
  • queryid ou qid: La requète des identifiants des objects.
  • count: Nombre d'éléments correspondants.
• cache_properties (list[str], default: [] ) –

  Liste de propriétés à mettre en cache.

• verbose (bool, default: False ) –

  Si True, est bavard.

Returns:

• list[Territory] –

  Liste des territoires recherchés.

• list[int] –

  List des identifiants des territoires recherchés.

• int –

  Nombre de territoires correspondants aux arguments donnés.

• Select –

  Requète des objets.

Raises:

• ValueError –

  Paramètres invalides.

get_actors

get_actors(
    property_name: str | None = None,
    property_value: str | None = None,
    /,
    *,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["list", "object"] = "list",
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Sequence[Actor]

get_actors(
    property_name: str | None = None,
    property_value: str | None = None,
    /,
    *,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["id"],
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Sequence[int]

get_actors(
    property_name: str | None = None,
    property_value: str | None = None,
    /,
    *,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["count"],
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> int

get_actors(
    property_name: str | None = None,
    property_value: str | None = None,
    /,
    *,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["query"],
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Select[tuple[Actor]]

get_actors(
    property_name: str | None = None,
    property_value: str | None = None,
    /,
    *,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["queryid", "qid"],
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Select[tuple[int]]

get_actors(
    property_name=None,
    property_value=None,
    /,
    *,
    match_pattern=False,
    ignore_case=False,
    ignore_accent=False,
    filter_ids=None,
    return_type="list",
    cache_properties=[],
    verbose=False,
)

Trouve plusieurs acteurs.

Examples:

>>> actors = get_actors("Name", "Michel")
>>> all_actors = get_actors()

Parameters:

• *args –

  Duo d'arguments "NomDeProprieté", "Valeur"

• match_pattern (bool, default: False ) –

  Si True, la valeur est recherchée par motif plutôt que par valeur exacte, via l'instruction LIKE de SQL Se référer à la documentation de postgresql pour plus de détails. Les charactères spéciaux % et _ ne sont pas échappés.

• ignore_case (bool, default: False ) –

  Recherche ignorant la casse.

• ignore_accent (bool, default: False ) –

  Recherche ignorant l'accentuation.

• filter_ids (Iterable[int] | Select[tuple[int]] | None, default: None ) –

  Filtre d'identifiants des objets.

• return_type (Literal['list', 'object', 'id', 'query', 'queryid', 'qid', 'count'], default: 'list' ) –

  Type de retour de la fonction. Valeurs possibles:

  • list ou object: La liste des objets Actor.
  • id: La liste des identifiants des objets.
  • query: La requète des objets.
  • queryid ou qid: La requète des identifiants des objects.
  • count: Nombre d'éléments correspondants.
• cache_properties (list[str], default: [] ) –

  Liste de propriétés à mettre en cache.

• verbose (bool, default: False ) –

  Si True, est bavard.

Returns:

• list[Actor] –

  Liste des acteurs recherchés.

• list[int] –

  List des identifiants des acteurs recherchés.

• int –

  Nombre d'acteurs correspondants aux arguments donnés.

• Select –

  Requète des acteurs ou des identifiants.

Raises:

• ValueError –

  Paramètres invalides.

get_products

get_products(
    property_name: str | None = None,
    property_value: str | None = None,
    /,
    *,
    nomenclature: str | None = None,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["list", "object"] = "list",
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Sequence[Product]

get_products(
    property_name: str | None = None,
    property_value: str | None = None,
    /,
    *,
    nomenclature: str | None = None,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["id"],
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Sequence[int]

get_products(
    property_name: str | None = None,
    property_value: str | None = None,
    /,
    *,
    nomenclature: str | None = None,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["count"],
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> int

get_products(
    property_name: str | None = None,
    property_value: str | None = None,
    /,
    *,
    nomenclature: str | None = None,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["query"],
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Select[tuple[Product]]

get_products(
    property_name: str | None = None,
    property_value: str | None = None,
    /,
    *,
    nomenclature: str | None = None,
    match_pattern: bool = False,
    ignore_case: bool = False,
    ignore_accent: bool = False,
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["queryid", "qid"],
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Select[tuple[int]]

get_products(
    property_name=None,
    property_value=None,
    /,
    *,
    nomenclature=None,
    match_pattern=False,
    ignore_case=False,
    ignore_accent=False,
    filter_ids=None,
    return_type="list",
    cache_properties=[],
    verbose=False,
)

Trouve plusieurs produits.

Parameters:

• *args –

  Duo d'arguments "NomDeProprieté", "Valeur"

• match_pattern (bool, default: False ) –

  Si True, la valeur est recherchée par motif plutôt que par valeur exacte, via l'instruction LIKE de SQL Se référer à la documentation de postgresql pour plus de détails. Les charactères spéciaux % et _ ne sont pas échappés.

• ignore_case (bool, default: False ) –

  Recherche ignorant la casse.

• ignore_accent (bool, default: False ) –

  Recherche ignorant l'accentuation.

• filter_ids (Iterable[int] | Select[tuple[int]] | None, default: None ) –

  Filtre d'identifiants des objets.

• return_type (Literal['list', 'object', 'id', 'query', 'queryid', 'qid', 'count'], default: 'list' ) –

  Type de retour de la fonction. Valeurs possibles:

  • list ou object: La liste des objets Product.
  • id: La liste des identifiants des objets.
  • query: La requète des objets.
  • queryid ou qid: La requète des identifiants des objects.
  • count: Nombre d'éléments correspondants.
• cache_properties (list[str], default: [] ) –

  Liste des propriétés à mettre en cache, en plus des noms et des codes.

• nomenclature (str | None, default: None ) –

  Nom de la nomenclature des produits recherchés.

• verbose (bool, default: False ) –

  Si True, est bavard.

Returns:

• list[Product] –

  Liste des produits recherchés.

• list[int] –

  List des identifiants des produits recherchés.

• int –

  Nombre de produits correspondants aux arguments donnés.

• Select –

  Requète des produits ou des identifiants.

Raises:

• ValueError –

  Paramètres invalides.

get_product_list

get_product_list(
    nomenclature: str,
    return_type: Literal["list", "object"] = "list",
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Sequence[Product]

get_product_list(
    nomenclature: str,
    return_type: Literal["id"],
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Sequence[int]

get_product_list(
    nomenclature: str,
    return_type: Literal["count"],
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> int

get_product_list(
    nomenclature: str,
    return_type: Literal["query"],
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Select[tuple[Product]]

get_product_list(
    nomenclature: str,
    return_type: Literal["queryid", "qid"],
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Select[tuple[int]]

get_product_list(
    nomenclature,
    return_type="list",
    cache_properties=[],
    verbose=False,
)

Trouve des produits par nomenclature.

Parameters:

• nomenclature (str) –

  La nomenclature des produits à rechercher.

• cache_properties (list[str], default: [] ) –

  Liste des propriétés à mettre en cache, en plus des noms et des codes.

• return_type (Literal['list', 'object', 'id', 'query', 'queryid', 'qid', 'count'], default: 'list' ) –

  Type de retour de la fonction. Valeurs possibles:

  • list ou object: La liste des objets Product.
  • id: La liste des identifiants des objets.
  • query: La requète des objets.
  • queryid ou qid: La requète des identifiants des objects.
  • count: Nombre d'éléments correspondants.
• verbose (bool, default: False ) –

  Si True, décrit le déroulement de la fonction dans le shell.

Returns:

• list[Product] –

  Liste des produits recherchés.

• list[int] –

  List des identifiants des produits recherchés.

• int –

  Nombre de produits correspondants aux arguments donnés.

• Select –

  Requète des produits ou des identifiants.

get_gateflows

get_gateflows(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    flowtype: Literal[
        "input",
        "output",
        "consumption",
        "production",
        "extraction",
        "emission",
        None,
    ] = None,
    product: (
        Product
        | Sequence[Product]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
        | None
    ) = None,
    *,
    include_parent_products: bool = False,
    include_children_products: bool = True,
    date_point: str | date | None = None,
    date_start: str | date | None = None,
    date_end: str | date | None = None,
    year: str | int | None = None,
    month: str | int | None = None,
    source_ref: str | None = None,
    filter_by: list[tuple[str, str]] = [],
    combine_targets: bool = True,
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["list", "object"] = "list",
    cache_properties: list[str] = [],
    verbose: bool = False
) -> Sequence[Gateflow]

get_gateflows(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    flowtype: Literal[
        "input",
        "output",
        "consumption",
        "production",
        "extraction",
        "emission",
        None,
    ] = None,
    product: (
        Product
        | Sequence[Product]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
        | None
    ) = None,
    *,
    include_parent_products: bool = False,
    include_children_products: bool = True,
    date_point: str | date | None = None,
    date_start: str | date | None = None,
    date_end: str | date | None = None,
    year: str | int | None = None,
    month: str | int | None = None,
    source_ref: str | None = None,
    filter_by: list[tuple[str, str]] = [],
    combine_targets: bool = True,
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["id"],
    cache_properties: list[str] = [],
    verbose: bool = False
) -> Sequence[int]

get_gateflows(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    flowtype: Literal[
        "input",
        "output",
        "consumption",
        "production",
        "extraction",
        "emission",
        None,
    ] = None,
    product: (
        Product
        | Sequence[Product]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
        | None
    ) = None,
    *,
    include_parent_products: bool = False,
    include_children_products: bool = True,
    date_point: str | date | None = None,
    date_start: str | date | None = None,
    date_end: str | date | None = None,
    year: str | int | None = None,
    month: str | int | None = None,
    source_ref: str | None = None,
    filter_by: list[tuple[str, str]] = [],
    combine_targets: bool = True,
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["count"],
    cache_properties: list[str] = [],
    verbose: bool = False
) -> int

get_gateflows(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    flowtype: Literal[
        "input",
        "output",
        "consumption",
        "production",
        "extraction",
        "emission",
        None,
    ] = None,
    product: (
        Product
        | Sequence[Product]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
        | None
    ) = None,
    *,
    include_parent_products: bool = False,
    include_children_products: bool = True,
    date_point: str | date | None = None,
    date_start: str | date | None = None,
    date_end: str | date | None = None,
    year: str | int | None = None,
    month: str | int | None = None,
    source_ref: str | None = None,
    filter_by: list[tuple[str, str]] = [],
    combine_targets: bool = True,
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["query"],
    cache_properties: list[str] = [],
    verbose: bool = False
) -> Select[tuple[Gateflow]]

get_gateflows(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    flowtype: Literal[
        "input",
        "output",
        "consumption",
        "production",
        "extraction",
        "emission",
        None,
    ] = None,
    product: (
        Product
        | Sequence[Product]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
        | None
    ) = None,
    *,
    include_parent_products: bool = False,
    include_children_products: bool = True,
    date_point: str | date | None = None,
    date_start: str | date | None = None,
    date_end: str | date | None = None,
    year: str | int | None = None,
    month: str | int | None = None,
    source_ref: str | None = None,
    filter_by: list[tuple[str, str]] = [],
    combine_targets: bool = True,
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["queryid", "qid"],
    cache_properties: list[str] = [],
    verbose: bool = False
) -> Select[tuple[int]]

get_gateflows(
    target=[],
    flowtype=None,
    product=None,
    *,
    include_parent_products=False,
    include_children_products=True,
    date_point=None,
    date_start=None,
    date_end=None,
    year=None,
    month=None,
    source_ref=None,
    filter_by=[],
    combine_targets=True,
    filter_ids=None,
    return_type="list",
    cache_properties=[],
    verbose=False
)

Trouve des flux de porte (Gateflow).

Parameters:

• target (Iterable[Territory | Actor] | Territory | Actor, default: [] ) –

  Le territoire et/ou l'acteur lié(s) aux flux.

• flowtype (Literal['input', 'output', 'consumption', 'production', 'extraction', 'emission', None], default: None ) –

  Type de flux, peut être input, output, consumption, production, extraction ou emission.

• product (Product | Sequence[Product] | int | Sequence[int] | Select[tuple[int]] | Sequence[Select[tuple[int]]] | None, default: None ) –

  Le produit lié aux flux.

• include_parent_products (bool, default: False ) –

  Effectue une recherche ascendante sur le produit, recherche le produit et ses parents.

• include_children_products (bool, default: True ) –

  Effectue une recherche descendante sur le produit, recherche le produit et ses enfants.

• date_point (str | date | None, default: None ) –

  La date ponctuelle des flux.

• date_start (str | date | None, default: None ) –

  La date de départ des flux.

• date_end (str | date | None, default: None ) –

  La date de fin des flux.

• year (str | int | None, default: None ) –

  L'année des flux.

• month (str | int | None, default: None ) –

  Le mois des flux.

• source_ref (str | None, default: None ) –

  La source de référence des flux.

• filter_by (list[tuple[str, str]], default: [] ) –

  Liste de propriétés supplémentaires pour le filtrage des flux (ex. [("Label", "Bio")]).

• combine_targets (bool, default: True ) –

  Si True (default), associe les target en utilisant un ET binaire, sinon associe les target en utilisant un OU binaire.

• filter_ids (Iterable[int] | Select[tuple[int]] | None, default: None ) –

  Filtre d'identifiants des objets.

• cache_properties (list[str], default: [] ) –

  Liste des propriétés à mettre en cache.

• return_type (Literal['list', 'object', 'id', 'query', 'queryid', 'qid', 'count'], default: 'list' ) –

  Type de retour de la fonction. Valeurs possibles:

  • list ou object: La liste des flux Gateflow.
  • id: La liste des identifiants des flux.
  • query: La requète des flux.
  • queryid ou qid: La requète des identifiants des flux.
  • count: Nombre de flux correspondants.
• verbose (bool, default: False ) –

  Si True, décrit le déroulement de la fonction dans le shell.

Returns:

• list[Gateflow] –

  Liste des flux recherchés.

• list[int] –

  Liste des identifiants des flux recherchés.

• int –

  Nombre de flux correspondants aux arguments donnés.

• Select –

  Requète des flux ou des identifiants.

get_inputs

get_inputs(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["list", "object"] = "list",
    **kwargs: Any
) -> Sequence[Gateflow]

get_inputs(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["id"],
    **kwargs: Any
) -> Sequence[int]

get_inputs(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["count"],
    **kwargs: Any
) -> int

get_inputs(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["query"],
    **kwargs: Any
) -> Select[tuple[Gateflow]]

get_inputs(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["queryid", "qid"],
    **kwargs: Any
) -> Select[tuple[int]]

get_inputs(target=[], *, return_type='list', **kwargs)

Retourne les flux d'entrée de target.

Fonction wrapper de get_gateflows.

get_outputs

get_outputs(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["list", "object"] = "list",
    **kwargs: Any
) -> Sequence[Gateflow]

get_outputs(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["id"],
    **kwargs: Any
) -> Sequence[int]

get_outputs(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["count"],
    **kwargs: Any
) -> int

get_outputs(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["query"],
    **kwargs: Any
) -> Select[tuple[Gateflow]]

get_outputs(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["queryid", "qid"],
    **kwargs: Any
) -> Select[tuple[int]]

get_outputs(target=[], *, return_type='list', **kwargs)

Retourne les flux de sortie de target.

Fonction wrapper de get_gateflows.

get_consumptions

get_consumptions(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["list", "object"] = "list",
    **kwargs: Any
) -> Sequence[Gateflow]

get_consumptions(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["id"],
    **kwargs: Any
) -> Sequence[int]

get_consumptions(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["count"],
    **kwargs: Any
) -> int

get_consumptions(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["query"],
    **kwargs: Any
) -> Select[tuple[Gateflow]]

get_consumptions(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["queryid", "qid"],
    **kwargs: Any
) -> Select[tuple[int]]

get_consumptions(
    target=[], *, return_type="list", **kwargs
)

Retourne les flux de consommation de target.

Fonction wrapper de get_gateflows.

get_productions

get_productions(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["list", "object"] = "list",
    **kwargs: Any
) -> Sequence[Gateflow]

get_productions(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["id"],
    **kwargs: Any
) -> Sequence[int]

get_productions(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["count"],
    **kwargs: Any
) -> int

get_productions(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["query"],
    **kwargs: Any
) -> Select[tuple[Gateflow]]

get_productions(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["queryid", "qid"],
    **kwargs: Any
) -> Select[tuple[int]]

get_productions(target=[], *, return_type='list', **kwargs)

Retourne les flux de production de target.

Fonction wrapper de get_gateflows.

get_extractions

get_extractions(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["list", "object"] = "list",
    **kwargs: Any
) -> Sequence[Gateflow]

get_extractions(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["id"],
    **kwargs: Any
) -> Sequence[int]

get_extractions(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["count"],
    **kwargs: Any
) -> int

get_extractions(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["query"],
    **kwargs: Any
) -> Select[tuple[Gateflow]]

get_extractions(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["queryid", "qid"],
    **kwargs: Any
) -> Select[tuple[int]]

get_extractions(target=[], *, return_type='list', **kwargs)

Retourne les flux d'extraction de target.

Fonction wrapper de get_gateflows.

get_emissions

get_emissions(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["list", "object"] = "list",
    **kwargs: Any
) -> Sequence[Gateflow]

get_emissions(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["id"],
    **kwargs: Any
) -> Sequence[int]

get_emissions(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["count"],
    **kwargs: Any
) -> int

get_emissions(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["query"],
    **kwargs: Any
) -> Select[tuple[Gateflow]]

get_emissions(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    *,
    return_type: Literal["queryid", "qid"],
    **kwargs: Any
) -> Select[tuple[int]]

get_emissions(target=[], *, return_type='list', **kwargs)

Retourne les flux d'émission de target.

Fonction wrapper de get_gateflows.

get_pathflows

get_pathflows(
    target: T | None = None,
    direction: Literal[
        "import", "export", "internal", "all", None
    ] = None,
    *,
    related_target: T | None = None,
    exclude_related_target: T | None = None,
    product: (
        Product
        | Sequence[Product]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
        | None
    ) = None,
    include_parent_products: bool = False,
    include_children_products: bool = True,
    date_point: date | str | None = None,
    date_start: date | str | None = None,
    date_end: date | str | None = None,
    year: str | int | None = None,
    month: str | int | None = None,
    source_ref: str | None = None,
    filter_by: list[tuple[str, str]] = [],
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["list", "object"] = "list",
    cache_properties: list[str] = []
) -> Sequence[Pathflow]

get_pathflows(
    target: T | None = None,
    direction: Literal[
        "import", "export", "internal", "all", None
    ] = None,
    *,
    related_target: T | None = None,
    exclude_related_target: T | None = None,
    product: (
        Product
        | Sequence[Product]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
        | None
    ) = None,
    include_parent_products: bool = False,
    include_children_products: bool = True,
    date_point: date | str | None = None,
    date_start: date | str | None = None,
    date_end: date | str | None = None,
    year: str | int | None = None,
    month: str | int | None = None,
    source_ref: str | None = None,
    filter_by: list[tuple[str, str]] = [],
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["id"],
    cache_properties: list[str] = []
) -> Sequence[int]

get_pathflows(
    target: T | None = None,
    direction: Literal[
        "import", "export", "internal", "all", None
    ] = None,
    *,
    related_target: T | None = None,
    exclude_related_target: T | None = None,
    product: (
        Product
        | Sequence[Product]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
        | None
    ) = None,
    include_parent_products: bool = False,
    include_children_products: bool = True,
    date_point: date | str | None = None,
    date_start: date | str | None = None,
    date_end: date | str | None = None,
    year: str | int | None = None,
    month: str | int | None = None,
    source_ref: str | None = None,
    filter_by: list[tuple[str, str]] = [],
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["count"],
    cache_properties: list[str] = []
) -> int

get_pathflows(
    target: T | None = None,
    direction: Literal[
        "import", "export", "internal", "all", None
    ] = None,
    *,
    related_target: T | None = None,
    exclude_related_target: T | None = None,
    product: (
        Product
        | Sequence[Product]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
        | None
    ) = None,
    include_parent_products: bool = False,
    include_children_products: bool = True,
    date_point: date | str | None = None,
    date_start: date | str | None = None,
    date_end: date | str | None = None,
    year: str | int | None = None,
    month: str | int | None = None,
    source_ref: str | None = None,
    filter_by: list[tuple[str, str]] = [],
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["query"],
    cache_properties: list[str] = []
) -> Select[tuple[Pathflow]]

get_pathflows(
    target: T | None = None,
    direction: Literal[
        "import", "export", "internal", "all", None
    ] = None,
    *,
    related_target: T | None = None,
    exclude_related_target: T | None = None,
    product: (
        Product
        | Sequence[Product]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
        | None
    ) = None,
    include_parent_products: bool = False,
    include_children_products: bool = True,
    date_point: date | str | None = None,
    date_start: date | str | None = None,
    date_end: date | str | None = None,
    year: str | int | None = None,
    month: str | int | None = None,
    source_ref: str | None = None,
    filter_by: list[tuple[str, str]] = [],
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["queryid", "qid"],
    cache_properties: list[str] = []
) -> Select[tuple[int]]

get_pathflows(
    target=None,
    direction=None,
    *,
    related_target=None,
    exclude_related_target=None,
    product=None,
    include_parent_products=False,
    include_children_products=True,
    date_point=None,
    date_start=None,
    date_end=None,
    year=None,
    month=None,
    source_ref=None,
    filter_by=[],
    filter_ids=None,
    return_type="list",
    cache_properties=[]
)

Trouve des flux de chemin (Pathflow).

Parameters:

• target (T | None, default: None ) –

  Le territoire ou l'acteur lié aux flux.

• direction (Literal['import', 'export', 'internal', 'all', None], default: None ) –

  La direction des flux, peut être import, export, internal ou all.

• related_target (T | None, default: None ) –

  Territoire ou acteur complémentaire spécifique (origine pour les imports, destination pour les exports)

• exclude_related_target (T | None, default: None ) –

  Territoire ou acteur complémentaire à exclure (origine pour les imports, destination pour les exports).

• product (Product | Sequence[Product] | int | Sequence[int] | Select[tuple[int]] | Sequence[Select[tuple[int]]] | None, default: None ) –

  Le produit lié aux flux.

• include_parent_products (bool, default: False ) –

  Effectue une recherche ascendante sur le produit (recherche le produit et ses parents).

• include_children_products (bool, default: True ) –

  Effectue une recherche descendante sur le produit (recherche le produit et ses enfants).

• date_point (date | str | None, default: None ) –

  La date ponctuelle des flux.

• date_start (date | str | None, default: None ) –

  La date de départ des flux.

• date_end (date | str | None, default: None ) –

  La date de fin des flux.

• year (str | int | None, default: None ) –

  L'année des flux.

• month (str | int | None, default: None ) –

  Le mois des flux.

• source_ref (str | None, default: None ) –

  La source de référence des flux.

• filter_by (list[tuple[str, str]], default: [] ) –

  Liste de propriétés supplémentaires pour le filtrage des flux (ex. [("Label", "Bio")]).

• filter_ids (Iterable[int] | Select[tuple[int]] | None, default: None ) –

  Filtre d'identifiants des objets.

• return_type (Literal['list', 'object', 'id', 'query', 'queryid', 'qid', 'count'], default: 'list' ) –

  Type de retour de la fonction. Valeurs possibles:

  • list ou object: La liste des flux Pathflow.
  • id: La liste des identifiants des flux.
  • query: La requète des flux.
  • queryid ou qid: La requète des identifiants des flux.
  • count: Nombre de flux correspondants.
• cache_properties (list[str], default: [] ) –

  Liste des propriétés à mettre en cache.

Returns:

• list[Pathflow] –

  Liste des flux recherchés.

• list[int] –

  Liste des identifiants des flux recherchés.

• int –

  Nombre de flux correspondants aux arguments donnés.

• Select –

  Requète des flux ou des identifiants.

get_imports

get_imports(
    target: T | None = None,
    *,
    return_type: Literal["list", "object"] = "list",
    **kwargs: Any
) -> Sequence[Pathflow]

get_imports(
    target: T | None = None,
    *,
    return_type: Literal["id"],
    **kwargs: Any
) -> Sequence[int]

get_imports(
    target: T | None = None,
    *,
    return_type: Literal["count"],
    **kwargs: Any
) -> int

get_imports(
    target: T | None = None,
    *,
    return_type: Literal["query"],
    **kwargs: Any
) -> Select[tuple[Pathflow]]

get_imports(
    target: T | None = None,
    *,
    return_type: Literal["queryid", "qid"],
    **kwargs: Any
) -> Select[tuple[int]]

get_imports(target=None, *, return_type='list', **kwargs)

Retourne les flux importés: ceux dont l'origine est à l'extérieur de target et la destination est à l'intérieur.

Fonction wrapper de get_pathflows.

get_exports

get_exports(
    target: T | None = None,
    *,
    return_type: Literal["list", "object"] = "list",
    **kwargs: Any
) -> Sequence[Pathflow]

get_exports(
    target: T | None = None,
    *,
    return_type: Literal["id"],
    **kwargs: Any
) -> Sequence[int]

get_exports(
    target: T | None = None,
    *,
    return_type: Literal["count"],
    **kwargs: Any
) -> int

get_exports(
    target: T | None = None,
    *,
    return_type: Literal["query"],
    **kwargs: Any
) -> Select[tuple[Pathflow]]

get_exports(
    target: T | None = None,
    *,
    return_type: Literal["queryid", "qid"],
    **kwargs: Any
) -> Select[tuple[int]]

get_exports(target=None, *, return_type='list', **kwargs)

Retourne les flux exportés: ceux dont l'origine est à l'intérieur de target et la destination est à l'extérieur.

Fonction wrapper de get_pathflows.

get_internals

get_internals(
    target: T | None = None,
    *,
    return_type: Literal["list", "object"] = "list",
    **kwargs: Any
) -> Sequence[Pathflow]

get_internals(
    target: T | None = None,
    *,
    return_type: Literal["id"],
    **kwargs: Any
) -> Sequence[int]

get_internals(
    target: T | None = None,
    *,
    return_type: Literal["count"],
    **kwargs: Any
) -> int

get_internals(
    target: T | None = None,
    *,
    return_type: Literal["query"],
    **kwargs: Any
) -> Select[tuple[Pathflow]]

get_internals(
    target: T | None = None,
    *,
    return_type: Literal["queryid", "qid"],
    **kwargs: Any
) -> Select[tuple[int]]

get_internals(target=None, *, return_type='list', **kwargs)

Retourne les flux internes: ceux dont l'origine et la destination sont dans target.

Fonction wrapper de get_pathflows.

get_stocks

get_stocks(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    product: (
        Product
        | Sequence[Product]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
        | None
    ) = None,
    *,
    include_parent_products: bool = False,
    include_children_products: bool = True,
    date_point: str | date | None = None,
    date_start: str | date | None = None,
    date_end: str | date | None = None,
    year: str | int | None = None,
    month: str | int | None = None,
    source_ref: str | None = None,
    filter_by: list[tuple[str, str]] = [],
    combine_targets: bool = True,
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["list", "object"] = "list",
    cache_properties: list[str] = [],
    verbose: bool = False
) -> Sequence[Stock]

get_stocks(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    product: (
        Product
        | Sequence[Product]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
        | None
    ) = None,
    *,
    include_parent_products: bool = False,
    include_children_products: bool = True,
    date_point: str | date | None = None,
    date_start: str | date | None = None,
    date_end: str | date | None = None,
    year: str | int | None = None,
    month: str | int | None = None,
    source_ref: str | None = None,
    filter_by: list[tuple[str, str]] = [],
    combine_targets: bool = True,
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["id"],
    cache_properties: list[str] = [],
    verbose: bool = False
) -> Sequence[int]

get_stocks(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    product: (
        Product
        | Sequence[Product]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
        | None
    ) = None,
    *,
    include_parent_products: bool = False,
    include_children_products: bool = True,
    date_point: str | date | None = None,
    date_start: str | date | None = None,
    date_end: str | date | None = None,
    year: str | int | None = None,
    month: str | int | None = None,
    source_ref: str | None = None,
    filter_by: list[tuple[str, str]] = [],
    combine_targets: bool = True,
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["count"],
    cache_properties: list[str] = [],
    verbose: bool = False
) -> int

get_stocks(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    product: (
        Product
        | Sequence[Product]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
        | None
    ) = None,
    *,
    include_parent_products: bool = False,
    include_children_products: bool = True,
    date_point: str | date | None = None,
    date_start: str | date | None = None,
    date_end: str | date | None = None,
    year: str | int | None = None,
    month: str | int | None = None,
    source_ref: str | None = None,
    filter_by: list[tuple[str, str]] = [],
    combine_targets: bool = True,
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["query"],
    cache_properties: list[str] = [],
    verbose: bool = False
) -> Select[tuple[Stock]]

get_stocks(
    target: (
        Iterable[Territory | Actor] | Territory | Actor
    ) = [],
    product: (
        Product
        | Sequence[Product]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
        | None
    ) = None,
    *,
    include_parent_products: bool = False,
    include_children_products: bool = True,
    date_point: str | date | None = None,
    date_start: str | date | None = None,
    date_end: str | date | None = None,
    year: str | int | None = None,
    month: str | int | None = None,
    source_ref: str | None = None,
    filter_by: list[tuple[str, str]] = [],
    combine_targets: bool = True,
    filter_ids: (
        Iterable[int] | Select[tuple[int]] | None
    ) = None,
    return_type: Literal["queryid", "qid"],
    cache_properties: list[str] = [],
    verbose: bool = False
) -> Select[tuple[int]]

get_stocks(
    target=[],
    product=None,
    *,
    include_parent_products=False,
    include_children_products=True,
    date_point=None,
    date_start=None,
    date_end=None,
    year=None,
    month=None,
    source_ref=None,
    filter_by=[],
    combine_targets=True,
    filter_ids=None,
    return_type="list",
    cache_properties=[],
    verbose=False
)

Trouve des stocks (Stock).

Parameters:

• target (Iterable[Territory | Actor] | Territory | Actor, default: [] ) –

  Le territoire et/ou l'acteur lié(s) aux stocks.

• product (Product | Sequence[Product] | int | Sequence[int] | Select[tuple[int]] | Sequence[Select[tuple[int]]] | None, default: None ) –

  Le produit lié aux stocks.

• include_parent_products (bool, default: False ) –

  Effectue une recherche ascendante sur le produit, recherche le produit et ses parents.

• include_children_products (bool, default: True ) –

  Effectue une recherche descendante sur le produit, recherche le produit et ses enfants.

• date_point (str | date | None, default: None ) –

  La date ponctuelle des stocks.

• date_start (str | date | None, default: None ) –

  La date de départ des stocks.

• date_end (str | date | None, default: None ) –

  La date de fin des stocks.

• year (str | int | None, default: None ) –

  L'année des stocks.

• month (str | int | None, default: None ) –

  Le mois des stocks.

• source_ref (str | None, default: None ) –

  La source de référence des stocks.

• filter_by (list[tuple[str, str]], default: [] ) –

  Liste de propriétés supplémentaires pour le filtrage des stocks (ex. [("Label", "Bio")]).

• combine_targets (bool, default: True ) –

  Si True (default), associe les target en utilisant un ET binaire, sinon associe les target en utilisant un OU binaire.

• filter_ids (Iterable[int] | Select[tuple[int]] | None, default: None ) –

  Filtre d'identifiants des objets.

• cache_properties (list[str], default: [] ) –

  Liste des propriétés à mettre en cache.

• return_type (Literal['list', 'object', 'id', 'query', 'queryid', 'qid', 'count'], default: 'list' ) –

  Type de retour de la fonction. Valeurs possibles:

  • list ou object: La liste des stocks Stock.
  • id: La liste des identifiants des stocks.
  • query: La requète des stocks.
  • queryid ou qid: La requète des identifiants des stocks.
  • count: Nombre de stocks correspondants.
• verbose (bool, default: False ) –

  Si True, décrit le déroulement de la fonction dans le shell.

Returns:

• list[Stock] –

  Liste des stocks recherchés.

• list[int] –

  Liste des identifiants des stocks recherchés.

• int –

  Nombre de stocks correspondants aux arguments donnés.

• Select –

  Requète des stocks ou des identifiants.

Récupérer une liste d'objets contenus dans un autre

get_territories_in

get_territories_in(
    territory: (
        Territory
        | Sequence[Territory]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["list", "object"] = "list",
    scale: str | None = None,
    include_self: bool = True,
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Sequence[Territory]

get_territories_in(
    territory: (
        Territory
        | Sequence[Territory]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["id"],
    scale: str | None = None,
    include_self: bool = True,
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Sequence[int]

get_territories_in(
    territory: (
        Territory
        | Sequence[Territory]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["count"],
    scale: str | None = None,
    include_self: bool = True,
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> int

get_territories_in(
    territory: (
        Territory
        | Sequence[Territory]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["query"],
    scale: str | None = None,
    include_self: bool = True,
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Select[tuple[Territory]]

get_territories_in(
    territory: (
        Territory
        | Sequence[Territory]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["queryid", "qid"],
    scale: str | None = None,
    include_self: bool = True,
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Select[tuple[int]]

get_territories_in(
    territory,
    return_type="list",
    scale=None,
    include_self=True,
    cache_properties=[],
    verbose=False,
)

Trouve des territoires contenus dans un territoire.

Parameters:

• territory (Territory | Sequence[Territory] | int | Sequence[int] | Select[tuple[int]] | Sequence[Select[tuple[int]]]) –

  L'object Territory contenant les territoires voulus.

• scale (str | None, default: None ) –

  Échelle de recherche.

• include_self (bool, default: True ) –

  Inclure ou non l'élément passé en paramètre.

• cache_properties (list[str], default: [] ) –

  Liste des propriétés à mettre en cache.

• return_type (Literal['list', 'object', 'id', 'query', 'queryid', 'qid', 'count'], default: 'list' ) –

  Type de retour de la fonction. Valeurs possibles:

  • list ou object: La liste des objets correspondants.
  • id: La liste des identifiants des objets.
  • query: La requète des objets.
  • queryid ou qid: La requète des identifiants des objects.
  • count: Nombre d'éléments correspondants.
• verbose (bool, default: False ) –

  Si True, est bavard.

Returns:

• list[Territory] –

  Liste des objets contenus dans l'objet passé en paramètre.

• list[int] –

  Liste des identifiants des objets contenus dans l'objet passé en paramètre.

• int –

  Nombre d'objets contenus dans l'objet passé en paramètre.

• Select –

  Requète des territoires ou des identifiants.

get_actors_in

get_actors_in(
    mtobject: (
        Actor
        | Sequence[Actor]
        | Territory
        | Sequence[Territory]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["list", "object"] = "list",
    scale: str | None = None,
    include_self: bool = True,
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Sequence[Actor]

get_actors_in(
    mtobject: (
        Actor
        | Sequence[Actor]
        | Territory
        | Sequence[Territory]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["id"],
    scale: str | None = None,
    include_self: bool = True,
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Sequence[int]

get_actors_in(
    mtobject: (
        Actor
        | Sequence[Actor]
        | Territory
        | Sequence[Territory]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["count"],
    scale: str | None = None,
    include_self: bool = True,
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> int

get_actors_in(
    mtobject: (
        Actor
        | Sequence[Actor]
        | Territory
        | Sequence[Territory]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["query"],
    scale: str | None = None,
    include_self: bool = True,
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Select[tuple[Actor]]

get_actors_in(
    mtobject: (
        Actor
        | Sequence[Actor]
        | Territory
        | Sequence[Territory]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["queryid", "qid"],
    scale: str | None = None,
    include_self: bool = True,
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Select[tuple[int]]

get_actors_in(
    mtobject,
    return_type="list",
    scale=None,
    include_self=True,
    cache_properties=[],
    verbose=False,
)

Trouve des acteurs contenus dans un territoire ou dans un autre acteur.

Parameters:

• actor –

  L'object Actor ou Territory contenant des acteurs.

• scale (str | None, default: None ) –

  Échelle de recherche.

• include_self (bool, default: True ) –

  Inclure ou non l'élément passé en paramètre.

• cache_properties (list[str], default: [] ) –

  Liste des propriétés à mettre en cache.

• return_type (Literal['list', 'object', 'id', 'query', 'queryid', 'qid', 'count'], default: 'list' ) –

  Type de retour de la fonction. Valeurs possibles:

  • list ou object: La liste des objets correspondants.
  • id: La liste des identifiants des objets.
  • query: La requète des objets.
  • queryid ou qid: La requète des identifiants des objects.
  • count: Nombre d'éléments correspondants.
• verbose (bool, default: False ) –

  Si True, est bavard.

Returns:

• list[MTobject] –

  Liste des objets contenus dans l'objet passé en paramètre.

• list[int] –

  List des identifiants des objets contenus dans l'objet passé en paramètre.

• int –

  Nombre d'objets contenus dans l'objet passé en paramètre.

• Select –

  Requète des objets.

Raises:

• TypeError –

  Type de l'object non supporté.

get_products_in

get_products_in(
    product: (
        Product
        | Sequence[Product]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["list", "object"] = "list",
    include_self: bool = True,
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Sequence[Product]

get_products_in(
    product: (
        Product
        | Sequence[Product]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["id"],
    include_self: bool = True,
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Sequence[int]

get_products_in(
    product: (
        Product
        | Sequence[Product]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["count"],
    include_self: bool = True,
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> int

get_products_in(
    product: (
        Product
        | Sequence[Product]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["query"],
    include_self: bool = True,
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Select[tuple[Product]]

get_products_in(
    product: (
        Product
        | Sequence[Product]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["queryid", "qid"],
    include_self: bool = True,
    cache_properties: list[str] = [],
    verbose: bool = False,
) -> Select[tuple[int]]

get_products_in(
    product,
    return_type="list",
    include_self=True,
    cache_properties=[],
    verbose=False,
)

Trouve des produits inclus dans le produit product.

Parameters:

• product (Product | Sequence[Product] | int | Sequence[int] | Select[tuple[int]] | Sequence[Select[tuple[int]]]) –

  L'object Product contenant des produits.

• include_self (bool, default: True ) –

  Inclure ou non l'élément passé en paramètre.

• cache_properties (list[str], default: [] ) –

  Liste des propriétés à mettre en cache, en plus des noms et des codes.

• return_type (Literal['list', 'object', 'id', 'query', 'queryid', 'qid', 'count'], default: 'list' ) –

  Type de retour de la fonction. Valeurs possibles:

  • list ou object: La liste des objets correspondants.
  • id: La liste des identifiants des objets.
  • query: La requète des objets.
  • queryid ou qid: La requète des identifiants des objects.
  • count: Nombre d'éléments correspondants.
• verbose (bool, default: False ) –

  Si True, est bavard.

Returns:

• list[Product] –

  Liste des objets contenus dans l'objet passé en paramètre.

• list[int] –

  List des identifiants des objets contenus dans l'objet passé en paramètre.

• int –

  Nombre d'objets contenus dans l'objet passé en paramètre.

• Select –

  Requète des objets.

Récupérer une liste d'objets en contenant un autre

get_territories_on

get_territories_on(
    territory: (
        Territory
        | Sequence[Territory]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["list", "object"] = "list",
    scale: str | None = None,
    include_self: bool = True,
    cache_properties: list[str] = [],
) -> Sequence[Territory]

get_territories_on(
    territory: (
        Territory
        | Sequence[Territory]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["id"],
    scale: str | None = None,
    include_self: bool = True,
    cache_properties: list[str] = [],
) -> Sequence[int]

get_territories_on(
    territory: (
        Territory
        | Sequence[Territory]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["count"],
    scale: str | None = None,
    include_self: bool = True,
    cache_properties: list[str] = [],
) -> int

get_territories_on(
    territory: (
        Territory
        | Sequence[Territory]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["query"],
    scale: str | None = None,
    include_self: bool = True,
    cache_properties: list[str] = [],
) -> Select[tuple[Territory]]

get_territories_on(
    territory: (
        Territory
        | Sequence[Territory]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["queryid", "qid"],
    scale: str | None = None,
    include_self: bool = True,
    cache_properties: list[str] = [],
) -> Select[tuple[int]]

get_territories_on(
    territory,
    return_type="list",
    scale=None,
    include_self=True,
    cache_properties=[],
)

Trouve des territoires contenant le territoire.

Parameters:

• territory (Territory | Sequence[Territory] | int | Sequence[int] | Select[tuple[int]] | Sequence[Select[tuple[int]]]) –

  L'object Territory contenu dans les territoires recherchés.

• scale (str | None, default: None ) –

  L'échelle des territoires recherchés (commune, pays...).

• include_self (bool, default: True ) –

  Si True, inclu le territoire d'origine dans le résultat.

• cache_properties (list[str], default: [] ) –

  Liste des propriétés à mettre en cache, en plus des noms et des codes.

• return_type (Literal['list', 'object', 'id', 'query', 'queryid', 'qid', 'count'], default: 'list' ) –

  Type de retour de la fonction. Valeurs possibles:

  • list ou object: La liste des objets correspondants.
  • id: La liste des identifiants des objets.
  • query: La requète des objets.
  • queryid ou qid: La requète des identifiants des objects.
  • count: Nombre d'éléments correspondants.

Returns:

• list[Territory] –

  Liste des objets contenus dans l'objet passé en paramètre.

• list[int] –

  Liste des identifiants des objets contenus dans l'objet passé en paramètre.

• int –

  Nombre d'objets contenus dans l'objet passé en paramètre.

• Select –

  Requète des territoires ou des identifiants.

get_actors_on

get_actors_on(
    actor: (
        Actor
        | Sequence[Actor]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["list", "object"] = "list",
    scale: str | None = None,
    include_self: bool = True,
    cache_properties: list[str] = [],
) -> Sequence[Actor]

get_actors_on(
    actor: (
        Actor
        | Sequence[Actor]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["id"],
    scale: str | None = None,
    include_self: bool = True,
    cache_properties: list[str] = [],
) -> Sequence[int]

get_actors_on(
    actor: (
        Actor
        | Sequence[Actor]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["count"],
    scale: str | None = None,
    include_self: bool = True,
    cache_properties: list[str] = [],
) -> int

get_actors_on(
    actor: (
        Actor
        | Sequence[Actor]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["query"],
    scale: str | None = None,
    include_self: bool = True,
    cache_properties: list[str] = [],
) -> Select[tuple[Actor]]

get_actors_on(
    actor: (
        Actor
        | Sequence[Actor]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["queryid", "qid"],
    scale: str | None = None,
    include_self: bool = True,
    cache_properties: list[str] = [],
) -> Select[tuple[int]]

get_actors_on(
    actor,
    return_type="list",
    scale=None,
    include_self=True,
    cache_properties=[],
)

Trouve des acteurs contenant un autre acteur.

Parameters:

• actor (Actor | Sequence[Actor] | int | Sequence[int] | Select[tuple[int]] | Sequence[Select[tuple[int]]]) –

  L'object Actor contenu dans les acteurs recherchés.

• scale (str | None, default: None ) –

  Échelle de recherche.

• include_self (bool, default: True ) –

  Inclure ou non l'élément passé en paramètre.

• cache_properties (list[str], default: [] ) –

  Liste des propriétés à mettre en cache, en plus des noms et des codes.

• return_type (Literal['list', 'object', 'id', 'query', 'queryid', 'qid', 'count'], default: 'list' ) –

  Type de retour de la fonction. Valeurs possibles:

  • list ou object: La liste des objets correspondants.
  • id: La liste des identifiants des objets.
  • query: La requète des objets.
  • queryid ou qid: La requète des identifiants des objects.
  • count: Nombre d'éléments correspondants.

Returns:

• list[Actor] –

  Liste des acteurs contenant l'acteur passé en paramètre.

• list[int] –

  List des identifiants des objets contenus dans l'objet passé en paramètre.

• int –

  Nombre d'objets contenus dans l'objet passé en paramètre.

• Select –

  Requète des objets.

get_products_on

get_products_on(
    product: (
        Product
        | Sequence[Product]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["list", "object"] = "list",
    include_self: bool = True,
    cache_properties: list[str] = [],
) -> Sequence[Product]

get_products_on(
    product: (
        Product
        | Sequence[Product]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["id"],
    include_self: bool = True,
    cache_properties: list[str] = [],
) -> Sequence[int]

get_products_on(
    product: (
        Product
        | Sequence[Product]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["count"],
    include_self: bool = True,
    cache_properties: list[str] = [],
) -> int

get_products_on(
    product: (
        Product
        | Sequence[Product]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["query"],
    include_self: bool = True,
    cache_properties: list[str] = [],
) -> Select[tuple[Product]]

get_products_on(
    product: (
        Product
        | Sequence[Product]
        | int
        | Sequence[int]
        | Select[tuple[int]]
        | Sequence[Select[tuple[int]]]
    ),
    return_type: Literal["queryid", "qid"],
    include_self: bool = True,
    cache_properties: list[str] = [],
) -> Select[tuple[int]]

get_products_on(
    product,
    return_type="list",
    include_self=True,
    cache_properties=[],
)

Trouve les produits incluant le produit product.

Parameters:

• product (Product | Sequence[Product] | int | Sequence[int] | Select[tuple[int]] | Sequence[Select[tuple[int]]]) –

  L'object Product inclus dans d'autres produits.

• include_self (bool, default: True ) –

  Inclure ou non l'élément passé en paramètre.

• cache_properties (list[str], default: [] ) –

  Liste des propriétés à mettre en cache, en plus des noms et des codes.

• return_type (Literal['list', 'object', 'id', 'query', 'queryid', 'qid', 'count'], default: 'list' ) –

  Type de retour de la fonction. Valeurs possibles:

  • list ou object: La liste des objets correspondants.
  • id: La liste des identifiants des objets.
  • query: La requète des objets.
  • queryid ou qid: La requète des identifiants des objects.
  • count: Nombre d'éléments correspondants.

Returns:

• list[Product] –

  Liste des objets contenant l'objet passé en paramètre.

• list[int] –

  List des identifiants des objets contenant l'objet passé en paramètre.

• int –

  Nombre d'objets contenant l'objet passé en paramètre.

• Select –

  Requète des objets ou des identifiants.

Autres fonctions

get_source_refs

get_source_refs(subinclude=True)

Renvoie toutes les sources des propriétés enregistrées.

Parameters:

• subinclude (bool, default: True ) –

  Inclut la décomposition des noms des sources selon ":" ex: source:nom1:nom2 => [source, source:nom1, source:nom1:nom2]

Returns:

• list[str] –

  La liste des sources des propriétés.

get_statistics

get_statistics()

Obtiens les statistiques de la base de donnée.

Returns:

• dict[str, list[str] | int] –

  Un dictionnaire contenant:

  • Le nombre d'objet de chaque type (Territory, Actor, ...).
  • La liste des nomenclatures de produit.
  • La liste des echelles de territoire, et la quantité de territoire leur appartenant.
  • La liste des sources de références.
  • La liste des noms de propriétés.

get_properties

get_properties(properties, filter_ids=None)

Charge et renvoie les propriétés correspondantes.

Parameters:

• properties (Iterable[str] | str | None) –

  Les noms des propriétés à charger. Si None, renvoie toutes les propriétés

• filter_ids (Select[tuple[int]] | list[int] | None, default: None ) –

  Si renseigné, charge uniquement les propriétés liées aux objets dont l'id correspond.

• return_type –

  Pas implémenté.

Returns:

• Sequence[Property] –

  La liste des propriétés correspondantes.

get_property_with_id

get_property_with_id(id)

Renvoie la propriété correspondant à l'identifiant.

Parameters:

• id (int) –

  L'identifiant de la propriété à renvoyer.

Returns:

• Property | None –

  La propriété correspondante ou None sinon.

get_distinct_property_values

get_distinct_property_values(prop_name)

Renvoie toutes les valeurs distinctes de propriétés avec un certain nom.

Parameters:

• prop_name (str) –

  Le nom de la propriétés dont on souhaite récupérer les valeurs. (Attention: ne peut pas avoir de précision)

Returns:

• Sequence[str | None] –

  La liste des valeurs distinctes.

is_loaded

is_loaded(source_ref)

Détermine si une source est chargée.

Parameters:

• source_ref (str) –

  Le nom de la source à vérifier.

Returns:

• bool –

  True si la source est déjà chargée dans la base de donnée, False sinon.

Supprimer des données

delete

delete(obj, verbose=False)

Supprime un objet de la base de donnée.

Parameters:

• obj (MTObject | Property) –

  L'objet à suprimer.

• verbose (bool, default: False ) –

  Si True, décrit le déroulement de la fonction dans le shell.

delete_source_ref

delete_source_ref(source_ref, exclude=[], recursive=False)

Supprime une source de référence.

Supprime une source de référence en supprimant les propriétés qui lui sont liées.

Parameters:

• source_ref (str) –

  La source de référence à supprimer.

• exclude (str | Iterable[str], default: [] ) –

  Liste de noms de propriétés à ne pas supprimer.

• recursive (bool, default: False ) –

  Si True, supprime également les sources enfants de source_ref.

reset

reset()

Ferme la session, supprime les tables de la base de donnée puis les recrée.

Charger des données

load

load(mapper, raise_error=True, verbose=False)

Charge un Mapper vers dans la base de donnée (créé ou met à jour le MTObject correspondant).

Parameters:

• mapper (Mapper) –

  L'objet Mapper contenant les informations de l'objet à charger.

• raise_error (bool, default: True ) –

  Si True, lève une erreur si l'objet n'a pas été chargé correctement.

• verbose (bool, default: False ) –

  Si True, décrit le déroulement de la fonction dans le shell.

Raises:

• MapperError –

  Les informations du mapper sont incorrectes.

• ValueError –

  Le type du mapper est inconnu.

progress

progress(steps_commit=1000, steps_print=20, commit=True)

Cette fonction permet de suivre l'importation de données, en affichant la progression dans le shell (affichage de +), et en commitant régulièrement les transactions (tous les steps_commit appel). La fonction permet d'éviter de saturer la mémoire sur de grand imports.

Parameters:

• steps_commit (int, default: 1000 ) –

  Le nombre d'appel entre chaque commit.

• steps_print (int, default: 20 ) –

  Le nombre d'appel entre chaque affichage dans le shell.

• commit (bool, default: True ) –

  Activer la fonction de commit (défault True)

Générateur de contexte

connect staticmethod

connect(autocommit=True, verbose=False, **kwargs)

Gestionnaire de contexte permettant une connexion à la base de donnée.

Parameters:

• autocommit (bool, default: True ) –

  Commit les transactions en attente automatiquement en quittant le contexte.

• verbose (bool, default: False ) –

  Si True, décrit le déroulement de la fonction dans le shell.

• kwargs (str, default: {} ) –

  Informations de connexion à la base de donnée.