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

Issues (158)

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

Labels

Duplication 2

Severity

Informational 2

"""jys http://www.uif.shcp.gob.mx/recepcion/jys"""
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_liquidacion:
    """
    
    def __init__(
            self,
            descripcion_bien_liquidacion: str,
    ): 
        super().__init__({
            'DescripcionBienLiquidacion': descripcion_bien_liquidacion,
        })
        

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 DatosBienLiquidacionType(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 valor_bien:
    :param moneda:
    :param bien_liquidacion:
    :param datos_bien_liquidacion:
    """
    
    def __init__(
            self,
            valor_bien: str,
            moneda: str,
            bien_liquidacion: str,
            datos_bien_liquidacion: DatosBienLiquidacionType | dict = None,
    ): 
        super().__init__({
            'ValorBien': valor_bien,
            'Moneda': moneda,
            'BienLiquidacion': bien_liquidacion,
            'DatosBienLiquidacion': datos_bien_liquidacion,
        })
        

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 DatosLiquidacionType(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 DatosSucursalOperadorType(ScalarMap):
    """
    
    :param nombre_operador:
    :param codigo_postal:
    """
    
    def __init__(
            self,
            nombre_operador: str,
            codigo_postal: str,
    ): 
        super().__init__({
            'NombreOperador': nombre_operador,
            'CodigoPostal': codigo_postal,
        })
        

class DatosSucursalPropiaType(ScalarMap):
    """
    
    :param codigo_postal:
    """
    
    def __init__(
            self,
            codigo_postal: str,
    ): 
        super().__init__({
            'CodigoPostal': codigo_postal,
        })
        

class TipoSucursalType(ScalarMap):
    """
    
    :param datos_sucursal_propia:
    :param datos_sucursal_operador:
    """
    
    def __init__(
            self,
            datos_sucursal_propia: DatosSucursalPropiaType | dict = None,
            datos_sucursal_operador: DatosSucursalOperadorType | dict = None,
    ): 
        super().__init__({
            'DatosSucursalPropia': datos_sucursal_propia,
            'DatosSucursalOperador': datos_sucursal_operador,
        })
        

class DatosOperacionType(ScalarMap):
    """
    
    :param fecha_operacion:
    :param tipo_sucursal:
    :param tipo_operacion:
    :param linea_negocio:
    :param medio_operacion:
    :param datos_liquidacion:
    """
    
    def __init__(
            self,
            fecha_operacion: date,
            tipo_sucursal: TipoSucursalType | dict,
            tipo_operacion: str,
            linea_negocio: str,
            medio_operacion: str,
            datos_liquidacion: DatosLiquidacionType | dict | Sequence[DatosLiquidacionType | dict],
    ): 
        super().__init__({
            'FechaOperacion': fecha_operacion,
            'TipoSucursal': tipo_sucursal,
            'TipoOperacion': tipo_operacion,
            'LineaNegocio': linea_negocio,
            'MedioOperacion': medio_operacion,
            '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/jys}archivo'



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

SAT-CFDI / python-satcfdi

Issues (158)

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

Labels

Severity

Introduced By

Duplication Side-by-Side

Filter issues like