satcfdi.create.pld.tdr - Code Metrics - SAT-CFDI/python-satcfdi - Measure and Improve Code Quality continuously with Scrutinizer

satcfdi.create.pld.tdr A
last analyzed 2025-06-07 00:41 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	579
Duplicated Lines	12.44 %

Importance

Changes

Metric	Value
eloc	291
dl	72
loc	579
rs	10
c	0
b	0
f	0
wmc	24

24 Methods

Rating	Name	Duplication	Size	Complexity
A	NacionalType.__init__()	0	14	1
A	RepresentanteApoderadoType.__init__()	0	16	1
A	PersonaAvisoType.__init__()	0	10	1
A	PersonaFisicaSimpleType.__init__()	0	18	1
A	AvisoType.__init__()	18	18	1
A	ExtranjeroType.__init__()	0	20	1
A	FideicomisoType.__init__()	0	12	1
A	DatosOperacionType.__init__()	14	14	1
A	SujetoObligadoType.__init__()	0	12	1
A	InformeType.__init__()	10	10	1
A	PersonaFisicaType.__init__()	0	20	1
A	DetalleOperacionesType.__init__()	0	6	1
A	PersonaMoralSimpleType.__init__()	0	12	1
A	AlertaType.__init__()	0	8	1
A	ModificatorioType.__init__()	0	8	1
A	DatosLiquidacionType.__init__()	0	8	1
A	ArchivoType.__init__()	0	6	1
A	TipoDomicilioType.__init__()	0	8	1
A	FideicomisoSimpleType.__init__()	0	10	1
A	TipoPersonaType.__init__()	0	10	1
A	TipoPersonaSimpleType.__init__()	0	10	1
A	TelefonoType.__init__()	0	10	1
A	DuenoBeneficiarioType.__init__()	0	6	1
A	PersonaMoralType.__init__()	0	16	1

How to fix Duplicated Code

"""tdr http://www.uif.shcp.gob.mx/recepcion/tdr"""
from decimal import Decimal
from datetime import datetime, date, time
from collections.abc import Sequence
from ...cfdi import CFDI
from ...xelement import XElement
from ...utils import ScalarMap


class DatosLiquidacionType(ScalarMap):
    """
    
    :param moneda:
    :param monto_operacion:
    """
    
    def __init__(
            self,
            moneda: str,
            monto_operacion: str,
    ): 
        super().__init__({
            'Moneda': moneda,
            'MontoOperacion': monto_operacion,
        })
        

class DatosOperacionType(ScalarMap):

    """
    
    :param fecha_operacion:
    :param codigo_postal:
    :param tipo_operacion:
    :param cantidad:
    :param datos_liquidacion:
    """
    
    def __init__(
            self,
            fecha_operacion: date,
            codigo_postal: str,
            tipo_operacion: str,
            cantidad: str,
            datos_liquidacion: DatosLiquidacionType | dict | Sequence[DatosLiquidacionType | dict],
    ): 
        super().__init__({
            'FechaOperacion': fecha_operacion,
            'CodigoPostal': codigo_postal,
            'TipoOperacion': tipo_operacion,
            'Cantidad': cantidad,
            'DatosLiquidacion': datos_liquidacion,
        })
        

class DetalleOperacionesType(ScalarMap):
    """
    
    :param datos_operacion:
    """
    
    def __init__(
            self,
            datos_operacion: DatosOperacionType | dict | Sequence[DatosOperacionType | dict],
    ): 
        super().__init__({
            'DatosOperacion': datos_operacion,
        })
        

class FideicomisoSimpleType(ScalarMap):
    """
    
    :param denominacion_razon:
    :param rfc:
    :param identificador_fideicomiso:
    """
    
    def __init__(
            self,
            denominacion_razon: str,
            rfc: str = None,
            identificador_fideicomiso: str = None,
    ): 
        super().__init__({
            'DenominacionRazon': denominacion_razon,
            'Rfc': rfc,
            'IdentificadorFideicomiso': identificador_fideicomiso,
        })
        

class PersonaMoralSimpleType(ScalarMap):
    """
    
    :param denominacion_razon:
    :param fecha_constitucion:
    :param rfc:
    :param pais_nacionalidad:
    """
    
    def __init__(
            self,
            denominacion_razon: str,
            fecha_constitucion: date = None,
            rfc: str = None,
            pais_nacionalidad: str = None,
    ): 
        super().__init__({
            'DenominacionRazon': denominacion_razon,
            'FechaConstitucion': fecha_constitucion,
            'Rfc': rfc,
            'PaisNacionalidad': pais_nacionalidad,
        })
        

class PersonaFisicaSimpleType(ScalarMap):
    """
    
    :param nombre:
    :param apellido_paterno:
    :param apellido_materno:
    :param fecha_nacimiento:
    :param rfc:
    :param curp:
    :param pais_nacionalidad:
    """
    
    def __init__(
            self,
            nombre: str,
            apellido_paterno: str,
            apellido_materno: str,
            fecha_nacimiento: date = None,
            rfc: str = None,
            curp: str = None,
            pais_nacionalidad: str = None,
    ): 
        super().__init__({
            'Nombre': nombre,
            'ApellidoPaterno': apellido_paterno,
            'ApellidoMaterno': apellido_materno,
            'FechaNacimiento': fecha_nacimiento,
            'Rfc': rfc,
            'Curp': curp,
            'PaisNacionalidad': pais_nacionalidad,
        })
        

class TipoPersonaSimpleType(ScalarMap):
    """
    
    :param persona_fisica:
    :param persona_moral:
    :param fideicomiso:
    """
    
    def __init__(
            self,
            persona_fisica: PersonaFisicaSimpleType | dict = None,
            persona_moral: PersonaMoralSimpleType | dict = None,
            fideicomiso: FideicomisoSimpleType | dict = None,
    ): 
        super().__init__({
            'PersonaFisica': persona_fisica,
            'PersonaMoral': persona_moral,
            'Fideicomiso': fideicomiso,
        })
        

class DuenoBeneficiarioType(ScalarMap):
    """
    
    :param tipo_persona:
    """
    
    def __init__(
            self,
            tipo_persona: TipoPersonaSimpleType | dict,
    ): 
        super().__init__({
            'TipoPersona': tipo_persona,
        })
        

class TelefonoType(ScalarMap):
    """
    
    :param clave_pais:
    :param numero_telefono:
    :param correo_electronico:
    """
    
    def __init__(
            self,
            clave_pais: str = None,
            numero_telefono: str = None,
            correo_electronico: str = None,
    ): 
        super().__init__({
            'ClavePais': clave_pais,
            'NumeroTelefono': numero_telefono,
            'CorreoElectronico': correo_electronico,
        })
        

class ExtranjeroType(ScalarMap):
    """
    
    :param pais:
    :param estado_provincia:
    :param ciudad_poblacion:
    :param colonia:
    :param calle:
    :param numero_exterior:
    :param codigo_postal:
    :param numero_interior:
    """
    
    def __init__(
            self,
            pais: str,
            estado_provincia: str,
            ciudad_poblacion: str,
            colonia: str,
            calle: str,
            numero_exterior: str,
            codigo_postal: str,
            numero_interior: str = None,
    ): 
        super().__init__({
            'Pais': pais,
            'EstadoProvincia': estado_provincia,
            'CiudadPoblacion': ciudad_poblacion,
            'Colonia': colonia,
            'Calle': calle,
            'NumeroExterior': numero_exterior,
            'CodigoPostal': codigo_postal,
            'NumeroInterior': numero_interior,
        })
        

class NacionalType(ScalarMap):
    """
    
    :param colonia:
    :param calle:
    :param numero_exterior:
    :param codigo_postal:
    :param numero_interior:
    """
    
    def __init__(
            self,
            colonia: str,
            calle: str,
            numero_exterior: str,
            codigo_postal: str,
            numero_interior: str = None,
    ): 
        super().__init__({
            'Colonia': colonia,
            'Calle': calle,
            'NumeroExterior': numero_exterior,
            'CodigoPostal': codigo_postal,
            'NumeroInterior': numero_interior,
        })
        

class TipoDomicilioType(ScalarMap):
    """
    
    :param nacional:
    :param extranjero:
    """
    
    def __init__(
            self,
            nacional: NacionalType | dict = None,
            extranjero: ExtranjeroType | dict = None,
    ): 
        super().__init__({
            'Nacional': nacional,
            'Extranjero': extranjero,
        })
        

class RepresentanteApoderadoType(ScalarMap):
    """
    
    :param nombre:
    :param apellido_paterno:
    :param apellido_materno:
    :param fecha_nacimiento:
    :param rfc:
    :param curp:
    """
    
    def __init__(
            self,
            nombre: str,
            apellido_paterno: str,
            apellido_materno: str,
            fecha_nacimiento: date = None,
            rfc: str = None,
            curp: str = None,
    ): 
        super().__init__({
            'Nombre': nombre,
            'ApellidoPaterno': apellido_paterno,
            'ApellidoMaterno': apellido_materno,
            'FechaNacimiento': fecha_nacimiento,
            'Rfc': rfc,
            'Curp': curp,
        })
        

class FideicomisoType(ScalarMap):
    """
    
    :param denominacion_razon:
    :param apoderado_delegado:
    :param rfc:
    :param identificador_fideicomiso:
    """
    
    def __init__(
            self,
            denominacion_razon: str,
            apoderado_delegado: RepresentanteApoderadoType | dict,
            rfc: str = None,
            identificador_fideicomiso: str = None,
    ): 
        super().__init__({
            'DenominacionRazon': denominacion_razon,
            'ApoderadoDelegado': apoderado_delegado,
            'Rfc': rfc,
            'IdentificadorFideicomiso': identificador_fideicomiso,
        })
        

class PersonaMoralType(ScalarMap):
    """
    
    :param denominacion_razon:
    :param pais_nacionalidad:
    :param giro_mercantil:
    :param representante_apoderado:
    :param fecha_constitucion:
    :param rfc:
    """
    
    def __init__(
            self,
            denominacion_razon: str,
            pais_nacionalidad: str,
            giro_mercantil: str,
            representante_apoderado: RepresentanteApoderadoType | dict,
            fecha_constitucion: date = None,
            rfc: str = None,
    ): 
        super().__init__({
            'DenominacionRazon': denominacion_razon,
            'PaisNacionalidad': pais_nacionalidad,
            'GiroMercantil': giro_mercantil,
            'RepresentanteApoderado': representante_apoderado,
            'FechaConstitucion': fecha_constitucion,
            'Rfc': rfc,
        })
        

class PersonaFisicaType(ScalarMap):
    """
    
    :param nombre:
    :param apellido_paterno:
    :param apellido_materno:
    :param pais_nacionalidad:
    :param actividad_economica:
    :param fecha_nacimiento:
    :param rfc:
    :param curp:
    """
    
    def __init__(
            self,
            nombre: str,
            apellido_paterno: str,
            apellido_materno: str,
            pais_nacionalidad: str,
            actividad_economica: str,
            fecha_nacimiento: date = None,
            rfc: str = None,
            curp: str = None,
    ): 
        super().__init__({
            'Nombre': nombre,
            'ApellidoPaterno': apellido_paterno,
            'ApellidoMaterno': apellido_materno,
            'PaisNacionalidad': pais_nacionalidad,
            'ActividadEconomica': actividad_economica,
            'FechaNacimiento': fecha_nacimiento,
            'Rfc': rfc,
            'Curp': curp,
        })
        

class TipoPersonaType(ScalarMap):
    """
    
    :param persona_fisica:
    :param persona_moral:
    :param fideicomiso:
    """
    
    def __init__(
            self,
            persona_fisica: PersonaFisicaType | dict = None,
            persona_moral: PersonaMoralType | dict = None,
            fideicomiso: FideicomisoType | dict = None,
    ): 
        super().__init__({
            'PersonaFisica': persona_fisica,
            'PersonaMoral': persona_moral,
            'Fideicomiso': fideicomiso,
        })
        

class PersonaAvisoType(ScalarMap):
    """
    
    :param tipo_persona:
    :param tipo_domicilio:
    :param telefono:
    """
    
    def __init__(
            self,
            tipo_persona: TipoPersonaType | dict,
            tipo_domicilio: TipoDomicilioType | dict = None,
            telefono: TelefonoType | dict = None,
    ): 
        super().__init__({
            'TipoPersona': tipo_persona,
            'TipoDomicilio': tipo_domicilio,
            'Telefono': telefono,
        })
        

class AlertaType(ScalarMap):
    """
    
    :param tipo_alerta:
    :param descripcion_alerta:
    """
    
    def __init__(
            self,
            tipo_alerta: str,
            descripcion_alerta: str = None,
    ): 
        super().__init__({
            'TipoAlerta': tipo_alerta,
            'DescripcionAlerta': descripcion_alerta,
        })
        

class ModificatorioType(ScalarMap):
    """
    
    :param folio_modificacion:
    :param descripcion_modificacion:
    """
    
    def __init__(
            self,
            folio_modificacion: str,
            descripcion_modificacion: str,
    ): 
        super().__init__({
            'FolioModificacion': folio_modificacion,
            'DescripcionModificacion': descripcion_modificacion,
        })
        

class AvisoType(ScalarMap):

    """
    
    :param referencia_aviso:
    :param prioridad:
    :param alerta:
    :param persona_aviso:
    :param detalle_operaciones:
    :param modificatorio:
    :param dueno_beneficiario:
    """
    
    def __init__(
            self,
            referencia_aviso: str,
            prioridad: str,
            alerta: AlertaType | dict,
            persona_aviso: PersonaAvisoType | dict | Sequence[PersonaAvisoType | dict],
            detalle_operaciones: DetalleOperacionesType | dict,
            modificatorio: ModificatorioType | dict = None,
            dueno_beneficiario: DuenoBeneficiarioType | dict | Sequence[DuenoBeneficiarioType | dict] = None,
    ): 
        super().__init__({
            'ReferenciaAviso': referencia_aviso,
            'Prioridad': prioridad,
            'Alerta': alerta,
            'PersonaAviso': persona_aviso,
            'DetalleOperaciones': detalle_operaciones,
            'Modificatorio': modificatorio,
            'DuenoBeneficiario': dueno_beneficiario,
        })
        

class SujetoObligadoType(ScalarMap):
    """
    
    :param clave_sujeto_obligado:
    :param clave_actividad:
    :param clave_entidad_colegiada:
    :param exento:
    """
    
    def __init__(
            self,
            clave_sujeto_obligado: str,
            clave_actividad: str,
            clave_entidad_colegiada: str = None,
            exento: str = None,
    ): 
        super().__init__({
            'ClaveSujetoObligado': clave_sujeto_obligado,
            'ClaveActividad': clave_actividad,
            'ClaveEntidadColegiada': clave_entidad_colegiada,
            'Exento': exento,
        })
        

class InformeType(ScalarMap):

    """
    
    :param mes_reportado:
    :param sujeto_obligado:
    :param aviso:
    """
    
    def __init__(
            self,
            mes_reportado: str,
            sujeto_obligado: SujetoObligadoType | dict,
            aviso: AvisoType | dict | Sequence[AvisoType | dict] = None,
    ): 
        super().__init__({
            'MesReportado': mes_reportado,
            'SujetoObligado': sujeto_obligado,
            'Aviso': aviso,
        })
        

class ArchivoType(ScalarMap):
    """
    
    :param informe:
    """
    
    def __init__(
            self,
            informe: InformeType | dict | Sequence[InformeType | dict],
    ): 
        super().__init__({
            'Informe': informe,
        })
        

class Archivo(ArchivoType, XElement):
    tag = '{http://www.uif.shcp.gob.mx/recepcion/tdr}archivo'



1		"""tdr http://www.uif.shcp.gob.mx/recepcion/tdr"""
2		from decimal import Decimal
3		from datetime import datetime, date, time
4		from collections.abc import Sequence
5		from ...cfdi import CFDI
6		from ...xelement import XElement
7		from ...utils import ScalarMap
8
9
10		class DatosLiquidacionType(ScalarMap):
11		"""
12
13		:param moneda:
14		:param monto_operacion:
15		"""
16
17		def __init__(
18		self,
19		moneda: str,
20		monto_operacion: str,
21		):
22		super().__init__({
23		'Moneda': moneda,
24		'MontoOperacion': monto_operacion,
25		})
26
27
28	View Code Duplication	class DatosOperacionType(ScalarMap):
		0 ignored issues – show Duplication introduced 2022-11-24 01:09 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
29		"""
30
31		:param fecha_operacion:
32		:param codigo_postal:
33		:param tipo_operacion:
34		:param cantidad:
35		:param datos_liquidacion:
36		"""
37
38		def __init__(
39		self,
40		fecha_operacion: date,
41		codigo_postal: str,
42		tipo_operacion: str,
43		cantidad: str,
44		datos_liquidacion: DatosLiquidacionType \| dict \| Sequence[DatosLiquidacionType \| dict],
45		):
46		super().__init__({
47		'FechaOperacion': fecha_operacion,
48		'CodigoPostal': codigo_postal,
49		'TipoOperacion': tipo_operacion,
50		'Cantidad': cantidad,
51		'DatosLiquidacion': datos_liquidacion,
52		})
53
54
55		class DetalleOperacionesType(ScalarMap):
56		"""
57
58		:param datos_operacion:
59		"""
60
61		def __init__(
62		self,
63		datos_operacion: DatosOperacionType \| dict \| Sequence[DatosOperacionType \| dict],
64		):
65		super().__init__({
66		'DatosOperacion': datos_operacion,
67		})
68
69
70		class FideicomisoSimpleType(ScalarMap):
71		"""
72
73		:param denominacion_razon:
74		:param rfc:
75		:param identificador_fideicomiso:
76		"""
77
78		def __init__(
79		self,
80		denominacion_razon: str,
81		rfc: str = None,
82		identificador_fideicomiso: str = None,
83		):
84		super().__init__({
85		'DenominacionRazon': denominacion_razon,
86		'Rfc': rfc,
87		'IdentificadorFideicomiso': identificador_fideicomiso,
88		})
89
90
91		class PersonaMoralSimpleType(ScalarMap):
92		"""
93
94		:param denominacion_razon:
95		:param fecha_constitucion:
96		:param rfc:
97		:param pais_nacionalidad:
98		"""
99
100		def __init__(
101		self,
102		denominacion_razon: str,
103		fecha_constitucion: date = None,
104		rfc: str = None,
105		pais_nacionalidad: str = None,
106		):
107		super().__init__({
108		'DenominacionRazon': denominacion_razon,
109		'FechaConstitucion': fecha_constitucion,
110		'Rfc': rfc,
111		'PaisNacionalidad': pais_nacionalidad,
112		})
113
114
115		class PersonaFisicaSimpleType(ScalarMap):
116		"""
117
118		:param nombre:
119		:param apellido_paterno:
120		:param apellido_materno:
121		:param fecha_nacimiento:
122		:param rfc:
123		:param curp:
124		:param pais_nacionalidad:
125		"""
126
127		def __init__(
128		self,
129		nombre: str,
130		apellido_paterno: str,
131		apellido_materno: str,
132		fecha_nacimiento: date = None,
133		rfc: str = None,
134		curp: str = None,
135		pais_nacionalidad: str = None,
136		):
137		super().__init__({
138		'Nombre': nombre,
139		'ApellidoPaterno': apellido_paterno,
140		'ApellidoMaterno': apellido_materno,
141		'FechaNacimiento': fecha_nacimiento,
142		'Rfc': rfc,
143		'Curp': curp,
144		'PaisNacionalidad': pais_nacionalidad,
145		})
146
147
148		class TipoPersonaSimpleType(ScalarMap):
149		"""
150
151		:param persona_fisica:
152		:param persona_moral:
153		:param fideicomiso:
154		"""
155
156		def __init__(
157		self,
158		persona_fisica: PersonaFisicaSimpleType \| dict = None,
159		persona_moral: PersonaMoralSimpleType \| dict = None,
160		fideicomiso: FideicomisoSimpleType \| dict = None,
161		):
162		super().__init__({
163		'PersonaFisica': persona_fisica,
164		'PersonaMoral': persona_moral,
165		'Fideicomiso': fideicomiso,
166		})
167
168
169		class DuenoBeneficiarioType(ScalarMap):
170		"""
171
172		:param tipo_persona:
173		"""
174
175		def __init__(
176		self,
177		tipo_persona: TipoPersonaSimpleType \| dict,
178		):
179		super().__init__({
180		'TipoPersona': tipo_persona,
181		})
182
183
184		class TelefonoType(ScalarMap):
185		"""
186
187		:param clave_pais:
188		:param numero_telefono:
189		:param correo_electronico:
190		"""
191
192		def __init__(
193		self,
194		clave_pais: str = None,
195		numero_telefono: str = None,
196		correo_electronico: str = None,
197		):
198		super().__init__({
199		'ClavePais': clave_pais,
200		'NumeroTelefono': numero_telefono,
201		'CorreoElectronico': correo_electronico,
202		})
203
204
205		class ExtranjeroType(ScalarMap):
206		"""
207
208		:param pais:
209		:param estado_provincia:
210		:param ciudad_poblacion:
211		:param colonia:
212		:param calle:
213		:param numero_exterior:
214		:param codigo_postal:
215		:param numero_interior:
216		"""
217
218		def __init__(
219		self,
220		pais: str,
221		estado_provincia: str,
222		ciudad_poblacion: str,
223		colonia: str,
224		calle: str,
225		numero_exterior: str,
226		codigo_postal: str,
227		numero_interior: str = None,
228		):
229		super().__init__({
230		'Pais': pais,
231		'EstadoProvincia': estado_provincia,
232		'CiudadPoblacion': ciudad_poblacion,
233		'Colonia': colonia,
234		'Calle': calle,
235		'NumeroExterior': numero_exterior,
236		'CodigoPostal': codigo_postal,
237		'NumeroInterior': numero_interior,
238		})
239
240
241		class NacionalType(ScalarMap):
242		"""
243
244		:param colonia:
245		:param calle:
246		:param numero_exterior:
247		:param codigo_postal:
248		:param numero_interior:
249		"""
250
251		def __init__(
252		self,
253		colonia: str,
254		calle: str,
255		numero_exterior: str,
256		codigo_postal: str,
257		numero_interior: str = None,
258		):
259		super().__init__({
260		'Colonia': colonia,
261		'Calle': calle,
262		'NumeroExterior': numero_exterior,
263		'CodigoPostal': codigo_postal,
264		'NumeroInterior': numero_interior,
265		})
266
267
268		class TipoDomicilioType(ScalarMap):
269		"""
270
271		:param nacional:
272		:param extranjero:
273		"""
274
275		def __init__(
276		self,
277		nacional: NacionalType \| dict = None,
278		extranjero: ExtranjeroType \| dict = None,
279		):
280		super().__init__({
281		'Nacional': nacional,
282		'Extranjero': extranjero,
283		})
284
285
286		class RepresentanteApoderadoType(ScalarMap):
287		"""
288
289		:param nombre:
290		:param apellido_paterno:
291		:param apellido_materno:
292		:param fecha_nacimiento:
293		:param rfc:
294		:param curp:
295		"""
296
297		def __init__(
298		self,
299		nombre: str,
300		apellido_paterno: str,
301		apellido_materno: str,
302		fecha_nacimiento: date = None,
303		rfc: str = None,
304		curp: str = None,
305		):
306		super().__init__({
307		'Nombre': nombre,
308		'ApellidoPaterno': apellido_paterno,
309		'ApellidoMaterno': apellido_materno,
310		'FechaNacimiento': fecha_nacimiento,
311		'Rfc': rfc,
312		'Curp': curp,
313		})
314
315
316		class FideicomisoType(ScalarMap):
317		"""
318
319		:param denominacion_razon:
320		:param apoderado_delegado:
321		:param rfc:
322		:param identificador_fideicomiso:
323		"""
324
325		def __init__(
326		self,
327		denominacion_razon: str,
328		apoderado_delegado: RepresentanteApoderadoType \| dict,
329		rfc: str = None,
330		identificador_fideicomiso: str = None,
331		):
332		super().__init__({
333		'DenominacionRazon': denominacion_razon,
334		'ApoderadoDelegado': apoderado_delegado,
335		'Rfc': rfc,
336		'IdentificadorFideicomiso': identificador_fideicomiso,
337		})
338
339
340		class PersonaMoralType(ScalarMap):
341		"""
342
343		:param denominacion_razon:
344		:param pais_nacionalidad:
345		:param giro_mercantil:
346		:param representante_apoderado:
347		:param fecha_constitucion:
348		:param rfc:
349		"""
350
351		def __init__(
352		self,
353		denominacion_razon: str,
354		pais_nacionalidad: str,
355		giro_mercantil: str,
356		representante_apoderado: RepresentanteApoderadoType \| dict,
357		fecha_constitucion: date = None,
358		rfc: str = None,
359		):
360		super().__init__({
361		'DenominacionRazon': denominacion_razon,
362		'PaisNacionalidad': pais_nacionalidad,
363		'GiroMercantil': giro_mercantil,
364		'RepresentanteApoderado': representante_apoderado,
365		'FechaConstitucion': fecha_constitucion,
366		'Rfc': rfc,
367		})
368
369
370		class PersonaFisicaType(ScalarMap):
371		"""
372
373		:param nombre:
374		:param apellido_paterno:
375		:param apellido_materno:
376		:param pais_nacionalidad:
377		:param actividad_economica:
378		:param fecha_nacimiento:
379		:param rfc:
380		:param curp:
381		"""
382
383		def __init__(
384		self,
385		nombre: str,
386		apellido_paterno: str,
387		apellido_materno: str,
388		pais_nacionalidad: str,
389		actividad_economica: str,
390		fecha_nacimiento: date = None,
391		rfc: str = None,
392		curp: str = None,
393		):
394		super().__init__({
395		'Nombre': nombre,
396		'ApellidoPaterno': apellido_paterno,
397		'ApellidoMaterno': apellido_materno,
398		'PaisNacionalidad': pais_nacionalidad,
399		'ActividadEconomica': actividad_economica,
400		'FechaNacimiento': fecha_nacimiento,
401		'Rfc': rfc,
402		'Curp': curp,
403		})
404
405
406		class TipoPersonaType(ScalarMap):
407		"""
408
409		:param persona_fisica:
410		:param persona_moral:
411		:param fideicomiso:
412		"""
413
414		def __init__(
415		self,
416		persona_fisica: PersonaFisicaType \| dict = None,
417		persona_moral: PersonaMoralType \| dict = None,
418		fideicomiso: FideicomisoType \| dict = None,
419		):
420		super().__init__({
421		'PersonaFisica': persona_fisica,
422		'PersonaMoral': persona_moral,
423		'Fideicomiso': fideicomiso,
424		})
425
426
427		class PersonaAvisoType(ScalarMap):
428		"""
429
430		:param tipo_persona:
431		:param tipo_domicilio:
432		:param telefono:
433		"""
434
435		def __init__(
436		self,
437		tipo_persona: TipoPersonaType \| dict,
438		tipo_domicilio: TipoDomicilioType \| dict = None,
439		telefono: TelefonoType \| dict = None,
440		):
441		super().__init__({
442		'TipoPersona': tipo_persona,
443		'TipoDomicilio': tipo_domicilio,
444		'Telefono': telefono,
445		})
446
447
448		class AlertaType(ScalarMap):
449		"""
450
451		:param tipo_alerta:
452		:param descripcion_alerta:
453		"""
454
455		def __init__(
456		self,
457		tipo_alerta: str,
458		descripcion_alerta: str = None,
459		):
460		super().__init__({
461		'TipoAlerta': tipo_alerta,
462		'DescripcionAlerta': descripcion_alerta,
463		})
464
465
466		class ModificatorioType(ScalarMap):
467		"""
468
469		:param folio_modificacion:
470		:param descripcion_modificacion:
471		"""
472
473		def __init__(
474		self,
475		folio_modificacion: str,
476		descripcion_modificacion: str,
477		):
478		super().__init__({
479		'FolioModificacion': folio_modificacion,
480		'DescripcionModificacion': descripcion_modificacion,
481		})
482
483
484	View Code Duplication	class AvisoType(ScalarMap):
		0 ignored issues – show Duplication introduced 2022-11-24 01:09 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
485		"""
486
487		:param referencia_aviso:
488		:param prioridad:
489		:param alerta:
490		:param persona_aviso:
491		:param detalle_operaciones:
492		:param modificatorio:
493		:param dueno_beneficiario:
494		"""
495
496		def __init__(
497		self,
498		referencia_aviso: str,
499		prioridad: str,
500		alerta: AlertaType \| dict,
501		persona_aviso: PersonaAvisoType \| dict \| Sequence[PersonaAvisoType \| dict],
502		detalle_operaciones: DetalleOperacionesType \| dict,
503		modificatorio: ModificatorioType \| dict = None,
504		dueno_beneficiario: DuenoBeneficiarioType \| dict \| Sequence[DuenoBeneficiarioType \| dict] = None,
505		):
506		super().__init__({
507		'ReferenciaAviso': referencia_aviso,
508		'Prioridad': prioridad,
509		'Alerta': alerta,
510		'PersonaAviso': persona_aviso,
511		'DetalleOperaciones': detalle_operaciones,
512		'Modificatorio': modificatorio,
513		'DuenoBeneficiario': dueno_beneficiario,
514		})
515
516
517		class SujetoObligadoType(ScalarMap):
518		"""
519
520		:param clave_sujeto_obligado:
521		:param clave_actividad:
522		:param clave_entidad_colegiada:
523		:param exento:
524		"""
525
526		def __init__(
527		self,
528		clave_sujeto_obligado: str,
529		clave_actividad: str,
530		clave_entidad_colegiada: str = None,
531		exento: str = None,
532		):
533		super().__init__({
534		'ClaveSujetoObligado': clave_sujeto_obligado,
535		'ClaveActividad': clave_actividad,
536		'ClaveEntidadColegiada': clave_entidad_colegiada,
537		'Exento': exento,
538		})
539
540
541	View Code Duplication	class InformeType(ScalarMap):
		0 ignored issues – show Duplication introduced 2022-11-24 01:09 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
542		"""
543
544		:param mes_reportado:
545		:param sujeto_obligado:
546		:param aviso:
547		"""
548
549		def __init__(
550		self,
551		mes_reportado: str,
552		sujeto_obligado: SujetoObligadoType \| dict,
553		aviso: AvisoType \| dict \| Sequence[AvisoType \| dict] = None,
554		):
555		super().__init__({
556		'MesReportado': mes_reportado,
557		'SujetoObligado': sujeto_obligado,
558		'Aviso': aviso,
559		})
560
561
562		class ArchivoType(ScalarMap):
563		"""
564
565		:param informe:
566		"""
567
568		def __init__(
569		self,
570		informe: InformeType \| dict \| Sequence[InformeType \| dict],
571		):
572		super().__init__({
573		'Informe': informe,
574		})
575
576
577		class Archivo(ArchivoType, XElement):
578		tag = '{http://www.uif.shcp.gob.mx/recepcion/tdr}archivo'
579
580

SAT-CFDI / python-satcfdi

satcfdi.create.pld.tdr A last analyzed 2025-06-07 00:41 UTC

Complexity

Size/Duplication

Importance

24 Methods

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like

satcfdi.create.pld.tdr A
last analyzed 2025-06-07 00:41 UTC