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

gbdtransformation/brands/notm/filters.py

@@ -0,0 +1,170 @@
+import re
+
+def translate_kind(kind):
+    if not kind: return 'Individual'
+
+    if kind.lower() == 'individual mark': return 'Individual'
+    if kind.lower() == 'trademark': return 'Individual'
+    if kind.lower() == 'collective mark': return 'Collective'
+    if kind.lower() == 'guarantee' or kind.lower() =='guarantee mark': return 'Collective'
+    if kind.lower() == 'certificate' or kind.lower() =='certificate mark': return 'Certificate'
+    if kind.lower() == 'certification' or kind.lower() =='certification mark': return 'Certificate'
+
+    return 'Other'
+    #raise Exception('kind "%s" is not mapped.' % kind)
+
+def translate_status(status):
+    if not status: return 'Ended'
+
+    if status in ['Registered',
+                  'Granted']: 
+        return 'Registered'
+
+    if status in ['Pending']:
+        return 'Pending'
+
+    if status in ['Refused',
+                  'Shelved',
+                  'Finally shelved',
+                  'Ceased',
+                  'Ceased/cancelled',
+                  'Withdrawn',
+                  'Rejected']:
+        return 'Ended'
+
+    return 'Unknown'
+    #raise Exception('Status "%s" unmapped' % status)
+
+def translate_feature(feature):
+    """translation of mark feature"""
+    if not feature: return 'Undefined'
+    feature = feature.upper()
+    if feature == 'COMBINED/FIGURATIVE MARK': return 'Combined'
+    if feature == 'FIGURATIVE MARK': return 'Figurative'
+    if feature == 'WORD MARK': return 'Word'
+    if feature == '3D-MARK': return "Three dimensional"
+    if feature == '3D MARK': return "Three dimensional"
+    if feature == 'SOUND MARK': return 'Sound'
+    if feature == 'COLOR MARK': return 'Colour'
+    if feature == 'MOTION MARK': return 'Motion'
+    if feature == 'MULTIMEDIA MARK': return 'Multimedia'
+    if feature == 'POSITION MARK': return 'Position'
+    if feature == 'PATTERN MARK': return 'Pattern'
+    if feature == 'HOLOGRAM MARK': return 'Hologram'
+    if feature == 'TRACER MARK': return 'Tracer'
+    if feature == 'OLFACTORY MARK': return 'Olfactory'
+    if feature == 'OLFACTIVE MARK': return 'Olfactory'
+    if feature == 'STYLIZED CHARACTERS': return 'Stylized characters'
+    if feature == 'STYLIZED CHARACTERS MARK': return 'Stylized characters'
+
+    return 'Unknown'
+
+    # raise Exception to recognize unmapped values
+    #raise Exception('Feature "%s" unmapped' % feature)
+
+def get_local_text(node):
+    if node is None:
+        return None
+    if "$" in node:
+        return node["$"]
+
+def get_local_texts(nodes):
+    if nodes is None:
+        return None
+    text = ""
+    start = True
+    for node in nodes:
+        if "$" in node:
+            if start:
+                start = False
+            else:
+                text += ", "
+            text += node["$"]
+    return text
+
+def get_full_address(postalStructuredAddress):
+    if postalStructuredAddress is None:
+        return 
+    result = ""
+    if "addressLineText" in postalStructuredAddress:
+        for addressLineText in postalStructuredAddress["addressLineText"]:
+            # always empty, which is good
+            """
+            if hasattr(addressLineText, '__value'):
+                if len(result) > 0:
+                    result += ", "
+                result += addressLineText.__value
+            """
+    if "cityName" in postalStructuredAddress:
+        if len(result) > 0:
+            result += ", "
+        result += postalStructuredAddress["cityName"]
+    if "countryCode" in postalStructuredAddress:
+        result += ", " + postalStructuredAddress["countryCode"]
+    if "postalCode" in postalStructuredAddress:
+        result += " " + postalStructuredAddress["postalCode"]
+    if len(result) == 0:
+        return
+    else: 
+        return result.strip()
+
+def local_guess_language(content):
+    if content == None:
+        return None
+    from lingua import Language, LanguageDetectorBuilder
+    detector = LanguageDetectorBuilder.from_all_spoken_languages().build()
+    language = detector.detect_language_of(content)
+    if language:
+        lang = language.iso_code_639_1.name.lower()
+        # we merge Norwegian flavors, Norwegian Bokmål and Norwegian Nynorsk 
+        if lang == "nn" or lang =="nb":
+            lang = "no"
+        return lang
+    else:
+        return "en"
+
+def has_vienna_classes(markImage):
+    if not "markImageClassification" in markImage:
+        return False
+    if not "figurativeElementClassificationBag" in markImage["markImageClassification"]:
+        return False
+    if not "viennaClassificationBag" in markImage["markImageClassification"]["figurativeElementClassificationBag"]:
+        return False
+
+    for element in markImage["markImageClassification"]["figurativeElementClassificationBag"]["viennaClassificationBag"]:
+        if "viennaClassification" in element:
+            for viennaClassification in element["viennaClassification"]:
+                if "viennaCategory" in viennaClassification:
+                    return True
+    return False
+
+def translate_licence_category(kind):
+    if not kind: return 'Other'
+
+    if kind.lower() == 'exclusive': return 'Exclusive'
+    if kind.lower() == 'nonexclusive' or kind.lower() == 'non exclusive' or kind.lower() == 'non-exclusive': return 'NonExclusive'
+
+    return 'Other'
+    #raise Exception('licence category "%s" is not mapped.' % kind)
+
+def translate_licence_status(status):
+    if not status: return 'Other'
+    # Cancelled, Valid, Other
+
+    if status.lower() == 'cancelled': return 'Cancelled'
+    if status.lower() == 'valid': return 'Valid'
+
+    return 'Other'
+    #raise Exception('licence status "%s" is not mapped.' % status)
+
+def clean_vienna_class(the_class):
+    if the_class == None:
+        return None
+    if len(the_class) == 0:
+        return None
+    # remove trailing dot
+    if the_class.endswith("."):
+        the_class = the_class[:-1]
+    if len(the_class) == 0:
+        return None
+    return the_class

gbdtransformation/brands/notm/template.yml

@@ -0,0 +1,289 @@
+{% from 'navigation.tmpl' import match %}
+{% from 'navigation.tmpl' import enumerate %}
+
+{% call(trademark) match('trademark', trademarkBag) %}
+
+{% call(applicationNumber) match('applicationNumber', trademark.trademarkTypeChoice1) %}
+st13: {{ applicationNumber.applicationNumberText | st13('NO', appdate=trademark.trademarkTypeChoice2.applicationDate) }}
+applicationNumber: {{ applicationNumber.applicationNumberText }}
+{% endcall %}
+applicationDate: {{ trademark.trademarkTypeChoice2.applicationDate | convertdate('%Y-%m-%d') }}
+
+registrationNumber: {{ trademark.trademarkTypeChoice1.registrationNumber }}
+registrationDate: {{ trademark.registrationDate }}
+
+expiryDate: {{ trademark.expiryDate }}
+
+# publication date appears as an event of category "markEventCategory": "Registration published"
+# with publication date given by markEventDate attribute
+{% call(event) match('markEvent', trademark.markEventBag) %}
+{% if event.markEventCategory == 'Registration published' %}  
+publicationDate: {{ event.markEventDate }}
+{% endif %}
+{% endcall %}
+
+{% set status = trademark.markCurrentStatusCode | translate_status %}
+gbdStatus: {{ status }}
+officeStatus: {{ trademark.markCurrentStatusCode }}
+statusDate: {{ trademark.markCurrentStatusDate }}
+
+registrationOfficeCode: "NO"
+designatedCountries:
+  - "NO"
+
+type: TRADEMARK
+
+kind:
+  {% call(markCategory) match('markCategory', trademark) %}
+  - {{ markCategory | translate_kind() }}
+  {% endcall %}
+  # (Individual|Collective|Certificate|Defensive|Other|Membership|Unknown)
+
+markFeature: {{ trademark.markFeatureDescription | translate_feature() }}
+# (Word|Stylized characters|Figurative|Combined|Three dimensional|Colour|Sound|Hologram|Olfactory|Motion|Municipal|Chimney|Other|Undefined)
+
+# in case it is relevant and available, we can store here the Madrid application from witch the national trademark originates
+{% set application_case = markApplicationCategory %}
+{% if application_case == 'International Mark' %}  
+reference:
+  registration:
+    - number: {{ trademark.trademarkTypeChoice1.registrationNumber }}
+      date: {{ trademark.registrationDate }}
+      office: "WO"
+{% endif %}
+
+markDisclaimerDetails:
+  {% call(markDisclaimerText) match('markDisclaimerText', trademark.markDisclaimerBag) %}
+  - languageCode: 
+    text: {{ markDisclaimerText | get_local_text() }}
+  {% endcall %}
+
+markDescriptionDetails:
+  - languageCode:
+    text: 
+
+wordMarkSpecification:
+  markVerbalElement:
+    - languageCode:
+      text: {{ trademark.markRepresentation.markReproduction.wordMarkSpecification.markVerbalElementText | get_local_text() }}
+  markSignificantVerbalElement:
+    - languageCode:
+      text: {{ trademark.markRepresentation.markReproduction.wordMarkSpecification.markSignificantVerbalElementText | get_local_text() }}
+  markTranslation:
+    - languageCode:
+      text:
+  markTransliteration:
+
+markImageDetails:
+  {% call(markImage) match('markImage', trademark.markRepresentation.markReproduction.markImageBag) %}
+  - name: {{ markImage.fileName }}
+    colourIndicator: {{ markImage.colourModeCategory }}
+    colourClaimed:
+      - languageCode:
+        text:
+    description:
+      {% call(markDescriptionText) match('markDescriptionText', trademark.markRepresentation.markDescriptionBag.markDescriptionBagTypeChoiceSequence) %}
+      - languageCode:
+        text: {{ markDescriptionText | get_local_text() }}
+      {% endcall %}
+    {% set has_vienna_classes = markImage | has_vienna_classes() %}
+    {% if has_vienna_classes %}  
+    classification:
+      kind: Vienna
+      version: 
+      code:
+      {% call(viennaClass) match('viennaClassificationBag', markImage.markImageClassification.figurativeElementClassificationBag) %}
+      {% call(viennaValue) match('viennaClassification', viennaClass) %}
+        - {{ viennaValue.viennaCategory | clean_vienna_class }}
+      {% endcall %}
+      {% endcall %}
+    {% endif %}
+  {% endcall %}
+
+markSoundDetails:
+  - filename:
+    fileformat:
+
+markVideoDetails:
+  - filename:
+    fileformat:
+
+goodsServicesClassification:
+  kind: Nice 
+  version:
+  class:
+    {% call(goodsServices) match('goodsServices', trademark.goodsServicesBag) %}
+    {% call(classDescription) match('classDescription', goodsServices.classDescriptionBag) %}
+    - code: {{ classDescription.classNumber }}
+      terms:
+        {% call(goodsServicesDescriptionText) match('goodsServicesDescriptionText', classDescription) %}
+        {{ goodsServicesDescriptionText.localizedTextType | get_local_text | local_guess_language() }}:
+          - {{ goodsServicesDescriptionText.localizedTextType | get_local_text }}
+        {% endcall %}  
+    {% endcall %}
+    {% endcall %}
+
+priorities:
+  {% call(priority) match('priority', trademark.priorityBag) %}
+  - countryCode: {{  priority.priorityCountryCode }}
+    number: {{ priority.applicationNumber.applicationNumberText }}
+    date: {{ priority.priorityApplicationFilingDate }}
+    comment:
+  {% endcall %}
+
+publications:
+  - identifier:
+    date:
+    section:
+
+representatives:
+  {% call(representative) match('representative', trademark.representativeBag) %}
+  - identifier: {{ representative.partyIdentifier  | get_local_text() }}
+    kind:
+    fullName:
+      - languageCode:
+        text: {{ representative.contact.contactTypeChoiceSequence.name.entityName.transliterationName | get_local_texts() }}
+    fullAddress:
+      {% call(postalAddress) match('postalAddress', representative.contact.contactTypeChoiceSequence.postalAddressBag) %}
+      - languageCode:
+        text: {{ postalAddress.postalStructuredAddress | get_full_address() }}
+      {% endcall %}
+    detailedAddress:
+      {% call(postalAddress) match('postalAddress', representative.contact.contactTypeChoiceSequence.postalAddressBag) %}
+      - languageCode:
+        text:
+        cityName: {{ postalAddress.postalStructuredAddress.cityName }}
+        geographicRegionName: 
+        postalCode: {{ postalAddress.postalStructuredAddress.postalCode }}
+        countryCode: {{ postalAddress.postalStructuredAddress.countryCode }}
+      {% endcall %}
+    {% call(postalAddress) match('postalAddress', representative.contact.contactTypeChoiceSequence.postalAddressBag) %}
+    countryCode: {{ postalAddress.postalStructuredAddress.countryCode }}
+    {% endcall %}  
+  {% endcall %}
+
+correspondence:
+  fullName:
+    - languageCode:
+      text:
+  fullAddress:
+    - languageCode:
+      text:
+  countryCode:
+
+applicants:
+  {% call(applicant) match('applicant', trademark.applicantBag) %}
+  - identifier: {{ applicant.partyIdentifier  | get_local_text() }}
+    kind:
+    fullName:
+      - languageCode:
+        text: {{ applicant.contact.contactTypeChoiceSequence.name.entityName.transliterationName | get_local_texts() }}
+    fullAddress:
+      {% call(postalAddress) match('postalAddress', applicant.contact.contactTypeChoiceSequence.postalAddressBag) %}
+      - languageCode: 
+        text: {{ postalAddress.postalStructuredAddress | get_full_address() }}
+      {% endcall %}
+    detailedAddress:
+      {% call(postalAddress) match('postalAddress', applicant.contact.contactTypeChoiceSequence.postalAddressBag) %}
+      - languageCode:
+        text:
+        cityName: {{ postalAddress.postalStructuredAddress.cityName }}
+        geographicRegionName: 
+        postalCode: {{ postalAddress.postalStructuredAddress.postalCode }}
+        countryCode: {{ postalAddress.postalStructuredAddress.countryCode }}
+      {% endcall %}
+    {% call(postalAddress) match('postalAddress', applicant.contact.contactTypeChoiceSequence.postalAddressBag) %}
+    countryCode: {{ postalAddress.postalStructuredAddress.countryCode }}
+    {% endcall %}  
+  {% endcall %}
+
+holders:
+  {% call(holder) match('holder', holderBag) %}
+  - identifier: {{ holder.partyIdentifier | get_local_text() }}
+    kind:
+    fullName:
+      - languageCode:
+        text: {{ holder.contact.contactTypeChoiceSequence.name.entityName.transliterationName | get_local_texts() }}
+    fullAddress:
+      {% call(postalAddress) match('postalAddress', holder.contact.contactTypeChoiceSequence.postalAddressBag) %}
+      - languageCode: 
+        text: {{ postalAddress.postalStructuredAddress | get_full_address() }}
+      {% endcall %}
+    detailedAddress:
+      {% call(postalAddress) match('postalAddress', holder.contact.contactTypeChoiceSequence.postalAddressBag) %}
+      - languageCode:
+        text:
+        cityName: {{ postalAddress.postalStructuredAddress.cityName }}
+        geographicRegionName: 
+        postalCode: {{ postalAddress.postalStructuredAddress.postalCode }}
+        countryCode: {{ postalAddress.postalStructuredAddress.countryCode }}
+      {% endcall %}
+    {% call(postalAddress) match('postalAddress', holder.contact.contactTypeChoiceSequence.postalAddressBag) %}
+    countryCode: {{ postalAddress.postalStructuredAddress.countryCode }}
+    {% endcall %}
+  {% endcall %}
+
+# licence information, not frequent, but provided by Singapore, Norway and UK as of 2025-04-23
+licences:
+  {% call(record) match('markRecord', trademark.markRecordBag) %}
+  {% if record.recordLicence.recordLicenceCategory == 'Licence' %}  
+  {% call(licence) match('licence', record.recordLicence.licenceBag) %}
+  - licenceCategory: {{ licence.licenceCategory | translate_licence_category() }}
+    # Exclusive, NonExclusive, Other
+    goodsServicesLimitation: 
+      {% call(goodsServices) match('commentText', licence.goodsServicesLimitation.commentTextBag) %}
+      - languageCode: 
+        text: {{ goodsServices.localizedTextType | get_local_text }}
+      {% endcall %}    
+    periodLimitationEndDate: {{ licence.periodLimitationEndDate }}
+    licenceDate: {{ licence.licenceDate }}
+    licenceStatus: {{ licence.licenceStatusCategory | translate_licence_status() }}
+    effectiveDate: {{ record.recordLicence.recordEffectiveDate }}
+    licensee:
+      {% call(licensee) match('licensee', licence.licenseeBag) %}
+      - identifier: {{ licensee.partyIdentifier | get_local_text() }}
+        kind:
+        fullName:
+          - languageCode:
+            text: {{ licensee.contact.contactTypeChoiceSequence.name.entityName.phraseType | get_local_text }}
+        firstName:
+          - languageCode:
+            text:
+        lastName:
+          - languageCode:
+            text:
+        middleName:
+          - languageCode:
+            text:
+        organizationName:
+          - languageCode:
+            text: 
+        fullAddress:
+          {% call(postalAddress) match('postalAddress', licensee.contact.contactTypeChoiceSequence.postalAddressBag) %}
+          - languageCode:
+            text: {{ postalAddress.postalStructuredAddress | get_full_address() }}
+          {% endcall %}
+        detailedAddress:
+          {% call(postalAddress) match('postalAddress', licensee.contact.contactTypeChoiceSequence.postalAddressBag) %}
+          - languageCode:
+            text:
+            cityName: {{ postalAddress.postalStructuredAddress.cityName }}
+            geographicRegionName: 
+            postalCode: {{ postalAddress.postalStructuredAddress.postalCode }}
+            countryCode: {{ postalAddress.postalStructuredAddress.countryCode }}
+          {% endcall %}
+        contact:
+          phone: 
+          fax: 
+          email: 
+          url:
+        countryCode: # sometimes, country name is provided instead
+      {% endcall %}
+  {% endcall %}
+  {% endif %}
+  {% endcall %}
+
+{% endcall %}
+
+# here goes extra information that is office specific and that is pertinent for us to retain.
+extra:

gbdtransformation/brands/nztm/__init__.py

@@ -0,0 +1,3 @@
+# instruction to render the output to JSON format
+render = 'JSON'
+source = 'national'

gbdtransformation/brands/nztm/filters.py

@@ -0,0 +1,126 @@
+# namespaces defined in XML and to be ignored in procecssing
+ignore_namespace = [
+    'http://www.iponz.govt.nz/XMLSchema/trademarks/information',
+    'http://www.iponz.govt.nz/XMLSchema/trademarks'
+]
+
+# -------------------------------------------------------------
+# data translation helpers:
+# translate values from office interpretation to gbd equivalent
+# -------------------------------------------------------------
+
+def translate_kind(kind, irn):
+    # collective international applications do not have KindMark
+    if not kind and irn: return ['Collective']
+
+    if not kind: return ['Individual']
+
+    if kind == 'Individual': return ['Individual']
+    if kind == 'Certificate': return ['Certificate']
+    if kind == 'Collective': return ['Collective']
+
+    raise Exception('kind "%s" is not mapped.' % kind)
+
+def translate_status(status):
+    if not status: return 'Unknown'
+
+    if status == 'Removed': return 'Delete'
+
+    if status == 'Abandoned': return 'Ended'
+    if status == 'Cancelled': return 'Ended'
+    if status == 'Refused': return 'Ended'
+    if status == 'Rejected': return 'Ended'
+    if status == 'Revoked': return 'Ended'
+    if status == 'Withdrawn': return 'Ended'
+    if status == 'Renounced': return 'Ended'
+    if status == 'Invalid': return 'Ended'
+    if status == 'Abandoned - continued processing available': return 'Ended'
+    if status == 'Refused - continued processing available': return 'Ended'
+
+    if status == 'Expired': return 'Expired'
+    if status == 'Expired but restorable': return 'Expired'
+    if status == 'Registered (past expiry date)': return 'Expired'
+    if status == 'Merged': return 'Expired'
+
+    if status == 'Registered': return 'Registered'
+    if status == 'Protected': return 'Registered'
+
+    if status == 'Under Opposition': return 'Pending'
+    if status == 'Under Examination': return 'Pending'
+    if status == 'Accepted': return 'Pending'
+    if status == 'Abeyance': return 'Pending'
+
+    raise Exception('Status "%s" unmapped' % status)
+
+def sanitize_vienna(vienna):
+    return '%s.%s.%s' % (vienna[0:2], vienna[2:4], vienna[4:])
+
+def get_registration_nb(trademark, tmstatus):
+    # default registration number to application number
+    # in case none is provided
+    if tmstatus in ['Registered', 'Expired']:
+        return trademark.ApplicationNumber
+
+def get_termination(value, gbd_status):
+    if gbd_status == 'Ended':
+        return value
+    return None
+
+def translate_feature(feature):
+    if not feature:
+        return 'Undefined'
+    if not isinstance(feature, list):
+        if feature == 'Word': return 'Word'
+        if feature == 'Figurative': return 'Figurative'
+        if feature == 'Colour': return 'Colour'
+        if feature == '3-D': return 'Three dimensional'
+        if feature == 'Sound': return 'Sound'
+        if feature == 'Motion': return 'Motion'
+        if feature == 'Olfactory': return 'Olfactory'
+        if feature == 'Undefined' or feature == "": return 'Undefined'
+    else:
+        if 'Word' in feature and 'Figurative' in feature:
+            return 'Combined'
+    raise Exception('Feature "%s" unmapped' % feature)
+
+def format_addressbook(abook):
+    # first try to get the Address from FormattedNameAddress
+    try:
+        address = abook.FormattedNameAddress.Address
+    except:
+        address = None
+
+    # if not set, then fallback to PostalAddress
+    if not address:
+        address = abook.PostalAddress
+
+    # if still not set, give up
+    if not address: return (None, None)
+
+    cc = address.AddressCountryCode
+    address_line = format_address(address)
+
+    return(address_line, cc)
+
+def format_address(address):
+    faddress = address.FormattedAddress
+    if not faddress: return None
+
+    addr = []
+    if faddress.AddressLine:
+        if not isinstance(faddress.AddressLine, list):
+            faddress.AddressLine = [faddress.AddressLine]
+
+        for line in faddress.AddressLine:
+            addr.append(line.__value)
+
+    if faddress.AddressSuburb:
+        addr.append(faddress.AddressSuburb)
+
+    if faddress.AddressCity:
+        addr.append(faddress.AddressCity)
+
+    if faddress.AddressPostcode:
+        addr.append(faddress.AddressPostcode)
+
+    return (', '.join(addr))