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

Issues (158)

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

Labels

Duplication 2

Severity

Informational 2

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

class DatosVehiculoAereoType(ScalarMap):
    """
    
    :param marca_fabricante:
    :param modelo:
    :param anio:
    :param numero_serie:
    :param nivel_blindaje:
    :param bandera:
    :param matricula:
    """
    
    def __init__(
            self,
            marca_fabricante: str,
            modelo: str,
            anio: str,
            numero_serie: str,
            nivel_blindaje: str,
            bandera: str = None,
            matricula: str = None,
    ): 
        super().__init__({
            'MarcaFabricante': marca_fabricante,
            'Modelo': modelo,
            'Anio': anio,
            'NumeroSerie': numero_serie,
            'NivelBlindaje': nivel_blindaje,
            'Bandera': bandera,
            'Matricula': matricula,
        })
        

class DatosVehiculoMaritimoType(ScalarMap):
    """
    
    :param marca_fabricante:
    :param modelo:
    :param anio:
    :param numero_serie:
    :param nivel_blindaje:
    :param bandera:
    :param matricula:
    """
    
    def __init__(
            self,
            marca_fabricante: str,
            modelo: str,
            anio: str,
            numero_serie: str,
            nivel_blindaje: str,
            bandera: str = None,
            matricula: str = None,
    ): 
        super().__init__({
            'MarcaFabricante': marca_fabricante,
            'Modelo': modelo,
            'Anio': anio,
            'NumeroSerie': numero_serie,
            'NivelBlindaje': nivel_blindaje,
            'Bandera': bandera,
            'Matricula': matricula,
        })
        

class DatosVehiculoTerrestreType(ScalarMap):
    """
    
    :param marca_fabricante:
    :param modelo:
    :param anio:
    :param nivel_blindaje:
    :param vin:
    :param repuve:
    :param placas:
    """
    
    def __init__(
            self,
            marca_fabricante: str,
            modelo: str,
            anio: str,
            nivel_blindaje: str,
            vin: str = None,
            repuve: str = None,
            placas: str = None,
    ): 
        super().__init__({
            'MarcaFabricante': marca_fabricante,
            'Modelo': modelo,
            'Anio': anio,
            'NivelBlindaje': nivel_blindaje,
            'Vin': vin,
            'Repuve': repuve,
            'Placas': placas,
        })
        

class TipoVehiculoType(ScalarMap):
    """
    
    :param datos_vehiculo_terrestre:
    :param datos_vehiculo_maritimo:
    :param datos_vehiculo_aereo:
    """
    
    def __init__(
            self,
            datos_vehiculo_terrestre: DatosVehiculoTerrestreType | dict = None,
            datos_vehiculo_maritimo: DatosVehiculoMaritimoType | dict = None,
            datos_vehiculo_aereo: DatosVehiculoAereoType | dict = None,
    ): 
        super().__init__({
            'DatosVehiculoTerrestre': datos_vehiculo_terrestre,
            'DatosVehiculoMaritimo': datos_vehiculo_maritimo,
            'DatosVehiculoAereo': datos_vehiculo_aereo,
        })
        

class DatosOperacionType(ScalarMap):
    """
    
    :param fecha_operacion:
    :param codigo_postal:
    :param tipo_operacion:
    :param tipo_vehiculo:
    :param datos_liquidacion:
    """
    
    def __init__(
            self,
            fecha_operacion: date,
            codigo_postal: str,
            tipo_operacion: str,
            tipo_vehiculo: TipoVehiculoType | dict | Sequence[TipoVehiculoType | dict],
            datos_liquidacion: DatosLiquidacionType | dict | Sequence[DatosLiquidacionType | dict] = None,
    ): 
        super().__init__({
            'FechaOperacion': fecha_operacion,
            'CodigoPostal': codigo_postal,
            'TipoOperacion': tipo_operacion,
            'TipoVehiculo': tipo_vehiculo,
            '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/veh}archivo'



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

SAT-CFDI / python-satcfdi

Issues (158)

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

Labels

Severity

Introduced By

Duplication Side-by-Side

Filter issues like