epptools 1.0.0__tar.gz → 1.0.2__tar.gz

{epptools-1.0.0 → epptools-1.0.2}/CHANGELOG.md

@@ -4,6 +4,50 @@ All notable changes to this library are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.0.2]
+
+### Fixed
+
+- **A postal change that carried only part of the block could delete the rest of the address.** A
+  `<contact:postalInfo>` inside `<contact:chg>` is not merged field by field by every registry: one
+  that *replaces* the block stores exactly what you sent and drops everything else — while answering
+  **1000**. Clearing an organisation on its own therefore left a contact with no name, no street, no
+  city, no postal code and no country, and nothing in the response said so. `name`, `city` and `cc`
+  are now required in every postal change, through `contact.update()` and the update builder alike.
+
+### Changed
+
+- A postal change missing `name`, `city` or `cc` now raises `ValidationException` instead of being
+  sent. This rejects calls that previously appeared to succeed — those were the calls losing data.
+  Read the current block with `client.contact.info(id).postal_info()` and send it back with your
+  change applied.
+- The documentation for partial postal updates was wrong in the same way and has been rewritten. A
+  block is replaced, not merged: a field you leave out is deleted, not preserved.
+
+## [1.0.1]
+
+### Fixed
+
+- **Clearing one optional part of an address built a frame the server rejects.** RFC 5733 makes
+  `<contact:addr>` a sequence with a required `city` and `cc`, so a change to any part of it sends
+  the whole block. What the library did was substitute an EMPTY STRING for whatever the caller had
+  not supplied — so `{"sp": ""}`, the documented way to remove a state, went out with `<city/>` and
+  `<cc/>` beside it. Both are schema-invalid (`postalLineType` has minLength 1, `ccType` is exactly
+  two characters), and an invalid frame comes back as a bare `2001` naming no element. A caller
+  following the manual got the least useful error in EPP.
+
+  A partial address change now requires `city` and `cc` and says so before anything is sent. Read
+  them back from `info()` and pass them through unchanged alongside what you are changing.
+
+- **An empty value is now refused for the fields the schema forbids it on.** Which parts of a
+  contact can be CLEARED is fixed by `contact-1.0.xsd` and not by convention: `org`, `street`, `sp`
+  and `pc` have types with no minimum length, so sending them empty is what removes them; `name`,
+  `city` and `cc` do not, so an empty one cannot be sent at all. Passing one is answered here, with
+  the reason, instead of costing a round trip.
+
+Neither changes a call that worked. Both turn a call the server was already rejecting into one that
+fails immediately and says why.
+
 ## [1.0.0]
 
 First public release.

{epptools-1.0.0/epptools.egg-info → epptools-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: epptools
-Version: 1.0.0
+Version: 1.0.2
 Summary: Dependency-free Python client for EPP domain registries (RFC 5730-5734 over TLS), with a registry's own extensions discovered from its greeting.
 Author: EppTools
 License: MIT

{epptools-1.0.0 → epptools-1.0.2}/docs/en/builders.md

@@ -398,24 +398,35 @@ Statuses go in their own blocks; every field change lands in `chg`.
     .send())
 ```
 
-### Presence decides, and an empty string clears
+### An address is REPLACED, not merged
 
-Inside an address, an argument you do not pass is not sent at all, so the registry keeps what it
-holds. An argument you pass as `""` **is** sent, empty, which is what clears a field — and it is the
-only way to remove an `org`, a state province or a postal code:
+The block you pass **replaces** the one the registry holds. It is not merged field by field, so an
+argument you do not pass is not sent — and the registry deletes what it held. An argument passed as
+`""` is sent empty, which is what clears a field.
+
+RFC 5733 can be read as "leave it out and the registry keeps what it holds", since every child of
+`chgPostalInfoType` is optional, but that reading is not safe. Against a registry that replaces —
+**every command answering 1000** — a block sent without its `org` comes back with the organisation
+gone, and a block carrying only an `org` leaves the contact with no postal address at all: name,
+street, city, postal code and country.
+
+`name`, `city` and `country_code` are required in every address change for that reason, and the
+builder refuses the call without them. They keep the frame valid; they cannot restore an argument you
+did not pass. **Read the block first and pass it back with your change applied:**
 
 ```python
-# Remove the organisation, leave the rest of the address alone.
+current = client.contact.info("C1").postal_info()["int"]
+
+# Remove the organisation, keeping the rest of the address exactly as it was.
 (client.contact.update_builder("C1")
-    .change_international_address(org="", city="Kyiv", country_code="UA")
+    .change_international_address(name=current["name"], city=current["city"],
+                                  country_code=current["cc"], street=current.get("street"),
+                                  org="")
     .send())
 ```
 
-**Give `city` and `country_code` whenever you touch the address at all.** The `<contact:addr>`
-element is a sequence whose city and country the schema requires, so it is sent whole or not at all
-— and when it is sent, city and country go with it. Leaving them out of a call that changes a street
-line sends them empty, and empty is a deliberate clear. The command answers 1000 and the contact
-loses its city and country.
+The form you do not mention — local or international — is untouched: the two are addressed
+separately.
 
 Changing one postal form leaves the other exactly as it was.
 

{epptools-1.0.0 → epptools-1.0.2}/docs/en/contacts.md

@@ -325,31 +325,43 @@ There is no way to *remove* a contact's transfer secret. RFC 5731 gives a domain
 RFC 5733 defines no equivalent for a contact, so a contact's code can be replaced but not cleared.
 An empty password is not a substitute: an empty value is still a value the holder can present.
 
-### The partial-update rule: presence decides
+### The partial-update rule: a postal block is REPLACED, not merged
 
-Inside a postal block, **presence decides and an empty string clears**:
+Send a postal block in `chg` and the registry **replaces** the block it holds with the one you sent.
+The two are not merged field by field, so whatever you leave out is gone.
 
-| You write | What happens |
+RFC 5733 can be read the other way: in `chgPostalInfoType` name, org and addr are each optional,
+which looks like "leave it out and the registry keeps what it holds". That reading is not safe.
+Against a registry that replaces, **every one of these commands answers 1000**:
+
+| What the `chg` carried | What the contact had afterwards |
 |---|---|
-| the key is absent | the field is not sent, and the registry keeps what it holds |
-| the key holds a value | the field is set to it |
-| the key holds `""` | the field is sent empty, which **clears** it |
+| the complete block, `"org": ""` | organisation removed, address untouched |
+| the complete block, no `org` key | organisation **also removed** |
+| `{"org": ""}` and nothing else | **no postal block at all** — name, street, city, postal code and country gone |
+
+So there is no such thing as changing one field of an address, and the failure is silent: the command
+succeeds and the data is gone. `name`, `city` and `cc` are required in every postal change and the
+SDK refuses the call without them, but that guard only keeps the frame schema-valid — it cannot put
+back an `org`, an `sp` or a `pc` you did not send.
 
-That is the only way to remove an `org`, an `sp` or a `pc`. It is also the only postal form that is
-touched: changing the `int` block leaves the `loc` block exactly as it was, and the other way round.
+**Read the block, apply your change, send it back whole:**
 
 ```python
-# Remove the organisation, change nothing else about the address.
-client.contact.update("C1",
-                      chg={"postal_info": {"type": "int", "org": "",
-                                           "city": "Kyiv", "cc": "UA"}})
+current = client.contact.info("C1").postal_info()["int"]
+client.contact.update("C1", chg={"postal_info": {**current, "type": "int", "org": ""}})
 ```
 
-**Give `city` and `cc` whenever you touch the address at all.** The `<contact:addr>` element is a
-sequence whose city and country are required by the schema, so it is sent whole or not at all — and
-when it is sent, city and country go with it. Leaving them out of a call that changes a street line
-sends them **empty**, and an empty value is a deliberate clear. The command answers 1000 and the
-contact loses its city and country.
+One thing the replacement does *not* reach is the other postal form: `int` and `loc` are addressed
+separately, so replacing one leaves the other exactly as it was.
+
+Inside the block you send, an empty string is still what clears an optional field:
+
+| You write | What happens |
+|---|---|
+| the key holds a value | the field is set to it |
+| the key holds `""` | the field is sent empty, which **clears** it |
+| the key is absent | the field is not sent — and the registry deletes what it held |
 
 Street lines behave differently and in your favour: an address block sent without any `street`
 leaves the existing lines untouched.

{epptools-1.0.0 → epptools-1.0.2}/docs/ru/builders.md

@@ -401,26 +401,35 @@ handle = (client.contact.create_builder(Contact.AUTO_ID, "contact@example.com")
     .send())
 ```
 
-### Решает присутствие, а пустая строка очищает
+### Адрес ЗАМЕЩАЕТСЯ целиком, а не сливается по полям
 
-Внутри адреса аргумент, которого вы не передали, не отправляется вовсе, поэтому реестр сохраняет то,
-что у него есть. Аргумент, переданный как `""`, **отправляется** пустым, и именно это очищает поле —
-и это единственный способ убрать `org`, область или почтовый индекс:
+Блок, который вы передаёте, **замещает** тот, что хранит реестр. Их не сливают поле за полем, поэтому
+аргумент, которого вы не передали, не отправляется — и реестр удаляет то, что хранил. Аргумент,
+переданный как `""`, отправляется пустым, и именно это очищает поле.
+
+RFC 5733 можно прочитать как «не передавайте — и реестр сохранит то, что хранит», ведь каждая
+составляющая `chgPostalInfoType` необязательна, но это чтение небезопасно. Против реестра, который
+замещает блок, — причём **каждая команда отвечает 1000** — блок, отправленный без `org`,
+возвращается уже без организации, а блок, в котором был один лишь `org`, оставляет контакт вообще
+без почтового адреса: без имени, улицы, города, индекса и страны.
+
+Именно поэтому `name`, `city` и `country_code` обязательны в любом изменении адреса, и билдер без
+них отказывает. Они удерживают кадр валидным, но вернуть аргумент, которого вы не передали, не
+могут. **Сначала прочитайте блок и верните его вместе со своим изменением:**
 
 ```python
-# Убрать организацию, остальной адрес не трогать.
+current = client.contact.info("C1").postal_info()["int"]
+
+# Убрать организацию, оставив остальной адрес ровно таким, каким он был.
 (client.contact.update_builder("C1")
-    .change_international_address(org="", city="Kyiv", country_code="UA")
+    .change_international_address(name=current["name"], city=current["city"],
+                                  country_code=current["cc"], street=current.get("street"),
+                                  org="")
     .send())
 ```
 
-**Передавайте `city` и `country_code` всякий раз, когда вообще трогаете адрес.** Элемент
-`<contact:addr>` — это последовательность, город и страну в которой требует схема, поэтому он
-отправляется целиком или не отправляется вовсе, — а раз отправляется, то вместе с городом и страной.
-Не указать их в вызове, который меняет строку улицы, значит отправить их пустыми, а пустое — это
-осознанная очистка. Команда ответит 1000, и контакт лишится города и страны.
-
-Изменение одной почтовой формы оставляет другую ровно такой, какой она была.
+Изменение одной почтовой формы оставляет другую ровно такой, какой она была: они адресуются
+раздельно.
 
 ### Здесь нет clear_auth_info()
 

{epptools-1.0.0 → epptools-1.0.2}/docs/ru/contacts.md

@@ -331,31 +331,43 @@ RFC 5733 ничего равнозначного для контакта не о
 очистить. Пустой пароль заменой не является: пустое значение — это по-прежнему значение, которое
 держатель может предъявить.
 
-### Правило частичного изменения: решает присутствие
+### Правило изменения: почтовый блок ЗАМЕЩАЕТСЯ, а не сливается
 
-Внутри почтового блока **решает присутствие ключа, а пустая строка очищает**:
+Отправьте почтовый блок в `chg` — и реестр **заместит** им тот, что хранит. Их не сливают поле за
+полем, поэтому всё, чего вы не передали, исчезает.
 
-| Что вы пишете | Что происходит |
+RFC 5733 можно прочитать и иначе: в `chgPostalInfoType` каждая из составляющих — name, org, addr —
+необязательна, и это выглядит как «не передавайте её, и реестр сохранит то, что хранит». Это чтение
+небезопасно: против реестра, который замещает блок, **каждая из этих команд отвечает 1000**:
+
+| Что нёс `chg` | Что осталось у контакта |
 |---|---|
-| ключа нет | поле не отправляется, и реестр сохраняет то, что хранит |
-| ключ несёт значение | поле принимает это значение |
-| ключ несёт `""` | поле отправляется пустым, что его **очищает** |
+| полный блок с `"org": ""` | организация убрана, адрес нетронут |
+| полный блок без ключа `org` | организация **тоже убрана** |
+| один лишь `{"org": ""}` | **почтового блока нет вообще** — ни имени, ни улицы, города, индекса и страны |
+
+То есть изменить одно поле адреса невозможно, и сбой молчаливый: команда успешна, а данных нет.
+`name`, `city` и `cc` обязательны в любом почтовом изменении, и этот SDK без них отказывает, — но
+эта проверка лишь удерживает кадр валидным и вернуть `org`, `sp` или `pc`, которого вы не передали,
+не может.
 
-Только так и можно убрать `org`, `sp` или `pc`. И затрагивается только та почтовая форма, о которой
-идёт речь: изменение блока `int` оставляет блок `loc` ровно таким, каким он был, и наоборот.
+**Прочитайте блок, примените своё изменение и отправьте его целиком:**
 
 ```python
-# Убрать организацию, не меняя в адресе больше ничего.
-client.contact.update("C1",
-                      chg={"postal_info": {"type": "int", "org": "",
-                                           "city": "Kyiv", "cc": "UA"}})
+current = client.contact.info("C1").postal_info()["int"]
+client.contact.update("C1", chg={"postal_info": {**current, "type": "int", "org": ""}})
 ```
 
-**Указывайте `city` и `cc` всякий раз, когда вообще трогаете адрес.** Элемент `<contact:addr>` — это
-последовательность, город и страна в которой обязательны по схеме, поэтому он отправляется целиком
-или не отправляется вовсе, а если отправляется, то вместе с городом и страной. Не указав их в
-вызове, который меняет строку улицы, вы отправите их **пустыми**, а пустое значение — это
-намеренная очистка. Команда ответит 1000, и контакт лишится города и страны.
+Чего замещение не достаёт — так это второй почтовой формы: `int` и `loc` адресуются раздельно,
+поэтому замена одной оставляет другую ровно такой, какой она была.
+
+Внутри блока, который вы отправляете, пустая строка по-прежнему очищает необязательное поле:
+
+| Что вы пишете | Что происходит |
+|---|---|
+| ключ несёт значение | поле принимает это значение |
+| ключ несёт `""` | поле отправляется пустым, что его **очищает** |
+| ключа нет | поле не отправляется — и реестр удаляет то, что хранил |
 
 Со строками улицы всё иначе, и в вашу пользу: блок адреса, отправленный без `street`, оставляет
 существующие строки нетронутыми.

{epptools-1.0.0 → epptools-1.0.2}/docs/uk/builders.md

@@ -399,24 +399,35 @@ handle = (client.contact.create_builder(Contact.AUTO_ID, "contact@example.com")
     .send())
 ```
 
-### Вирішує наявність, а порожній рядок очищає
+### Адресу ЗАМІЩУЮТЬ цілком, а не зливають по полях
 
-Усередині адреси аргумент, якого ви не передали, не надсилається взагалі, тож реєстр зберігає те, що
-тримає. Аргумент, переданий як `""`, **надсилається** — порожнім, і саме це очищає поле; це єдиний
-спосіб прибрати `org`, область чи поштовий індекс:
+Блок, який ви передаєте, **заміщає** той, що тримає реєстр. Їх не зливають поле за полем, тож
+аргумент, якого ви не передали, не надсилається — і реєстр видаляє те, що тримав. Аргумент,
+переданий як `""`, надсилається порожнім, і саме це очищає поле.
+
+RFC 5733 можна прочитати як «не подавайте — і реєстр збереже те, що має», бо кожна складова
+`chgPostalInfoType` необов'язкова, але це читання небезпечне. Проти реєстру, який заміщає блок, —
+причому **кожна команда відповідає 1000** — блок, надісланий без `org`, повертається вже без
+організації, а блок, у якому був самий лише `org`, лишає контакт узагалі без поштової адреси: без
+імені, вулиці, міста, індексу та країни.
+
+Саме тому `name`, `city` і `country_code` обов'язкові в кожній зміні адреси, і білдер без них
+відмовляє. Вони тримають кадр валідним, але не здатні повернути аргумент, якого ви не передали.
+**Спершу прочитайте блок і поверніть його разом зі своєю зміною:**
 
 ```python
-# Прибрати організацію, решту адреси не чіпати.
+current = client.contact.info("C1").postal_info()["int"]
+
+# Прибрати організацію, лишивши решту адреси точно такою, як була.
 (client.contact.update_builder("C1")
-    .change_international_address(org="", city="Kyiv", country_code="UA")
+    .change_international_address(name=current["name"], city=current["city"],
+                                  country_code=current["cc"], street=current.get("street"),
+                                  org="")
     .send())
 ```
 
-**Указуйте `city` і `country_code`, щойно ви взагалі торкаєтесь адреси.** Елемент `<contact:addr>` є
-послідовністю, чиї місто і країну вимагає схема, тож він надсилається цілком або не надсилається
-зовсім, — а коли надсилається, місто і країна їдуть разом із ним. Якщо не вказати їх у виклику, який
-змінює рядок вулиці, вони підуть порожніми, а порожнє — це свідоме очищення. Команда відповість 1000,
-і контакт втратить своє місто та країну.
+Форма, якої ви не згадали — локальна чи міжнародна, — лишається недоторканою: вони адресуються
+окремо.
 
 Зміна однієї поштової форми лишає другу рівно такою, як була.
 

{epptools-1.0.0 → epptools-1.0.2}/docs/uk/contacts.md

@@ -328,31 +328,42 @@ RFC 5733 не визначає для контакту жодного відпо
 очистити. Порожній пароль замінником не є: порожнє значення — це все одно значення, яке той, хто
 його має, може пред'явити.
 
-### Правило часткового оновлення: вирішує присутність
+### Правило оновлення: поштовий блок ЗАМІЩУЄТЬСЯ, а не зливається
 
-Усередині поштового блоку **вирішує присутність, а порожній рядок очищає**:
+Надішліть поштовий блок у `chg` — і реєстр **замістить** ним той, що тримає. Їх не зливають поле за
+полем, тож усе, чого ви не подали, зникає.
 
-| Ви пишете | Що відбувається |
+RFC 5733 можна прочитати й інакше: у `chgPostalInfoType` кожна зі складових — name, org, addr —
+необов'язкова, і це схоже на «не подавайте її, і реєстр збереже те, що має». Це читання небезпечне:
+проти реєстру, який заміщає блок, **кожна з цих команд відповідає 1000**:
+
+| Що ніс `chg` | Що лишилося в контакті |
 |---|---|
-| ключа немає | поле не надсилається, і реєстр зберігає те, що має |
-| ключ має значення | поле встановлюється в це значення |
-| ключ містить `""` | поле надсилається порожнім, що **очищає** його |
+| повний блок із `"org": ""` | організацію прибрано, адреса недоторкана |
+| повний блок без ключа `org` | організацію **також прибрано** |
+| самий лише `{"org": ""}` | **поштового блоку немає взагалі** — ані імені, ані вулиці, міста, індексу чи країни |
+
+Тобто змінити одне поле адреси неможливо, і збій мовчазний: команда успішна, а даних немає. `name`,
+`city` і `cc` обов'язкові в кожній поштовій зміні, і цей SDK без них відмовляє, — але ця перевірка
+лише тримає кадр валідним і не здатна повернути `org`, `sp` чи `pc`, якого ви не подали.
 
-Це єдиний спосіб прибрати `org`, `sp` чи `pc`. І це також єдина поштова форма, якої торкаються:
-зміна блоку `int` лишає блок `loc` точно таким, як був, і навпаки.
+**Прочитайте блок, застосуйте свою зміну і надішліть його цілим:**
 
 ```python
-# Прибрати організацію, більше нічого в адресі не змінювати.
-client.contact.update("C1",
-                      chg={"postal_info": {"type": "int", "org": "",
-                                           "city": "Kyiv", "cc": "UA"}})
+current = client.contact.info("C1").postal_info()["int"]
+client.contact.update("C1", chg={"postal_info": {**current, "type": "int", "org": ""}})
 ```
 
-**Вказуйте `city` та `cc` щоразу, коли взагалі торкаєтеся адреси.** Елемент `<contact:addr>` — це
-послідовність, у якій місто й країну вимагає схема, тож він надсилається цілком або не надсилається
-зовсім, — а коли надсилається, місто й країна йдуть разом з ним. Пропустивши їх у виклику, що змінює
-рядок вулиці, ви надсилаєте їх **порожніми**, а порожнє значення — це навмисне очищення. Команда
-відповідає 1000, і контакт втрачає своє місто й країну.
+Чого заміщення не досягає — то це другої поштової форми: `int` і `loc` адресуються окремо, тож
+заміна однієї лишає другу точно такою, як була.
+
+Усередині блоку, який ви надсилаєте, порожній рядок так само очищає необов'язкове поле:
+
+| Ви пишете | Що відбувається |
+|---|---|
+| ключ має значення | поле встановлюється в це значення |
+| ключ містить `""` | поле надсилається порожнім, що **очищає** його |
+| ключа немає | поле не надсилається — і реєстр видаляє те, що тримав |
 
 Рядки вулиці поводяться інакше і на вашу користь: блок адреси, надісланий без жодного `street`,
 лишає наявні рядки недоторканими.

{epptools-1.0.0 → epptools-1.0.2}/epptools/_version.py

@@ -4,4 +4,4 @@ Kept in its own module so ``client`` can report it (RFC 8807 ``<loginSec:app>``)
 the package root, which imports ``client`` in turn.
 """
 
-__version__ = "1.0.0"
+__version__ = "1.0.2"

{epptools-1.0.0 → epptools-1.0.2}/epptools/builders.py

@@ -508,18 +508,27 @@ class ContactUpdateBuilder(Builder):
                                      org: Optional[str] = None,
                                      state_province: Optional[str] = None,
                                      postal_code: Optional[str] = None) -> "ContactUpdateBuilder":
-        """Change the ASCII address. Only the fields you pass are sent, and PRESENCE decides:
+        """Change the ASCII address.
+
+        THE BLOCK YOU PASS REPLACES THE ONE THE REGISTRY HOLDS. It is not merged field by field,
+        so anything you leave out is deleted:
 
         ==================  ===========================================================
-        leave it out/None   the field is not sent, and the registry keeps its value
         give a value        the field is set to it
-        give ``""``         the field is CLEARED — the only way to remove org, state
-                            province or postal code
+        give ``""``         the field is CLEARED — the way to remove org, state province
+                            or postal code
+        leave it out/None   the field is not sent, and the registry DELETES what it held
         ==================  ===========================================================
 
-        The other form (local or international) is untouched. The address block is a sequence with
-        a required city and country, so passing any part of it sends the whole block: give
-        ``city`` and ``country_code`` whenever you touch street, state province or postal code.
+        RFC 5733 can be read as "leave it out and the registry keeps its value", since every child
+        of chgPostalInfoType is optional, but that reading is not safe: against a registry that
+        replaces, a block sent without its org comes back 1000 with the org gone, and a block
+        carrying only an org leaves the contact with no postal address at all. ``name``, ``city``
+        and ``country_code`` are required here for that reason — but they only keep the frame valid,
+        they cannot restore a field you did not send. Read the current block with ``contact.info()``
+        and pass it back with your change applied.
+
+        The other form (local or international) IS untouched — the two are addressed separately.
         """
         return self._address("int", name, city, country_code, street, org, state_province, postal_code)
 

{epptools-1.0.0 → epptools-1.0.2}/epptools/commands.py

@@ -706,24 +706,67 @@ def _append_postal(frame: Frame, parent: ET.Element, pi: Dict[str, Any],
     """
     block = frame.ns(parent, _ADMIN, "contact:postalInfo", None, {"type": pi.get("type") or "int"})
 
-    if not partial or "name" in pi:
-        frame.ns(block, _ADMIN, "contact:name", pi.get("name") or "")
+    # A postalInfo inside <contact:chg> REPLACES the stored one. It is not merged field by field.
+    #
+    # RFC 5733 can be read the other way: in chgPostalInfoType each of name/org/addr is optional,
+    # which looks like "omit it and the registry keeps what it holds". That reading is not safe.
+    # Against a registry that replaces, a chg carrying only <contact:org/> answers **1000** and leaves
+    # the contact with NO postalInfo at all — name, street, city, postal code and country gone, in
+    # both the int and loc blocks — and a complete block sent without an <org> removes the
+    # organisation just as surely.
+    #
+    # So the short form does not fail, it DESTROYS, and it reports success while doing it. A client
+    # cannot tell a replacing registry from a merging one, and the cost of guessing wrong is a
+    # registrant's postal address. Every change therefore carries the whole block.
+    for required in ("name", "city", "cc"):
+        if not str(pi.get(required) or "").strip():
+            raise ValidationException(
+                "postalInfo: a <contact:postalInfo> is REPLACED as a whole, not merged, so every "
+                f'change must carry the complete block — "{required}" is missing. (A registry that '
+                "replaces answers 1000 and silently drops everything you left out.) Read the current "
+                "block with contact.info() and send it back with your change applied."
+            )
+
+    # name is postalLineType, minLength 1: there is NO WAY to clear a name. An empty element is
+    # schema-invalid and the server answers a bare 2001 naming no field — refused here, where the
+    # message can say so.
+    _require_not_empty(pi.get("name"), "name")
+    frame.ns(block, _ADMIN, "contact:name", pi["name"])
+
+    # org is optPostalLineType, which HAS no minLength — an empty one is legal and is exactly how an
+    # organisation is removed.
     if ("org" in pi) if partial else bool(pi.get("org")):
         frame.ns(block, _ADMIN, "contact:org", pi.get("org") or "")
 
-    # <addr> is a sequence with a required city and cc, so it is emitted whole or not at all.
-    addr_keys = ("street", "city", "sp", "pc", "cc")
-    if partial and not any(k in pi for k in addr_keys):
-        return
+    # <addr> is a sequence with a required city and cc, and it is always emitted: the block replaces
+    # what the registry holds, so leaving the address out is what deletes it. The required parts were
+    # already asserted above, before anything was written.
+
     addr = frame.ns(block, _ADMIN, "contact:addr")
     for line in (pi.get("street") or []):
         frame.ns(addr, _ADMIN, "contact:street", line)
-    frame.ns(addr, _ADMIN, "contact:city", pi.get("city") or "")
+    frame.ns(addr, _ADMIN, "contact:city", pi["city"])
     if ("sp" in pi) if partial else bool(pi.get("sp")):
         frame.ns(addr, _ADMIN, "contact:sp", pi.get("sp") or "")
     if ("pc" in pi) if partial else bool(pi.get("pc")):
         frame.ns(addr, _ADMIN, "contact:pc", pi.get("pc") or "")
-    frame.ns(addr, _ADMIN, "contact:cc", pi.get("cc") or "")
+    frame.ns(addr, _ADMIN, "contact:cc", pi["cc"])
+
+
+def _require_not_empty(value: Any, field: str) -> None:
+    """Refuse an empty value for an element whose schema type forbids one.
+
+    The distinction is not a house rule, it is contact-1.0.xsd: ``optPostalLineType`` (org, street,
+    sp) has no minLength and ``pcType`` has none either, so those four clear by being sent empty.
+    ``postalLineType`` (name, city) has minLength 1 and ``ccType`` is exactly two characters, so an
+    empty one of those cannot be sent at all. Getting it wrong costs a round trip and returns a bare
+    2001 with no field named — the least useful error in EPP.
+    """
+    if not str(value or "").strip():
+        raise ValidationException(
+            'postalInfo: "%s" cannot be empty — RFC 5733 gives it a schema type with a minimum '
+            "length, so there is no way to clear it. Omit the key to leave it unchanged." % field
+        )
 
 
 def _append_disclose(frame: Frame, parent: ET.Element, disclose: Dict[str, Any]) -> None:

{epptools-1.0.0 → epptools-1.0.2/epptools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: epptools
-Version: 1.0.0
+Version: 1.0.2
 Summary: Dependency-free Python client for EPP domain registries (RFC 5730-5734 over TLS), with a registry's own extensions discovered from its greeting.
 Author: EppTools
 License: MIT

{epptools-1.0.0 → epptools-1.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "epptools"
-version = "1.0.0"
+version = "1.0.2"
 description = "Dependency-free Python client for EPP domain registries (RFC 5730-5734 over TLS), with a registry's own extensions discovered from its greeting."
 readme = "README.md"
 requires-python = ">=3.8"