followthemoney 3.8.4__py3-none-any.whl → 4.0.0__py3-none-any.whl

followthemoney/schema/Post.yaml

@@ -1,42 +0,0 @@
-Post:
-  label: "Post"
-  plural: "Posts"
-  extends:
-    - Interest
-  matchable: false
-  deprecated: true
-  # cf. https://www.popoloproject.com/specs/post.html
-  # But they're using it to define the post as an abstract thing, this
-  # describes the interval in which it is held by an individual.
-  description: >
-    A post, role or position held by an individual within an organization
-    or body. This describes the period for which the position is held,
-    not the abstract concept of the post.
-  featured:
-    - holder
-    - organization
-    - role
-    - startDate
-    - endDate
-  required:
-    - holder
-  caption:
-    - summary
-    - organization
-    - role
-  properties:
-    holder:
-      label: "Holder"
-      reverse:
-        name: posts
-        label: "Posts held"
-      type: entity
-      range: Person
-    organization:
-      # This is a stub text version of the org, describing it by name.
-      label: "Organization"
-      type: string
-    wikidataId:
-      label: "Wikidata ID"
-      hidden: true
-      type: identifier

followthemoney/types/iban.py

@@ -1,58 +0,0 @@
-from typing import Optional, TYPE_CHECKING
-from rigour.ids import IBAN
-
-from followthemoney.types.common import PropertyType
-from followthemoney.rdf import URIRef, Identifier
-from followthemoney.util import sanitize_text, defer as _
-
-if TYPE_CHECKING:
-    from followthemoney.proxy import EntityProxy
-
-
-class IbanType(PropertyType):
-    """An international bank account number, as defined in ISO 13616. IBANs are
-    managed by SWIFT used in the European SEPA payment system.
-
-    A notable aspect of IBANs is that they share a country prefix and validation
-    mechanism, but the specific length of an IBAN is dependent on the country
-    code defined in the first two characters: `NO8330001234567` and
-    `CY21002001950000357001234567` are both valid values."""
-
-    name = "iban"
-    group = "ibans"
-    label = _("IBAN")
-    plural = _("IBANs")
-    matchable = True
-    pivot = True
-    max_length = 64
-
-    def validate(
-        self, value: str, fuzzy: bool = False, format: Optional[str] = None
-    ) -> bool:
-        text = sanitize_text(value)
-        if text is None:
-            return False
-        return IBAN.is_valid(text)
-
-    def clean_text(
-        self,
-        text: str,
-        fuzzy: bool = False,
-        format: Optional[str] = None,
-        proxy: Optional["EntityProxy"] = None,
-    ) -> Optional[str]:
-        """Create a more clean, but still user-facing version of an
-        instance of the type."""
-        return IBAN.normalize(text)
-
-    def country_hint(self, value: str) -> str:
-        return value[:2].lower()
-
-    def rdf(self, value: str) -> Identifier:
-        return URIRef(self.node_id(value))
-
-    def node_id(self, value: str) -> str:
-        return f"iban:{value.upper()}"
-
-    def caption(self, value: str) -> str:
-        return IBAN.format(value)

followthemoney/types/registry.py

@@ -1,52 +0,0 @@
-from banal import ensure_list
-from typing import Iterable, Set, Dict, Type, Union, List, Optional
-
-from followthemoney.types.common import PropertyType
-
-
-class Registry(object):
-    """This registry keeps the processing helpers for all property types
-    in the system. They are instantiated as singletons when the system is first
-    loaded. The registry can be used to get a type, which can itself then
-    clean, validate or format values of that type."""
-
-    def __init__(self) -> None:
-        self.named: Dict[str, PropertyType] = {}
-        self.matchable: Set[PropertyType] = set()
-        self.types: Set[PropertyType] = set()
-        self.groups: Dict[str, PropertyType] = {}
-        self.pivots: Set[PropertyType] = set()
-
-    def add(self, clazz: Type[PropertyType]) -> None:
-        """Add a singleton class."""
-        type_ = clazz()
-        self.named[clazz.name] = type_
-        self.types.add(type_)
-        if type_.matchable:
-            self.matchable.add(type_)
-        if type_.pivot:
-            self.pivots.add(type_)
-        if type_.group is not None:
-            self.groups[type_.group] = type_
-
-    def get(self, name: Union[str, PropertyType]) -> Optional[PropertyType]:
-        """For a given property type name, get its type object. This can also
-        be used via getattr, e.g. ``registry.phone``."""
-        # Allow transparent re-checking.
-        if isinstance(name, PropertyType):
-            return name
-        return self.named.get(name)
-
-    def get_types(
-        self, names: Iterable[Union[str, PropertyType]]
-    ) -> List[PropertyType]:
-        """Get a list of all type names."""
-        names = ensure_list(names)
-        types = [self.get(n) for n in names]
-        return [t for t in types if t is not None]
-
-    def __getitem__(self, name: str) -> PropertyType:
-        return self.named[name]
-
-    def __getattr__(self, name: str) -> PropertyType:
-        return self.named[name]