From ca58cfaccb048885bc303d725b6bc0c3acdccb4c Mon Sep 17 00:00:00 2001 From: Colas Geier Date: Fri, 8 Oct 2021 15:14:47 +0200 Subject: [PATCH] Initial commit --- __init__.py | 25 + __pycache__/__init__.cpython-38.pyc | Bin 0 -> 854 bytes __pycache__/bilan.cpython-38.pyc | Bin 0 -> 2257 bytes __pycache__/params.cpython-38.pyc | Bin 0 -> 2774 bytes __pycache__/ps.cpython-38.pyc | Bin 0 -> 6178 bytes __pycache__/tools.cpython-38.pyc | Bin 0 -> 11318 bytes __pycache__/update.cpython-38.pyc | Bin 0 -> 7422 bytes __pycache__/zh.cpython-38.pyc | Bin 0 -> 13386 bytes bilan.py | 80 ++ params.py | 113 +++ pers/__init__.py | 9 + pers/__pycache__/__init__.cpython-38.pyc | Bin 0 -> 168 bytes pers/__pycache__/pers.cpython-38.pyc | Bin 0 -> 3802 bytes pers/pers.py | 124 ++++ ps.py | 220 ++++++ ref/__init__.py | 4 + ref/__pycache__/__init__.cpython-38.pyc | Bin 0 -> 173 bytes ref/territoire/__init__.py | 4 + .../__pycache__/__init__.cpython-38.pyc | Bin 0 -> 207 bytes .../__pycache__/territoire.cpython-38.pyc | Bin 0 -> 413 bytes ref/territoire/territoire.py | 11 + sites/__init__.py | 3 + sites/__pycache__/__init__.cpython-38.pyc | Bin 0 -> 148 bytes sites/__pycache__/sites.cpython-38.pyc | Bin 0 -> 3702 bytes sites/sites.py | 144 ++++ tools.py | 345 +++++++++ update.py | 282 ++++++++ vrac/Modif_caract_connect.py | 73 ++ vrac/Modif_caract_delim.py | 63 ++ vrac/Modif_caract_fct.py | 70 ++ vrac/Modif_caract_hab.py | 73 ++ vrac/Modif_caract_reghydro.py | 81 +++ vrac/Modif_caract_sub.py | 82 +++ vrac/Modif_caract_usageprocess.py | 83 +++ wfs/__init__.py | 4 + wfs/__pycache__/__init__.cpython-38.pyc | Bin 0 -> 166 bytes wfs/__pycache__/wfs.cpython-38.pyc | Bin 0 -> 761 bytes wfs/wfs.py | 24 + zh.py | 684 ++++++++++++++++++ 39 files changed, 2601 insertions(+) create mode 100644 __init__.py create mode 100644 __pycache__/__init__.cpython-38.pyc create mode 100644 __pycache__/bilan.cpython-38.pyc create mode 100644 __pycache__/params.cpython-38.pyc create mode 100644 __pycache__/ps.cpython-38.pyc create mode 100644 __pycache__/tools.cpython-38.pyc create mode 100644 __pycache__/update.cpython-38.pyc create mode 100644 __pycache__/zh.cpython-38.pyc create mode 100644 bilan.py create mode 100644 params.py create mode 100644 pers/__init__.py create mode 100644 pers/__pycache__/__init__.cpython-38.pyc create mode 100644 pers/__pycache__/pers.cpython-38.pyc create mode 100644 pers/pers.py create mode 100644 ps.py create mode 100644 ref/__init__.py create mode 100644 ref/__pycache__/__init__.cpython-38.pyc create mode 100644 ref/territoire/__init__.py create mode 100644 ref/territoire/__pycache__/__init__.cpython-38.pyc create mode 100644 ref/territoire/__pycache__/territoire.cpython-38.pyc create mode 100644 ref/territoire/territoire.py create mode 100644 sites/__init__.py create mode 100644 sites/__pycache__/__init__.cpython-38.pyc create mode 100644 sites/__pycache__/sites.cpython-38.pyc create mode 100644 sites/sites.py create mode 100644 tools.py create mode 100644 update.py create mode 100644 vrac/Modif_caract_connect.py create mode 100644 vrac/Modif_caract_delim.py create mode 100644 vrac/Modif_caract_fct.py create mode 100644 vrac/Modif_caract_hab.py create mode 100644 vrac/Modif_caract_reghydro.py create mode 100644 vrac/Modif_caract_sub.py create mode 100644 vrac/Modif_caract_usageprocess.py create mode 100644 wfs/__init__.py create mode 100644 wfs/__pycache__/__init__.cpython-38.pyc create mode 100644 wfs/__pycache__/wfs.cpython-38.pyc create mode 100644 wfs/wfs.py create mode 100644 zh.py diff --git a/__init__.py b/__init__.py new file mode 100644 index 0000000..f362416 --- /dev/null +++ b/__init__.py @@ -0,0 +1,25 @@ +#!/usr/bin/env python3 +# -*- coding: UTF-8 -*- + +from .zh import * +from .bilan import * +from .update import update +from .pers import pers +from .sites import sites +from .ps import * +from .ref import * +from .params import con + + + +__version__ = "1.0.2" +__author__ = "Colas Geier" +__email__ = "colas.geier@cen-isere.org" +__all__ = [] +__license__ = "GPL" +__spec__ = 'Outils de récupération de données de zones humide de la base de données MEDWET' +__changes__ = { + "1.0.1" : "Création de la librairie, extraction des données zones humides et sites", + "1.0.2" : """Suppression des class et répartition des fonctions par sous-dossier pour faciliter l'appel. + Ajout de la récupération de données des pelouses sèches""" +} diff --git a/__pycache__/__init__.cpython-38.pyc b/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bea6a64bf4ec0cc3fa9b679634f61dfe5a1e58c5 GIT binary patch literal 854 zcmaJ<&2AGh5Z=Ee+oWl^aNuT%0}7&93Ri>*rK*tlsb~?>UMzP#&ANEkmc6cMo`nNP za^oHH7JKCckI(~Rya`cHc(pU%jK|;n*dNE^VSww${WJDE3WA^BxV>UD4)C{ED0sj_ z8Jw+j*y%_{Rg_1e_r)@<;ymtfB9kh~lMaWnw?5PFbWaYdG*5A_pKtL&KICaWng#hb z-^#~)nD6ir-{#}5QNGJ}PJ_wruMm?@!Zv(}qVF_k4IoN17>l}RMFSqhg{p6Q`_sqM zC-c#vlFX805Mbu_3U5qj-Z&_r-V+uKOqH3n@$tzU_W}9eyGBS$I1sa36izP}hBZRf z-osU0FBj15&Q*<|bd~TMKqMpQ%yw`S_V(!2r=v6X8fg!aZNr1HQk)wmjDSZ3zBGmv z>m11aFUjo;mOw+g{@gcYJ9Szcuy$3KB?Y$Cgrj$}n=gvO=+9rYVFeZd literal 0 HcmV?d00001 diff --git a/__pycache__/bilan.cpython-38.pyc b/__pycache__/bilan.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6ce295cf69149d146343d7081bf2543c4cf113be GIT binary patch literal 2257 zcmZWq%Wm676rCA9L_I9qN|3}s(Q=hmXRbyiB*W9C|JQIKN1tWu!dHN1dsz{&yWk` z%uof$ogojXGDB4$Z-#0>)fuWIUhM=8>(c6TX&>=PBWn!jifU1l4t<;S`j)I7*~6x+ z$$B_lGgo+pH=LJ^ZL!2)I|tjQoIeuB`i1}L=j7r`Ytk(2!YSOMQZ$Qt(U7f|mC1ZD zzsjCGo-AYw#eA`_#1Mb+P`u#!QgN*5wq|o@${BaM5_V@Ni^bv;6^l!(+j_xwuAkV+ zGuId}R%36@9$c;Y{z|zgD}EHF*=K2{m;Lo*b!ShR()LYW#X zPDYR`q3qHc;{i`4yRR_CO{JGa`6y0}ljNDwMubwk*k@zQAXDULkn9?f#HKD)+SB1U z3r|3|m&CE!Gp>p=t(0-YxC<|M_v1vvSXarDtF%sZYTPu@S*Y5UsZ9;KD#%T3sy&wT z&10wSigChtD@jeWm*_B7-OVt`lCd%ksiJTcW&tIl=P5#SD~WpqV>Nfijj^ATdvaz8dSKr_$6kNTXH% z?!MHCsSrx@O;aP`xGJS`tCyL%a+cca4r-3V>SS!hSQ=-fbRT8YDh?o0o0(dehH;t& zaZj1*YLErDHRg;>D_|P-vUbZ8lB ze_V^+;&0a#{M7xY>v_DzYJ7n=cnhN@D*6vc(McnIEIH~z$x*L(!C&(i{AV!%N1^Zj z0AI1fT4EDB6NR0zp>-(qxUj)fz(YrJDWnC-1*^E6fo&>74@@S&L6`?`)Ubw^Yn>yD zR=ldeW}NM`N{_;YR z;FNm)8`TQ5BDYq2I#J91Dn@FbAk-z1%nlxr30-UG{0tlJ%a8Ne-%@!PMJn^hf%f0N ziQc}Uwj(AYcPEZcY`;-HXoqHJZhe(zex!VKB>Bu|9+!Ot1c!|CY{f6Bt~XF4@XAxA z)9xsVyIWyz5Gvg{B`@zq=^pGf{m9 NXQ%XUK^&)c>0fk0csu|A literal 0 HcmV?d00001 diff --git a/__pycache__/params.cpython-38.pyc b/__pycache__/params.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..da5514e8d7afd6fa256102b33f309e2fcc31e1c5 GIT binary patch literal 2774 zcmb7F&2Jl35Z^Da*K4~?zncQ3rIcb?>^Ln|i=wJHaX$ogLY*M>Nocj%d9}CQufAP_ zoHktOfeT37bAV(1rFVoAH;xDpVrJK|n<^ZzwX<*Do0<2UdB1tPQLozy{yK-=a=)o6 z%CDrn`a6NjZG6&yP=EqzpoA(@RRuJrfzEU=m;ohL0+X3sh4N2ju5*KzxcRdI7F531 zm<2YgK$Y20V^yfL+QhEHZC>TIsa+io!C{z#BXAUs!ErbNCwDBII{~L~_B71zlydD1 zyn*_g@D`kfw_mY1w_{AL&%--#0p5j+@E%-(_n`qFz-71sAMVUSbEm{;r&Dkyk4*Yu z^lZTbv@!A`>T`D$xC+-^Dsb&vjU9oH`by*aZ&(ARp~|`^xSMf@M*~0N>(WZ%G#dz> zG9w#hqpf=T=3=vb{YLZpLbJWV%uR4S9&KIRGkX?XPSUX#CxgY0Tdn5{+aEt~Z{L2t zxZQewb^8u(U~q33vkE#nE`)xxRlBggF z=L=?icE3}MDmb;g`rvMNm6#OpKY~K|ExY$jwHAI|*-; zgoQ;D6%^7~hShu0T#u7@^&Yc&xzSpeRS{0;rm4f-5vzN^M>Ewl$~3iXhzLX+d2!@C_B~d`!}T*CwZuh*i_}juH}W{MW8o7|9CAr{glT&5 zDB!G$jKPeZMEDUa0}uSrrz8VH?*y(Gu=1vGQ*x})@x>!i)CdcK=O-Rh!5VW1;+#}> z{T}92z`TPf?X?NYHLT6r6eO#x78uFAj}W^BLi=HkaE$=kD+NF|^RZ+(#?J_%*+Gcp zw+zb!u#0Di<4J+LjgmBSLRv}SMg&+^=&Z4OXgJMD*7vG89D|7QQsGG^^;is$%A>GR zVpjkDdKam0@C9CfOT}AXQZnU<`b5hVoYm(^ zYV!&h-|ILkp_K{cmo!_NS5}m7$=90r=m+{#CacDQtM(GcLb%nQIEHwn5xF6kX6g-j z=yQ9|HI2*=MYt8kZx&xlJlJVBC zmAJwU(`GW3_ELbYf!9)U%b}eKf~jcA)`h(OO~mdLqopAB+#tQxoO#IdBokT1&dY@B zM|ft^NS^ZXZi&!EvJAc(a4(b90nhd_mvf{%js^Dzk%QK$JVG@j0t*9exe`|DX{O#n?w9V@jh^P9qa(R0b=jkvXN& z9#IM!z3ziV$%$Fe==Ig=ghsUG@*~ks3xg1AarhTvM-+Y!Nwdf<-mq?C$vGdaQ8b_s_J`3D{ zx^^t65t-$ue&lQdNMn?8A@$^IV7d!J8u-1#7Dw)eZYJI(V>|!iJ7mZz#hA<|Lv-4+ zAlJQV?zYX)Xwf%8a?RVoBb8%|( Kmsx#fZ2b!f&dz}V literal 0 HcmV?d00001 diff --git a/__pycache__/ps.cpython-38.pyc b/__pycache__/ps.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d3556b77724a575519c1a5431edcb66fec21c5ad GIT binary patch literal 6178 zcmb_gOOG5^6|Q$zKc~B=$Mf*m8QXD^cI+7^JOjpr1Puu!gTYRO8bMR;Tiw&0e&tqm zGGkQ(Vw`}4MmR{3SY**7v0yf=fIq+vBvvfY-6A1bV#h9m4Bt7`j~Sad8>-c(?&I8Z z&pr3n`M#>xve}e|>#x6k$t$jE+TW>i{Bluw9{=Fi5JD4rTkGf*UDt#m%(l@nD<+q% zw$-sKHka+T(@9hk9k=45?o^T@QAr6`B=2gKv{(^Yk-Mu`GGb2T(UKJ@{-s5_sfkQI zAqt|1{+u{1N@4+}Ik75EiA9w1GhLAu^9=(sU3bNjSVnI_q;6{EGxy=CR@Rl>@nyrm zugA4iwc&@=(7WCC(U*^FyZvgX*>3uSowA_{+$R0D7dCrcQdP-nfI$tv*HK14802B< zhTrZD0zX&_{`i~Pwjb1Jw#h|vIrzVbe}HfzUc#V=4K-bhv=A{9mav7hZ^6^VmNcPr zsH@nyz9+qoviVj?g}Z&f%H_?nrJMkhbv%{kmUta1*5Ngc%eCG>hGkRPVXxN?B<-!t zkVw)*nk?Y<;gyZ;UdP|4_1a#r@xnm*-eBX#Zn)j+Zrt!{Z+Hzq*y!)x+1}^}>-}Ao zq`>jC3m6?(5SpIRt>q=s2_RV7GGQLC_5S;N@<;7nB`kHbtP!F7_pXWehsqKxN-FC2s%pI$W(Slz8dLoUH9m1uVRZLj7dzG*hU&Qj7ke4tD$!w>d8!H& z<#sa&Ux`QGxcLMWX8ZjlYBk#0$wg<1P8fUn6be%>6WGGUc$=-rjBNPqV5{As8@V&D zv9;Oh)_x67S=p86U`L)OLF?uKt27R3SRM3*7y2p{uc(TB=RM-^mreN?sgoDnT24M_ zsXQ?!FHwm%jnywu^<*sA&eLcQ$O+9jv1{?p{l{@w>sF0U`sAWRLt){N{KYsH5=w7Y;!Wm{lJ9MHnhs%ttFd-8AiD6c_QMTp2;mFrPUa-eR@8U zQ8vnij>u3l-M5F?C>3QXq3#sS?-{|LaLjILjd0@bUZCt@E6;F*@7F$cyHY}lcSzL`u?;BIE=ZD!Y#c~BUXDcz}I@&O9xPUuF z<;*^JnJj#t;pjaEhRK*y@iU{$B0T2)WQP$?MH>&+cMP!NTsXB})f_Rbsu*B% zYBeAwi5o^8-=zB$0N zN#+MS6(@maF}{9Vc>_$lpdbvrr^gMj#K92I2{Yl=V&%0 zIHZ|zB8k(8i7A!Ug-;c$i>C|o)%k_O;dOw;iu$u~jHnG*?T)gLcMt`MTZR0sVFNov zc1}_hHTS@&{5%{8?m~dB=y}7^Ej<-el_SSU=|%i9deLxnSI?o((n~rH(2-@hA32tV z5jphcbqBpJetCTjx(1gG9axLU4SjEFIzjd+YGF=Hx*3sI37Q*q3IaQGDO9#^@PvHo~O32kl3US zljd=mRiFd_c#pb%N#Yy{&djf%bONqEktfJkY48?_Z<9EgiR3M`{f^pSgE)?s@PWem zFeQ+$L-T|W1QLWV4E$>-Fk~)GfIlR#2Zh}O?2m!dV3?QRg)V}_Nb_-s`FrTh;QZn& zasCen|8IZ}+tS0tAB*FEAg^XPE?*|)8pNg~dWA*N>B8+7bUQ0sxW%aR29+L(%d$-> zZ<3HC)*zH|XItK*fIs+F8;M zegZKAML<~$ivT|c#<-3$;1Qt5y{K7$MF)^s(wB4xb%IHPxhX&zt0)sd;#shEfv*rOrqCoJ?XE5u5NpMf1O{7m#>_4<4g literal 0 HcmV?d00001 diff --git a/__pycache__/tools.cpython-38.pyc b/__pycache__/tools.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..77dda4949d379b02241ab0e15a638491198fccc9 GIT binary patch literal 11318 zcmdT~O>i8?b)KHT{lQ`Zf*?prv^|n2flE=KL|GMCq7+LcCDEZ^T7YE-k!rcz9xP_L zJG<A$;rHdzrA0$Ps@a9XTuap{^hwk^AKVhugG$Axsf_eU)B87s9HqX|8w!{;5mgSx`ITC#E|AmBQ_FoU7R*v zzwnybwYs(xT_>@mb;(vo5)*l&4$8znX!Oi2V+w6n&4Whb>^FATBsSIDUQR7e8keUN z1MJ(2idaeAO0A~+ni6;^S!vD>J7BvK`>EAvRZ}~N!b-_aO}Uz88c|%Xwi>Aw`R!Cx zQ;T0JQf?b+58D6u(c^2arhgp8mFW2M9Y~^c{QP>n)(VfGuT(EpYJPOQy}q$_JZ`lb z(L#GY&6jC>>NT214^a_`A+lmx*hp>hC874Bq)O}!{wQzbVG*7{2BI@!5o3DSO*I!= ziE&+Yb*UXYT)IG|H3+y1+9hLKEMijmAPT}Lu7p)TwHrYcD-*q?PTXlXF#jNoG1XXY zi_~getn(CgGDBq9xK(D#gLsR06NsXb#giB65X$b(^a5%%(_nZeHpdvYVyqrYk4n+Q zns4@;@cTKG-JRbMwL^ZrSV$qw8;0ilG=x1Aw*}6>7(;9CQcpAcy0ob_F{tHWnNVI& zjGnV)=mjb{i#yn%g`qWH!V}FRsiA|{3tf?jp0Q>8hI!du(sRaYIh}UfSKDT4Efhp9X2*ELLI;}8VJO&3l=_bZL)S!4#JKO;NJL+|Q-N_H-bdJtvw z49EXeMtEp^gn|B$G_~sNryOh2eU!VC`jDQpR34zNNc9boH|F|J5x-fXXqX-R@7Sbo zq4rbPpKoaWkq%BpqvviJ(v`-q@JZO$sm$#owzK6 zrXNN@D=e9$g%t@bB0J4?1l6QHt7wT8Nql4!`1JWainLA&oPGzTYPDDHq>Cjd%|vUJ zw%=G+WV%wj+G?+>9A%xgN>tt`nQDUGvLseAHhLr;lZ~aroj*nc7LXXC0P~&~Gat`o z)suL?O(wJqr|_^$AbuS3z(zCJoGkPR3y_FsjLTUG0V}cykcfTBUymRKAyaW_*Lj=n zQGT;^#V`BKcD!CD%4ey6(s0d=I*Ht3>Qt(6uv(=>8T^rPCpy-RZ(-X@QOEF!Da}o@ zo4skM!>kopFghk?ti+y@p;gmrVR- zWp=+oG-?g`TtEK~=x>1jMxXwjKK(nO$uo_uzKi@sKmP$}zu%|*pile3kTxR=80&}q z@*kpnlG|lu5#>MXm;VUmQ&fJ_cvq;r?u~QIE9d&7GsW}Nf6vy495R3zCmC!B>Vx;p z4A4D#8`MBLB$>T(mZTE936?X?B-V9-)V?m{zTYu#8s9PH+@{sd$^A*Lp1tH^+_&Of zk^^i&ihXsU^Xu3PdCyz&8$MR86?$^M6Z&3Ux!CZZ%A@9dMOB)9?5hYbj|~6tQU&!> z-l;<7JA=aWttbX)29#O=C6Bd((DxdZe(_Gy zKt>=WNZ~JdXQdxP(Sk}Cdverd!9$;(ce)kC#A57+f$}<`S6!<#+unR2=V{Oo3=Ml? z?tbbX(3HC%%suMkRI5Rfh{jp*ZuPwA)^=aCp$|b|=r&0-qD_w0r-N#|poM(v{aE?b zdBc!bpDt(zXox()H-D=jRsE*3ZaQ5CKLrRQcOjGsZRUWw(`|69FA!F4gVVkPYo_8Ceom>-~l{Ae#} z_Q+PM=aAHiGa7D*iDf2_1&&X-7qAp6uJNn21S#2Mg*hpDT(Vq0Izs~6BTb)b^X zD9tFp-KbQ3MNXa~?@xV!64E$!RMU*!l2Mu~N6-s0;^^aL)TgdK2;mgdk*Ww7sb8Q9 zV1P!X&T1OoZR#9V5)ROld5Lmt{qrMrW1IdwYK;9w`1doWZA_bo;6m7V2EPZ8pYA{R z;MWz0#GF|WCjXoLFV`mcpuUD)mUn=-!A7Fr=rodX5Qn_cFtMS8Ix!C9$YappO*#bF z>J|l|WCo^P!?)}Jz9|AQcT`f=19Hn*Nv8?E4S?GKwk<<1tu_Cu7S7|KRbQus-9lb? z@&-5Xj8yV7!}S>3rbCV7#ooxBIluJcQzssK;`1~>RYizNP4wZ~0^lYyo#wEp?Mf&s zQCb+Ru^+2-oFcqpzld>DtJap9ALfjidIc37Vrq!nOk3O|il(BPDk;(6j{qSZGrY$C zjLbm#U4-~>jQs!+0~@%_lorgo(|;4vPMo^cv$u>uNN3aTy0MeEiGw%+hXG}7)2+LB z%hyafu_?L$F-fMLx#R*UA^(g4$aE7WuAHn1qNrynNQmB;Iy}U6Mbsf=xM`wxa#Snb zn&<-V^n3gpf<86za|FaPyb@|- zSE%bLShT7N+Jtqek2HgWfHRYnskS-_=Q_%5VgRjcVM`Gs+}eeM+Jb^is72z7HaKr0 zRiVD!xJ9a^9D1<{u=iUjKLmzKbEG!`2RSE{KYS_W6xpqGf=?iARMI>Rza!7A=`+P5 z1}%_lr@`SqwcZUk10sWDqPWjD(S39n32-`;uL$*<74FBbnKxXV8;5W@xNs)&V%mgS zUIX0=Rno=5A9YIatd|Xj@7lHN<`8;@L)Snkx|>Jd?oK3m=_F=iK~vo%18s0OGu=Ys zMCX!1-R9Ima9T(}^i2zTU8uXg3^Zgi5okRLka{7`COPQ&gv=+Ctc7;BnAqx{WC173 zWXWhd7PhtEb_%76Q43m!{kKT12rPCO92ApK&UfqsMW|N8D9=T7#HIXn_a!&5oVU8V? z_PZi_EuKjVNl_la4Du9E-*kJ9yq9+*TKD$K0`^IPxJZgiMm#GIT^Eq&9QMd(I?v;f z_+%`ujm!Yso%UBNod!X@#a0NU%y?_5x^`o`h=jk&8kwvG{mKm$U+gVxlFAjBuL^ok#MRLBj97`6zPD5Ke<4~=O0js{`V@yT85 zYUZA6w;MrqG#g+c8PMFQFZNyrt_TTsz#>aKV(4D+2rI&If#c}WC}a@2&=cYcWK83){X@}G&S`FJ-u_}D~_!iFql`l z;#WzrR$HNVvM$h_%7X4fBdzszS$A{wNa+G5`~Sjsq9a0U1u{cV{Smy#RU~X_RT<|v zaLyzd2cGeZP##544<-xy01-qsb!3C7KFyL{k^g+BuHw`RA5M$7{E?$F@)3-5qn= zc|$KOER^<*tUdrDxvN@dRD#Y@hvQugPJ@+iK2Q}MX1uKLPb>Kv~dv?m-aAhP(M$U-=O4|DS49;4p@?Fp}t88 zFAswi;*>GfiY-@{UexXgM;@)X*;Z3j%@BeU!msHb-Vw@g@EJjn65CI@zn=T-Rjoh4=K}ivK_W*K7-7G;5P}-*XQP#FiMZKjtEJ_6jVMkTT zX&d|z=%D*=1|B4hAs}{}W;X)^X(a+M_DS3`;Qo6H7i%!)xIWW4z*0NWF+rEYof?(^ zB0F$QGAPk*ibZZp-G*_`5;css3ur>{fMU;i4N>7ZPL=sWx;&6YI@vD(=W8vM+N2Ze z*T81U(M|!QR|a<)r~<dv|I8TD8=_ zVAzN*PYtYYRvf?sEfD5Mu2saEtKUV<4o43VhVSjG_~pRya4GRALzjh(`1Ikfgj;$((OB)@$$q^5=rk*SEBA4Wi3bPHn~>%DurBh_T_wi_R^BToYB_c25F9Hc?nay4W(JhHEAZ4 zO|548L}~%V?Oyf$m<%>15kbi!Zcf_qALurs$d!>pFa@XE0k~GQ3uf>@B}gg$0=0Kn zitnKI|4b>4Kq=mWQoN;=;yozEP%XX!K#V2~Q3A%%DBuBbJIpCEDEvMK z!ZsW%y4Ar+qcPmAZSsNW!~(%jJbWIz!|6i<+~rIHW_BX}M2Nr@K7GQ?l8SKi6%8>b z;ytTWH^D}{%n_+&fY@)LkkP7o3%QlN4pq@%r2-Vdgqf{SV^zX&9}-|iXxmrSvZ`Kb z#)`md>7b%(2=!M~=@MoPE9$TL1^5}kBK=VlK}sE>CSagpCS@I%H0t=;?s@n5-WMCHJk%X6W@n zB(IXZsVn|^>)61emw|J}&F@`9=gX|n13N%AnXXYn#K_eTXpAQ)8QOz1&%O_D4)|tl zmWd4Cd6E@Ye@fJR`jZ&+#m9lW@pPV8r-{&~2XvV+i+>MsUi~9V;a$>Mj~`O}lE6M( z#07#Pn_HSw|9~IFQnKax=SPDfw%JVdV#Q}QGwCn;fWq?G*^hPw;_ z+2phBVGU$n##UnFR%K5%TN3Bovm~F0m^_fl=dup|WwM$4WY(EIk)O!#bBDfF{^fiz Mo6Fvt-J31_H{I5rWdHyG literal 0 HcmV?d00001 diff --git a/__pycache__/update.cpython-38.pyc b/__pycache__/update.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..249d74ace1ff47a1d7acf6ad5fa63f37b48e1fed GIT binary patch literal 7422 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 I>xJH*0jw1yfB*mh literal 0 HcmV?d00001 diff --git a/__pycache__/zh.cpython-38.pyc b/__pycache__/zh.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3dd2cf1637dbbdfe23a5aaad3aa4c6699bee7226 GIT binary patch literal 13386 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 literal 0 HcmV?d00001 diff --git a/pers/__pycache__/pers.cpython-38.pyc b/pers/__pycache__/pers.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b6d5eb16782a68509365ae3d9385455307a570a7 GIT binary patch literal 3802 zcmZWs&2JmW6`z^??8w)Y9ZG zJ-b3AVbw$JQ&0gpw6`9pqi;RukLVvTrvT~2=iUso?(fY~vg|Cevv1zK`TqUhdwkGr z1`N*~_g>UoV(dGrTzo84euFpvD+y|3zuX|)@1OMhnM7KS(gn+%d#mKp0aR7 zuF55O37VE%lgn}i(q-x2W1aQqSP|=Ry`>3+Ua@g>~Dy_mU9O{7*I_dpG zNdLq-wo7~D%Gw&k*P~Jf+a&vVYqQ{#$@)NSysilbf^2Zyjc(|lZSH90-tA9s-@4!a zpuPLW=byE&<(t>?Bd`7YPi}v4yM45fW|Q`vZu{DG2%Y@MX@A_^X&<$wDn4(i>~No1!M zQD|$N_0$m%W)Be`o!(uN> zx9&#$N6|3Ox2A_jds}oSrr4Yw>VUuz?HBRBx`a{k>nIqvd4v1R$JeLdxgUtapC|v)(oII<+voft81AWMro1*=s4O$ z=4P*2B(h_xItHmus0B&aax6DVWqg3Px2esX*&0dfRM1gW#T7`pN!vRg{~A;|ftq%> z4D3RBZT-}C4*I*Cv4TBe*a1fgz|X`f1E~29`;$Dj0bBrWgBA7@k#AS>%qiScfWNf2 z0e)&7d8IY-XSGv?Z$Mv3r(p3{?PA_8M)iyBkJlw^q=k`a#t%RTHfoS&gUy;4&oOC@9GsrRU*LFW68YOv>=0%kDV?a19v>WBc;WXCHV4OvT_EcPL_#O1uZjp`Q|HDQi zUxBki@@2HERVwIcXx<5Y3dV^i)8bG&(R4aKR6izzt5p1utQ^A#ZA+C+JFX!@806D& zQW#gSEigb^V7cafTJU80=2_J*91IOU_X93>jR#m@%e>9sGxBwmAK_hvk8t@re1WT9 zqsMNa$ba^bcOy4v9Kly}BFz8=fDB%pE|a1LB!F{`jl|3%KuZT8v!x4=+Jyj-Ad?3E z-jUuT^g=xF4g5d~)Hr~NKwQDgXgpaT669*KaY6*;=noK=e2CsN9|U$w)X-OqY6#gi zxo{$mz0#cprH9qIr8la}Ma5j6Td$vhu&^?7Q#=NNHoAK5HkWZjCf=A( zqX?U!cc**n^KSQnA~M`p@1i`i{`Pr&$#8G((RDyAm3LRW)ZGR@4m+0m z1Qm6g3Q~7k74zIdG9IT9!f&CpgCd!#kI2Y`1lo+cLB$pdv=be)J<5_4mAweuw26e+ zRg?~6gJJbEvTu;Ri^z}EOZ}2GgzQdG@rpbF13(Rd zULwO9mG@}!(CwSA`W21&W}uoA5F_tp>SI{sG&K_qP;8mEtYv%!&hyz$bvu5kOMYpDn5-KSu7_E3s(&dGnHQd(-YB#ux(VW%tsD%17S zR-2_mFIp&c%v2=z*iAP$bIKSQ!9oI~=!N82zBp<)QO6TfG!bfo)~fn8qV zl^y~LB+UM|!p9t*^pO+RFeXbs#q8f=_HWNyY>dcc0AAEjTte`uMlV7svcXgEnAQh= z`sl|-_0s=4mkrrG4>${5U^S@nGV+F6s9xyJQyyKzeN~YCUKDb0Lg!IP@)@R{A&)u5 zra&Umt$1LmyRfTp_ZdmosCfNy)%&EQm$Iv)cjs5F;&D_YS^E7zL@`Jr`&Yk%eMelt z{|+f^qtKqA3vsI=QI;Bd+*dy(qecbh^ZZE%2v4fWzf6if?Z>ICByXs){prI)^>cJm zv}c2MLtkY!L@?~ss_e?-S(J#)eMLoB8O~RbNRve350)B+j+)@O-#7}r_{Qey(a8Bpf0FxX1t%}L5!1Y&y_x}&uBXpVo literal 0 HcmV?d00001 diff --git a/pers/pers.py b/pers/pers.py new file mode 100644 index 0000000..ede0e5e --- /dev/null +++ b/pers/pers.py @@ -0,0 +1,124 @@ +#!/usr/bin/env python3 +# -*- coding: UTF-8 -*- +#Nom : : pers.py +#Description : +#Copyright : 2021, CEN38 +#Auteur : Colas Geier +#Version : 1.0 + +from os import register_at_fork +from pandas import read_sql, merge, DataFrame +from pandas.core.indexing import is_nested_tuple +from ..tools import to_upper, to_tuple, to_upperfirst, _get_table,_aggr_cols +from ..params import con + +schema = 'personnes' + +def get_auteur(nom=None, prenom=None): + table = 'personne' + sql = 'SELECT * FROM %s.%s'%(schema,table) + if nom or prenom : sql = sql + ' WHERE ' + if nom : + sql = sql + 'nom IN %(nom)s' + nom = to_upper(nom) + if nom and prenom : sql = sql + ' AND ' + if prenom : + sql = sql + 'prenom IN %(prenom)s' + prenom = to_upperfirst(prenom) + df = read_sql( + sql = sql, + con = con, + params = {'nom': to_tuple(nom), 'prenom': to_tuple(prenom) }) + df['nom_prenom'] = df.nom + ' ' + df.prenom + df.loc[df.nom_prenom.isna(), 'nom_prenom'] = df.loc[df.nom_prenom.isna(), 'nom'] + + return df + +def get_organisme(ids=None, nom=None): + table = 'organisme' + df = _get_table(con, schema, table, ids=ids, nom=nom) + return df.set_index('id') + + +def _merge_orga(df, split_cols): + org = get_organisme() + aut = get_auteur() + df = df.copy() + for c in split_cols: + if not isinstance(df[c], int): df[c] = df[c].astype(float) + df[c].replace(aut.id.tolist(), aut.id_organisme.tolist(), inplace=True) + df[c].replace(org.id.tolist(), org.nom.tolist(), inplace=True) + df['organisme'] = None + for c in split_cols: + df.loc[df.organisme.isna(), 'organisme'] = df.loc[df['organisme'].isna(), c] + for c in split_cols: + comp = df.loc[~df[c].isna(),'organisme'].compare(df.loc[~df[c].isna(), c]) + if not comp.empty: + comp['test'] = comp.apply(lambda x: x['other'] in x['self'], axis=1) + comp = comp[~comp.test] + if not comp.empty: + df.loc[comp.index,'organisme'] = comp.self + ' & ' + comp.other + df.drop(columns=split_cols, inplace=True) + return df + + +def _merge_author(df, col_aut, orga=False, on_index=False): + # récupération des auteurs + aut = get_auteur().fillna('') + aut['nom_prenom'] = (aut['nom'] + ' ' + aut['prenom']).str.strip() + aut['id'] = aut['id'].astype(str) + id_inconnu = aut[aut.nom == 'INCONNU'].id[0] + + # merge des auteurs + df[col_aut].fillna(id_inconnu, inplace=True) + df[col_aut] = df[col_aut].replace(['\.0'],'',regex=True) + r_id = df[['id', col_aut]].copy() + r_idSplit = r_id[col_aut].str.split(' & ', expand=True) + r_id = r_id.join(r_idSplit) + cSplit = r_idSplit.shape[1] + cSplit = list(range(cSplit)) + + if orga: + # récup des organismes + org = _merge_orga(r_id, cSplit) + + r_id[cSplit] = r_id[cSplit].replace(aut['id'].tolist(),aut['nom_prenom'].tolist()) + r_id = _aggr_cols(r_id,cSplit,' & ') \ + .rename(columns={'aggreg': 'auteur'}) \ + .drop(columns=cSplit) + + if orga: + # merge des organismes + r_id = merge(r_id,org, on=['id', col_aut], suffixes=[None,'_y']) + + if on_index: + df = merge(df,r_id,how='left', right_index=True,left_index=True, suffixes=[None,'_y']) \ + .drop(columns=['id'+'_y',col_aut+'_y',col_aut]) + else: + df = merge(df,r_id,how='left', on=['id', col_aut], suffixes=[None,'_y']) \ + .drop(columns=[col_aut]) + + return df + + +def _merge_relation(df, table, schema, id=None, left_id=None,right_id=None): + if id: + params = {id: df[id].tolist() } + elif left_id and right_id: + params = {right_id: df[left_id].tolist() } + + mrg = _get_table(con, schema, table, params_col=params) + # if table == 'r_sites_auteur' or table == 'r_geomsites_auteur': + if table.startswith('r_') and table.endswith('_auteur'): + mrg = mrg[[right_id,'id_auteur']].groupby( + [right_id])['id_auteur'].apply(lambda x: ' & '.join(x.astype(str))) + mrg = DataFrame(data=mrg) + + if id: + df = merge(df,mrg, how='left', on=id) + elif left_id and right_id: + df = merge(df,mrg, how='left', left_on=left_id, right_on=right_id,suffixes=[None,'_y']) + rmcol = df.columns[df.columns.str.endswith('_y')].tolist() + if rmcol: + df.drop(columns=[*rmcol], inplace=True) + return df \ No newline at end of file diff --git a/ps.py b/ps.py new file mode 100644 index 0000000..6f5f442 --- /dev/null +++ b/ps.py @@ -0,0 +1,220 @@ +#!/usr/bin/env python3 +# -*- coding: UTF-8 -*- +#Nom : : ps.py +#Description : +#Copyright : 2021, CEN38 +#Auteur : Colas Geier +#Version : 1.0 + + + +from pandas.core.reshape.merge import merge +from .pers.pers import _get_table +from .sites.sites import _get_typ_milieux +# from .params import con +from .tools import _get_relation_tab,_set_geom + +schema = 'ps' +milieu = 'Pelouses sèches' + + +def get_param(): + from .tools import _get_param + return _get_param(schema=schema,param_table='param',type_table='type_param',type_court=False) + + + +def get_sitesInfos(id_site=None, nom_site=None, columns=None, with_nameOrga=False, statut='actif'): + from .sites.sites import get_sitesInfos + + df = get_sitesInfos( + ids=id_site, nom=nom_site, columns=columns, + with_nameOrga=with_nameOrga, milieu=milieu, statut=statut) + df.drop(columns=['typo_sdage'], inplace=True) + + return df + + +def get_listLegendePS(): + from .params import con + return _get_table(con,schema,'param_legende') + + +def get_sitesGeom(id_site=None, nom_site=None, columns=None, last_update=False, with_nameOrga=False, + params_col={}, statut='actif'): + from .sites.sites import get_sitesGeom + + df = get_sitesGeom( + id_site=id_site, nom_site=nom_site, columns=columns, + with_nameOrga=with_nameOrga,last_update=last_update, + params_col=params_col, milieu=milieu, statut=statut) + # df.drop(columns=['typo_sdage'], inplace=True) + + return df + + +def ps_r_site_param(id_site=None, nom_site=None, columns=None, last_update=False, + geom=False, raw=False, idparam=False, pivot=True): + from pandas import pivot_table + from .pers.pers import _merge_relation, _merge_author + + table = 'r_site_param' + r_tab_auteur = 'r_siteparam_auteur' + df = _get_relation_tab(schema=schema,tab=table,id_site=id_site,nom_site=nom_site, + last_update=last_update,geom=geom,milieu=milieu) + if 'auteur' in df.columns: + df.rename(columns={'auteur': 'auteur_geom'}, inplace=True) + df = _merge_relation(df=df,table=r_tab_auteur,schema=schema, left_id='id',right_id='id_siteparam') + df = _merge_author(df=df, col_aut='id_auteur') + df.rename(columns={'auteur': 'auteur_param'}, inplace=True) + + dic = get_param() + if not df.empty: + df.date_geom = df.date_geom.astype(str) + nval = 'param' + ntyp = 'type' + df = merge(df,dic, how='left', left_on='id_param', right_on='id', suffixes=(None,'_y'))\ + .drop(['id_y','id_param'],1) \ + .rename(columns={'description':'desc_param_ps', 'nom':nval}) + + if raw: + df.drop(columns='desc_param_ps', inplace=True) + else: + df.drop(columns=nval, inplace=True) + df.rename(columns={'desc_param_ps':nval}, inplace=True) + + df.taux.fillna(-999, inplace=True) + if geom: + dfgeom = df[['id_site', 'date_geom', 'geom']] + print(dfgeom) + dfgeom = dfgeom.drop_duplicates() + df.drop(columns=['geom'], inplace=True) + indexs = df.columns[~df.columns.isin(['taux',nval,'id','type'])].tolist() + + if pivot: + df2 = pivot_table( + df.fillna(''), + values=['taux',nval,'id'], + index=indexs, + columns=['type'], + # dropna=False, + aggfunc={lambda x: ', '.join(x.astype(str))}) + df2.columns = [ x[0].split('_')[0] + '_' + x[2][:6] for x in df2.columns ] + date = [x for x in df2.index.names if x.startswith('date_par')] + df2.reset_index(['auteur_param', *date], inplace=True) + df = df2 + else : + df.set_index(indexs, inplace=True) + + if geom: + idx = df.index.names + df.reset_index(inplace=True) + df = df.merge(dfgeom, how='left', on=['id_site', 'date_geom']) + df.set_index(idx, inplace=True) + df = _set_geom(df, hex=False) + + cols = df.columns[df.columns.str.startswith('param')].sort_values() + rcol = dic.type.unique() + rcol.sort() + dicc = dict(zip(cols,rcol)) + df.rename(columns=dicc, inplace=True) + + if not idparam: + rmcol = df.columns[df.columns.str.startswith('id')] + df.drop(columns=rmcol, inplace=True) + + df.replace(['-999',-999],[None, None],inplace=True, regex=True) + df.dropna(how='all', axis=1, inplace=True) + + return df + + + +def ps_r_site_habitat(id_site=None, nom_site=None, columns=None, last_update=False, + geom=False, raw=False, idhabitat=False, pivot=True): + from pandas import pivot_table + from .pers.pers import _merge_relation, _merge_author + + table = 'r_site_habitat' + r_tab_auteur = 'r_sitehab_auteur' + r_hab_cb = 'r_hab_cb' + + df = _get_relation_tab(schema=schema,tab=table,id_site=id_site, + nom_site=nom_site,last_update=last_update,geom=geom,milieu=milieu) + if 'auteur' in df.columns: + df.rename(columns={'auteur': 'auteur_geom'}, inplace=True) + + df = _merge_relation(df=df,table=r_tab_auteur,schema=schema, + left_id='id',right_id='id_sitehab') + df = _merge_author(df=df, col_aut='id_auteur') + df.rename(columns={'auteur': 'auteur_hab'}, inplace=True) + indexs = df.columns[~df.columns.isin(['id','n_hab','geom','index'])].tolist() + + df = _merge_relation(df=df,table=r_hab_cb,schema=schema, + left_id='id',right_id='id_sitehab') \ + .drop(columns=['id_sitehab']) + + if not raw: + from .zh import ref_hab + cb = ref_hab().get_CB(cols=['id','lb_hab_fr','descriptif_cb_fr']) + df = merge(df,cb, how='left', left_on='code_hab',right_on='id',suffixes=[None,'_y']) \ + .drop(columns=['code_hab','id_y']) \ + .rename(columns={'lb_hab_fr':'hab','descriptif_cb_fr':'desc_hab'}) + + if not df.empty: + df.date_geom = df.date_geom.astype(str) + if geom: + dfgeom = df[['id_site', 'date_geom', 'geom']] + print(dfgeom) + dfgeom = dfgeom.drop_duplicates() + df.drop(columns=['geom'], inplace=True) + + vals = df.columns[~df.columns.isin(['id',*indexs])].tolist() + if pivot: + df2 = pivot_table( + df.fillna(''), + values=vals, + index=indexs, + columns=['index'], + # dropna=False, + aggfunc={lambda x: ', '.join(x.astype(str)),}) + df2.columns = [ x[0] + str(x[2]) for x in df2.columns ] + date = [x for x in df2.index.names if x.startswith('date_hab')] + df2.reset_index(['auteur_hab', *date], inplace=True) + df = df2 + else : + df.set_index(indexs, inplace=True) + + if geom: + idx = df.index.names + df.reset_index(inplace=True) + df = df.merge(dfgeom, how='left', on=['id_site', 'date_geom']) + df.set_index(idx, inplace=True) + df = _set_geom(df, hex=False) + + if not idhabitat: + idx = df.columns[df.columns.str.startswith('id')] + df.drop(columns=idx, inplace=True) + + return df + + + +def get_ps(id_site=None, nom_site=None, columns=None, last_update=False, + geom=False, raw=[False,True], idparam=False, idhabitat=False): + + if isinstance(raw, bool): + rawp = rawh = raw + elif isinstance(raw, list): + rawp = raw[0] + rawh = raw[1] + + df = ps_r_site_param(id_site=id_site, nom_site=nom_site, columns=columns, + last_update=last_update, geom=False, raw=rawp, idparam=idparam, pivot=True) + df2 = ps_r_site_habitat(id_site=id_site, nom_site=nom_site, columns=columns, + last_update=last_update, geom=geom, raw=rawh, idhabitat=idhabitat, pivot=True) + + df = merge(df, df2, on=df.index.names) + + return df + diff --git a/ref/__init__.py b/ref/__init__.py new file mode 100644 index 0000000..c0a57e7 --- /dev/null +++ b/ref/__init__.py @@ -0,0 +1,4 @@ +#!/usr/bin/env python3 +# -*- coding: UTF-8 -*- + +from .territoire import * \ No newline at end of file diff --git a/ref/__pycache__/__init__.cpython-38.pyc b/ref/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c01fc21ef6b35b076523a88cece963add1e0ea56 GIT binary patch literal 173 zcmWIL<>g`kf+fl!iJn0EF^Gc(44TX@8G%BYjJFuI z{4^P(xJpusiZV;`GmBDJG88cbrNG25bN!6`+*JMK{G7yMeW%i*)WlN#fXb4L{5<`D x#N_P6^weVgg3784{i4(~{rLFIyv&mLc)fzkTO2mI`6;D2sdg+tvpxec0{}H{DYF0o literal 0 HcmV?d00001 diff --git a/ref/territoire/__init__.py b/ref/territoire/__init__.py new file mode 100644 index 0000000..1c66a0b --- /dev/null +++ b/ref/territoire/__init__.py @@ -0,0 +1,4 @@ +#!/usr/bin/env python3 +# -*- coding: UTF-8 -*- + +from .territoire import get_districtNat \ No newline at end of file diff --git a/ref/territoire/__pycache__/__init__.cpython-38.pyc b/ref/territoire/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b4eb026c37beb69f0be413f38d69c94d90e95ea7 GIT binary patch literal 207 zcmYj}F$%&!6hwEUg$O|pVUxyx0TIaoLO?~ZS(fZKSxmCwXH&!*d8M>g)^=9@*yzB_ zFjKr^7|sO?RtJ6JevIQ^0goNKU2+&{tap}>M$BE%lCFYp6_Qnt2U Tsddv2vrXkpSK@ZWzS!aebk#LY literal 0 HcmV?d00001 diff --git a/ref/territoire/__pycache__/territoire.cpython-38.pyc b/ref/territoire/__pycache__/territoire.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bb0d0d112a46d942ffc35f324ed388f24833f609 GIT binary patch literal 413 zcmY*Vu};J=3{9H0hfY0^_yrcakRLz@0dsW{uwy3dLVK-GVm+BBe#4#LgRYA zmg-4vOyI-#+;9}ecf$7Q*)UE=af83g`kf{3>wi3ULWF^Gc<7=auIATDMB5-AM944RC7D;bJF!U*D*rG7?!ZmNEA zeokVszEf#YYGSE=KxIirex80nVsdt3dTOzLL1k5jesN|AkQpDJnU`4-AFo$Xd5gm) RH$SB`C)EyQZ$bI1SzF=maZk@!ka z)4MW;m+T@30}3{moP3auy5y8!k)P0qTml5xzmP+muX;!>Ef~nbB&MeNRbAa(-`6$2 zZ8jqZKY#G6^zS>4^Di!J{z4Sq#Z&wff*cYfXDkvSSeGNo`q)j}v6pzZ&K>#VAPKDQ zjcVgsQiJX%VOG1UUpq;JcLVP@3(lHntt`kw3NB^Rw&jj3`&7GhldX-K(AIQmk0NS3 z7s)p5Q%p^0J9Lj))P}Z8b^Gs7CwHK2orKh-ZM59^f|ecHMax~fLwBD$$sW}oJH7ia zB^KEeCh89}-Ph@dqpasDt~Aa5I8(!{pU(B^RGId&sIpP2^XUYG+<|?0vrHAnFLIp~ zs11t2X*N!KQt?ij$QtcW(s5>D)wjJc*>rq7;AvJr4@wQs&+ruYAV@5vcC^s4l%-P& zl9&F%EnRr+9-D@~m}UKOKFYKCjWljfg>fg-@lEBt@?pWwf8(hp>n#Z5TVIT%lN(2E zqvk)~KRlg|v%|r3lop3SovSRJA3nOkf+vTM(!qH;%!tteC8|~+J%g@2iYtG^*&-FAn#HvTBT2Z**fz{>^oP1u3d{<{8cV|9qPJ{%7`Nf zapadZU@u&>%l290g(&_+HE8j9pq}I1q#A`(zm&q!t+Gv#2KE?rh`hGO81#0jb?GkJ z#1?qmzss;}mrd$W8-2H^dkK_7-yTZZxfEv|+GWIjYD<{6PIrdl9bVO5W#NTT-?lbl z*x1{!vA1DkADG{?ac^nEU)xaDMgund4IBQ3jr;U~UZdAPb=fcL3CcsszLXyC1@8d- zTkb&FzS^S3wE*7UIDW~81#J745)=dVMpT$;<<#ENFRX|0%|>SSb2Xe1k1H@@n^0ky@#a!hTMo#;Ng zgeo7NvIZXDKGrf%WW1>wrb)bVmc!Y2Jgg^;V`TrL=Nb2O`ovVWrjwN|){6PbN&Yk| zjEC_TJ)tGC2N0&dZtZnVFiR(t7U}^vGXp6GzhdaAZ$X$KE%>aATWDoj z{uNOgKO4{VgvrUaM zo#vxLeZ`un$Xb1sjammEvc`vK*?dK$%5F{wH|=2?F|JPg7VEW`^eid=dU7%?z5_GG zF@z&y>4Aa+{zHqzp4^k6j6@5x+`@ZD1fK;m{BPh!GXBC+gtk})=&jy^#m})7bMcz3 z{tUJ%rFx_xwRk3rol*{QZxOiWyr$kN<&`9quE8ke+PWiK=aFmcd|UU()&=Bq9eC{{ z?Sj{8KxqhG3(N4#BMDyfb+FQmw?*JKu-%z=66jOD%GT0&LgCqlo zH=_OZ$WNegPINC9tI=h|8O^bcbjA0vdJEzu&d4zyXB>)E^%{%USul;MH(2nAB4Ob` zRc}H70IAMC0Mfr%weU-Ez=AY@p`HsSn}1kjAeQqio7ryaYuxGU5J^|r6vxKrlIIL_ z4|`#wR`s~=ciCXDq_{@)wtad#Cd!L^0=AqCn5gnXn*ilZ=?d5kXZ1rCM=Us%+Q4$4 zr*;UOyC~GVXfzF#!QFm7q3o$?Grs#YpN;YX7Ftwbyue38 z{gqmyJRM~NZQ3^F<*yZc-5_xoAs(?f)8LlnidCPNxL!Yl4_$6wj2v+`R_vlScEAR! wO|iqH@s#GH>|q^!i?< 0: + add = sep + df.loc[~df[col].isna(),'aggreg'] = df.loc[~df[col].isna(),'aggreg'] + add + df.loc[~df[col].isna(),col] + return df + +def to_tuple(obj): + if isinstance(obj, (list,Series)): obj = tuple(obj) + if isinstance(obj, (int, str)) : obj = tuple([obj]) + return obj + +def to_colStringSQL(obj): + if isinstance(obj, (int)) : obj = str(obj) + if isinstance(obj, (list,Index)): obj = ",".join(obj) # Don't work with df.columns + return obj + +def to_upper(obj): + if isinstance(obj, Series): obj = Series([o.upper() for o in list(obj)]) + if isinstance(obj, tuple): obj = tuple([o.upper() for o in list(obj)]) + if isinstance(obj, list) : obj = [o.upper() for o in obj] + if isinstance(obj, str) : obj = obj.upper() + return obj + +def to_upperfirst(obj): + if isinstance(obj, Series): obj = Series([o.upper()[0] + o.lower()[1:] for o in list(obj)]) + if isinstance(obj, tuple): obj = tuple([o.upper()[0] + o.lower()[1:] for o in list(obj)]) + if isinstance(obj, list) : obj = [o.upper()[0] + o.lower()[1:] for o in obj] + if isinstance(obj, str) : obj = obj.upper()[0] + obj.lower()[1:] + return obj + +def dropZ(df,geom_col='geom'): + from shapely import wkb + df = df.copy() + df.loc[df[geom_col].has_z, geom_col] = [ + wkb.loads(wkb.dumps(geom, output_dimension=2)) for geom in df.loc[df[geom_col].has_z, geom_col] + ] + # if all(df_sites['geom'].has_z): + # # Suppression de la dimension Z + # geom_type = df_sites['geom'].geom_type + # df_sites['geom'] = [wkb.loads(wkb.dumps(geom, output_dimension=2)) for geom in df_sites['geom']] + # df_sites.set_geometry('geom', drop=False, inplace=True, crs=crs) + return df + +def remove_empty_keys(d): + for k in d.keys(): + if not d[k]: + del d[k] + +def _get_table(con, schema, table, ids=None, nom=None, cols=None, params_col={}, statut='actif'): + ''' + Selection d'une table: + + Parameters + ---------- + con : Connection sqlalchemy + schema : str. Nom du schema PostgreSQL. + table : str. Nom de la table PostgreSQL. + ids : liste. Identifiant de la table. + Doit contenir un champ 'id'. + nom : liste. Nom de la table. + Doit contenir un champ 'nom'. + cols : liste. Colonnes de la table à sélectionner. + params_col : Dict. Paramètre de Séléction IN. + requete : {'column': [liste]} + sql trad : 'column IN (liste)' + statut : str. 'actif', 'history', 'all'. + Statut des sites à récupérer, + 'actif'; Date_fin IS NULL + 'history'; A une Date_fin + 'all'; Tous les Sites + ''' + sql = 'SELECT * FROM {sch}.{tab}'.format(sch=schema, tab=table) + if params_col: + params_col = { k: v for k, v in params_col.items() if v } + + if cols : sql = sql.replace('*', to_colStringSQL(cols) ) + # Si arg (ids|nom|params_col), ajout de 'WHERE' + if ids or nom or params_col or (statut!='all' and table=='sites') : sql = sql + ' WHERE ' + if ids : sql = sql + 'id IN %(ids)s' + if ids and (nom or params_col or (statut!='all' and table=='sites')) : sql = sql + ' AND ' + if nom : sql = sql + 'nom IN %(nom)s' + if nom and (params_col or (statut!='all' and table=='sites')) : sql = sql + ' AND ' + if statut=='actif' and table=='sites': sql = sql + ' date_fin IS NULL ' + if statut=='history' and table=='sites': sql = sql + ' date_fin IS NOT NULL ' + if params_col and (statut!='all' and table=='sites') : sql = sql + ' AND ' + if params_col : + sql = sql + ' AND '.join([k + ' IN %({})s'.format(k) for k in params_col.keys()]) + params_col = {key:to_tuple(params_col[key]) for key in params_col.keys()} + + sql = sql.replace("',)","')") + df = read_sql( + sql = sql, + con = con, + params = {'ids': to_tuple(ids), 'nom': to_tuple(nom), **params_col }) + if 'geom' in df.columns: + df = _set_geom(df) + return df + +def _set_geom(df, hex=True): + from shapely.wkb import loads + import geopandas as gpd # set_geometry + + if hex: + df['geom'] = [(loads(geom, hex=True)) for geom in df['geom']] + df = df.set_geometry('geom', crs='EPSG:2154') + + return df + + +def _get_param(schema, param_table, type_table=None, type_court=True): + from .params import con + + if type_table: + typ = _get_table(con, schema, table=type_table) + par = _get_table(con, schema, table=param_table, params_col={'id_type':typ.id.tolist()}) + df = merge(par, typ, left_on='id_type', right_on='id', how='left', suffixes=(None, '_typ')) \ + .drop(columns=['id_type','id_typ']) + if 'description_typ' in df.columns: del df['description_typ'] + if type_court: df = df.drop(columns=['nom_typ']).rename(columns={'nom_court_typ':'type'}) + else : df = df.drop(columns=['nom_court_typ'],errors='ignore').rename(columns={'nom_typ':'type'}) + index = ['id'] + if 'type' in df.columns: + index += ['type'] + df = df.set_index(index).reset_index() + else: + df = _get_table(con, schema, table=param_table) + + return df + + +def _get_relation_tab(schema, tab, id_site=None, nom_site=None, last_update=False, + geom=False,params_col={},milieu=None,statut='actif'): + ''' + + Parameters + ---------- + schema : str. Default : None. + Schéma de la database New_cen38. + tab : str. Default : None. + Schéma de la database New_cen38. + id_site : str,list. Default : None. + Identifiants des sites présent dans la table 'sites'. + nom_site : str,list. + Nom des sites présent dans la table 'sites'. + last_update : bool. Default : False. + If True, récupération des dernières données à jour. + If False, récupération des toutes les données. + geom : bool. Default : False. + Return les geometries des sites + params_col : dict. Default : {}. + Application des conditions de séléction des données + sous la forme d'un dictionnaire {'nomcolumn': conditions}. + milieu : str. Default : None. + Nom d'un milieu référencé dans la table `sites.type_milieu`. + Liste récupérable avec la fonction `pyzh.sites._get_typ_milieux()` + statut : str. 'actif', 'history', 'all'. + Statut des sites à récupérer, + 'actif'; Date_fin IS NULL + 'history'; A une Date_fin + 'all'; Tous les Sites + + + Return + ---------- + df + ''' + from .params import con + from .sites.sites import get_sitesGeom + # from .pers.pers import _merge_relation, _merge_author + + table = 'sites' + dfSG = get_sitesGeom(columns='date', id_site=id_site, nom_site=nom_site, + last_update=last_update,params_col=params_col,milieu=milieu,statut=statut) + + if not geom and not dfSG.empty: + dfSG.drop('geom',1,inplace=True) + ids = dfSG.id.tolist() + table = tab + + if ids : + df = _get_table(con, schema, table, params_col={'id_geom_site':ids}) + if last_update: + tmp = ['id', 'date', 'valid'] + col = [*df.columns[~df.columns.isin(tmp)]] + df = df.sort_values(col).reset_index(drop=True) + df.drop_duplicates(subset=col, keep='last', inplace=True) + df.reset_index(drop=True, inplace=True) + df = df[df.valid].copy() + + if 'date' in dfSG.columns and 'date' in df.columns: + dfSG.rename(columns={'date':'date_geom'}, inplace=True) + df.rename(columns={'date':'date_'+table.rsplit('_',1)[1][:5]}, inplace=True) + # if table == 'r_site_sub': + # print('DF : {}'.format(df)) + # print(df.empty) + # print('DFSG : {}'.format(dfSG)) + + if not df.empty: + df = merge(dfSG,df, how='left', left_on='id', right_on='id_geom_site', suffixes=('_x', None)) \ + .drop(['id_x','id_geom_site'],1) \ + .set_index('id').reset_index() + + return df + else: + print('PAS de géometries de sites sélectionnées ...') + + +def _get_relation_autor(df, relation_tab, schema, id_df, id_relation, id_rela_auth='id_auteur'): + from .pers.pers import _merge_relation, _merge_author + if 'site' in relation_tab: + suffixe = relation_tab.split('_')[1].split('site')[1] + suffixe = '_' + suffixe + df = _merge_relation(df=df,table=relation_tab,schema=schema, + left_id = id_df, + right_id = id_relation) + df = _merge_author(df=df, col_aut=id_rela_auth, on_index=True) + df.rename(columns={'auteur': 'auteur'+suffixe}, inplace=True) + return df + + + +def to_geoms(geometries): + from shapely.geometry import Polygon,LineString + for geometry in geometries: + if isinstance(geometry, (Polygon,LineString)): + yield geometry + else: + yield from geometry + + +def union_polygons_geometry(df): + ''' + Transforme un GeoDataFrame de Polygons + et/ou MultiPolygons en un MultiPolygon unique: + + Parameters + ---------- + df : GeoDataFrame. + ''' + from shapely.geometry import MultiPolygon + name_geom = df.geometry.name + + poly = df.loc[df.geom_type=='Polygon',name_geom].tolist() + multipoly = df.loc[df.geom_type=='MultiPolygon',name_geom].tolist() + + if poly: + mp2 = MultiPolygon(poly) + if poly and multipoly: + res = MultiPolygon(to_geoms([*mp2, *multipoly])) + elif not poly and multipoly: + res = MultiPolygon(to_geoms(multipoly)) + elif not multipoly and poly: + res = MultiPolygon(poly) + + return res + + +def union_lines_geometry(df): + from shapely.geometry import MultiLineString + name_geom = df.geometry.name + + line = df.loc[df.geom_type=='LineString',name_geom].tolist() + multiline = df.loc[df.geom_type=='MultiLineString',name_geom].tolist() + + if line: + mp2 = MultiLineString(line) + if line and multiline: + res = MultiLineString(to_geoms([*mp2, *multiline])) + elif not line and multiline: + res = MultiLineString(to_geoms([*multiline])) + elif not multiline and line: + res = MultiLineString(line) + + return res + + +def calc_recouvrmt(df1,df2): + ''' + Calcule le recouvrement de df2 sur df1 + pour chaque géométrie de df1: + + Parameters + ---------- + df1 : GeoDataFrame. + df2 : GeoDataFrame. + ''' + from geopandas import sjoin + tmp = sjoin( + df1, + df2[['geom']], + op = 'intersects', + how = 'left') + tmp.dropna(subset=['index_right'],inplace=True) + tmp.index_right = tmp.index_right.astype(int) + tmp.reset_index(inplace=True) + tmp = tmp.join( + df2[['geom']].rename(columns={'geom': 'right_geom'}), + on=['index_right'], how='left') + tmp2 = tmp[['index_right','right_geom']].copy() \ + .rename(columns={'right_geom': 'geom'}) \ + .set_geometry('geom') + tmp1 = tmp[['id_site','geom']].copy() \ + .set_geometry('geom') + + if not tmp1.geom.values.is_valid.all(): + tmp1.loc[~tmp1.geom.values.is_valid,'geom'] = tmp1.loc[~tmp1.geom.values.is_valid,'geom'].buffer(0) + if not tmp2.geom.values.is_valid.all(): + tmp2.loc[~tmp2.geom.values.is_valid,'geom'] = tmp2.loc[~tmp2.geom.values.is_valid,'geom'].buffer(0) + + tmp['perc_rcvmt'] = (tmp1.intersection(tmp2).area/tmp1.area)*100 + tmp = tmp.groupby(['id_site']).sum().reset_index() + df1 = df1.merge(tmp[['id_site','perc_rcvmt']], on=['id_site'], how='left') + df1.perc_rcvmt.fillna(0, inplace=True) + df1.perc_rcvmt = df1.perc_rcvmt.round(2) + return df1 + + +def Polygons_to_MultiPolygon(df): + from shapely.geometry import MultiPolygon + from pandas import concat + df = df.copy() + multi = df.loc[df.geom_type=='MultiPolygon'].copy() + poly = df.loc[df.geom_type=='Polygon'].copy() + poly['geom'] = [MultiPolygon([geom]) for geom in df.loc[df.geom_type=='Polygon','geom'] ] + df = concat([multi,poly]) + df.sort_index(inplace=True) + return df \ No newline at end of file diff --git a/update.py b/update.py new file mode 100644 index 0000000..3b4c754 --- /dev/null +++ b/update.py @@ -0,0 +1,282 @@ +#!/usr/bin/env python3 +# -*- coding: UTF-8 -*- +#Nom : : update.py +#Description : +#Copyright : 2021, CEN38 +#Auteur : Colas Geier +#Version : 1.0 +""" +Module contains tools for processing files into DataFrames or other objects +""" + +import geopandas as gpd +import pandas as pd +from .params import DIC_REF_HAB, DIC_UNIQUE_KEY +from .tools import _get_table + +##################################### +### Update ### +##################################### +def __get_pkey__(engine,table_name,schema): + pk = engine.dialect.get_pk_constraint(engine,table_name=table_name,schema=schema) + return pk + +def _get_dic(self): + if self._table: + select_cols = DIC_REF_HAB[self._table] + return select_cols + +def _get_schema_name(self): + engine = self.con + lst_sch = engine.dialect.get_schema_names(engine) + tab = [] + for sch in lst_sch: + lst_tab = engine.dialect.get_table_names(engine,schema=sch) + if self._table in lst_tab: + tab += [sch] + + if len(tab) > 1: + print('La table %s exitent dans plusieurs schéma ! Préciser l''argument ''schema'''%self._table) + elif len(tab) == 0: + print('La table %s sitée n''existe pas ...') + else: + return tab[0] + +def _check_data_exist(self, df): + engine = self.con + pk = __get_pkey__(engine,table_name=self._table,schema=self._schema) + self._pkey = pk['constrained_columns'][0] + pkey = self._pkey + if self._table in DIC_UNIQUE_KEY.keys(): + pkey = DIC_UNIQUE_KEY[self._table] + + data_indb = _get_table(self.con, self._schema, self._table, cols=[pkey]) + data_exist_not = df[~df[pkey].isin(data_indb[pkey])] + data_exist = df[df[pkey].isin(data_indb[pkey])] + data_exist_eq, data_exist_ne = _check_eq_df(self, data_exist) + + return [data_exist_eq, data_exist_ne, data_exist_not] + + +def _check_eq_df(self,df): + from .zh import _get_table + pkey = self._pkey + params = {} + if isinstance(pkey, list): + for key in pkey: + p = {key: df[key]} + params = {**params, **p} + else: + params = {pkey:df[pkey]} + data = _get_table(self.con, self._schema, self._table, cols=df.columns.tolist(), params_col=params) + if self._table in DIC_UNIQUE_KEY.keys(): + if DIC_UNIQUE_KEY[self._table] != pkey: + df = df.sort_values(DIC_UNIQUE_KEY[self._table]) + data = data.sort_values(DIC_UNIQUE_KEY[self._table]) + else : + df = df.sort_values(pkey) + data = data.sort_values(pkey) + else: + df = df.sort_values(pkey) + data = data.sort_values(pkey) + if self._table in DIC_UNIQUE_KEY.keys(): + if DIC_UNIQUE_KEY[self._table] != pkey: + df.set_index(pkey, inplace=True) + data.set_index(pkey, inplace=True) + eq = df[df.eq(data).all(axis=1)] + ne = df[df.ne(data).any(axis=1)] + eq.reset_index(drop=False, inplace=True) + ne.reset_index(drop=False, inplace=True) + else: + eq = df[df.eq(data).all(axis=1)] + ne = df[df.ne(data).any(axis=1)] + else: + eq = df[df.eq(data).all(axis=1)] + ne = df[df.ne(data).any(axis=1)] + return [eq,ne] + + def __openFile__(file): + if isinstance(file,str): + df = pd.read_table(file) + + + +class update_ref_table: + ''' + Mise à jour des tables de référance situées dans les + schéma : + ref_habitats, ref_hydro + + Paramètres : + ------------ + file : str. chemain du vecteur. + table : str. Nom de la table à mettre à jour. + schema : str. Nom du schéma. + update : bool. Si True, mise à jour des champs différents. + Défault False. + ''' + + def __init__(self, file, table, schema=None, update=False): + + from .params import con + + self.con = con + self._file = file + self._table = table + self._updt = update + self._schema = schema + + if not self._schema: + self._schema = _get_schema_name(self) + self._pkey = __get_pkey__( + self.con,table_name=self._table,schema=self._schema + )['constrained_columns'][0] + + self._update_table_with_geom() + + + def _update_table_with_geom(self): + dic = _get_dic(self) + select_cols = list(dic.values()) + + if isinstance(self._file,str): + df = gpd.read_file(self._file) + elif isinstance(self._file,gpd.GeoDataFrame): + df = self._file.copy() + else: + print('Argument ''file'' ERROR !') + + if 'id' not in df.columns: + df.index.name = 'id' + df.reset_index(drop=False, inplace=True) + + if not df.crs: + df.set_crs(epsg=2154, inplace=True) + + if df.crs.srs != 'epsg:2154': + df.to_crs(epsg=2154, inplace=True) + + df.rename(columns=dic, inplace=True) + df = df[select_cols] + + df = df.set_geometry('geom') + + if 'Polygon' in df.geom_type.unique() and 'MultiPolygon' in df.geom_type.unique(): + from shapely.geometry.multipolygon import MultiPolygon + tmp = df.loc[df.geom_type == 'Polygon'].copy() + geom = [MultiPolygon([x]) for x in tmp.loc[tmp.geom_type == 'Polygon','geom']] + tmp = tmp.set_geometry(geom) + df = pd.concat([df.drop(tmp.index), tmp]).sort_values('id') + + if 'LineString' in df.geom_type.unique() and 'MultiLineString' in df.geom_type.unique(): + from shapely.geometry.multilinestring import MultiLineString + tmp = df.loc[df.geom_type == 'LineString'].copy() + geom = [MultiLineString([x]) for x in tmp.loc[tmp.geom_type == 'LineString','geom']] + tmp = tmp.set_geometry(geom) + df = pd.concat([df.drop(tmp.index), tmp]).sort_values('id') + + df_exst, df_updt, df_imp = _check_data_exist(self,df) + len_imp = len(df_imp) + len_updt = len(df_updt) + len_exst = len(df_exst) + if len_exst > 0: + print('DATAS {0}/{1} already exist'.format(len_exst,len(df))) + else: + print('NO DATA EXIST ...') + if df_imp.empty: + print('NO DATA TO IMPORT ...') + else : + Q = input('IMPORT {0}/{1} ... Yes(y)/No(n)/View(v) ?'.format(len_imp,len(df))) + while Q.lower() in ['view','v']: + print(df_imp) + Q = input('IMPORT {0}/{1} ... Yes(y)/No(n)/View(v) ?'.format(len_imp,len(df))) + if Q.lower() in ['yes','y']: + print('IMPORT {0}/{1} ...'.format(len_imp,len(df))) + df_imp.to_postgis( + name = self._table, + con = self.con, + schema = self._schema, + if_exists = 'append', + geom_col = 'geom' + ) + elif Q.lower() in ['no','n']: + pass + + if df_updt.empty: + print('NO DATA TO UPDATE ...') + else : + Q = input('UPDATE {0}/{1} ... Yes(y)/No(n)/View(v) ?'.format(len_updt,len(df))) + while Q.lower() in ['view','v']: + print(df_updt) + Q = input('UPDATE {0}/{1} ... Yes(y)/No(n)/View(v) ?'.format(len_updt,len(df))) + if Q.lower() in ['yes','y']: + print('UPDATE {0}/{1} ...'.format(len_updt,len(df))) + update.update_to_sql( + df=df_updt, + con=self.con, + table_name=self._table, + schema_name=self._schema, + key_name=self._pkey + ) + elif Q.lower() in ['no','n']: + pass + + + +class update: + def update_ref(file, table, schema=None, update=False): + update_ref_table(file, table, schema, update) + + + def update_to_sql(df, con, table_name, schema_name, key_name): + from sys import exit + + a = [] + b = [] + table = table_name + schema = schema_name + primary_key = key_name + pkey = __get_pkey__( + con,table_name=table,schema=schema) + + if pkey not in df.columns: + exit('Le champs clé primaire "%s" ne figure pas dans le DataFrame'%pkey) + + if isinstance(primary_key, str): + primary_key = [primary_key] + + for col in df.columns: + if col in primary_key: + b.append("t.{col}=f.{col}".format(col=col)) + else: + a.append("{col}=t.{col}".format(col=col)) + + if isinstance(df, gpd.GeoDataFrame): + df.to_postgis( + name = 'temp_table', + con = con, + schema = schema, + if_exists = 'replace', + geom_col = df.geometry.name + ) + else: + df.to_sql( + name = 'temp_table', + con = con, + schema = schema, + if_exists = 'replace', + index = False, + method = 'multi' + ) + + update_stmt_1 = "UPDATE {sch}.{final_table} f".format(sch=schema,final_table=table) + update_stmt_2 = " FROM {sch}.temp_table t".format(sch=schema) + update_stmt_6 = " WHERE %s"%' AND '.join(b) + update_stmt_3 = " SET " + update_stmt_4 = ", ".join(a) + update_stmt_5 = update_stmt_1 + update_stmt_3 + update_stmt_4 + update_stmt_2 + update_stmt_6 + ";" + drop_stmt = "DROP TABLE {sch}.temp_table ;".format(sch=schema) + with con.begin() as cnx: + cnx.execute(update_stmt_5) + cnx.execute(drop_stmt) + return print('END update') \ No newline at end of file diff --git a/vrac/Modif_caract_connect.py b/vrac/Modif_caract_connect.py new file mode 100644 index 0000000..d240f17 --- /dev/null +++ b/vrac/Modif_caract_connect.py @@ -0,0 +1,73 @@ +#!/usr/bin/env python3 +# -*- coding: UTF-8 -*- +import pandas as pd +import pyzh +zh = pyzh.zh() + +con = pyzh.con +sch = 'zones_humides' +lst_site_old = ['38RD0146','38RD0147'] +lst_site_new = ['38RD0164','38RD0165'] +df = zh.get_connex(id_site=lst_site_old) +geomsite = zh.get_sitesGeom(id_site=lst_site_new) +aut = pyzh.pers.get_auteur() + +tab = 'r_site_type_connect' +rtab_aut = 'r_rsiteconnect_auteur' +id_rsiteaut = 'id_siteconnect' +date_champ = 'date_conne' +nom_champ = 'connexion' +id_champ = 'id_param_connect' +delim = zh._get_param(param_table='param_type_connect', type_court=False) + + +df.drop( + columns=['id','valid', 'date_geom', 'auteur_geom', 'description','type','lb_hab_fr'], + inplace=True, + errors='ignore') + +for i, s in enumerate(lst_site_new): + df.loc[df.id_site==lst_site_old[i], 'id_site'] = s + df.loc[df.id_site==s, ['id_geom_site']] = geomsite.loc[geomsite.id_site==s,'id'].values[0].astype(str) + +df['id_geom_site'] = df.id_geom_site.astype(int) +df[id_champ] = df[nom_champ] +df[id_champ] = df[id_champ].replace(delim.nom.tolist(),delim.id.tolist()) +df['date'] = df[date_champ] + +df.drop(columns=['id_site',nom_champ,date_champ], inplace=True) +lst_idgeom = df.id_geom_site.unique().astype(str) + +# check si data in bdd +sql = 'select exists(select * from {sch}.{tab} where id_geom_site in ({lst_id}));'.format( + sch=sch, tab=tab, lst_id=','.join(lst_idgeom) +) +res = pd.read_sql(sql,con) +if res.exists[0]: + # delete if exist + sql = 'delete from {sch}.{tab} where id_geom_site in ({lst_id});'.format( + sch=sch, tab=tab, lst_id=','.join(lst_idgeom) + ) + pd.read_sql(sql,con) +# insert new line in bdd +col = df.columns[~df.columns.str.contains('auteur')] +colaut = df.columns[df.columns.str.contains('auteur')] +df[col].to_sql( + tab, con, schema=sch, + if_exists='append',index=False,method='multi' +) +# Récupération des nouveaux ids insérés +sql = 'select * from {sch}.{tab} where id_geom_site in ({lst_id});'.format( + sch=sch, tab=tab, lst_id=','.join(lst_idgeom) +) +res = pd.read_sql(sql,con) +df = df.merge(res, how='left', on=[*col]) + +ins_aut = df[['id',*colaut]].copy() +aut['nom_prenom'] = aut.nom + ' ' + aut.prenom +aut.loc[aut.nom_prenom.isna(), 'nom_prenom'] = aut.loc[aut.nom_prenom.isna(), 'nom'] +ins_aut[colaut] = ins_aut[colaut].replace(aut.nom_prenom.tolist(), aut.id.tolist()) +ins_aut.columns = [id_rsiteaut, 'id_auteur'] +ins_aut.to_sql( + rtab_aut, con, schema=sch, + if_exists='append',index=False,method='multi') \ No newline at end of file diff --git a/vrac/Modif_caract_delim.py b/vrac/Modif_caract_delim.py new file mode 100644 index 0000000..3be32de --- /dev/null +++ b/vrac/Modif_caract_delim.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# -*- coding: UTF-8 -*- +import pandas as pd +import pyzh +zh = pyzh.zh() + +con = pyzh.con +tab = 'r_site_critdelim' +sch = 'zones_humides' + +lst_site_old = ['38RD0146','38RD0147'] +lst_site_new = ['38RD0164','38RD0165'] + +df = zh.get_delim(id_site=lst_site_old) +geomsite = zh.get_sitesGeom(id_site=lst_site_new) +delim = zh._get_param(param_table='param_delim_fct',type_table='type_param_delim_fct') +aut = pyzh.pers.get_auteur() + +df.drop(columns=['id','valid', 'date_geom', 'auteur_geom', 'desc_param','type'], inplace=True) +for i, s in enumerate(lst_site_new): + df.loc[df.id_site==lst_site_old[i], 'id_site'] = s + df.loc[df.id_site==s, ['id_geom_site']] = geomsite.loc[geomsite.id_site==s,'id'].values[0].astype(str) + +df['id_geom_site'] = df.id_geom_site.astype(int) +df['id_crit_delim'] = df.nom_crit +df['id_crit_delim'] = df['id_crit_delim'].replace(delim.nom.tolist(),delim.id.tolist()) +df['date'] = df.date_critd + + +df.drop(columns=['id_site','nom_crit','date_critd'], inplace=True) +lst_idgeom = df.id_geom_site.unique().astype(str) + +sql = 'select exists(select * from {sch}.{tab} where id_geom_site in ({lst_id}));'.format( + sch=sch, tab=tab, lst_id=','.join(lst_idgeom) +) +res = pd.read_sql(sql,con) +if res.exists[0]: + sql = 'delete from {sch}.{tab} where id_geom_site in ({lst_id});'.format( + sch=sch, tab=tab, lst_id=','.join(lst_idgeom) + ) + pd.read_sql(sql,con) +col = df.columns[~df.columns.str.contains('auteur')] +colaut = df.columns[df.columns.str.contains('auteur')] +df[col].to_sql( + tab, con, schema=sch, + if_exists='append',index=False,method='multi' +) +sql = 'select * from {sch}.{tab} where id_geom_site in ({lst_id});'.format( + sch=sch, tab=tab, lst_id=','.join(lst_idgeom) +) +res = pd.read_sql(sql,con) +df = df.merge(res, how='left', on=[*col]) + +ins_aut = df[['id',*colaut]].copy() +aut['nom_prenom'] = aut.nom + ' ' + aut.prenom +aut.loc[aut.nom_prenom.isna(), 'nom_prenom'] = aut.loc[aut.nom_prenom.isna(), 'nom'] +ins_aut[colaut] = ins_aut[colaut].replace(aut.nom_prenom.tolist(), aut.id.tolist()) +ins_aut.columns = ['id_sitedelim', 'id_auteur'] +ins_aut.to_sql( + 'r_rsitedelim_auteur', con, schema=sch, + if_exists='append',index=False,method='multi') + + diff --git a/vrac/Modif_caract_fct.py b/vrac/Modif_caract_fct.py new file mode 100644 index 0000000..4da6f1d --- /dev/null +++ b/vrac/Modif_caract_fct.py @@ -0,0 +1,70 @@ +#!/usr/bin/env python3 +# -*- coding: UTF-8 -*- +import pandas as pd +import pyzh +zh = pyzh.zh() + +con = pyzh.con +sch = 'zones_humides' +lst_site_old = ['38RD0146','38RD0147'] +lst_site_new = ['38RD0164','38RD0165'] +df = zh.get_fct(id_site=lst_site_old) +geomsite = zh.get_sitesGeom(id_site=lst_site_new) +aut = pyzh.pers.get_auteur() + +tab = 'r_site_fctecosociopatri' +rtab_aut = 'r_rsitefct_auteur' +id_rsiteaut = 'id_sitefct' +delim = zh._get_param(param_table='param_fct_eco_socio_patri',type_table='type_param_fct') + + +df.drop( + columns=['id','valid', 'date_geom', 'auteur_geom', 'desc_param','type'], + inplace=True, + errors='ignore') + +for i, s in enumerate(lst_site_new): + df.loc[df.id_site==lst_site_old[i], 'id_site'] = s + df.loc[df.id_site==s, ['id_geom_site']] = geomsite.loc[geomsite.id_site==s,'id'].values[0].astype(str) + +df['id_geom_site'] = df.id_geom_site.astype(int) +df['id_fct'] = df['nom_fct'] +df['id_fct'] = df['id_fct'].replace(delim.nom.tolist(),delim.id.tolist()) +df['date'] = df.date_fctec + +df.drop(columns=['id_site','nom_fct','date_fctec'], inplace=True) +lst_idgeom = df.id_geom_site.unique().astype(str) + +# check si data in bdd +sql = 'select exists(select * from {sch}.{tab} where id_geom_site in ({lst_id}));'.format( + sch=sch, tab=tab, lst_id=','.join(lst_idgeom) +) +res = pd.read_sql(sql,con) +if res.exists[0]: + # delete if exist + sql = 'delete from {sch}.{tab} where id_geom_site in ({lst_id});'.format( + sch=sch, tab=tab, lst_id=','.join(lst_idgeom) + ) + pd.read_sql(sql,con) +# insert new line in bdd +col = df.columns[~df.columns.str.contains('auteur')] +colaut = df.columns[df.columns.str.contains('auteur')] +df[col].to_sql( + tab, con, schema=sch, + if_exists='append',index=False,method='multi' +) +# Récupération des nouveaux ids insérés +sql = 'select * from {sch}.{tab} where id_geom_site in ({lst_id});'.format( + sch=sch, tab=tab, lst_id=','.join(lst_idgeom) +) +res = pd.read_sql(sql,con) +df = df.merge(res, how='left', on=[*col]) + +ins_aut = df[['id',*colaut]].copy() +aut['nom_prenom'] = aut.nom + ' ' + aut.prenom +aut.loc[aut.nom_prenom.isna(), 'nom_prenom'] = aut.loc[aut.nom_prenom.isna(), 'nom'] +ins_aut[colaut] = ins_aut[colaut].replace(aut.nom_prenom.tolist(), aut.id.tolist()) +ins_aut.columns = [id_rsiteaut, 'id_auteur'] +ins_aut.to_sql( + rtab_aut, con, schema=sch, + if_exists='append',index=False,method='multi') \ No newline at end of file diff --git a/vrac/Modif_caract_hab.py b/vrac/Modif_caract_hab.py new file mode 100644 index 0000000..0709427 --- /dev/null +++ b/vrac/Modif_caract_hab.py @@ -0,0 +1,73 @@ +#!/usr/bin/env python3 +# -*- coding: UTF-8 -*- +import pandas as pd +import pyzh +zh = pyzh.zh() + +con = pyzh.con +sch = 'zones_humides' +lst_site_old = ['38RD0146','38RD0147'] +lst_site_new = ['38RD0164','38RD0165'] +df = zh.get_habitat(id_site=lst_site_old) +geomsite = zh.get_sitesGeom(id_site=lst_site_new) +aut = pyzh.pers.get_auteur() + +tab = 'r_site_habitat' +rtab_aut = 'r_rsitehab_auteur' +id_rsiteaut = 'id_sitehab' +date_champ = 'date_habit' +nom_champ = 'code_cb' +id_champ = 'id_cb' +# delim = zh._get_param(param_table='param_fct_eco_socio_patri',type_table='type_param_fct') + + +df.drop( + columns=['id','valid', 'date_geom', 'auteur_geom', 'desc_param','type','lb_hab_fr'], + inplace=True, + errors='ignore') + +for i, s in enumerate(lst_site_new): + df.loc[df.id_site==lst_site_old[i], 'id_site'] = s + df.loc[df.id_site==s, ['id_geom_site']] = geomsite.loc[geomsite.id_site==s,'id'].values[0].astype(str) + +df['id_geom_site'] = df.id_geom_site.astype(int) +df[id_champ] = df[nom_champ] +# df[id_champ] = df[id_champ].replace(delim.nom.tolist(),delim.id.tolist()) +df['date'] = df[date_champ] + +df.drop(columns=['id_site',nom_champ,date_champ], inplace=True) +lst_idgeom = df.id_geom_site.unique().astype(str) + +# check si data in bdd +sql = 'select exists(select * from {sch}.{tab} where id_geom_site in ({lst_id}));'.format( + sch=sch, tab=tab, lst_id=','.join(lst_idgeom) +) +res = pd.read_sql(sql,con) +if res.exists[0]: + # delete if exist + sql = 'delete from {sch}.{tab} where id_geom_site in ({lst_id});'.format( + sch=sch, tab=tab, lst_id=','.join(lst_idgeom) + ) + pd.read_sql(sql,con) +# insert new line in bdd +col = df.columns[~df.columns.str.contains('auteur')] +colaut = df.columns[df.columns.str.contains('auteur')] +df[col].to_sql( + tab, con, schema=sch, + if_exists='append',index=False,method='multi' +) +# Récupération des nouveaux ids insérés +sql = 'select * from {sch}.{tab} where id_geom_site in ({lst_id});'.format( + sch=sch, tab=tab, lst_id=','.join(lst_idgeom) +) +res = pd.read_sql(sql,con) +df = df.merge(res, how='left', on=[*col]) + +ins_aut = df[['id',*colaut]].copy() +aut['nom_prenom'] = aut.nom + ' ' + aut.prenom +aut.loc[aut.nom_prenom.isna(), 'nom_prenom'] = aut.loc[aut.nom_prenom.isna(), 'nom'] +ins_aut[colaut] = ins_aut[colaut].replace(aut.nom_prenom.tolist(), aut.id.tolist()) +ins_aut.columns = [id_rsiteaut, 'id_auteur'] +ins_aut.to_sql( + rtab_aut, con, schema=sch, + if_exists='append',index=False,method='multi') \ No newline at end of file diff --git a/vrac/Modif_caract_reghydro.py b/vrac/Modif_caract_reghydro.py new file mode 100644 index 0000000..830acbf --- /dev/null +++ b/vrac/Modif_caract_reghydro.py @@ -0,0 +1,81 @@ +#!/usr/bin/env python3 +# -*- coding: UTF-8 -*- +import pandas as pd +import pyzh +zh = pyzh.zh() + +con = pyzh.con +sch = 'zones_humides' +lst_site_old = ['38RD0146','38RD0147'] +lst_site_new = ['38RD0164','38RD0165'] +df = zh.get_regHydro(id_site=lst_site_old) +geomsite = zh.get_sitesGeom(id_site=lst_site_new) +aut = pyzh.pers.get_auteur() + + +tab = 'r_site_reghydro' +rtab_aut = 'r_rsitehydro_auteur' +id_rsiteaut = 'id_sitehydro' +date_champ = 'date_reghy' +nom_champ1 = 'regime_hydri' +nom_champ2 = 'permanence' +id_champ1 = 'id_reg_hydro' +id_champ2 = 'id_permanence' +delim1 = zh._get_param(param_table='param_reg_hydro', type_court=False) +delim2 = zh._get_param(param_table='param_permanence', type_court=False) + +col_desc = df.columns[df.columns.str.contains('desc')] +df.drop( + columns=['id','valid', 'date_geom', 'auteur_geom', *col_desc,'type','lb_hab_fr'], + inplace=True, + errors='ignore') + +for i, s in enumerate(lst_site_new): + df.loc[df.id_site==lst_site_old[i], 'id_site'] = s + df.loc[df.id_site==s, ['id_geom_site']] = geomsite.loc[geomsite.id_site==s,'id'].values[0].astype(str) + +df['id_geom_site'] = df.id_geom_site.astype(int) +df[id_champ1] = df[nom_champ1] +df[id_champ2] = df[nom_champ2] +df[id_champ1] = df[id_champ1].replace(delim1.nom.tolist(),delim1.id.tolist()) +df[id_champ2] = df[id_champ2].replace(delim2.nom.tolist(),delim2.id.tolist()) +df['date'] = df[date_champ] +df.in_out = df.in_out == 'entree' + + +df.drop(columns=['id_site',nom_champ1,nom_champ2,date_champ], inplace=True) +lst_idgeom = df.id_geom_site.unique().astype(str) + +# check si data in bdd +sql = 'select exists(select * from {sch}.{tab} where id_geom_site in ({lst_id}));'.format( + sch=sch, tab=tab, lst_id=','.join(lst_idgeom) +) +res = pd.read_sql(sql,con) +if res.exists[0]: + # delete if exist + sql = 'delete from {sch}.{tab} where id_geom_site in ({lst_id});'.format( + sch=sch, tab=tab, lst_id=','.join(lst_idgeom) + ) + pd.read_sql(sql,con) +# insert new line in bdd +col = df.columns[~df.columns.str.contains('auteur')] +colaut = df.columns[df.columns.str.contains('auteur')] +df[col].to_sql( + tab, con, schema=sch, + if_exists='append',index=False,method='multi' +) +# Récupération des nouveaux ids insérés +sql = 'select * from {sch}.{tab} where id_geom_site in ({lst_id});'.format( + sch=sch, tab=tab, lst_id=','.join(lst_idgeom) +) +res = pd.read_sql(sql,con) +df = df.merge(res, how='left', on=[*col]) + +ins_aut = df[['id',*colaut]].copy() +aut['nom_prenom'] = aut.nom + ' ' + aut.prenom +aut.loc[aut.nom_prenom.isna(), 'nom_prenom'] = aut.loc[aut.nom_prenom.isna(), 'nom'] +ins_aut[colaut] = ins_aut[colaut].replace(aut.nom_prenom.tolist(), aut.id.tolist()) +ins_aut.columns = [id_rsiteaut, 'id_auteur'] +ins_aut.to_sql( + rtab_aut, con, schema=sch, + if_exists='append',index=False,method='multi') \ No newline at end of file diff --git a/vrac/Modif_caract_sub.py b/vrac/Modif_caract_sub.py new file mode 100644 index 0000000..835f9d4 --- /dev/null +++ b/vrac/Modif_caract_sub.py @@ -0,0 +1,82 @@ +#!/usr/bin/env python3 +# -*- coding: UTF-8 -*- +import pandas as pd +import pyzh +zh = pyzh.zh() + +con = pyzh.con +sch = 'zones_humides' +lst_site_old = ['38RD0146','38RD0147'] +lst_site_new = ['38RD0164','38RD0165'] +df = zh.get_sub(id_site=lst_site_old) +geomsite = zh.get_sitesGeom(id_site=lst_site_new) +aut = pyzh.pers.get_auteur() + +tab = 'r_site_sub' +rtab_aut = 'r_rsitesub_auteur' +id_rsiteaut = 'id_sitesub' +date_champ = 'date_sub' +nom_champ1 = 'Submersion étendue' +nom_champ2 = 'Submersion fréquente' +nom_champ3 = 'origine_sub' +id_champ1 = 'id_freqsub' +id_champ2 = 'id_etendsub' +id_champ3 = 'id_origsub' +delim = zh._get_param(param_table='param_sub',type_table='type_param_sub', type_court=False) +delim1 = delim.loc[delim.type == nom_champ1] +delim2 = delim.loc[delim.type == nom_champ2] + + +df.drop( + columns=['id','valid', 'date_geom', 'auteur_geom', 'desc_param','type','lb_hab_fr'], + inplace=True, + errors='ignore') + +for i, s in enumerate(lst_site_new): + df.loc[df.id_site==lst_site_old[i], 'id_site'] = s + df.loc[df.id_site==s, ['id_geom_site']] = geomsite.loc[geomsite.id_site==s,'id'].values[0].astype(str) + +df['id_geom_site'] = df.id_geom_site.astype(int) +df[id_champ1] = df[nom_champ1] +df[id_champ2] = df[nom_champ2] +df[id_champ3] = df[nom_champ3] +df[id_champ1] = df[id_champ1].replace(delim1.nom.tolist(),delim1.id.tolist()) +df[id_champ2] = df[id_champ2].replace(delim2.nom.tolist(),delim2.id.tolist()) +df['date'] = df[date_champ] + +df.drop(columns=['id_site',nom_champ1,nom_champ2,nom_champ3,date_champ], inplace=True) +lst_idgeom = df.id_geom_site.unique().astype(str) + +# check si data in bdd +sql = 'select exists(select * from {sch}.{tab} where id_geom_site in ({lst_id}));'.format( + sch=sch, tab=tab, lst_id=','.join(lst_idgeom) +) +res = pd.read_sql(sql,con) +if res.exists[0]: + # delete if exist + sql = 'delete from {sch}.{tab} where id_geom_site in ({lst_id});'.format( + sch=sch, tab=tab, lst_id=','.join(lst_idgeom) + ) + pd.read_sql(sql,con) +# insert new line in bdd +col = df.columns[~df.columns.str.contains('auteur')] +colaut = df.columns[df.columns.str.contains('auteur')] +df[col].to_sql( + tab, con, schema=sch, + if_exists='append',index=False,method='multi' +) +# Récupération des nouveaux ids insérés +sql = 'select * from {sch}.{tab} where id_geom_site in ({lst_id});'.format( + sch=sch, tab=tab, lst_id=','.join(lst_idgeom) +) +res = pd.read_sql(sql,con) +df = df.merge(res, how='left', on=[*col]) + +ins_aut = df[['id',*colaut]].copy() +aut['nom_prenom'] = aut.nom + ' ' + aut.prenom +aut.loc[aut.nom_prenom.isna(), 'nom_prenom'] = aut.loc[aut.nom_prenom.isna(), 'nom'] +ins_aut[colaut] = ins_aut[colaut].replace(aut.nom_prenom.tolist(), aut.id.tolist()) +ins_aut.columns = [id_rsiteaut, 'id_auteur'] +ins_aut.to_sql( + rtab_aut, con, schema=sch, + if_exists='append',index=False,method='multi') \ No newline at end of file diff --git a/vrac/Modif_caract_usageprocess.py b/vrac/Modif_caract_usageprocess.py new file mode 100644 index 0000000..f0ed903 --- /dev/null +++ b/vrac/Modif_caract_usageprocess.py @@ -0,0 +1,83 @@ +#!/usr/bin/env python3 +# -*- coding: UTF-8 -*- +import pandas as pd +import pyzh +zh = pyzh.zh() + +con = pyzh.con +sch = 'zones_humides' +lst_site_old = ['38RD0146','38RD0147'] +lst_site_new = ['38RD0164','38RD0165'] +df = zh.get_usageprocess(id_site=lst_site_old) +geomsite = zh.get_sitesGeom(id_site=lst_site_new) +aut = pyzh.pers.get_auteur() + +tab = 'r_site_usageprocess' +rtab_aut = 'r_rsiteusage_auteur' +id_rsiteaut = 'id_siteusage' +date_champ = 'date_usage' +nom_champ1 = 'activite_hum' +nom_champ2 = 'impact' +nom_champ3 = 'position' +id_champ1 = 'id_activ_hum' +id_champ2 = 'id_impact' +id_champ3 = 'id_position' +delim1 = zh._get_param(param_table='param_activ_hum', type_court=False) +delim2 = zh._get_param(param_table='param_impact', type_court=False) +delim3 = zh._get_param(param_table='param_position', type_court=False) + +col_desc = df.columns[df.columns.str.contains('desc')] +df.drop( + columns=['id','valid', 'date_geom', 'auteur_geom', *col_desc,'description','type','lb_hab_fr'], + inplace=True, + errors='ignore') + +for i, s in enumerate(lst_site_new): + df.loc[df.id_site==lst_site_old[i], 'id_site'] = s + df.loc[df.id_site==s, ['id_geom_site']] = geomsite.loc[geomsite.id_site==s,'id'].values[0].astype(str) + +df['id_geom_site'] = df.id_geom_site.astype(int) +df[id_champ1] = df[nom_champ1] +df[id_champ2] = df[nom_champ2] +df[id_champ3] = df[nom_champ3] +df[id_champ1] = df[id_champ1].replace(delim1.nom.tolist(),delim1.id.tolist()) +df[id_champ2] = df[id_champ2].replace(delim2.nom.tolist(),delim2.id.tolist()) +df[id_champ3] = df[id_champ3].replace(delim3.nom.tolist(),delim3.id.tolist()) +df['date'] = df[date_champ] + +df.drop(columns=['id_site',nom_champ1,nom_champ2,nom_champ3,date_champ], inplace=True) +lst_idgeom = df.id_geom_site.unique().astype(str) + +# check si data in bdd +sql = 'select exists(select * from {sch}.{tab} where id_geom_site in ({lst_id}));'.format( + sch=sch, tab=tab, lst_id=','.join(lst_idgeom) +) +res = pd.read_sql(sql,con) +if res.exists[0]: + # delete if exist + sql = 'delete from {sch}.{tab} where id_geom_site in ({lst_id});'.format( + sch=sch, tab=tab, lst_id=','.join(lst_idgeom) + ) + pd.read_sql(sql,con) +# insert new line in bdd +col = df.columns[~df.columns.str.contains('auteur')] +colaut = df.columns[df.columns.str.contains('auteur')] +df[col].to_sql( + tab, con, schema=sch, + if_exists='append',index=False,method='multi' +) +# Récupération des nouveaux ids insérés +sql = 'select * from {sch}.{tab} where id_geom_site in ({lst_id});'.format( + sch=sch, tab=tab, lst_id=','.join(lst_idgeom) +) +res = pd.read_sql(sql,con) +df = df.merge(res, how='left', on=[*col]) + +ins_aut = df[['id',*colaut]].copy() +aut['nom_prenom'] = aut.nom + ' ' + aut.prenom +aut.loc[aut.nom_prenom.isna(), 'nom_prenom'] = aut.loc[aut.nom_prenom.isna(), 'nom'] +ins_aut[colaut] = ins_aut[colaut].replace(aut.nom_prenom.tolist(), aut.id.tolist()) +ins_aut.columns = [id_rsiteaut, 'id_auteur'] +ins_aut.to_sql( + rtab_aut, con, schema=sch, + if_exists='append',index=False,method='multi') \ No newline at end of file diff --git a/wfs/__init__.py b/wfs/__init__.py new file mode 100644 index 0000000..939b2fc --- /dev/null +++ b/wfs/__init__.py @@ -0,0 +1,4 @@ +#!/usr/bin/env python3 +# -*- coding: UTF-8 -*- + +from .wfs import * \ No newline at end of file diff --git a/wfs/__pycache__/__init__.cpython-38.pyc b/wfs/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5ec99944afa858720c796f7d02756d246264779b GIT binary patch literal 166 zcmWIL<>g`kg7llxiB3TJF^Gc(44TX@8G%BYjJFuI z{D35Ld0O#Gh9VZA7?}8FuAh;go2s9jpOaXu?^IfpnpmnIP+5|ZpQj&?n4F!Mo?5J5 nP+66s57ek1AD@|*SrQ+wS5SG2!zMRBr8Fni4rJD6AZ7pnE7m80 literal 0 HcmV?d00001 diff --git a/wfs/__pycache__/wfs.cpython-38.pyc b/wfs/__pycache__/wfs.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3a48f298c4567d7f23cb6ed3e8ea8c1ef3444cfa GIT binary patch literal 761 zcmYjOJ8u**5cXqVx5^_o(_c8c8H=NK4Ns zC6Y=0jhrzV$ryJolPM|E-xx&->Ykj!#Q_MjQZNN|T~|(pv`A!PsZ2M~5L+%YOKdDh8~#20K^EDNSZ0&2bVzNA z-Q*L6U-IpY6bN~KSvP=AdJI=9(B_spzEX|jrw3D)AA;F7TtqI_cTKzW8kDZPrAyUa zlFQ7xhlyyx@xzZN2$%FiiB=aQH=04$i=`A=ajfgIZH`tEy2=yaB3V~PdCpzhE5KY( zo{1t0n~NK<1{Lx{mg6^xsObXRe7{F^KMxl ziR!bMfiC;?mwAZ@UibR7OJ`ut@$5_Lr)UV>!Ik4;{}Q%KGpb(TZRLr(7ylWrVOr1e zUjz z+Y2N-#;edM3H_;8=udDsd3U3m`eF~`LYdHTczuB98Bzf>d)sz$)xbMH1ntcZ%kux4 C39=vn literal 0 HcmV?d00001 diff --git a/wfs/wfs.py b/wfs/wfs.py new file mode 100644 index 0000000..8ef2f3a --- /dev/null +++ b/wfs/wfs.py @@ -0,0 +1,24 @@ +#!/usr/bin/env python3 +# -*- coding: UTF-8 -*- + +from owslib.wfs import WebFeatureService + +def get_wfs(url, layer, bbox=None): + from geopandas import read_file + from requests import Request + wfs = WebFeatureService(url=url) + item = dict(wfs.items())[layer] + crs = item.crsOptions[0].getcode() + params = dict(service='WFS', version=wfs.version, request='GetFeature', + typeName=layer) + q = Request('GET', url, params=params).prepare().url + data = read_file(q, bbox=bbox) + data.set_crs(crs=crs, inplace=True) + if crs != 'EPSG:2154': + data.to_crs(epsg=2154, inplace=True) + return data + +def list_layer(url): + wfs = WebFeatureService(url=url) + lst = list(wfs.contents) + return lst \ No newline at end of file diff --git a/zh.py b/zh.py new file mode 100644 index 0000000..c354749 --- /dev/null +++ b/zh.py @@ -0,0 +1,684 @@ +#!/usr/bin/env python3 +# -*- coding: UTF-8 -*- +#Nom : : zh.py +#Description : +#Copyright : 2021, CEN38 +#Auteur : Colas Geier +#Version : 1.0 + + + +import pandas as pd +# import pandas_access as mdb +# import numpy as np +# from sqlalchemy.sql.expression import column +from sqlalchemy import create_engine +from geoalchemy2 import Geometry +from .pers.pers import _get_table +from .sites.sites import _get_typ_milieux +from .tools import _get_relation_autor + + +##################################### +### schema personnes ### +##################################### +# class pers: +# def __init__(self): +# from .params import con +# self.schema = 'personnes' +# self.con = con +# # self._get_table = _get_table + +# def get_auteur(self, nom=None, prenom=None): +# sql = 'SELECT * FROM %s.personne'%self.schema +# if nom or prenom : sql = sql + ' WHERE ' +# if nom : +# sql = sql + 'nom IN %(nom)s' +# nom = to_upper(nom) +# if nom and prenom : sql = sql + ' AND ' +# if prenom : +# sql = sql + 'prenom IN %(prenom)s' +# prenom = to_upperfirst(prenom) +# df = pd.read_sql( +# sql = sql, +# con = self.con, +# params = {'nom': to_tuple(nom), 'prenom': to_tuple(prenom) }) +# return df + +# def get_organisme(self, ids=None, nom=None): +# table = 'organisme' +# return _get_table(self.con, self.schema, table, ids=ids, nom=nom) + +##################################### +### schema sites ### +##################################### +# class sites: +# def __init__(self): +# from .params import con +# from .pers import pers +# self.schema = 'sites' +# self.con = con +# self.typ_milieux = self._get_typ_milieux() +# self.typo_sdage = self._get_typo_sdage() +# self.typ_site = self._get_typ_site() +# self.auteur = pers.get_auteur() +# self.organisme = pers.get_organisme() + +# def _get_typ_milieux(self, ids=None, nom=None): +# table = 'type_milieu' +# df = _get_table(self.con, self.schema, table, ids=ids, nom=nom) +# return df + +# def _get_typo_sdage(self, ids=None, nom=None): +# table = 'typo_sdage' +# df = _get_table(self.con, self.schema, table, ids=ids, nom=nom) +# return df + +# def _get_typ_site(self, ids=None, nom=None): +# table = 'type_site' +# df = _get_table(self.con, self.schema, table, ids=ids, nom=nom) +# return df + + # def _merge_orga(self, df, split_cols): + # org = self.organisme + # aut = self.auteur + # df = df.copy() + # for c in split_cols: + # if not isinstance(df[c], int): df[c] = df[c].astype(float) + # df[c].replace(aut.id.tolist(), aut.id_organisme.tolist(), inplace=True) + # df[c].replace(org.id.tolist(), org.nom.tolist(), inplace=True) + # df['organisme'] = None + # for c in split_cols: + # df.loc[df.organisme.isna(), 'organisme'] = df.loc[df['organisme'].isna(), c] + # for c in split_cols: + # comp = df.loc[~df[c].isna(),'organisme'].compare(df.loc[~df[c].isna(), c]) + # if not comp.empty: + # comp['test'] = comp.apply(lambda x: x['other'] in x['self'], axis=1) + # comp = comp[~comp.test] + # if not comp.empty: + # df.loc[comp.index,'organisme'] = comp.self + ' & ' + comp.other + # df.drop(columns=split_cols, inplace=True) + # return df + + # def _merge_author(self, df, col_aut, orga=False): + # # récupération des auteurs + # aut = self.auteur.fillna('') + # aut['nom_prenom'] = (aut['nom'] + ' ' + aut['prenom']).str.strip() + # aut['id'] = aut['id'].astype(str) + # # merge des auteurs + # r_id = df[['id', col_aut]].copy() + # r_idSplit = r_id[col_aut].str.split(' & ', expand=True) + # r_id = r_id.join(r_idSplit) + # cSplit = r_idSplit.shape[1] + # cSplit = list(range(cSplit)) + # if orga: + # # récup des organismes + # org = self._merge_orga(r_id, cSplit) + # r_id[cSplit] = r_id[cSplit].replace(aut['id'].tolist(),aut['nom_prenom'].tolist()) + # r_id = _aggr_cols(r_id,cSplit,' & ') \ + # .rename(columns={'aggreg': 'auteur'}) \ + # .drop(columns=cSplit) + # if orga: + # # merge des organismes + # r_id = pd.merge(r_id,org, on=['id', col_aut]) + # df = pd.merge(df,r_id, on=['id', col_aut]) \ + # .drop(columns=[col_aut]) + # return df + + # def _merge_relation(self, df, table, schema, id=None, left_id=None,right_id=None): + # con = self.con + # if id: + # params = {id: df[id].tolist() } + # elif left_id and right_id: + # params = {right_id: df[left_id].tolist() } + # mrg = _get_table(con, schema, table, params_col=params) + # if table == 'r_sites_auteur' or table == 'r_geomsites_auteur': + # mrg = mrg[[right_id,'id_auteur']].groupby( + # [right_id])['id_auteur'].apply(lambda x: ' & '.join(x.astype(str))) + # mrg = pd.DataFrame(data=mrg) + # if id: + # df = pd.merge(df,mrg, how='left', on=id) + # elif left_id and right_id: + # df = pd.merge(df,mrg, how='left', left_on=left_id, right_on=right_id) + # return df + + + # def get_sitesInfos(self, ids=None, nom=None, columns=None, with_nameOrga=False, details=False, params_col={}): + # drop = [] + # table = 'sites' + # df = _get_table(self.con, self.schema, table, ids=ids, nom=nom, cols=columns, params_col=params_col) + # # récupération des auteurs + # if 'id_auteur' in df.columns: + # df.drop(columns='id_auteur', inplace=True) + # df = _merge_relation(df=df,table='r_sites_auteur',schema=self.schema, left_id='id',right_id='id_site') + # df = _merge_author(df=df, col_aut='id_auteur', orga=with_nameOrga) + # # merge type_site + # if 'id_type_site' in df.columns: + # df = pd.merge(df, self.typ_site, how='left', left_on='id_type_site', right_on='id', suffixes=('','_y') ) \ + # .drop(columns=['id_type_site', 'id_y']) \ + # .rename(columns={'nom_y': 'type_site', 'description': 'desc_type_site'}) + # drop += ['desc_type_site'] + # # merge typo_sdage + # if 'id_typo_sdage' in df.columns: + # df = pd.merge(df, self.typo_sdage, how='left', left_on='id_typo_sdage', right_on='id', suffixes=('','_y') ) \ + # .drop(columns=['id_typo_sdage', 'id_y']) \ + # .rename(columns={'nom_y': 'typo_sdage', 'description': 'desc_typo_sdage'}) + # drop += ['desc_typo_sdage'] + # # merge type_milieu + # if 'id_type_milieu' in df.columns: + # df = pd.merge(df, self.typ_milieux, how='left', left_on='id_type_milieu', right_on='id', suffixes=('','_y') ) \ + # .drop(columns=['id_type_milieu', 'id_y']) \ + # .rename(columns={'nom_y': 'type_milieu', 'description': 'desc_type_milieu', 'nom_court': 'nom_court_milieu'}) + # drop += ['desc_type_milieu', 'nom_court_milieu'] + + # if not details: + # df.drop(columns=drop, inplace=True) + + # return df.sort_values('id') + + # def get_sitesGeom(self, id_site=None, nom_site=None, columns=None, last_update=False, with_nameOrga=False, params_col={}): + # # from shapely.wkb import loads + # # import geopandas as gpd # set_geometry + + # if columns: + # if not isinstance(columns, list): columns = [columns] + # if 'id' not in columns: columns.insert(0,'id') + # if 'id_site' not in columns: columns.insert(1,'id_site') + # if 'geom' not in columns: columns.insert(2,'geom') + + # table = 'sites' + # df = _get_table(self.con, self.schema, table, ids=id_site, nom=nom_site, cols='id', params_col=params_col) + # idSite = df.id.tolist() + # table = 'r_sites_geom' + # df = _get_table(self.con, self.schema, table, params_col={'id_site':idSite}, cols=columns) + # if last_update: + # df.drop_duplicates(subset=['id_site'], keep='last', inplace=True) + # df.reset_index(inplace=True, drop=True) + + + # # df = _set_geom(df) + # # df['geom'] = [(loads(geom, hex=True)) for geom in df['geom']] + # # df = df.set_geometry('geom', crs='EPSG:2154') + # # merge auteur + # if 'id_auteur' in df.columns: + # df.drop(columns='id_auteur', inplace=True) + # df = _merge_relation(df=df,table='r_geomsites_auteur',schema=self.schema, left_id='id',right_id='id_geom_site') + # df = _merge_author(df=df, col_aut='id_auteur', orga=with_nameOrga) + + # return df + + + +##################################### +### schema zh ### +##################################### +class zh(): + def __init__(self): + from .params import con + from .tools import _get_relation_tab + self.schema = 'zones_humides' + self.con = con + self.typ_milieux = _get_typ_milieux(nom='Tourbières et marais') + self.id_milieux = self.typ_milieux.id.values[0] + self._get_relation_tab = _get_relation_tab + self.lst_tab = con.dialect.get_table_names(con,schema=self.schema) + self.columns_rSiteFcts = con.dialect.get_columns(con,schema=self.schema,table_name='r_site_fctecosociopatri') + self.columns_r_SiteCon = con.dialect.get_columns(con,schema=self.schema,table_name='r_site_type_connect') + self.columns_rSiteCritDelim = con.dialect.get_columns(con,schema=self.schema,table_name='r_site_critdelim') + self.columns_r_SiteHabs = con.dialect.get_columns(con,schema=self.schema,table_name='r_site_habitat') + self.columns_rSiteRegHyd = con.dialect.get_columns(con,schema=self.schema,table_name='r_site_reghydro') + self.columns_r_SiteSub = con.dialect.get_columns(con,schema=self.schema,table_name='r_site_sub') + self.columns_r_SiteUsgPrss = con.dialect.get_columns(con,schema=self.schema,table_name='r_site_usageprocess') + + + def _get_param(self, param_table, type_table=None, type_court=True): + if type_table: + typ = _get_table(self.con, self.schema, table=type_table) + par = _get_table(self.con, self.schema, table=param_table, params_col={'id_type':typ.id.tolist()}) + df = pd.merge(par, typ, left_on='id_type', right_on='id', how='left', suffixes=(None, '_typ')) \ + .drop(columns=['id_type','id_typ']) + if 'description_typ' in df.columns: del df['description_typ'] + if type_court: df = df.drop(columns=['nom_typ']).rename(columns={'nom_court_typ':'type'}) + else : df = df.drop(columns=['nom_court_typ'],errors='ignore').rename(columns={'nom_typ':'type'}) + df = df.set_index(['id', 'type']).reset_index() + else: + df = _get_table(self.con, self.schema, table=param_table) + + return df + + + # def _get_relation_tab(self, tab, id_site=None, nom_site=None, last_update=False, geom=False,params_col={}): + # table = 'sites' + # dfSG = get_sitesGeom(columns='date', id_site=id_site, nom_site=nom_site, last_update=last_update,params_col=params_col) + # if not geom and not dfSG.empty: + # dfSG.drop('geom',1,inplace=True) + # ids = dfSG.id.tolist() + # table = tab + + # if ids : + # df = _get_table(self.con, self.schema, table, params_col={'id_geom_site':ids}) + # # if not df.empty: + # df = pd.merge(dfSG,df, how='left', left_on='id', right_on='id_geom_site', suffixes=('_x', None)) \ + # .drop(['id_x','id_geom_site'],1) \ + # .set_index('id').reset_index() + # return df + # else: + # print('PAS de géometries de sites sélectionnées ...') + + + def get_delim(self, id_site=None, nom_site=None, last_update=True, geom=False, + nom_type_court=True,statut='actif'): + + table = 'r_site_critdelim' + df = self._get_relation_tab( + schema=self.schema,tab=table,id_site=id_site,nom_site=nom_site,last_update=last_update,geom=geom, + params_col={'id_type_milieu':self.id_milieux.astype(str)}, statut=statut) + dic = self._get_param(type_table='type_param_delim_fct', param_table='param_delim_fct', type_court=nom_type_court) + + if not df.empty: + df = _get_relation_autor(df, relation_tab='r_rsitedelim_auteur', schema=self.schema, + id_df='id', id_relation='id_sitedelim', id_rela_auth='id_auteur' ) + + df = pd.merge(df,dic, how='left', left_on='id_crit_delim', right_on='id', suffixes=(None,'_y')) \ + .drop(['id_y','id_crit_delim'],1) \ + .rename(columns={'description_y':'desc_param', 'nom_court':'nom_court_crit','nom':'nom_crit'}) \ + .sort_values('id_site') + + if df.nom_court_crit.isnull().sum() == df.shape[0] : del df['nom_court_crit'] + # typ = df.type.unique() + # x = {} + # for t in typ: + # x[t] = df[df.type == t] + # x[t] = x[t].rename(columns={'nom': t}) \ + # .reset_index(drop=True) + + return df + + + def get_fct(self, id_site=None, nom_site=None, last_update=True, geom=False, nom_type_court=True,statut='actif'): + + table = 'r_site_fctecosociopatri' + df = self._get_relation_tab(schema=self.schema,tab=table,id_site=id_site,nom_site=nom_site,last_update=last_update,geom=geom, + params_col={'id_type_milieu':self.id_milieux.astype(str)}, statut=statut) + dic = self._get_param(type_table='type_param_fct', param_table='param_fct_eco_socio_patri', type_court=nom_type_court) + + if not df.empty: + df = _get_relation_autor(df, relation_tab='r_rsitefct_auteur', schema=self.schema, + id_df='id', id_relation='id_sitefct', id_rela_auth='id_auteur' ) + + df = pd.merge(df,dic, how='left', left_on='id_fct', right_on='id', suffixes=(None,'_y')) \ + .drop(['id_y','id_fct'],1) \ + .rename(columns={'description_y':'desc_param', 'nom_court':'nom_court_fct','nom':'nom_fct'}) \ + .sort_values('id_site') + + if df.nom_court_fct.isnull().sum() == df.shape[0] : del df['nom_court_fct'] + + return df + + + def get_connex(self, id_site=None, nom_site=None, last_update=True, geom=False,statut='actif'): + + table = 'r_site_type_connect' + df = self._get_relation_tab(schema=self.schema,tab=table,id_site=id_site,nom_site=nom_site,last_update=last_update,geom=geom, + params_col={'id_type_milieu':self.id_milieux.astype(str)}, statut=statut) + dic = self._get_param(param_table='param_type_connect') + + if not df.empty: + df = _get_relation_autor(df, relation_tab='r_rsiteconnect_auteur', schema=self.schema, + id_df='id', id_relation='id_siteconnect', id_rela_auth='id_auteur' ) + df = pd.merge(df,dic, how='left', left_on='id_param_connect', right_on='id', suffixes=(None,'_y')) \ + .drop(['id_y','id_param_connect'],1) \ + .rename(columns={'description_y':'desc_param', 'nom':'connexion'}) \ + .sort_values('id_site') + + return df + + + def get_sub(self, id_site=None, nom_site=None, last_update=True, geom=False,statut='actif'): + + table = 'r_site_sub' + df = self._get_relation_tab(schema=self.schema,tab=table,id_site=id_site,nom_site=nom_site,last_update=last_update,geom=geom, + params_col={'id_type_milieu':self.id_milieux.astype(str)}, statut=statut) + dic = self._get_param(type_table='type_param_sub', param_table='param_sub', type_court=False) + d1 = dic[dic.type == 'Submersion étendue'] + d2 = dic[dic.type == 'Submersion fréquente'] + + if not df.empty: + df = _get_relation_autor(df, relation_tab='r_rsitesub_auteur', schema=self.schema, + id_df='id', id_relation='id_sitesub', id_rela_auth='id_auteur' ) + + df = pd.merge(df,d1, how='left', left_on='id_etendsub', right_on='id', suffixes=(None,'_y')) \ + .drop(['id_y','id_etendsub', 'type'],1) \ + .rename(columns={'description':'desc_param_etend', 'nom':'Submersion étendue'}) + + df = pd.merge(df,d2, how='left', left_on='id_freqsub', right_on='id', suffixes=(None,'_y')) \ + .drop(['id_y','id_freqsub', 'type'],1) \ + .rename(columns={'description':'desc_param_freq', 'nom':'Submersion fréquente'}) \ + .sort_values('id_site') + + df.rename(columns={'id_origsub': 'origine_sub'}, inplace=True) + + if df['desc_param_etend'].isnull().sum() == df.shape[0] : del df['desc_param_etend'] + if df['desc_param_freq'].isnull().sum() == df.shape[0] : del df['desc_param_freq'] + + return df + + + def get_usageprocess(self, id_site=None, nom_site=None, last_update=True, geom=False,statut='actif'): + + table = 'r_site_usageprocess' + df = self._get_relation_tab(schema=self.schema,tab=table,id_site=id_site,nom_site=nom_site,last_update=last_update,geom=geom, + params_col={'id_type_milieu':self.id_milieux.astype(str)}, statut=statut) + dic1 = self._get_param(param_table='param_activ_hum') + dic2 = self._get_param(param_table='param_position') + dic3 = self._get_param(param_table='param_impact') + + if not df.empty: + df = _get_relation_autor(df, relation_tab='r_rsiteusage_auteur', schema=self.schema, + id_df='id', id_relation='id_siteusage', id_rela_auth='id_auteur' ) + + df = pd.merge(df,dic1, how='left', left_on='id_activ_hum', right_on='id', suffixes=(None,'_y')) \ + .drop(['id_y','id_activ_hum'],1) \ + .rename(columns={'description':'desc_param_usag', 'nom':'activite_hum'}) + df = pd.merge(df,dic2, how='left', left_on='id_position', right_on='id', suffixes=(None,'_y')) \ + .drop(['id_y','id_position'],1) \ + .rename(columns={'description':'desc_param_pos', 'nom':'position'}) \ + .sort_values('id_site') + df = pd.merge(df,dic3, how='left', left_on='id_impact', right_on='id', suffixes=(None,'_y')) \ + .drop(['id_y','id_impact'],1) \ + .rename(columns={'description':'desc_param_imp', 'nom':'impact'}) \ + .sort_values('id_site') + + return df + + + def _get_r_toponymie(self, ids=None): + table = 'r_toponymie' + df = _get_table(self.con, self.schema, table=table, ids=ids) + dic1 = self._get_param(param_table='liste_table_topohydro') + if not df.empty: + df = pd.merge(df,dic1, how='left', left_on='id_orig', right_on='id', suffixes=(None,'_y')) \ + .drop(['id_y','id_orig'],1) + n_tab = df.nom_table.unique() + for tab in n_tab: + iids = df.loc[df.nom_table == tab, 'id_topo'].to_list() + if tab == 'orig_hydro': dic = _get_table(self.con, self.schema, table='orig_hydro', ids=iids) + if tab == 'troncon_hydro': dic = ref_hydro.get_troncon(cols=['id','nom'], ids=iids) + df.loc[df.nom_table == tab, 'id_topo'] = df.loc[df.nom_table == tab, 'id_topo'].replace(dic.id.to_list(),dic.nom.to_list()) + if tab == 'troncon_hydro': df = pd.merge(df, dic, how='left', left_on='id_topo', right_on='nom', suffixes=(None,'_y')) \ + .drop(columns=['id_y', 'nom']) + df.rename(columns={'id_topo':'toponymie'}) + + return df + + + def get_regHydro(self, id_site=None, nom_site=None, last_update=True, geom=False,statut='actif'): + + table = 'r_site_reghydro' + df = self._get_relation_tab(schema=self.schema,tab=table,id_site=id_site,nom_site=nom_site,last_update=last_update,geom=geom, + params_col={'id_type_milieu':self.id_milieux.astype(str)}, statut=statut) + dic1 = self._get_param(param_table='param_reg_hydro') + dic2 = self._get_param(param_table='param_permanence') + + if not df.empty: + df = _get_relation_autor(df, relation_tab='r_rsitehydro_auteur', schema=self.schema, + id_df='id', id_relation='id_sitehydro', id_rela_auth='id_auteur' ) + + # dic3 = self._get_r_toponymie(ids=df.rmq_toponymie.unique().tolist()) + df.in_out = df.in_out.replace([True,False],['entree','sortie']) + df = pd.merge(df,dic1, how='left', left_on='id_reg_hydro', right_on='id', suffixes=(None,'_y')) \ + .drop(['id_y','id_reg_hydro'],1) \ + .rename(columns={'description':'desc_param_regHydri', 'nom':'regime_hydri'}) + + if df.id_permanence.isna().all() : + df.rename(columns={'id_permanence':'permanence'}, inplace=True) + df['desc_param_perm'] = None + else: + df = pd.merge(df,dic2, how='left', left_on='id_permanence', right_on='id', suffixes=(None,'_y')) \ + .drop(['id_y','id_permanence'],1) \ + .rename(columns={'description':'desc_param_perm', 'nom':'permanence'}) + + # df = pd.merge(df,dic3, left_on='rmq_toponymie', right_on='id', suffixes=(None,'_y')) \ + # .drop(['id_y','rmq_toponymie'],1) \ + # .rename(columns={'description':'desc_topo'}) \ + # .sort_values('id_site') + + return df + + + def get_habitat(self, id_site=None, nom_site=None, last_update=True, geom=False,statut='actif'): + + table = 'r_site_habitat' + df = self._get_relation_tab(schema=self.schema,tab=table,id_site=id_site,nom_site=nom_site,last_update=last_update,geom=geom, + params_col={'id_type_milieu':self.id_milieux.astype(str)}, statut=statut) + + if not df.empty: + df = _get_relation_autor(df, relation_tab='r_rsitehab_auteur', schema=self.schema, + id_df='id', id_relation='id_sitehab', id_rela_auth='id_auteur' ) + + ids = df[~df.id_cb.isna()].id_cb.unique().tolist() + dic = ref_hab().get_CB(ids=ids,cols=['id','lb_hab_fr']) + df = pd.merge(df,dic, how='left', left_on='id_cb', right_on='id', suffixes=(None,'_y')) \ + .drop(['id_y'], 1) \ + .rename(columns={'id_cb':'code_cb'}) \ + .sort_values('id_site') + + return df + + + def get_sitesInfos(self, id_site=None, nom_site=None, columns=None, with_nameOrga=False, statut='actif'): + from .sites.sites import get_sitesInfos + + df = get_sitesInfos(ids=id_site, nom=nom_site, columns=columns, with_nameOrga=with_nameOrga, + params_col={'id_type_milieu':self.id_milieux.astype(str)}, statut=statut) + + return df + + + def get_sitesGeom(self, id_site=None, nom_site=None, columns=None, last_update=True, with_nameOrga=False, + params_col={}, statut='actif'): + from .sites.sites import get_sitesGeom + + if params_col: + params_col = {**params_col, 'id_type_milieu':self.id_milieux.astype(str) } + + df = get_sitesGeom(id_site=id_site, nom_site=nom_site, columns=columns, + with_nameOrga=with_nameOrga,last_update=last_update, + params_col=params_col , statut=statut) + + drop_cols = ['link_pdf', 'rmq_fct_majeur', + 'rmq_interet_patri', 'rmq_bilan_menace', 'rmq_orient_act', + 'rmq_usage_process'] + cols = df.columns + c = cols[cols.isin(drop_cols)] + if not c.empty: + df.drop(columns=c, inplace=True) + + return df + + + def get_evaluation(self, id_site=None, nom_site=None, columns=None, last_update=True, with_nameOrga=False, + params_col={}, statut='actif'): + from .sites.sites import get_sitesGeom + + if params_col: + params_col = {**params_col, 'id_type_milieu':self.id_milieux.astype(str) } + + df = get_sitesGeom(id_site=id_site, nom_site=nom_site, columns=columns, + with_nameOrga=with_nameOrga,last_update=last_update, + params_col=params_col, statut=statut) + + df.drop(columns=['geom'], inplace=True) + + return df + + + def get_bilan(self, code_site=None, nom_site=None, statut='actif',last_update=True): + ''' + :code_site: list,str. Code du site de la zh. + :nom_site: list,str. Nom du site de la zh. + ''' + info = self.get_sitesInfos(id_site=code_site, nom_site=nom_site,statut=statut) + CB = self.get_habitat(id_site=code_site, nom_site=nom_site,last_update=last_update,statut=statut) + delim = self.get_delim(id_site=code_site, nom_site=nom_site,last_update=last_update,statut=statut) + desc = self.get_usageprocess(id_site=code_site, nom_site=nom_site,last_update=last_update,statut=statut) + rghyd = self.get_regHydro(id_site=code_site, nom_site=nom_site,last_update=last_update,statut=statut) + subm = self.get_sub(id_site=code_site, nom_site=nom_site,last_update=last_update,statut=statut) + conn = self.get_connex(id_site=code_site, nom_site=nom_site,last_update=last_update,statut=statut) + fct = self.get_fct(id_site=code_site, nom_site=nom_site,last_update=last_update,statut=statut) + evall = self.get_evaluation(id_site=code_site, nom_site=nom_site,last_update=last_update,statut=statut) + + print('subm : {}'.format(subm)) + print('conn : {}'.format(conn)) + if subm.empty: + sub_con = conn.rename(columns={ + 'description': 'desc_connex', + 'valid': 'valid_cnx', + }) + elif conn.empty: + sub_con = subm.rename(columns={'valid': 'valid_sub',}) + else: + sub_con = pd.merge(subm, conn, how='outer', on=['id', 'id_site', 'date_geom','auteur_geom']) \ + .rename(columns={ + 'description': 'desc_connex', + 'valid_x': 'valid_sub', + 'valid_y': 'valid_cnx', + }) + fctmt = { + 'entree_eau': rghyd[rghyd.in_out == 'entree'].drop(columns=['in_out']), + 'sortie_eau': rghyd[rghyd.in_out == 'sortie'].drop(columns=['in_out']), + 'sub_connex': sub_con, + } + lst_df = { + 'infos':info, + 'corine_biotope': CB, + 'delimitation': delim, + 'description': desc, + 'fonctionnement': fctmt, + 'fonction': fct, + 'evaluation': evall} + for key in lst_df: + if isinstance(lst_df[key], pd.DataFrame): lst_df[key].name = key + if isinstance(lst_df[key], dict): + for d in lst_df[key]: + lst_df[key][d].name = d + lst_df[key]['title'] = key + return lst_df + +##################################### +### schema ref_habitats ### +##################################### +class ref_hab: + def __init__(self): + from .params import con + self.schema = 'ref_habitats' + self.con = con + + def get_CB(self, ids=None, cols=None, params_col={}): + table = 'corine_biotope' + df = _get_table(self.con, self.schema, table=table, ids=ids, cols=cols, params_col=params_col) + return df + + +##################################### +### schema ref_hydro ### +##################################### +class ref_hydro: + def __init__(self): + from .params import con + self.schema = 'ref_hydro' + self.con = con + + def get_troncon(self, ids=None, cols=None, params_col={}): + + table = 'troncon_hydro' + df = _get_table(self.con, self.schema, table=table, ids=ids, cols=cols, params_col=params_col) + # df = _set_geom(df) + + return df + + def get_coursEau(self, ids=None, cols=None, params_col={}): + + table = 'cours_eau' + df = _get_table(self.con, self.schema, table=table, ids=ids, cols=cols, params_col=params_col) + # df = _set_geom(df) + + return df + + def get_masseEau(self, ids=None, cols=None, params_col={}): + + table = 'masse_eau' + df = _get_table(self.con, self.schema, table=table, ids=ids, cols=cols, params_col=params_col) + # df = _set_geom(df) + + return df + + def get_planEau(self, ids=None, cols=None, params_col={}): + + table = 'plan_eau' + df = _get_table(self.con, self.schema, table=table, ids=ids, cols=cols, params_col=params_col) + # df = _set_geom(df) + + return df + + def get_ssbv(self, ids=None, cols=None, params_col={}): + + table = 'ssbv' + df = _get_table(self.con, self.schema, table=table, ids=ids, cols=cols, params_col=params_col) + # df = _set_geom(df) + + return df + + + + + +##################################### +### Update ### +##################################### +def update_to_sql(df, con, table_name, schema_name, key_name): + a = [] + b = [] + table = table_name + schema = schema_name + primary_key = key_name + if isinstance(primary_key, str): primary_key = [primary_key] + for col in df.columns: + if col in primary_key: + b.append("t.{col}=f.{col}".format(col=col)) + else: + a.append("{col}=t.{col}".format(col=col)) + df.to_sql( + name = 'temp_table', + con = con, + schema = schema, + if_exists = 'replace', + index = False, + method = 'multi' + ) + update_stmt_1 = "UPDATE {sch}.{final_table} f".format(sch=schema,final_table=table) + update_stmt_2 = " FROM {sch}.temp_table t".format(sch=schema) + update_stmt_6 = " WHERE %s"%' AND '.join(b) + update_stmt_3 = " SET " + update_stmt_4 = ", ".join(a) + update_stmt_5 = update_stmt_1 + update_stmt_3 + update_stmt_4 + update_stmt_2 + update_stmt_6 + ";" + drop_stmt = "DROP TABLE {sch}.temp_table ;".format(sch=schema) + with con.begin() as cnx: + cnx.execute(update_stmt_5) + cnx.execute(drop_stmt) + return print('END update') + + +# [SQL: INSERT INTO zones_humides.r_site_reghydro (id, id_geom_site, id_reg_hydro, id_permanence, rmq_toponymie, in_out) +# VALUES (%(id)s, %(id_geom_site)s, %(id_reg_hydro)s, %(id_permanence)s, %(rmq_toponymie)s, %(in_out)s)] +# [parameters: ({'id': 0, 'id_geom_site': 5, 'id_reg_hydro': '0', 'id_permanence': '1', 'rmq_toponymie': '', 'in_out': True}, +# {'id': 1, 'id_geom_site': 5, 'id_reg_hydro': '1', 'id_permanence': '1', 'rmq_toponymie': '', 'in_out': False}, +# {'id': 2, 'id_geom_site': 6, 'id_reg_hydro': '0', 'id_permanence': '1', 'rmq_toponymie': '', 'in_out': True}, +# {'id': 3, 'id_geom_site': 6, 'id_reg_hydro': '1', 'id_permanence': '1', 'rmq_toponymie': '', 'in_out': False}, +# {'id': 4, 'id_geom_site': 7, 'id_reg_hydro': '2', 'id_permanence': '2', 'rmq_toponymie': 'plusieurs petites sources dans versant', 'in_out': True}, +# {'id': 5, 'id_geom_site': 7, 'id_reg_hydro': '1', 'id_permanence': '2', 'rmq_toponymie': 'longe la route D209a', 'in_out': False}, +# {'id': 6, 'id_geom_site': 8, 'id_reg_hydro': '0', 'id_permanence': '2', 'rmq_toponymie': '', 'in_out': True}, +# {'id': 7, 'id_geom_site': 8, 'id_reg_hydro': '3', 'id_permanence': None, 'rmq_toponymie': '', 'in_out': False} +# ... displaying 10 of 5779 total bound parameter sets ... +# {'id': 5777, 'id_geom_site': 1951, 'id_reg_hydro': '0', 'id_permanence': None, 'rmq_toponymie': '', 'in_out': True}, +# {'id': 5778, 'id_geom_site': 1951, 'id_reg_hydro': '3', 'id_permanence': None, 'rmq_toponymie': '', 'in_out': False})]