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

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

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	585
Duplicated Lines	12.31 %

Importance

Changes

Metric	Value
eloc	295
dl	72
loc	585
rs	10
c	0
b	0
f	0
wmc	24

24 Methods

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

How to fix Duplicated Code

"""tpp http://www.uif.shcp.gob.mx/recepcion/tpp"""
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 fecha_pago:
    :param instrumento_monetario:
    :param moneda:
    :param monto_operacion:
    """
    
    def __init__(
            self,
            fecha_pago: date,
            instrumento_monetario: str,
            moneda: str,
            monto_operacion: str,
    ): 
        super().__init__({
            'FechaPago': fecha_pago,
            'InstrumentoMonetario': instrumento_monetario,
            '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/tpp}archivo'



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

SAT-CFDI / python-satcfdi

satcfdi.create.pld.tpp 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.tpp A
last analyzed 2025-06-07 00:41 UTC