wipo-gbd-transformation 1.1.105__py3-none-any.whl

gbdtransformation/brands/estm/template.yml

@@ -0,0 +1,144 @@
+{% from 'navigation.tmpl' import match %}
+
+{% set TradeMark = Transaction.TradeMarkTransactionBody.TransactionContentDetails.TransactionData.TradeMarkDetails.TradeMark %}
+{% set status = TradeMark.MarkCurrentStatusCode | translate_status %}
+
+st13: {{ TradeMark.ApplicationNumber | st13('ES', appdate=TradeMark.ApplicationDate) }}
+gbdStatus: {{ status }}
+registrationOfficeCode: {{ TradeMark.RegistrationOfficeCode }}
+type: TRADEMARK
+
+{% if not status == 'Delete' %}
+kind: {{ TradeMark.KindMark | translate_kind }}
+markFeature: {{ TradeMark.MarkFeature | translate_feature }}
+designatedCountries:
+  - {{ TradeMark.RegistrationOfficeCode }}
+applicationNumber: {{ TradeMark.ApplicationNumber }}
+applicationDate: {{ TradeMark.ApplicationDate | convertdate('%Y-%m-%d') }}
+registrationNumber: {{ TradeMark | get_registration_nb(TradeMark.MarkCurrentStatusCode) }}
+registrationDate: {{ TradeMark.RegistrationDate }}
+applicationLanguageCode: {{ TradeMark.ApplicationLanguageCode }}
+officeStatus: {{ TradeMark.MarkCurrentStatusCode }}
+statusDate: {{ TradeMark.MarkCurrentStatusDate | convertdate('%Y-%m-%d') }}
+
+markDisclaimerDetails:
+  {% call(desc) match('MarkDisclaimerDetails.MarkDisclaimer', TradeMark) %}
+  - text: {{ desc }}
+    languageCode: {{ desc | guess_language(TradeMark.ApplicationLanguageCode) }}
+  {% endcall %}
+
+markDescriptionDetails:
+  {% call(desc) match('MarkDisclaimerDetails.MarkDisclaimer', TradeMark) %}
+  - text: {{ desc }}
+    languageCode: {{ desc | guess_language(TradeMark.ApplicationLanguageCode) }}
+  {% endcall %}
+
+wordMarkSpecification:
+  markVerbalElement:
+    {% call(desc) match('WordMarkSpecification.MarkVerbalElementText', TradeMark) %}
+    - text: {{ desc }}
+      languageCode: {{ desc | guess_language(TradeMark.ApplicationLanguageCode) }}
+    {% endcall %}
+
+markImageDetails:
+  {% call(img) match('MarkImageDetails.MarkImage', TradeMark) %}
+  - name: {{ img.MarkImageURI }}
+    colourIndicator: {{ img.MarkImageColourClaimedText | get_true_or_false }}
+    colourClaimed:
+      {% call(desc) match('MarkImageColourClaimedText', img) %}
+      - text: {{ desc }}
+        languageCode: {{ desc | guess_language(TradeMark.ApplicationLanguageCode) }}
+      {% endcall %}
+    classification:
+      kind: Vienna
+      code:
+      {% call(code) match('MarkImageCategory.CategoryCodeDetails.CategoryCode', img) %}
+      - {{ code }}
+      {% endcall %}
+  {% endcall %}
+
+markSoundDetails:
+  {% call(sound) match('MarkSoundDetails.MarkSound', TradeMark) %}
+  - filename: {{ sound.MarkSoundFilename }}
+    fileformat: {{ sound.MarkSoundFileFormat }}
+  {% endcall %}
+
+markVideoDetails:
+  {% call(video) match('MarkVideoDetails.MarkVideo', TradeMark) %}
+  - filename: {{ video.MarkVideoFilename }}
+    fileformat: {{ video.MarkVideoFileFormat }}
+  {% endcall %}
+
+{% set nc_gs = TradeMark.GoodsServicesDetails.GoodsServices.ClassDescriptionDetails.ClassDescription | get_goods_services %}
+{% if (nc_gs.keys() | length) > 0 %}
+goodsServicesClassification:
+  kind: Nice
+  version: {{ ASK_THE_OFFICE }}
+  class:
+    {% for nc in nc_gs.keys() %}
+    - code: {{ nc | int }}
+      {% if nc_gs[nc]['terms'] %}
+      terms:
+        {{ nc_gs[nc]['terms'] | guess_language(nc_gs[nc]['lang'], TradeMark.ApplicationLanguageCode) | field_name}}:
+        {% for gsline in nc_gs[nc]['terms'] | remove_trailing('.', '-') | split_terms %}
+          - {{ gsline | lower }}
+        {% endfor %}
+      {% endif %}
+    {% endfor %}
+{% endif %}
+
+priorities:
+  {% call(priority) match('PriorityDetails.Priority', TradeMark) %}
+  - countryCode: {{ priority.PriorityCountryCode }}
+    number: {{ priority.PriorityNumber }}
+    date: {{ priority.PriorityDate }}
+  {% endcall %}
+
+publications:
+  {% call(publication) match('PublicationDetails.Publication', TradeMark) %}
+  - identifier: {{ publication.PublicationIdentifier }}
+    date: {{ publication.PublicationDate }}
+    section: {{ publication.PublicationSection }}
+  {% endcall %}
+
+applicants:
+  {% call(Applicant) match('ApplicantDetails.Applicant', TradeMark) %}
+  - identifier: {{ Applicant.ApplicantIdentifier }}
+    {% call(nameline) match('FormattedNameAddress.Name.FormattedName', Applicant.ApplicantAddressBook) %}
+    kind: {{ nameline | get_entity_kind}}
+    fullName:
+      - text: {{ nameline | get_entity_name}}
+        languageCode: es
+      {% endcall %}
+    fullAddress:
+      {% call(adrline) match('FormattedNameAddress.Address.FormattedAddress', Applicant.ApplicantAddressBook) %}
+      - text: {{ adrline | get_entity_addr}}
+        languageCode: es
+      {% endcall %}
+    {% call(adrline) match('FormattedNameAddress.Address', Applicant.ApplicantAddressBook) %}
+    countryCode: {{ adrline.AddressCountryCode }}
+    {% endcall %}
+  {% endcall %}
+
+representatives:
+  {% call(Representative) match('RepresentativeDetails.Representative', TradeMark) %}
+  {% if not Representative.RepresentativeIdentifier.endswith('-null') %}
+  - identifier: {{ Representative.RepresentativeIdentifier }}
+    {% call(nameline) match('FormattedNameAddress.Name.FormattedName', Representative.RepresentativeAddressBook) %}
+    kind: {{ nameline | get_entity_kind}}
+    fullName:
+      - text: {{ nameline | get_entity_name}}
+        languageCode: {{ nameline | guess_language('es') }}
+      {% endcall %}
+    fullAddress:
+      {% call(adrline) match('FormattedNameAddress.Address.FormattedAddress', Representative.RepresentativeAddressBook) %}
+      - text: {{ adrline | get_entity_addr}}
+        languageCode: {{ adrline | guess_language('es') }}
+      {% endcall %}
+    {% call(adrline) match('FormattedNameAddress.Address', Representative.RepresentativeAddressBook) %}
+    countryCode: {{ adrline.AddressCountryCode }}
+    {% endcall %}
+  {% endif %}
+  {% endcall %}
+
+{% endif %}

gbdtransformation/brands/filters.py

@@ -0,0 +1,125 @@
+import re
+
+from gbdtransformation.brands import st13_identifier
+from gbdtransformation.common.filters import *
+
+def parseStatus(x):
+    return x
+
+def parse_version(x):
+    return x
+
+def split_vienna(data, separator='.'):
+    """when the class is xxyyzz"""
+    if not len(data) == 6:
+        raise Exception('cannot split vienna "%s"' % data)
+    return separator.join([data[:2], data[2:4], data[4:6]])
+
+def pad_vienna(data, separator='.'):
+    """Convert to vienna style with padding"""
+    if separator in data:
+        slice = data.split('.')
+        return slice[0].zfill(2) + '.' + pad_vienna('.'.join(slice[1:]))
+    return data.zfill(2)
+
+
+# create synonyms for application/registration numbers
+# type = appnum | regnum
+def create_synonyms(original, office, numtype, lenient=False):
+    if not original: return []
+    original = str(original)
+    if not office: return [original]
+    # collections are usually office code followed with tm: xxtm
+    collection = '%stm' % office.lower()
+    # some exceptions:
+    if office == 'WHO': collection = 'whoinn'
+
+    # get the appnum_mask / regnum_mask
+    try:
+        module_pckg = load_collection_package('brands', collection)
+        masks = getattr(module_pckg, '%s_mask' % numtype)
+        if not isinstance(masks, list): masks = [masks]
+        # set when making synonyms for reference numbers
+        if lenient:
+            masks.append('(.*)')
+    except (AttributeError, ModuleNotFoundError) as e:
+        masks = ['(.*)']
+
+    # match the regex
+    matches = None
+    for mask in masks:
+        regex = re.compile(mask)
+        matches = regex.search(original)
+        if matches:
+            break
+    if not matches:
+        return [original]
+    masked = ''.join([m for m in matches.groups() if m])
+
+    synonyms = []
+    def _to_synonyms(value):
+        synonyms.append(value)
+        value = remove_special(value)
+        synonyms.append(value)
+        value = remove_non_numeric(value)
+        synonyms.append(value)
+        value = remove_leading(value, '0')
+        synonyms.append(value)
+
+    _to_synonyms(masked)
+    _to_synonyms(original)
+
+    return set(synonyms)
+
+
+# TRADEMARK is a safe default here
+def st13(appnum, office, type='TRADEMARK', appdate=None, roffice=None, sanitize=True):
+    if not appnum:
+        return None
+    # collections are usually office code followed with tm: xxtm
+    collection = '%stm' % office.lower()
+    # some exceptions:
+    if office == 'WHO': collection = 'whoinn'
+
+    module_pckg = load_collection_package('brands', collection)
+    try:
+        masks = getattr(module_pckg, 'appnum_mask')
+        if not isinstance(masks, list): masks = [masks]
+    except:
+        masks = ['(.*)']
+
+    try:
+        source = getattr(module_pckg, 'source')
+    except:
+        source = 'national'
+    matches = None
+    for mask in masks:
+        regex = re.compile('^%s$' % mask)
+        matches = regex.search(appnum)
+        if matches:
+            break
+
+    if not matches:
+        raise Exception('could not apply appnum mask %s on %s' % (mask, appnum))
+
+    #print(appnum, ''.join(matches.groups()))
+    appnum = ''.join(matches.groups())
+
+    prefix = st13_identifier[source.lower()][type.lower()]
+    if sanitize:
+        # remove special characters
+        special_chars = re.compile(r'\W')
+        appnum = special_chars.sub('', appnum)
+
+    # reference office (only relevant for madrid)
+    if roffice:
+        appnum = '%s%s' % (roffice.upper(), appnum)
+
+    st13 = '%s%s' % (office.upper(), prefix)
+    if appdate:
+        st13 = '%s%s' % (st13, appdate[:4])
+
+    # add application number and zfill till 17
+    return '%s%s' % (st13, appnum.zfill(17 - len(st13)))
+
+

gbdtransformation/brands/frtm/__init__.py

@@ -0,0 +1,2 @@
+render = 'JSON'
+source = 'national'

gbdtransformation/brands/frtm/filters.py

@@ -0,0 +1,172 @@
+import datetime
+
+ignore_namespace = [
+   'http://www.inpi.fr/schemas/frst66/v1_00_11',
+   'http://www.inpi.fr/schemas/frst66/v1_00_12',
+   'http://www.inpi.fr/schemas/frst66/v1_00_13'
+]
+
+def translate_kind(kind):
+    if not kind: return ['Individual']
+
+    kind = kind.lower()
+    if kind == 'collective de certification': return ['Certificate', 'Collective']
+    if kind == 'collective': return ['Collective']
+    if kind == 'guarantee': return ['Certificate']
+    if kind == 'other': return ['Other']
+    if kind == 'marque collective de certification': return ['Certificate', 'Collective']
+
+    raise Exception('"%s" kind not mapped' % kind)
+
+def translate_status(trademark):
+    if trademark._operationCode == 'Delete':
+        return 'Delete'
+
+    status = trademark.MarkCurrentStatusCode
+    status = status.lower()
+
+    if status == "marque renouvelée": return "Registered"
+    if status == "renouvellement demandé": return "Registered"
+    if status == "marque enregistrée": return "Registered"
+
+    if status == "marque expirée": return "Expired"
+    if status == "marque ayant fait l'objet d'une renonciation totale": return "Expired"
+
+    if status == "marque annulée": return "Ended"
+    if status == "marque déchue": return "Ended"
+    if status == "demande totalement rejetée": return "Ended"
+    if status == "demande irrecevable après publication": return "Ended"
+    if status == "marque ayant fait l'objet d'un retrait total": return "Ended"
+
+    if status == "demande publiée": return "Pending"
+    if status == "demande non publiée": return "Pending"
+    if status == "demande déposée": return "Pending"
+
+    raise Exception('"%s" status not mapped' % status)
+
+def translate_feature(feature):
+    # needed information from office
+    if not feature: return 'Undefined'
+
+    if feature == 'Word': return 'Word'
+    if feature == 'Figurative': return 'Figurative'
+    if feature == 'Combined': return 'Combined'
+    if feature == '3-D': return 'Three dimensional'
+    if feature == 'Form': return 'Three dimensional'
+    if feature == 'Hologram': return 'Hologram'
+    if feature == 'Sound': return 'Sound'
+    if feature == 'Colour': return 'Colour'
+    if feature == 'Position': return 'Position'
+    if feature == 'Pattern': return 'Pattern'
+    if feature == 'Motion': return 'Motion'
+    if feature == 'Multimedia': return 'Multimedia'
+    if feature == 'Other': return 'Other'
+
+    raise Exception('"%s" feature not mapped' % feature)
+
+# -------------------------
+# handling dates exceptions
+# -------------------------
+
+# registration number = application number
+# in case the record has an Enregistrement recordal
+def get_registration_number(trademark):
+    registeration_recordal = _get_registered_recordal(trademark)
+    if registeration_recordal:
+        return trademark.get('ApplicationNumber')
+
+# registration date = date of Enregistrement recordal
+def get_registration_date(trademark):
+    registeration_recordal = _get_registered_recordal(trademark)
+
+    return _get_recordal_date(registeration_recordal)
+
+def get_publication_date(trademark):
+    publication_recordal = _get_publication_recordal(trademark)
+
+    return _get_recordal_date(publication_recordal)
+
+def get_status_date(trademark):
+    recordals = _get_recordals(trademark)
+    if not len(recordals):
+        return None
+
+    # the last recordal is the latest
+    return _get_recordal_date(recordals[-1].get('BasicRecord'))
+
+def _get_recordal_date(recordal):
+    if not recordal:
+        return None
+
+    pubdetails = recordal.get('RecordPublicationDetails', {}) \
+                         .get('RecordPublication', {})
+
+    pub_date = pubdetails.get('PublicationDate', None)
+
+    # if no PublicationDate or it is malformed
+    #   Ex: 3735098: 'PublicationDate': '2020-10-'
+    # => fall back to PublicationIdentifier
+    if pub_date and len(pub_date) < len('yyyy-mm-dd'):
+        # sometimes only the Identifier is provided (yyyy-ww)
+        # => deduce the date (friday of the week)
+        return _weeknb_to_date(pubdetails.get('PublicationIdentifier'))
+    else:
+        return pub_date
+
+
+
+# get the Enregistrement recordal
+def _get_registered_recordal(trademark):
+    recordals = _get_recordals(trademark)
+    for record in recordals:
+        brecord = record.get('BasicRecord', {})
+        brecordKind = brecord.get('BasicRecordKind', None)
+        if brecordKind and brecordKind.startswith('Enregistrement'):
+            return brecord
+
+    return None
+
+# get the Publication recordal
+def _get_publication_recordal(trademark):
+    recordals = _get_recordals(trademark)
+    for record in recordals:
+        brecord = record.get('BasicRecord', {})
+        brecordKind = brecord.get('BasicRecordKind', None)
+        if brecordKind and brecordKind.startswith('Publication'):
+            return brecord
+
+    return None
+
+def _get_recordals(trademark):
+    recordals = trademark.get('MarkRecordDetails', {}).get('MarkRecord', [])
+    if not isinstance(recordals, list):
+        recordals = [recordals]
+
+    recordals = [r for r in recordals if r is not None]
+
+    return recordals
+
+
+# ------------
+# helpers
+# ------------
+# doing our best attempt
+def _weeknb_to_date(weeknb):
+    try:
+        friday = datetime.datetime.strptime(weeknb + '-5', '%G-%V-%u')
+        return friday.strftime('%Y-%m-%d')
+    except:
+        return None
+
+
+def get_full_address(address):
+    if not address:
+        return None
+
+    details = [address.AddressStreet, address.AddressPostOfficeBox, address.AddressPostcode, address.AddressCity]
+    details = [d for d in details if d]
+    line = ', '.join(details)
+    if line:
+        return line
+    else:
+        return None