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

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

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	561
Duplicated Lines	8.56 %

Importance

Changes

Metric	Value
eloc	283
dl	48
loc	561
rs	10
c	0
b	0
f	0
wmc	23

23 Methods

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

How to fix Duplicated Code

"""tsc http://www.uif.shcp.gob.mx/recepcion/tsc"""
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 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 DatosOperacionType(ScalarMap):
    """
    
    :param fecha_periodo:
    :param tipo_operacion:
    :param tipo_tarjeta:
    :param numero_identificador:
    :param monto_gasto:
    """
    
    def __init__(
            self,
            fecha_periodo: str,
            tipo_operacion: str,
            tipo_tarjeta: str,
            numero_identificador: str,
            monto_gasto: str,
    ): 
        super().__init__({
            'FechaPeriodo': fecha_periodo,
            'TipoOperacion': tipo_operacion,
            'TipoTarjeta': tipo_tarjeta,
            'NumeroIdentificador': numero_identificador,
            'MontoGasto': monto_gasto,
        })
        

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

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



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

SAT-CFDI / python-satcfdi

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

Complexity

Size/Duplication

Importance

23 Methods

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like

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