Issues in don.py (main) - Issues in main - SAT-CFDI/python-satcfdi - Measure and Improve Code Quality continuously with Scrutinizer

Issues (158)

satcfdi/create/pld/don.py (2 issues)

Labels

Duplication 2

Severity

Informational 2

"""don http://www.uif.shcp.gob.mx/recepcion/don"""
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 DatosOtroType(ScalarMap):
    """
    
    :param descripcion_bien_donado:
    """
    
    def __init__(
            self,
            descripcion_bien_donado: str,
    ): 
        super().__init__({
            'DescripcionBienDonado': descripcion_bien_donado,
        })
        

class DatosInmuebleType(ScalarMap):
    """
    
    :param tipo_inmueble:
    :param codigo_postal:
    :param folio_real:
    """
    
    def __init__(
            self,
            tipo_inmueble: str,
            codigo_postal: str,
            folio_real: str,
    ): 
        super().__init__({
            'TipoInmueble': tipo_inmueble,
            'CodigoPostal': codigo_postal,
            'FolioReal': folio_real,
        })
        

class DatosBienDonadoType(ScalarMap):
    """
    
    :param datos_inmueble:
    :param datos_otro:
    """
    
    def __init__(
            self,
            datos_inmueble: DatosInmuebleType | dict = None,
            datos_otro: DatosOtroType | dict = None,
    ): 
        super().__init__({
            'DatosInmueble': datos_inmueble,
            'DatosOtro': datos_otro,
        })
        

class LiquidacionEspecieType(ScalarMap):
    """
    
    :param monto_operacion:
    :param moneda:
    :param bien_donado:
    :param datos_bien_donado:
    """
    
    def __init__(
            self,
            monto_operacion: str,
            moneda: str,
            bien_donado: str,
            datos_bien_donado: DatosBienDonadoType | dict = None,
    ): 
        super().__init__({
            'MontoOperacion': monto_operacion,
            'Moneda': moneda,
            'BienDonado': bien_donado,
            'DatosBienDonado': datos_bien_donado,
        })
        

class LiquidacionNumerarioType(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 TipoDonativoType(ScalarMap):
    """
    
    :param liquidacion_numerario:
    :param liquidacion_especie:
    """
    
    def __init__(
            self,
            liquidacion_numerario: LiquidacionNumerarioType | dict = None,
            liquidacion_especie: LiquidacionEspecieType | dict = None,
    ): 
        super().__init__({
            'LiquidacionNumerario': liquidacion_numerario,
            'LiquidacionEspecie': liquidacion_especie,
        })
        

class DatosDonativoType(ScalarMap):
    """
    
    :param tipo_donativo:
    """
    
    def __init__(
            self,
            tipo_donativo: TipoDonativoType | dict | Sequence[TipoDonativoType | dict],
    ): 
        super().__init__({
            'TipoDonativo': tipo_donativo,
        })
        

class DatosOperacionType(ScalarMap):
    """
    
    :param fecha_operacion:
    :param codigo_postal:
    :param tipo_operacion:
    :param datos_donativo:
    """
    
    def __init__(
            self,
            fecha_operacion: date,
            codigo_postal: str,
            tipo_operacion: str,
            datos_donativo: DatosDonativoType | dict,
    ): 
        super().__init__({
            'FechaOperacion': fecha_operacion,
            'CodigoPostal': codigo_postal,
            'TipoOperacion': tipo_operacion,
            'DatosDonativo': datos_donativo,
        })
        

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/don}archivo'



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

SAT-CFDI / python-satcfdi

Issues (158)

satcfdi/create/pld/don.py (2 issues)

Labels

Severity

Introduced By

Duplication Side-by-Side

Filter issues like