# packages

pkgId: a88dd62a36f835576155ed2e53d4fe283c35ae2a54814721165791c86bd9785d
name: python-bpemb
arch: src
version: 0.3.6
epoch: 0
release: 1
summary: Byte-pair embeddings in 275 languages
url: https://nlp.h-its.org/bpemb
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bpemb-0.3.6-1.src.rpm
checksum_type: sha256
description:
  BPEmb is a collection of pre-trained subword embeddings in 275 languages, based on Byte-Pair Encoding (BPE) and trained on Wikipedia. Its intended use is as input for neural models in natural language processing.

  [Website](https://nlp.h-its.org/bpemb) ・
  [Usage](#usage) ・
  [Download](#downloads-for-each-language) ・
  [MultiBPEmb](#multibpemb) ・
  [Paper (pdf)](http://www.lrec-conf.org/proceedings/lrec2018/pdf/1049.pdf) ・
  [Citing BPEmb](#citing-bpemb)





  Install BPEmb with pip:

  ```bash
  pip install bpemb
  ```

  Embeddings and SentencePiece models will be downloaded automatically the first time you use them.

  ```python
  >>> from bpemb import BPEmb

  >>> bpemb_en = BPEmb(lang="en", dim=50)
  downloading https://nlp.h-its.org/bpemb/en/en.wiki.bpe.vs10000.model
  downloading https://nlp.h-its.org/bpemb/en/en.wiki.bpe.vs10000.d50.w2v.bin.tar.gz
  ```

  You can do two main things with BPEmb. The first is subword segmentation:
  ```python

  >>> bpemb_en.encode("Stratford")
  ['▁strat', 'ford']

  >>> bpemb_zh = BPEmb(lang="zh", vs=100000)

  >>> bpemb_zh.encode("这是一个中文句子")  # "This is a Chinese sentence."
  ['▁这是一个', '中文', '句子']  # ["This is a", "Chinese", "sentence"]
  ```

  If / how a word gets split depends on the vocabulary size. Generally, a smaller vocabulary size will yield a segmentation into many subwords, while a large vocabulary size will result in frequent words not being split:

  | vocabulary size | segmentation |
  | --- | --- |
  | 1000 | ['▁str', 'at', 'f', 'ord'] |
  | 3000 |  ['▁str', 'at', 'ford'] |
  | 5000 | ['▁str', 'at', 'ford'] |
  | 10000 | ['▁strat', 'ford'] |
  | 25000 | ['▁stratford'] |
  | 50000 | ['▁stratford'] |
  | 100000 | ['▁stratford'] |
  | 200000 | ['▁stratford'] |


  The second purpose of BPEmb is to provide pretrained subword embeddings:

  ```python

  >>> type(bpemb_zh.emb)
  gensim.models.keyedvectors.Word2VecKeyedVectors

  >>> bpemb_en.most_similar("ford")
  [('bury', 0.8745079040527344),
   ('ton', 0.8725000619888306),
   ('well', 0.871537446975708),
   ('ston', 0.8701574206352234),
   ('worth', 0.8672043085098267),
   ('field', 0.859795331954956),
   ('ley', 0.8591548204421997),
   ('ington', 0.8126075267791748),
   ('bridge', 0.8099068999290466),
   ('brook', 0.7979353070259094)]
  >>> type(bpemb_en.vectors)
  numpy.ndarray
  >>> bpemb_en.vectors.shape
  (10000, 50)
  >>> bpemb_zh.vectors.shape
  (100000, 100)
  ```

  To use subword embeddings in your neural network, either encode your input into subword IDs:
  ```python
  >>> ids = bpemb_zh.encode_ids("这是一个中文句子")
  [25950, 695, 20199]
  >>> bpemb_zh.vectors[ids].shape
  (3, 100)
  ```

  Or use the `embed` method:
  ```python

  >>> bpemb_zh.embed("这是一个中文句子").shape
  (3, 100)
  ```



  [ab (Abkhazian)](http://nlp.h-its.org/bpemb/ab) ・
  [ace (Achinese)](http://nlp.h-its.org/bpemb/ace) ・
  [ady (Adyghe)](http://nlp.h-its.org/bpemb/ady) ・
  [af (Afrikaans)](http://nlp.h-its.org/bpemb/af) ・
  [ak (Akan)](http://nlp.h-its.org/bpemb/ak) ・
  [als (Alemannic)](http://nlp.h-its.org/bpemb/als) ・
  [am (Amharic)](http://nlp.h-its.org/bpemb/am) ・
  [an (Aragonese)](http://nlp.h-its.org/bpemb/an) ・
  [ang (Old English)](http://nlp.h-its.org/bpemb/ang) ・
  [ar (Arabic)](http://nlp.h-its.org/bpemb/ar) ・
  [arc (Official Aramaic)](http://nlp.h-its.org/bpemb/arc) ・
  [arz (Egyptian Arabic)](http://nlp.h-its.org/bpemb/arz) ・
  [as (Assamese)](http://nlp.h-its.org/bpemb/as) ・
  [ast (Asturian)](http://nlp.h-its.org/bpemb/ast) ・
  [atj (Atikamekw)](http://nlp.h-its.org/bpemb/atj) ・
  [av (Avaric)](http://nlp.h-its.org/bpemb/av) ・
  [ay (Aymara)](http://nlp.h-its.org/bpemb/ay) ・
  [az (Azerbaijani)](http://nlp.h-its.org/bpemb/az) ・
  [azb (South Azerbaijani)](http://nlp.h-its.org/bpemb/azb)

  [ba (Bashkir)](http://nlp.h-its.org/bpemb/ba) ・
  [bar (Bavarian)](http://nlp.h-its.org/bpemb/bar) ・
  [bcl (Central Bikol)](http://nlp.h-its.org/bpemb/bcl) ・
  [be (Belarusian)](http://nlp.h-its.org/bpemb/be) ・
  [bg (Bulgarian)](http://nlp.h-its.org/bpemb/bg) ・
  [bi (Bislama)](http://nlp.h-its.org/bpemb/bi) ・
  [bjn (Banjar)](http://nlp.h-its.org/bpemb/bjn) ・
  [bm (Bambara)](http://nlp.h-its.org/bpemb/bm) ・
  [bn (Bengali)](http://nlp.h-its.org/bpemb/bn) ・
  [bo (Tibetan)](http://nlp.h-its.org/bpemb/bo) ・
  [bpy (Bishnupriya)](http://nlp.h-its.org/bpemb/bpy) ・
  [br (Breton)](http://nlp.h-its.org/bpemb/br) ・
  [bs (Bosnian)](http://nlp.h-its.org/bpemb/bs) ・
  [bug (Buginese)](http://nlp.h-its.org/bpemb/bug) ・
  [bxr (Russia Buriat)](http://nlp.h-its.org/bpemb/bxr)

  [ca (Catalan)](http://nlp.h-its.org/bpemb/ca) ・
  [cdo (Min Dong Chinese)](http://nlp.h-its.org/bpemb/cdo) ・
  [ce (Chechen)](http://nlp.h-its.org/bpemb/ce) ・
  [ceb (Cebuano)](http://nlp.h-its.org/bpemb/ceb) ・
  [ch (Chamorro)](http://nlp.h-its.org/bpemb/ch) ・
  [chr (Cherokee)](http://nlp.h-its.org/bpemb/chr) ・
  [chy (Cheyenne)](http://nlp.h-its.org/bpemb/chy) ・
  [ckb (Central Kurdish)](http://nlp.h-its.org/bpemb/ckb) ・
  [co (Corsican)](http://nlp.h-its.org/bpemb/co) ・
  [cr (Cree)](http://nlp.h-its.org/bpemb/cr) ・
  [crh (Crimean Tatar)](http://nlp.h-its.org/bpemb/crh) ・
  [cs (Czech)](http://nlp.h-its.org/bpemb/cs) ・
  [csb (Kashubian)](http://nlp.h-its.org/bpemb/csb) ・
  [cu (Church Slavic)](http://nlp.h-its.org/bpemb/cu) ・
  [cv (Chuvash)](http://nlp.h-its.org/bpemb/cv) ・
  [cy (Welsh)](http://nlp.h-its.org/bpemb/cy)

  [da (Danish)](http://nlp.h-its.org/bpemb/da) ・
  [de (German)](http://nlp.h-its.org/bpemb/de) ・
  [din (Dinka)](http://nlp.h-its.org/bpemb/din) ・
  [diq (Dimli)](http://nlp.h-its.org/bpemb/diq) ・
  [dsb (Lower Sorbian)](http://nlp.h-its.org/bpemb/dsb) ・
  [dty (Dotyali)](http://nlp.h-its.org/bpemb/dty) ・
  [dv (Dhivehi)](http://nlp.h-its.org/bpemb/dv) ・
  [dz (Dzongkha)](http://nlp.h-its.org/bpemb/dz)

  [ee (Ewe)](http://nlp.h-its.org/bpemb/ee) ・
  [el (Modern Greek)](http://nlp.h-its.org/bpemb/el) ・
  [en (English)](http://nlp.h-its.org/bpemb/en) ・
  [eo (Esperanto)](http://nlp.h-its.org/bpemb/eo) ・
  [es (Spanish)](http://nlp.h-its.org/bpemb/es) ・
  [et (Estonian)](http://nlp.h-its.org/bpemb/et) ・
  [eu (Basque)](http://nlp.h-its.org/bpemb/eu) ・
  [ext (Extremaduran)](http://nlp.h-its.org/bpemb/ext)

  [fa (Persian)](http://nlp.h-its.org/bpemb/fa) ・
  [ff (Fulah)](http://nlp.h-its.org/bpemb/ff) ・
  [fi (Finnish)](http://nlp.h-its.org/bpemb/fi) ・
  [fj (Fijian)](http://nlp.h-its.org/bpemb/fj) ・
  [fo (Faroese)](http://nlp.h-its.org/bpemb/fo) ・
  [fr (French)](http://nlp.h-its.org/bpemb/fr) ・
  [frp (Arpitan)](http://nlp.h-its.org/bpemb/frp) ・
  [frr (Northern Frisian)](http://nlp.h-its.org/bpemb/frr) ・
  [fur (Friulian)](http://nlp.h-its.org/bpemb/fur) ・
  [fy (Western Frisian)](http://nlp.h-its.org/bpemb/fy)

  [ga (Irish)](http://nlp.h-its.org/bpemb/ga) ・
  [gag (Gagauz)](http://nlp.h-its.org/bpemb/gag) ・
  [gan (Gan Chinese)](http://nlp.h-its.org/bpemb/gan) ・
  [gd (Scottish Gaelic)](http://nlp.h-its.org/bpemb/gd) ・
  [gl (Galician)](http://nlp.h-its.org/bpemb/gl) ・
  [glk (Gilaki)](http://nlp.h-its.org/bpemb/glk) ・
  [gn (Guarani)](http://nlp.h-its.org/bpemb/gn) ・
  [gom (Goan Konkani)](http://nlp.h-its.org/bpemb/gom) ・
  [got (Gothic)](http://nlp.h-its.org/bpemb/got) ・
  [gu (Gujarati)](http://nlp.h-its.org/bpemb/gu) ・
  [gv (Manx)](http://nlp.h-its.org/bpemb/gv)

  [ha (Hausa)](http://nlp.h-its.org/bpemb/ha) ・
  [hak (Hakka Chinese)](http://nlp.h-its.org/bpemb/hak) ・
  [haw (Hawaiian)](http://nlp.h-its.org/bpemb/haw) ・
  [he (Hebrew)](http://nlp.h-its.org/bpemb/he) ・
  [hi (Hindi)](http://nlp.h-its.org/bpemb/hi) ・
  [hif (Fiji Hindi)](http://nlp.h-its.org/bpemb/hif) ・
  [hr (Croatian)](http://nlp.h-its.org/bpemb/hr) ・
  [hsb (Upper Sorbian)](http://nlp.h-its.org/bpemb/hsb) ・
  [ht (Haitian)](http://nlp.h-its.org/bpemb/ht) ・
  [hu (Hungarian)](http://nlp.h-its.org/bpemb/hu) ・
  [hy (Armenian)](http://nlp.h-its.org/bpemb/hy)

  [ia (Interlingua)](http://nlp.h-its.org/bpemb/ia) ・
  [id (Indonesian)](http://nlp.h-its.org/bpemb/id) ・
  [ie (Interlingue)](http://nlp.h-its.org/bpemb/ie) ・
  [ig (Igbo)](http://nlp.h-its.org/bpemb/ig) ・
  [ik (Inupiaq)](http://nlp.h-its.org/bpemb/ik) ・
  [ilo (Iloko)](http://nlp.h-its.org/bpemb/ilo) ・
  [io (Ido)](http://nlp.h-its.org/bpemb/io) ・
  [is (Icelandic)](http://nlp.h-its.org/bpemb/is) ・
  [it (Italian)](http://nlp.h-its.org/bpemb/it) ・
  [iu (Inuktitut)](http://nlp.h-its.org/bpemb/iu)

  [ja (Japanese)](http://nlp.h-its.org/bpemb/ja) ・
  [jam (Jamaican Creole English)](http://nlp.h-its.org/bpemb/jam) ・
  [jbo (Lojban)](http://nlp.h-its.org/bpemb/jbo) ・
  [jv (Javanese)](http://nlp.h-its.org/bpemb/jv)

  [ka (Georgian)](http://nlp.h-its.org/bpemb/ka) ・
  [kaa (Kara-Kalpak)](http://nlp.h-its.org/bpemb/kaa) ・
  [kab (Kabyle)](http://nlp.h-its.org/bpemb/kab) ・
  [kbd (Kabardian)](http://nlp.h-its.org/bpemb/kbd) ・
  [kbp (Kabiyè)](http://nlp.h-its.org/bpemb/kbp) ・
  [kg (Kongo)](http://nlp.h-its.org/bpemb/kg) ・
  [ki (Kikuyu)](http://nlp.h-its.org/bpemb/ki) ・
  [kk (Kazakh)](http://nlp.h-its.org/bpemb/kk) ・
  [kl (Kalaallisut)](http://nlp.h-its.org/bpemb/kl) ・
  [km (Central Khmer)](http://nlp.h-its.org/bpemb/km) ・
  [kn (Kannada)](http://nlp.h-its.org/bpemb/kn) ・
  [ko (Korean)](http://nlp.h-its.org/bpemb/ko) ・
  [koi (Komi-Permyak)](http://nlp.h-its.org/bpemb/koi) ・
  [krc (Karachay-Balkar)](http://nlp.h-its.org/bpemb/krc) ・
  [ks (Kashmiri)](http://nlp.h-its.org/bpemb/ks) ・
  [ksh (Kölsch)](http://nlp.h-its.org/bpemb/ksh) ・
  [ku (Kurdish)](http://nlp.h-its.org/bpemb/ku) ・
  [kv (Komi)](http://nlp.h-its.org/bpemb/kv) ・
  [kw (Cornish)](http://nlp.h-its.org/bpemb/kw) ・
  [ky (Kirghiz)](http://nlp.h-its.org/bpemb/ky)

  [la (Latin)](http://nlp.h-its.org/bpemb/la) ・
  [lad (Ladino)](http://nlp.h-its.org/bpemb/lad) ・
  [lb (Luxembourgish)](http://nlp.h-its.org/bpemb/lb) ・
  [lbe (Lak)](http://nlp.h-its.org/bpemb/lbe) ・
  [lez (Lezghian)](http://nlp.h-its.org/bpemb/lez) ・
  [lg (Ganda)](http://nlp.h-its.org/bpemb/lg) ・
  [li (Limburgan)](http://nlp.h-its.org/bpemb/li) ・
  [lij (Ligurian)](http://nlp.h-its.org/bpemb/lij) ・
  [lmo (Lombard)](http://nlp.h-its.org/bpemb/lmo) ・
  [ln (Lingala)](http://nlp.h-its.org/bpemb/ln) ・
  [lo (Lao)](http://nlp.h-its.org/bpemb/lo) ・
  [lrc (Northern Luri)](http://nlp.h-its.org/bpemb/lrc) ・
  [lt (Lithuanian)](http://nlp.h-its.org/bpemb/lt) ・
  [ltg (Latgalian)](http://nlp.h-its.org/bpemb/ltg) ・
  [lv (Latvian)](http://nlp.h-its.org/bpemb/lv)

  [mai (Maithili)](http://nlp.h-its.org/bpemb/mai) ・
  [mdf (Moksha)](http://nlp.h-its.org/bpemb/mdf) ・
  [mg (Malagasy)](http://nlp.h-its.org/bpemb/mg) ・
  [mh (Marshallese)](http://nlp.h-its.org/bpemb/mh) ・
  [mhr (Eastern Mari)](http://nlp.h-its.org/bpemb/mhr) ・
  [mi (Maori)](http://nlp.h-its.org/bpemb/mi) ・
  [min (Minangkabau)](http://nlp.h-its.org/bpemb/min) ・
  [mk (Macedonian)](http://nlp.h-its.org/bpemb/mk) ・
  [ml (Malayalam)](http://nlp.h-its.org/bpemb/ml) ・
  [mn (Mongolian)](http://nlp.h-its.org/bpemb/mn) ・
  [mr (Marathi)](http://nlp.h-its.org/bpemb/mr) ・
  [mrj (Western Mari)](http://nlp.h-its.org/bpemb/mrj) ・
  [ms (Malay)](http://nlp.h-its.org/bpemb/ms) ・
  [mt (Maltese)](http://nlp.h-its.org/bpemb/mt) ・
  [mwl (Mirandese)](http://nlp.h-its.org/bpemb/mwl) ・
  [my (Burmese)](http://nlp.h-its.org/bpemb/my) ・
  [myv (Erzya)](http://nlp.h-its.org/bpemb/myv) ・
  [mzn (Mazanderani)](http://nlp.h-its.org/bpemb/mzn)

  [na (Nauru)](http://nlp.h-its.org/bpemb/na) ・
  [nap (Neapolitan)](http://nlp.h-its.org/bpemb/nap) ・
  [nds (Low German)](http://nlp.h-its.org/bpemb/nds) ・
  [ne (Nepali)](http://nlp.h-its.org/bpemb/ne) ・
  [new (Newari)](http://nlp.h-its.org/bpemb/new) ・
  [ng (Ndonga)](http://nlp.h-its.org/bpemb/ng) ・
  [nl (Dutch)](http://nlp.h-its.org/bpemb/nl) ・
  [nn (Norwegian Nynorsk)](http://nlp.h-its.org/bpemb/nn) ・
  [no (Norwegian)](http://nlp.h-its.org/bpemb/no) ・
  [nov (Novial)](http://nlp.h-its.org/bpemb/nov) ・
  [nrm (Narom)](http://nlp.h-its.org/bpemb/nrm) ・
  [nso (Pedi)](http://nlp.h-its.org/bpemb/nso) ・
  [nv (Navajo)](http://nlp.h-its.org/bpemb/nv) ・
  [ny (Nyanja)](http://nlp.h-its.org/bpemb/ny)

  [oc (Occitan)](http://nlp.h-its.org/bpemb/oc) ・
  [olo (Livvi)](http://nlp.h-its.org/bpemb/olo) ・
  [om (Oromo)](http://nlp.h-its.org/bpemb/om) ・
  [or (Oriya)](http://nlp.h-its.org/bpemb/or) ・
  [os (Ossetian)](http://nlp.h-its.org/bpemb/os)

  [pa (Panjabi)](http://nlp.h-its.org/bpemb/pa) ・
  [pag (Pangasinan)](http://nlp.h-its.org/bpemb/pag) ・
  [pam (Pampanga)](http://nlp.h-its.org/bpemb/pam) ・
  [pap (Papiamento)](http://nlp.h-its.org/bpemb/pap) ・
  [pcd (Picard)](http://nlp.h-its.org/bpemb/pcd) ・
  [pdc (Pennsylvania German)](http://nlp.h-its.org/bpemb/pdc) ・
  [pfl (Pfaelzisch)](http://nlp.h-its.org/bpemb/pfl) ・
  [pi (Pali)](http://nlp.h-its.org/bpemb/pi) ・
  [pih (Pitcairn-Norfolk)](http://nlp.h-its.org/bpemb/pih) ・
  [pl (Polish)](http://nlp.h-its.org/bpemb/pl) ・
  [pms (Piemontese)](http://nlp.h-its.org/bpemb/pms) ・
  [pnb (Western Panjabi)](http://nlp.h-its.org/bpemb/pnb) ・
  [pnt (Pontic)](http://nlp.h-its.org/bpemb/pnt) ・
  [ps (Pushto)](http://nlp.h-its.org/bpemb/ps) ・
  [pt (Portuguese)](http://nlp.h-its.org/bpemb/pt)

  [qu (Quechua)](http://nlp.h-its.org/bpemb/qu)

  [rm (Romansh)](http://nlp.h-its.org/bpemb/rm) ・
  [rmy (Vlax Romani)](http://nlp.h-its.org/bpemb/rmy) ・
  [rn (Rundi)](http://nlp.h-its.org/bpemb/rn) ・
  [ro (Romanian)](http://nlp.h-its.org/bpemb/ro) ・
  [ru (Russian)](http://nlp.h-its.org/bpemb/ru) ・
  [rue (Rusyn)](http://nlp.h-its.org/bpemb/rue) ・
  [rw (Kinyarwanda)](http://nlp.h-its.org/bpemb/rw)

  [sa (Sanskrit)](http://nlp.h-its.org/bpemb/sa) ・
  [sah (Yakut)](http://nlp.h-its.org/bpemb/sah) ・
  [sc (Sardinian)](http://nlp.h-its.org/bpemb/sc) ・
  [scn (Sicilian)](http://nlp.h-its.org/bpemb/scn) ・
  [sco (Scots)](http://nlp.h-its.org/bpemb/sco) ・
  [sd (Sindhi)](http://nlp.h-its.org/bpemb/sd) ・
  [se (Northern Sami)](http://nlp.h-its.org/bpemb/se) ・
  [sg (Sango)](http://nlp.h-its.org/bpemb/sg) ・
  [sh (Serbo-Croatian)](http://nlp.h-its.org/bpemb/sh) ・
  [si (Sinhala)](http://nlp.h-its.org/bpemb/si) ・
  [sk (Slovak)](http://nlp.h-its.org/bpemb/sk) ・
  [sl (Slovenian)](http://nlp.h-its.org/bpemb/sl) ・
  [sm (Samoan)](http://nlp.h-its.org/bpemb/sm) ・
  [sn (Shona)](http://nlp.h-its.org/bpemb/sn) ・
  [so (Somali)](http://nlp.h-its.org/bpemb/so) ・
  [sq (Albanian)](http://nlp.h-its.org/bpemb/sq) ・
  [sr (Serbian)](http://nlp.h-its.org/bpemb/sr) ・
  [srn (Sranan Tongo)](http://nlp.h-its.org/bpemb/srn) ・
  [ss (Swati)](http://nlp.h-its.org/bpemb/ss) ・
  [st (Southern Sotho)](http://nlp.h-its.org/bpemb/st) ・
  [stq (Saterfriesisch)](http://nlp.h-its.org/bpemb/stq) ・
  [su (Sundanese)](http://nlp.h-its.org/bpemb/su) ・
  [sv (Swedish)](http://nlp.h-its.org/bpemb/sv) ・
  [sw (Swahili)](http://nlp.h-its.org/bpemb/sw) ・
  [szl (Silesian)](http://nlp.h-its.org/bpemb/szl)

  [ta (Tamil)](http://nlp.h-its.org/bpemb/ta) ・
  [tcy (Tulu)](http://nlp.h-its.org/bpemb/tcy) ・
  [te (Telugu)](http://nlp.h-its.org/bpemb/te) ・
  [tet (Tetum)](http://nlp.h-its.org/bpemb/tet) ・
  [tg (Tajik)](http://nlp.h-its.org/bpemb/tg) ・
  [th (Thai)](http://nlp.h-its.org/bpemb/th) ・
  [ti (Tigrinya)](http://nlp.h-its.org/bpemb/ti) ・
  [tk (Turkmen)](http://nlp.h-its.org/bpemb/tk) ・
  [tl (Tagalog)](http://nlp.h-its.org/bpemb/tl) ・
  [tn (Tswana)](http://nlp.h-its.org/bpemb/tn) ・
  [to (Tonga)](http://nlp.h-its.org/bpemb/to) ・
  [tpi (Tok Pisin)](http://nlp.h-its.org/bpemb/tpi) ・
  [tr (Turkish)](http://nlp.h-its.org/bpemb/tr) ・
  [ts (Tsonga)](http://nlp.h-its.org/bpemb/ts) ・
  [tt (Tatar)](http://nlp.h-its.org/bpemb/tt) ・
  [tum (Tumbuka)](http://nlp.h-its.org/bpemb/tum) ・
  [tw (Twi)](http://nlp.h-its.org/bpemb/tw) ・
  [ty (Tahitian)](http://nlp.h-its.org/bpemb/ty) ・
  [tyv (Tuvinian)](http://nlp.h-its.org/bpemb/tyv)

  [udm (Udmurt)](http://nlp.h-its.org/bpemb/udm) ・
  [ug (Uighur)](http://nlp.h-its.org/bpemb/ug) ・
  [uk (Ukrainian)](http://nlp.h-its.org/bpemb/uk) ・
  [ur (Urdu)](http://nlp.h-its.org/bpemb/ur) ・
  [uz (Uzbek)](http://nlp.h-its.org/bpemb/uz)

  [ve (Venda)](http://nlp.h-its.org/bpemb/ve) ・
  [vec (Venetian)](http://nlp.h-its.org/bpemb/vec) ・
  [vep (Veps)](http://nlp.h-its.org/bpemb/vep) ・
  [vi (Vietnamese)](http://nlp.h-its.org/bpemb/vi) ・
  [vls (Vlaams)](http://nlp.h-its.org/bpemb/vls) ・
  [vo (Volapük)](http://nlp.h-its.org/bpemb/vo)

  [wa (Walloon)](http://nlp.h-its.org/bpemb/wa) ・
  [war (Waray)](http://nlp.h-its.org/bpemb/war) ・
  [wo (Wolof)](http://nlp.h-its.org/bpemb/wo) ・
  [wuu (Wu Chinese)](http://nlp.h-its.org/bpemb/wuu)

  [xal (Kalmyk)](http://nlp.h-its.org/bpemb/xal) ・
  [xh (Xhosa)](http://nlp.h-its.org/bpemb/xh) ・
  [xmf (Mingrelian)](http://nlp.h-its.org/bpemb/xmf)

  [yi (Yiddish)](http://nlp.h-its.org/bpemb/yi) ・
  [yo (Yoruba)](http://nlp.h-its.org/bpemb/yo)

  [za (Zhuang)](http://nlp.h-its.org/bpemb/za) ・
  [zea (Zeeuws)](http://nlp.h-its.org/bpemb/zea) ・
  [zh (Chinese)](http://nlp.h-its.org/bpemb/zh) ・
  [zu (Zulu)](http://nlp.h-its.org/bpemb/zu)



  [multi (multilingual)](http://nlp.h-its.org/bpemb/multi)



  If you use BPEmb in academic work, please cite:

  ```
  @InProceedings{heinzerling2018bpemb,
    author = {Benjamin Heinzerling and Michael Strube},
    title = "{BPEmb: Tokenization-free Pre-trained Subword Embeddings in 275 Languages}",
    booktitle = {Proceedings of the Eleventh International Conference on Language Resources and Evaluation (LREC 2018)},
    year = {2018},
    month = {May 7-12, 2018},
    address = {Miyazaki, Japan},
    editor = {Nicoletta Calzolari (Conference chair) and Khalid Choukri and Christopher Cieri and Thierry Declerck and Sara Goggi and Koiti Hasida and Hitoshi Isahara and Bente Maegaard and Joseph Mariani and Hélène Mazo and Asuncion Moreno and Jan Odijk and Stelios Piperidis and Takenobu Tokunaga},
    publisher = {European Language Resources Association (ELRA)},
    isbn = {979-10-95546-00-9},
    language = {english}
    }
  ```


pkgId: 64d258afc6f97378913e1f9930bcc09059356b5a6fa427d3134bcac5cbde7422
name: python-bpm-ai
arch: src
version: 1.7.3
epoch: 0
release: 1
summary: AI task automation for BPM engines.
url: https://www.holisticon.de/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bpm-ai-1.7.3-1.src.rpm
checksum_type: sha256
description:
  This project is developed under
  [![Apache 2.0 License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](/LICENSE)

  [![sponsored](https://img.shields.io/badge/sponsoredBy-Holisticon-red.svg)](https://holisticon.de/)


pkgId: 9b407817a86dd0500eeb0abd220d256c7c4c4d03cf45af4321e0c80417eb57f1
name: python-bpm-ai-inference
arch: src
version: 0.3.6
epoch: 0
release: 1
summary: Inference and server for local AI implementations of bpm-ai-core abstractions.
url: https://www.holisticon.de/
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bpm-ai-inference-0.3.6-1.src.rpm
checksum_type: sha256
description:
  Extension to bpm-ai project for local AI inference.



  Install PyTorch (with CUDA GPU support) and spaCy:
  ```bash
  $ pip install -r requirements.txt
  ```
  or CPU-only:
  ```bash
  $ pip install -r requirements.linux-cpu.txt
  ```


  ```bash
  $ pip install -r requirements.apple.txt
  ```


  ```bash
  $ pip install bpm-ai-inference
  ```



  This project is developed under

  [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)

  due to dependency licenses.



  [![sponsored](https://img.shields.io/badge/sponsoredBy-Holisticon-red.svg)](https://holisticon.de/)


pkgId: 7cb2a99ec42c4adf22d84fcd729773b5ae48750a986e5e9034d8e98d6745e021
name: python-bpm-tools
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: Shared functions for BPM data pipelines.
url: https://pypi.org/project/bpm-tools/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bpm-tools-0.2.5-1.src.rpm
checksum_type: sha256
description:
  This README would normally document whatever steps are necessary to get your application up and running.



  * Quick summary
  * Version
  * [Learn Markdown](https://bitbucket.org/tutorials/markdowndemo)



  * Summary of set up
  * Configuration
  * Dependencies
  * Database configuration
  * How to run tests
  * Deployment instructions



  * Writing tests
  * Code review
  * Other guidelines



  * Repo owner or admin
  * Other community or team contact


pkgId: 85c43aa94c66a556edf9ad12395c0df0a3efdc895c0562a19f0636f8144a91be
name: python-bpm2fps
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: Convert beats per minute to animation frames.
url: https://github.com/BreadMakesYouFull/bpm2fps.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bpm2fps-1.0.2-1.src.rpm
checksum_type: sha256
description:
  Match song beats to their closest frame for animation.

  * Utility to convert beats per minute to animation frames.
  * Data export to CSV or JSON.
  * USD export for bouncing ball reference.
  * Also available as cli / python utility

  [https://github.com/BreadMakesYouFull/bpm2fps](https://github.com/BreadMakesYouFull/bpm2fps)



  ![GUI](https://raw.githubusercontent.com/BreadMakesYouFull/bpm2fps/main/preview_gui.gif)

  ![Exported USD reference](https://raw.githubusercontent.com/BreadMakesYouFull/bpm2fps/main/preview_usd.gif)



  <a href='https://flathub.org/apps/io.github.breadmakesyoufull.bpm2fps'>
    <img width='128' alt='Get it on Flathub' src='https://flathub.org/api/badge?locale=en'/>
    Linux install via flatpak
  </a>

  [![PyPI version](https://badge.fury.io/py/bpm2fps.svg)](https://badge.fury.io/py/bpm2fps) [Python install](https://pypi.org/project/bpm2fps/)

  [![](https://github.com/breadmakesyoufull/bpm2fps/actions/workflows/lint-then-test.yml/badge.svg)](https://github.com/BreadMakesYouFull/bpm2fps/actions/workflows/lint-then-test.yml)


  Requires:

  * python 3
  * pyside6 (gui)

  ```

  pip install bpm2fps[gui]


  pip install bpm2fps
  ```



  ```

  bpm2fps
  ```






  ```
  ./bpm2fps.sh --help
  usage: cli.py [-h] [-s START] [-e END] [-b BPM] [-f FPS]

  bpm2fps - Match song beats to their closest frame.

  options:
    -h, --help            show this help message and exit
    -s START, --start START
                          Start time (seconds).
    -e END, --end END     End time (seconds)
    -b BPM, --bpm BPM     Beats per minute
    -f FPS, --fps FPS     Frames per second
  ```


  ```
  ./bpm2fps.sh --bpm 120

  [
    {
      "beat": 0,
      "frame": 0.0,
      "second": 0.0
    },
    {
      "beat": 1,
      "frame": 12.0,
      "second": 0.5
    },
    {
      "beat": 2,
      "frame": 24.0,
      "second": 1.0
    },
    
  ]
  ```

  Example chained with ``jq`` to get only beat frames:
  ```
  ./bpm2fps.sh --bpm 120 | jq '.[]["frame"]'

  0
  12
  24
  36
  48
  60
  72
  84
  96
  108
  ```


pkgId: 2a1cd74a5d20b900a85c94ab8ba7128b306908a72d44a9c5264e49da9624d84c
name: python-bpmappers
arch: src
version: 1.3
epoch: 0
release: 1
url: https://bpmappers.readthedocs.io/ja/stable/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bpmappers-1.3-1.src.rpm
checksum_type: sha256
summary:
  bpmappers is a Python moudle that maps Python dictionary values and object properties to different dictionary.


pkgId: 2d7e51078275dd8b869f974059aa0be672b0b44905984b6c6a1bf66587d82320
name: python-bpmn-parser
arch: src
version: 1.0.16
epoch: 0
release: 1
summary: A simple BPMN Parser implemented in Python
url: https://github.com/danbailo/bpmn-parser
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bpmn-parser-1.0.16-1.src.rpm
checksum_type: sha256
description:
  **Documentation**: <a href="https://danbailo.github.io/bpmn-parser/" target="_blank">https://danbailo.github.io/bpmn-parser/</a>


pkgId: 40fcd3c59bd0665429a9395d06e9b266b9625429b76cb453814e08891cd3ea41
name: python-bpnet
arch: src
version: 0.0.23
epoch: 0
release: 1
url: https://github.com/kundajelab/bpnet
rpm_license: MIT license
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bpnet-0.0.23-1.src.rpm
checksum_type: sha256
summary:
  BPNet: toolkit to learn motif synthax from high-resolution functional genomics data using convolutional neural networks


pkgId: 5d67744b51a579894a5218ce0a853eb41e89b3ab73f6570f9a22980982310dfb
name: python-bpnet-lite
arch: src
version: 0.8.1
epoch: 0
release: 1
url: https://github.com/jmschrei/bpnet-lite
rpm_license: LICENSE.txt
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bpnet-lite-0.8.1-1.src.rpm
checksum_type: sha256
summary:
  bpnet-lite is a minimal implementation of BPNet, a neural network aimed at interpreting regulatory activity of the genome.


pkgId: 53407a796679a922f0e909a6447d85fc4bc046b9847dc9b246f4bef1aa06a1c9
name: python-bpptkg-meteo
arch: src
version: 1.2.3
epoch: 0
release: 1
summary: BPPTKG weather station data fetcher and schema tables library
url: https://pypi.org/project/bpptkg-meteo/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bpptkg-meteo-1.2.3-1.src.rpm
checksum_type: sha256
description:
  ![GitHub Badge](https://github.com/bpptkg/bpptkg-meteo/workflows/Build/badge.svg)

  BPPTKG weather station data fetcher and schema tables library.



  Install the latest version from PyPI by typing this command:

      pip install -U bpptkg-meteo



  Full documentation is available at `docs/` directory. You can build the
  documentation by running these commands:

      cd /path/to/bpptkg-meteo/
      pip install -r requirements.txt
      sphinx-build -b html docs/ /path/to/build/



  Use black formatter to lint and fixes code files if you made changes to the
  scripts.



  See `CONTRIBUTING.md` to learn how to contribute to this project.



  By contributing to the project, you agree that your contributions will be
  licensed under its MIT license. See
  [LICENSE](https://github.com/bpptkg/bpptkg-meteo/blob/master/LICENSE) for
  details.


pkgId: b3c3b4c9826753291f5b01b4d1debba8461eb997fc51863d89399f460aefbfd5
name: python-bptk-py
arch: src
version: 1.9.2
epoch: 0
release: 1
summary: A python simulation engine for System Dynamics & Agent based models
url: https://bptk.transentis.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bptk-py-1.9.2-1.src.rpm
checksum_type: sha256
description:
  [![Coverage Status](https://coveralls.io/repos/github/transentis/bptk_py/badge.svg)](https://coveralls.io/github/transentis/bptk_py)

  __System Dynamics and Agent-based Modeling in Python__

  The Business Prototyping Toolkit for Python (BPTK-Py) is a computational modeling framework that enables you to build simulation models using System Dynamics (SD) and/or agent-based modeling (ABM) natively in Python and manage simulation scenarios with ease.

  Next to providing the necessary SD and ABM language constructs to build simulation models directly in Python, the framework also includes a compiler for transpiling System Dynamics models conforming to the XMILE standard into Python code.

  This means you can build models in a XMILE-compatible visual modeling environment (such as [Stella](https://www.iseesystems.com) or [iThink](https://www.iseesystems.com)) and then use them _independently_ in an Python environment.

  The best way to get started with BPTK-Py is to read the [Quickstart](https://bptk.transentis.com/quickstart/quickstart.html) that is part ot the extensive [online documentation](https://bptk.transentis.com). The Quickstart provides a _single page_ overview of all the computational modeling techniques supported by BPTK.




  *   The objective of the framework is to let the modeller concentrate on building simulation models by providing a seamless interface for managing model settings and scenarios and for plotting simulation results.
  *   The BPTK-Py framework supports System Dynamics models in XMILE Format, native SD models using a domain-specific language for System Dynamics (SD DSL) and native Agent-based models. You can also build hybrid SD-ABM-Models natively in Python.
  *   All plotting is done using [Matplotlib](https://www.matplotlib.org).
  *   Simulation results are returned as [Pandas dataframes](https://pandas.pydata.org) and thus can easily be used for analytics.
  *   Model settings and scenarios are kept in JSON files. These settings are automatically loaded by the framework upon initialization, as are the model classes themselves. This makes interactive modeling, coding and testing very painless, especially if using the Jupyter notebook environment.



  BPTK-Py is developed and maintained by [transentis labs](https://www.transentis.com/business-prototyping-toolki/en/).

  The first place to go to for help and installation instructions is the [online documentation](https://bptk.transentis.com).

  The [Quickstart](https://bptk.transentis.com/quickstart/quickstart.html) provides a _single page_ overview of all the modeling techniques supported by BPTK.

  The online documentation is generated from an extensive set of Jupyter notebooks, the __BPTK Tutorial__. The tutorial is available as a [git repository](https://github.com/transentis/bptk_py_tutorial) on GitHub.

  Our [Business Prototyping Toolkit Meetup Group](https://www.transentis.com/business-prototyping-toolkit-meetup/en/) gathers online regularly. This is a good place to see BPTK in action, ask questions and suggest new features. We record every session and you can _view past recordings_ on the [meetup homepage](https://www.transentis.com/resources/business-prototyping-toolkit-meetup).

  We used BPTK to build our implementation of the infamous [Beer Distribution Game](https://beergame.transentis.com).

  Our [beergame repository](https://github.com/transentis/bptk_py_tutorial/tree/master/model_library/beergame) contains Jupyter notebooks that analyse the Beergame in-depth and also provides XMILE, SD DSL and Agent-based versions of the Beergame.

  For any questions our suggestions you have regarding BPTK, please contact us at: [support@transentis.com](mailto:support@transentis.com).





  * Fix to build script



  * Bump versions of key dependencies
  * Update XMILE parser grammar to remove depreciation warning
  * Remove obsolete documentation files
  * Update setup to use pyproject.toml
  * Bump Python Version to 3.11


  * BPTKServer: `run` endpoint now also works for agent-based models
  * Model: Add `configure_agent`, `configure_properties` and `delete_agent(s)` methods
  * Bump versions of key dependencies


  * BPTKServer: Add new endpoint `start-instances` that starts multiple instances in one goo


  * BPTK: Improve handling of floating point numbers when using small DTs
  * ScenarioManagerSD: Fixed an issue that caused models with biflows to be cloned incorrectly


  * BPTK: Fix that caused a crash when using multiple scenario files for hybrid models


  * BPTK: Fix bug in reset_scenarios for Hybrid Scenario Managers

  * BPTK: Update dependencies of Pandas/Matplotlib/Sympy/Parsimonious/Pyyaml/Xlsxwriter/Jinja2/Requests/Jsonpickle/Flask
  * Successfully tested with Python 3.11


  * BPTK: Fix imports of SimpleDashboard class
  * BPTK: Update dependency of Scipy, Numpy and Pyyaml

  * BPTK: reset_cache now also resets the data collector in agent based models
  * BPTK: reset_cache calls the reset_cache method on all agents
  * BPTK: agents now have a reset_cache method that can be used to reset agent state
  * BPTK: Updated dependency on ipywidgets to 8.0.4


  * BPTK Server: Remote authorization for root, full-metrics and metrics endpoints
  * BPTK Server: Add /healthy endpoint
  * BPTK Server: stop-instance and load-state are now POST resources
  * Bug Fix: Remove debug print message



  * BPTK: Defer import of matplotlib and ipywidgets until they are needed



  * BPTK: Hybrid scenarios can now be spread accross multiple scenario files
  * BPTK: Remove filename attribute from hybrid scenario manager as it is obsolete
  * BPTK: Scenario definitions for SD DSL scenarios now accept a runspecs setting to override starttime, stoptime and dt
  * BPTK: begin_session now accepts a settings parameter to override scenario settings
  * BPTK Server: begin_session now accepts a settings parameter to override scenario settings



  * BPTK Server: Simplified bearer token authentication


  * BPTK Server: Added optional bearer token authentication


  * BPTK Server: Fixed unsafe external state adapter code
  * BPTK Server: start_instance now returns correct content type



  * SimpleDashboard: Deleted superfluous import statement
  * bptk: Small improvements to documentation



  * BPTK Server: The run_step methods now also support agent-based models
  * BPTK Server: A new endpoint streams_steps runs all the steps of a model and streams the results, especially useful for models that run for a long-time.
  * SimpleDashboard: A new utility class that allows easy creation of dashboards based on Jupyter Widgets.



  * BPTK Server: Since v 1.5.0, BPTK Server requires a Python version >= 3.9. The package now informs the user about this upon import. Other parts of the BPTK framework should work fine with older Python3 versions.



  * BPTK Server: Added file adapter as a concrete example of an external adapter
  * BPTK: Improve cleanup of resources when bptk instance is destroyed



  * BPTK Server: Improvements to the new state externalisation feature
  * BPTK Server: Improve cleanup of resources when an instance times out



  * SD DSL: Added a new module class that makes it easy to structure large models
  * BPTK Server: Add new endpoints to allow externalising the instance state
  * BPTK Server: Changed the default timeout for equations for instances to 12h



  * SD DSL: fix to delay function



  * Small bugfixes in prometheus metrics.



  * BPTK: Fix to plot_lookup
  * BPTK Server: 'flat' version of session results
  * SD DSL: small changes to SD functions pulse and delay to make them more robust.



  * BPTK Server: add metrics endpoint
  * SD DSL: fixed missing imports that caused some sddsl functions to throw an exception



  * BPTK Server: fixed an issue that could lead to race conditions leading to server crashes


  * BPTK Server: add a keep-alive method to keep instances from timing out
  * BPTK Server: start-instances now accepts a timeout structure so that instance timeouts can be set flexibly.
  * BPTK Server: fixed an issue that could lead to race conditions leading to server crashes
  * XMILE: fixed an issue regarding lookups (graphical functions) that do not contain values on the x-axis


  * BPTK: fixed an issue in train_scenarios which caused an exception in recent versions of bptk-py


  * XMILE: Array arithmetic (such as array multiplication,...) within array functions such as SUM is now handled correctly.


  * XMILE: Arrayed variables that have non-arrayed inputs with "apply to all" set are now handled correctly


  * XMILE: Ensure the startime and stoptime in transpiled XMILE models are floating point values (e.g. 1.0, not 1)
  * XMILE: Top level variables in a model that contains modules are now referenced correctly from submodules
  * XMILE: Nested modules are now handled correctly
  * XMILE: Array dimensions of length <3 are now handled correctly


  * Add new method session_results to bptk and corresponding endpoint session-results to Bptk server that allows the session results so far to be retrieved.


  * Fixed an issue that caused bptk-server to crash if start-instance was called after a previous instance had timed out


  * Small improvements to the XMILE/SMILE parser regarding element names that include special characters and regarding operators surrounded by newlines.

  * Return message from end-session resource now correctly reads "session terminated"

  * Rename package due to issues with test pypi


  * Add missing package in setup.py


  * Fix bug in run_scenarios that arose with multiple scenario managers and when return_format was json or dict
  * Add begin_session, end_session and run_step methods to bptk
  * Add agent endpoint to BptkServer
  * BptksServer now takes a bptk_factory function instead of a bptk object in its constructor
  * Add start-instance endpoint to BptkServer
  * Add begin-session, end-session and run-step endpoint to BptkServer


  * Improve documentation
  * Bugfix for bptk.export_scenarios


  *   Major tidy up of the bptk API, including a number of breaking changes. In particular the run_simulation method has been renamed to run_scenarios and reset_simulation_model was renamed to reset_scenario_cache. A number of rarely used methods have been removed.
  *   Documentation improved and extended.
  *   Internal refactoring.


  *   Fix bug in XMILE compiler regrading parsing of names that start with a keyword



  *   Fix bug in XMILE compiler that causes parsing of if/then/else structures to fail under some circumstances
  *   Fix bug in XMILE pulse function that causes the function to misbehave in some circumstances
  *   Fix bug in XMILE previous function that causes the function to misbehave in some circumstances


  *   Improve error handling and fault tolerance on BptkServer


  *   Update to BptkServer internals


  *   Add a new experimental feature that allows REST APIs for simulation models to be set up easily.


  *   SD DSL: Add python power operator (**) to all SD DSL operators
  *   XMILE: Ensure SAFEDIV works in complex expressions


  *   Improve handling of SAFEDIV in SD compiler


  *   Fix for the SD compiler regarding dimension names usage


  *   Little fix regarding the SD-Compiler


  *   Improvement of SD compiler: Support for empty initial value of ``DELAY`` function. Support for dimension names as arguments for functions (e.g. ``SIZE(<dimension>)``)


  *   Improvement of Extended Data Collector: Renamed to Agent Data Collector and code optimizations


  *   Bugfix for the plotting component that solves compatibility issues with newer versions of matplotlib


  *   New dataCollector for retrieving agent-wise data (Refer to [BPTK-Py Tutorial](https://github.com/transentis/bptk_py_tutorial) for more info)


  *   Fixed a bug in the interactive scenario component that caused scenarios being plotted multiple times
  *   Fixed a bug that caused the SD operator ``delay`` to not accept floating point values and fixed a bug that caused the same to be parsed incorrectly in some cases.


  *   Fixed a bug in the XMILE Converter that prevented the SAFEDIV operator to be parsed correctly


  *   SD-DSL: Fixed a bug that caused converter equations (subtraction and division) to be computed incorrectly.


  *   SD-DSL: Added support for right-hand side addition and subtraction to support equations such as ``converter.equation = 1 - b``
  *   Visualisation for SD-DSL elements now follows conventions to work properly with Matplotlib 3.3+


  *   Visualisation using matplotlib now follows conventions to work properly with Matplotlib 3.3+


  *   SD-DSL: System Dynamics element such as converters did not implement comparison operators (">", "<", ">=", "==", "!="). They have been added


  *   Another bugfix for series renaming. Simplified the code for renaming by using Pandas' standard method ``rename``


  *   Bugfix for ``plot_scenarios``: The ``series_names`` replacer did not work properly for when only one scenario manager / scenario is given.


  *   Bugfix for XMILE compiler: A little error in the parser prevented certain models being parsed correctly
  *   Bugfix for ``plot_scenarios``: The new error messages showed up for Agent based models although the scenarios were present


  *   The XMILE compiler is a great tool that handles model conversion from XMILE SD Models to Python. For compatibility and readability, we change the equation names to camelCasing upon conversion. This might be confusing for some users. That's why we decided to give you a new function call that lists all equations for System Dynamics Models. Simply run ``bptk.list_equations()`` (optionally add scenario manager(s) and scenario(s)) and get an overview over available model elements. More details [in our documentation](https://bptk.transentis.com/en/latest/docs/xmile/how-to/how_to_working_with_XMILE/how_to_working_with_XMILE.html).
  *   Improved error messages. In previous versions, a long error trace was printed when an equation was not found. Now you get a neat error message output wiht hints as to why the plotting failed.
  *   If an equation / scenario / scenario manager is not found, ``BPTK_Py`` gives hints on which similar equations / scenarios / scenario managers might be available for use.
  *   Register XMILE models without having to follow the directory structure: ``BPTK_PY`` scans the ``scenarios`` folder upon startup to find new scenario managers and XMILE / ABM models. We developed a simpler way to add simulation models during runtime without having to add scenarios beforehand: ``bptk.register_model("<path_to_itmx_stmx>","<modelname>")``. You can then easily simulate the model just as you're used to.


  XMILE equations make use of double-quote enclosed identifiers in case it actually looks like a function call. For example, ``100*"Identifier(enclosed)"`` is a valid equation where one element (stock/flow) is called ``Identifier(enclosed)``. However, we were not able to parse this, until now.
  Update BPTK-Py using the new update mechanism: [documentation](https://bptk.transentis.com/en/latest/docs/usage/installation.html#keeping-bptk-py-up-to-date)


  We figured that the update mechanisms via ``pip`` might be confusing sometimes, especially for non-programmers. This is
  why we decided to implement an update mechanism. Details are available in the [documentation](https://bptk.transentis.com/en/latest/docs/usage/installation.html#keeping-bptk-py-up-to-date)


  *   Bugfix to (XMILE) SD Compiler: Added support for array expressions within function calls. We had trouble with equations that contain another expression within a function call. E.g. ``DELAY(arrayedElement[1,2]*5, 1, 1)`` was not supported.
  *   Improvement to (XMILE) SD Compiler: Removed replacement of currency symbols (``€``, ``$`` etc.) and percentage signs with abbreviations. We had implemented this in earlier releases but figured it leads to confusion with modellers.


  *   The SD DSL now differentiates flows and biflows. Simply add a biflow using ```biflow = model.biflow(<name>)```.
  *   The SD DSL now supports: RANDOM, IF, NOT, AND, OR, NAN, SQRT, ROUND and all trigonometric and statistical builtins you know from XMILE. Furthermore the operators support Comparison Operators (>, <, >=, <=, ==, !=) and the modulo operator (x % y).
      *   RANDOM: ``converter.equation = sd.Random(<min>, <max>)`` draws a uniformly distributed float random number between <min> and <max>
      *   ROUND: ``converter.equation = sd.Round(sd.random(0,1),2))`` rounds a random number between 0 and 1 to a 2 digit float
      *   IF: ```converter.equation = sd.If( <condition>, <then> , <else> ) ``` corresponds to ```IF <condition> THEN <then> ELSE <else>```. Each term inside the IF clause can be a SD term again. Example for a valid If clause: ``equation = sd.If(sd.time()>10,sd.random(1,2), 100)``
      *   AND/OR: ```sd.Or(<left hand side>, <right hand side>)``` and ```sd.And(<left hand side>, <right hand side>)``` for multiple conditions
      *   NOT: Use ```sd.Not(<condition>)``` for "not" conditions, e.g:  ```sd.If(sd.Not(sd.time()>10), 1, 0 )```
      *   NAN / INF / PI: ``sd.nan()`` returns a NAN value, ``sd.Inf()`` gives you the infinity value, ```sd.pi()``` returns the number pi.
      *   SQRT: ``sd.sqrt(<value of function>)`` computes the square root
      *   SIN / TAN / COS: ``sd.sin(x) / sd.cos(x) / sd.tan(x)`` for sinus, cosinus or tangent of x (radians) and of course we also support ARCCOS, ARCSIN, ARCTAN with the same syntax
      *   SINWAVE / COSWAVE: ``sd.sinwave(amplitude,period)`` / ``sd.coswave(amplitude,period)`` to generate sine / cosine waves with given amplitude and period
      *   More documentation and how to use the __statistical (random numbers from various distributions) and trigonometric operators__ can be found in our [online documentation](https://bptk.transentis.com/en/latest/docs/sd-dsl/in-depth/in_depth_sd_dsl_functions/in_depth_sd_dsl_functions.html)
  *   We fixed a bug that caused BPTK to crash when an XMILE model was updated while BPTK was monitoring it
  *   We fixed SINWAVE in the XMILE transpiler and added support for COSWAVE


  *   We are supporting all XMILE operators now. Note that random numbers with seed are **never** the same as when using Stella Architect's seed! This is due to different random number generators in Python and Stella. We neither support the min / max arguments for the random number operators. Refer to the [documentation](https://bptk.transentis.com/en/latest/docs/usage/limitations.html))
  *   RUNCOUNT and SENSIRUNCOUNT are not supported and support is not planned.


  *   Bugfix release: Better support for multidimensional arrays



  *   Bugfix release: Fixed an issue with plot_lookup



  *   SD Compiler: Added new operators
      *   Arrays and Array Operators (MIN, MAX, SUM, MEAN, SELF, SIZE, PROD)
      *   Statistical operators (COMBINATIONS, BETA, BINOMIAL, FACTORIAL, GAMMA, GAMMALN, EXPRND, GEOMETRIC)
      *   Trigonometric operators (ARCSIN, ARCCOS, ARCTAN)
  *   The ``plot_scenarios`` API now supports array calls such as ``stock[*]`` or ``stock[dim1,dim2]``
  *   SD DSL: ABS, DT, PULSE, STARTTIME, STOPTIME


pkgId: 033641e2f8709d85e9a58c10dc5c161de86977a584ca9673dbcd8a7b4f0ae22c
name: python-bpx
arch: src
version: 0.4.0
epoch: 0
release: 1
summary: BPX schema and parsers
url: https://pypi.org/project/bpx/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bpx-0.4.0-1.src.rpm
checksum_type: sha256
description:
  ![tests](https://github.com/FaradayInstitution/BPX/actions/workflows/test.yml/badge.svg)
  [![codecov](https://codecov.io/gh/FaradayInstitution/BPX/branch/main/graph/badge.svg?token=Krv0JW3gYZ)](https://codecov.io/gh/FaradayInstitution/BPX)

  An implementation of the Battery Parameter eXchange (BPX) format in Pydantic. BPX, an outcome of the Faraday Institution [Multi-scale Modelling project](https://www.faraday.ac.uk/research/lithium-ion/battery-system-modelling/), is an open standard for physics-based Li-ion battery models that has been developed to reduce costs and time-to-market through a common definition of physics-based battery models that can be used widely across industry. To find out more, visit the [BPX website](https://bpxstandard.com/).

  This repository features a Pydantic-based parser for JSON files in the BPX format, which validates your file against the schema.

  To support the new open standard, [About:Energy](https://www.aboutenergy.io/) have supplied two parameters sets for an NMC and LFP cell. The BPX files and associated examples and information can be found on the [A:E BPX Parameterisation repository](https://github.com/About-Energy-OpenSource/About-Energy-BPX-Parameterisation/).

  To see how to use BPX with [PyBaMM](https://www.pybamm.org/), check out the [BPX example repository](https://github.com/pybamm-team/bpx-example).


  The BPX package can be installed using pip
  ```bash
  pip install bpx
  ```

  BPX is available on GNU/Linux, MacOS and Windows. We strongly recommend to install PyBaMM within a python [virtual environment](https://docs.python.org/3/tutorial/venv.html), in order not to alter any distribution python files.


  To create a BPX object from a JSON file, you can use the `parse_bpx_file` function
  ```python
  import bpx

  filename = 'path/to/my/file.json'
  my_params = bpx.parse_bpx_file(filename)
  ```
  `my_params` will now be of type `BPX`, which acts like a python dataclass with the same attributes as the BPX format. To obatin example files, see the `examples` folder, the [A:E BPX Parameterisation repository](https://github.com/About-Energy-OpenSource/About-Energy-BPX-Parameterisation/), or the [BPX example repository](https://github.com/pybamm-team/bpx-example).

  Attributes of the class can be printed out using the standard Python dot notation, for example, you can print out the initial temperature of the cell using
  ```python
  print('Initial temperature of cell:', my_params.parameterisation.cell.initial_temperature)
  ```

  Alternatively, you can export the `BPX` object as a dictionary and use the string names (aliases) of the parameters from the standard
  ```python
  my_params_dict = my_params.dict(by_alias=True)
  print('Initial temperature of cell:', my_params_dict["Parameterisation"]["Cell"]["Initial temperature [K]"])
  ```

  The entire BPX object can be pretty printed using the `devtools` package
  ```python
  from devtools import pprint
  pprint(my_params)
  ```

  You can convert any `Function` objects in `BPX` to regular callable Python functions, for example:
  ```python
  positive_electrode_diffusivity = my_params.parameterisation.positive_electrode.diffusivity.to_python_function()
  diff_at_one = positive_electrode_diffusivity(1.0)
  print('positive electrode diffusivity at x = 1.0:', diff_at_one)
  ```

  If you want to output the complete JSON schema in order to build a custom tool yourself, you can do so:
  ```python
  print(bpx.BPX.schema_json(indent=2))
  ```

  According to the `pydantic` docs, the generated schemas are compliant with the specifications: JSON Schema Core, JSON Schema Validation and OpenAPI.


  API documentation for the `bpx` package can be built locally using [Sphinx](https://www.sphinx-doc.org/en/master/). To build the documentation first [clone the repository](https://github.com/git-guides/git-clone), install the `bpx` package, and then run the following command:
  ```bash
  sphinx-build docs docs/_build/html
  ```
  This will generate a number of html files in the `docs/_build/html` directory. To view the documentation, open the file `docs/_build/html/index.html` in a web browser, e.g. by running
  ```bash
  open docs/_build/html/index.html
  ```


  If you have any questions please get in touch via email <bpx@faraday.ac.uk>.


pkgId: 812e8b82239566103d534421209f1ca3a7f99af0f389c6efc7003e71eeb61a31
name: python-bpx-py
arch: src
version: 1.2.2
epoch: 0
release: 1
summary: Backpack API SDK tool
url: https://backpack.exchange
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bpx-py-1.2.2-1.src.rpm
checksum_type: sha256
description:
  [![Downloads](https://static.pepy.tech/badge/bpx-py)](https://pepy.tech/project/bpx-py)



  This Backpack SDK is a continuously updated and supported Python toolkit that provides comprehensive access to all Backpack endpoints, including custom artificial endpoints for enhanced functionality. This SDK ensures developers have the most current tools for seamless integration with Backpack services.



  bpx-py is stable on _python_ >= 3.8

  ```bash
  pip install bpx-py
  ```



  Make an account and generate API keys on [Backpack](https://backpack.exchange/settings/api-keys)



  ```python
  from bpx.account import Account

  public_key = "<KEY>"
  secret_key = "<KEY>"
  account = Account(public_key,
          secret_key,
          window=6000, # default value is 5000
          proxy={"http":"132.142.132.12:3128"}) # you can use any requests proxy supported by requests
  deposit_address_sol = account.get_deposit_address("Solana")
  account_fills = account.get_fill_history_query("SOL_USDC",
                                                 limit=10,
                                                 window=10000) # window only for this order
  print(deposit_address_sol)
  print(account_fills)
  ```

  bpx-py supports **async** code:
  ```python
  from bpx.async_.account import Account
  import asyncio

  async def main():
      public_key = "<KEY>"
      secret_key = "<KEY>"
      account = Account(public_key, secret_key, proxy="http://your_proxy-address:1234")
      deposit_address_sol = await account.get_deposit_address("Solana")
      await asyncio.sleep(1)
      account_fills = await account.get_fill_history_query("SOL_USDC",
                                                 limit=10,
                                                 window=10000)
      print(deposit_address_sol)
      print(account_fills)

  asyncio.run(main())
  ```



  Backpack has public endpoints that don't need API keys:

  ```python
  from bpx.public import Public

  public = Public()
  server_time = public.get_time()
  markets = public.get_markets()
  print(server_time)
  print(markets)
  ```
  **Async** code:

  ```python
  from bpx.async_.public import Public
  import asyncio

  async def main():
      public = Public()
      assets = await public.get_assets()
      await asyncio.sleep(1)
      klines = await public.get_klines("SOL_USDC", "1d")
      print(assets)
      print(klines)

  asyncio.run(main())
  ```



  You can get the request configuration using `bpx.base.base_account` and `bpx.base.base_public` without doing a request.

  ```python
  from bpx.base.base_account import BaseAccount
  from bpx.base.base_public import BasePublic
  from bpx.models.request_configuration import RequestConfiguration # unnecessary

  base_public = BasePublic()
  base_account = BaseAccount("<PUBLIC_KEY>", "<SECRET_KEY>", window=5000, debug=True)


  request_config: RequestConfiguration = base_account.get_balances()
  url = request_config.url
  headers = request_config.headers

  request_url: str = base_public.get_ticker_url(symbol="SOL_USDC")
  ```



  `bpx.models` - models that are in use by request.

  `bpx.constants` - constants that may help if you don't know which variables are existing.



  [Discord channel to get help](https://discord.gg/backpack)

  [Backpack API DOCS](https://docs.backpack.exchange)

  [PYPI](https://pypi.org/project/bpx-py/)

  [Backpack help center](https://support.backpack.exchange)


pkgId: d95bd6f509792f63a0fe052c27994d8d49c7929d04d69302bc101bc1420a68bd
name: python-bpy-build
arch: src
version: 2.1.0
epoch: 0
release: 1
summary: Find Blender sources in version control, create build scripts
url: https://github.com/TylerGubala/bpy-build
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bpy-build-2.1.0-1.src.rpm
checksum_type: sha256
description:
  Python build script for Blender as a python module

  It needs to be its own repository to satisfy the `install_requires` of blenderpy

  It is important to note that this is a toolset to build your own Blender build scripts. It does not create builds for you. It just generates the build script.


pkgId: ddc47a6956b28fae868d628bb253bd1ad36849ae7e6da0a09d3dc1350b951630
name: python-bpy-helper
arch: src
version: 0.0.2
epoch: 0
release: 1
summary: A lightweight alternative to BlenderProc
url: https://pypi.org/project/bpy-helper/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bpy-helper-0.0.2-1.src.rpm
checksum_type: sha256
description:
  A lightweight alternative to BlenderProc

  [![Upload Python Package](https://github.com/iamNCJ/bpy-helper/actions/workflows/python-publish.yml/badge.svg)](https://github.com/iamNCJ/bpy-helper/actions/workflows/python-publish.yml)



  BlenderProc needs a separate blender installation, and a lot of restrictions when using with other pypi packages. Debugging a BlenderProc script is also painful especially when you are using a headless environment. Hence I decide to build my own blender wrapper using `bpy`.



  ```bash
  pip install bpy-helper
  ```



  - [NRHints: Relighting Neural Radiance Fields with Shadow and Highlight Hints](https://nrhints.github.io/): bpy-helper is derived from the data rendering scripts of NRHints.
  - [DiLightNet: Fine-grained Lighting Control for Diffusion-based Image Generation](https://dilightnet.github.io/): bpy-helper is used to render the training data and radiance hints for DiLightNet.

rpm_license:
  MIT License  Copyright (c) 2024 NCJ  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: 919cce6cb3687892a38018397fbea67dfcc0a21bb11c47a0948d9caf15377f4b
name: python-bpy-helper
arch: src
version: 0.0.4
epoch: 0
release: 1
summary: A lightweight alternative to BlenderProc
url: https://pypi.org/project/bpy-helper/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bpy-helper-0.0.4-1.src.rpm
checksum_type: sha256
description:
  A lightweight alternative to BlenderProc

  [![PyPI version](https://badge.fury.io/py/bpy-helper.svg)](https://pypi.org/project/bpy-helper/) [![Upload Python Package](https://github.com/iamNCJ/bpy-helper/actions/workflows/python-publish.yml/badge.svg)](https://github.com/iamNCJ/bpy-helper/actions/workflows/python-publish.yml)



  BlenderProc needs a separate blender installation, and a lot of restrictions when using with other pypi packages. Debugging a BlenderProc script is also painful especially when you are using a headless environment. Hence I decide to build my own blender wrapper using `bpy`.



  ```bash
  pip install bpy-helper
  ```



  - [NRHints: Relighting Neural Radiance Fields with Shadow and Highlight Hints](https://nrhints.github.io/): bpy-helper is derived from the data rendering scripts of NRHints.
  - [DiLightNet: Fine-grained Lighting Control for Diffusion-based Image Generation](https://dilightnet.github.io/): bpy-helper is used to render the training data and radiance hints for DiLightNet.
  - [GS^3: Efficient Relighting with Triple Gaussian Splatting](https://gsrelight.github.io/): bpy-helper is used to render the training data for GS^3.

rpm_license:
  MIT License  Copyright (c) 2024 NCJ  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: e818201db7e6d7ce0d20205014393a340432c409f6a771007620c21ba8809e76
name: python-bpylist2
arch: src
version: 4.1.1
epoch: 0
release: 1
summary: Parse and generate NSKeyedArchiver archives
url: https://pypi.org/project/bpylist2/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bpylist2-4.1.1-1.src.rpm
checksum_type: sha256
description:
  This is a fork of Marketcircle/bpylist. This one is hopefully more responsive to PRs.
  Implementation of the `Apple's Binary
  Plist <https://developer.apple.com/legacy/library/documentation/Darwin/Reference/ManPages/man5/plist.5.html>`__
  and the NSKeyedArchiver format


pkgId: a3b6b251800ce44cf42bd10bd9b42b826d36f140b72aeb9d7c04021c051308f8
name: python-bpystubgen
arch: src
version: 0.2.7
epoch: 0
release: 1
summary: A utility to generate Python API stubs from documentation files in reStructuredText format.
url: https://github.com/mysticfall/bpystubgen
rpm_license: GNU General Public License v3 or later (GPLv3+)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bpystubgen-0.2.7-1.src.rpm
checksum_type: sha256
description:
  A utility to generate Python [API stubs](https://www.python.org/dev/peps/pep-0561/) from
  documentation files in [_reStructuredText_](https://docutils.sourceforge.io/rst.html) format.

  The main usage of the program is to create Python API stubs from the documentation generated
  during the build process of [Blender](https://www.blender.org) or [UPBGE](https://upbge.org)
  so that an IDE can provide autocompletion support and type hints for relevant modules like
  `bpy` or `bge`.
  There are already a number of tools created with a similar goal in mind, notably
  [fake-bpy-module](https://github.com/nutti/fake-bpy-module) which can be a good alternative
  to this project.
  However, _bpystubgen_ has a few advantages over the others:
   * It's very fast - Some of those tools may take over an hour to generate the entire stubs
     for Blender. But _bpystubgen_ can do it under a minute (1,593 source documents).
   * The generated stub modules preserve most of the source documentation, so you can use them
     as a manual as well.
   * It generates _PEP-561_ compliant stub modules, so it's safe to include them in your runtime
     module path.
   * Along with its fast execution speed, the project also provides well-organised API and test
     suites to make it easier to fix bugs or improve the output quality.

  Auto-completion at work in PyCharm:
  ![Screenshot in PyCharm](images/screenshot-pycharm.png?raw=true "Screenshot in PyCharm")
  Pop-up documentation support in VSCode:
  ![Screenshot in VSCode](images/screenshot-vscode.png?raw=true "Screenshot in VSCode")

  The library can be installed using `pip` as follows:
  ```bash
  $ pip install bpystubgen
  ```


  If you want to generate the API stubs yourself, you can use `bpystubgen` module which
  can be invoked with the following options:
  ```bash
  $ python -m bpystubgen -h
  usage: bpystubgen [-h] [--verbose] [--quiet] input output
  Generate Python API stubs from Blender documentation.
  positional arguments:
    input       Source directory where *.rst files are located
    output      Output directory where generated modules will be saved
  optional arguments:
    -h, --help  show this help message and exit
    --verbose   Print debug messages
    --quiet     Print only error messages
  ```

  If you just want to use the API stubs, you can install them from PyPI without having to generate
  them yourself.
  There are two variants of the API stubs, one for Blender and the other for UPBGE. For Blender,
  you can install `blender-stubs` module with an appropriate version qualifier as follows:
  ```bash
  $ pip install blender-stubs==3.1.*
  ```
  This will install the latest module for Blender 3.1, and for now stubs are provided for Blender
  2.80 and onwards. You can also specify the next unreleased version as `3.2.*` to get the latest
  snapshot of the module.
  As for UPBGE, stubs are available for the 0.3 release, which you can install as follows:
  ```bash
  $ pip install upbge-stubs==0.3.0.*
  ```
  And for the latest snapshot version,
  ```bash
  $ pip install upbge-stubs==0.3.1.*
  ```
  You can also install it using `Pipenv`. Note that it is required to set `allow_preleases` option
  in case the target application has no stable release (i.e. UPBGE 0.3 branch). You can use the
  following content as a template for your `Pipfile`:
  ```toml
  [[source]]
  name = "pypi"
  url = "https://pypi.org/simple"
  verify_ssl = true
  [packages]
  "upbge-stubs" = "==0.3.1.*"
  [requires]
  python_version = "3.10"
  [pipenv]
  allow_prereleases = true
  ```
  Also, it would be more correct to use `[dev-packages]` instead of `[packages]`, in which
  case you can install or update the stubs using the `-d` flag like `pipenv update -d`.

  This project is provided under the terms of _[GNU General Public License v3 (GPL3)](LICENSE)_.


pkgId: 25963bdc70eaa9904c2c48f3d5f961c3302e5fb8dc0f8c48ceb9d9568f915d51
name: python-bpyth
arch: src
version: 0.1.9
epoch: 0
release: 1
summary: Various Python Tools
url: https://github.com/djekra/bpyth
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bpyth-0.1.9-1.src.rpm
checksum_type: sha256
description:
  Some boring Python Tools, see `jupyter` directory.


  The directory `jupyter` contains many notebooks with examples. They are very easy to try out interactively online, with Google Colab. Just click the link at the top of the page and then select Runtime/Run all from the menu in Colab.


  `pip install bpyth`


  * `dump_pickle`: open, dump, close
  * `load_pickle`: open, load, close
  * `StreamFiles`: Iterable, returns all filenames of a parent directory
  * `StreamLines`: Iterable, returns all lines of a text file


  * `human_readable_number`: Rounds a number to a fixed number of significant digits.
  * `human_readable_seconds`: Converts seconds to human readable time
  * `human_readable_bytes`:   Converts Bytes to human readable size


  * `minivenn`: Compare two sets
  * `flatten`: Yield all items from any nested iterable
  * `remove_dups`: Remove dups from a list whilst-preserving-order
  * `sort_by_priority_list`: Sort a list by a list or tuple of prioritized objects
  * `cut_counter`: Truncates rare values of a counter
  * `ranking_from_counter`: Converts a counter into a ranking


  * `rtype`: Recursive type. Parses an n-dimensional object and returns a tuple of stype for the scalar in the top left corner.
  * `shape`: Recursive len. Parses an n-dimensional object and returns a tuple of sizes.
  * `has_shape`: Does an object have additional dimensions? (Skalars: No, Strings: No, Empty Iterables: No,
      Other Iterables: Yes)
  * `memory_consumption`: Returns the memory consumption of Python objects.


  * `superstrip`     : Removes Unicode whitespaces
  * `remove_words`   : Removes stopwords
  * `remove_dupwords`: Removes dup words from a string whilst-preserving-order
  * `longest_substr` : Finds the longest common substring in a list of strings
  * `random_str`     : Returns a random string


  ```python

  ```


pkgId: cc89c7349adf83425e51dfcdea67446c7aef35e0cfff11cbe12f1cd0478d9a57
name: python-bpytop
arch: src
version: 1.0.68
epoch: 0
release: 1
summary: Resource monitor that shows usage and stats for processor, memory, disks, network and processes.
url: https://github.com/aristocratos/bpytop
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bpytop-1.0.68-1.src.rpm
checksum_type: sha256
description:
  <a href="https://repology.org/project/bpytop/versions">
      <img src="https://repology.org/badge/vertical-allrepos/bpytop.svg" alt="Packaging status" align="right">
  </a>

  ![Linux](https://img.shields.io/badge/-Linux-grey?logo=linux)
  ![OSX](https://img.shields.io/badge/-OSX-black?logo=apple)
  ![FreeBSD](https://img.shields.io/badge/-FreeBSD-red?logo=freebsd)
  ![Usage](https://img.shields.io/badge/Usage-System%20resource%20monitor-yellow)
  ![Python](https://img.shields.io/badge/Python-v3.7%5E-green?logo=python)
  ![bpytop_version](https://img.shields.io/github/v/tag/aristocratos/bpytop?label=version)
  [![pypi_version](https://img.shields.io/pypi/v/bpytop?label=pypi)](https://pypi.org/project/bpytop)
  [![Test Status](https://img.shields.io/github/workflow/status/aristocratos/bpytop/Testing?label=tests)](https://github.com/aristocratos/bpytop/actions?query=workflow%3Atesting)
  [![Donate](https://img.shields.io/badge/-Donate-yellow?logo=paypal)](https://paypal.me/aristocratos)
  [![Sponsor](https://img.shields.io/badge/-Sponsor-red?logo=github)](https://github.com/sponsors/aristocratos)
  [![Coffee](https://img.shields.io/badge/-Buy%20me%20a%20Coffee-grey?logo=Ko-fi)](https://ko-fi.com/aristocratos)

  [![bpytop](https://img.shields.io/badge/-snapcraft.io-black)](https://snapcraft.io/bpytop)[![bpytop](https://snapcraft.io//bpytop/badge.svg)](https://snapcraft.io/bpytop)



  * [News](#news)
  * [Documents](#documents)
  * [Description](#description)
  * [Features](#features)
  * [Themes](#themes)
  * [Support and funding](#support-and-funding)
  * [Prerequisites](#prerequisites) (Read this if you are having issues!)
  * [Dependencies](#dependencies)
  * [Screenshots](#screenshots)
  * [Installation](#installation)
  * [Configurability](#configurability)
  * [License](#license)







  ![btop++](https://raw.githubusercontent.com/aristocratos/btop/main/Img/logo.png)

  The Linux version of btop++ is complete. Released as version 1.0.0

  Get it at https://github.com/aristocratos/btop

  The development plan right now:

  * 1.1.0 Mac OsX support
  * 1.2.0 FreeBSD support
  * 1.3.0 Support for GPU monitoring
  * 1.X.0 Other platforms and features...



  I've started work on the third iteration of bashtop->bpytop.
  It's being written in C++ and will simply be called `btop`.

  I'm aiming at releasing a beta version around August this year and will publish the repo when I've got the core functionality and structure ready for anybody that wanna help out.

  This project is gonna take some time until it has complete feature parity with bpytop, since all system information gathering will likely have to be written from scratch without any external libraries.
  And will need some help in the form of code contributions to get complete support for BSD and OSX.

  If you got suggestions of C++ libraries that are multi-platform and are as extensive as [psutil](https://github.com/giampaolo/psutil) are for python, feel free to open up a new thread in Discussions, it could help speed up the development a lot.

  Will post any updates about this project here until the repo is made available.











  Resource monitor that shows usage and stats for processor, memory, disks, network and processes.

  Python port and continuation of [bashtop](https://github.com/aristocratos/bashtop).



  * Easy to use, with a game inspired menu system.
  * Full mouse support, all buttons with a highlighted key is clickable and mouse scroll works in process list and menu boxes.
  * Fast and responsive UI with UP, DOWN keys process selection.
  * Function for showing detailed stats for selected process.
  * Ability to filter processes, multiple filters can be entered.
  * Easy switching between sorting options.
  * Send SIGTERM, SIGKILL, SIGINT to selected process.
  * UI menu for changing all config file options.
  * Auto scaling graph for network usage.
  * Shows message in menu if new version is available
  * Shows current read and write speeds for disks



  Bpytop uses the same theme files as bashtop so any theme made for bashtop will work.

  See [themes](https://github.com/aristocratos/bpytop/tree/master/themes) folder for available themes.

  The `make install` command places the default themes in `/usr/local/share/bpytop/themes`.
  If installed with `pip3` the themes will be located in a folder called `bpytop-themes` in the python3 site-packages folder.
  User created themes should be placed in `$HOME/.config/bpytop/themes`.

  Let me know if you want to contribute with new themes.



  You can sponsor this project through github, see [my sponsors page](https://github.com/sponsors/aristocratos) for options.

  Or donate through [paypal](https://paypal.me/aristocratos) or [ko-fi](https://ko-fi.com/aristocratos).

  Any support is greatly appreciated!





  Will not display correctly in the standard terminal (unless truecolor is set to False)!
  Recommended alternative [iTerm2](https://www.iterm2.com/)

  Will also need to be run as superuser to display stats for processes not owned by user.

  OsX on Apple Silicon (arm) requires psutil version 5.8.0 to work and currently has no temperature monitoring.
  Upgrade psutil with `sudo pip3 install psutil --upgrade`



  For correct display, a terminal with support for:

  * 24-bit truecolor ([See list of terminals with truecolor support](https://gist.github.com/XVilka/8346728))
  * 256-color terminals are supported through 24-bit to 256-color conversion when setting "truecolor" to False in the options or with "-lc/--low-color" argument.
  * Wide characters (Are sometimes problematic in web-based terminals)

  Also needs a UTF8 locale and a font that covers:

  * Unicode Block “Braille Patterns” U+2800 - U+28FF
  * Unicode Block “Geometric Shapes” U+25A0 - U+25FF
  * Unicode Block "Box Drawing" and "Block Elements" U+2500 - U+259F



  If you are having problems with the characters in the graphs not looking like they do in the screenshots,
  it's likely a problem with your systems configured fallback font not having support for braille characters.

  See [Terminess Powerline](https://github.com/ryanoasis/nerd-fonts/tree/master/patched-fonts/Terminus/terminus-ttf-4.40.1) for an example of a font that includes the braille symbols.

  See comments by @sgleizes [link](https://github.com/aristocratos/bpytop/issues/100#issuecomment-684036827) and @XenHat [link](https://github.com/aristocratos/bpytop/issues/100#issuecomment-691585587) in issue #100 for possible solutions.

  If text are misaligned and you are using Konsole or Yakuake, turning off "Bi-Directional text rendering" is a possible fix.

  Characters clipping in to each other or text/border misalignments is not bugs caused by bpytop, but most likely a fontconfig or terminal problem where the braille characters making up the graphs aren't rendered correctly.
  Look to the creators of the terminal emulator you use to fix these issues if the previous mentioned fixes don't work for you.



  Dropbear seems to not be able to set correct locale. So if accessing bpytop over ssh, OpenSSH is recommended.



  **[Python3](https://www.python.org/downloads/)** (v3.7 or later)

  **[psutil module](https://github.com/giampaolo/psutil)** (v5.7.0 or later)



  (Optional OSX) **[coretemp](https://github.com/hacker1024/coretemp)** (recommended), or **[osx-cpu-temp](https://github.com/lavoiesl/osx-cpu-temp)** (less accurate) needed to show CPU temperatures.



  Main UI showing details for a selected process.
  ![Screenshot 1](https://github.com/aristocratos/bpytop/raw/master/Imgs/main.png)

  Main UI in mini mode.
  ![Screenshot 2](https://github.com/aristocratos/bpytop/raw/master/Imgs/mini.png)

  Main menu.
  ![Screenshot 3](https://github.com/aristocratos/bpytop/raw/master/Imgs/menu.png)

  Options menu.
  ![Screenshot 4](https://github.com/aristocratos/bpytop/raw/master/Imgs/options.png)



  I only maintain the PyPi package, so will not take responsibility for issues caused by any other install method!



  > Install or update to latest version
  ``` bash
  pip3 install bpytop --upgrade
  ```



  >Install with Homebrew
  ```bash
  brew install bpytop
  ```

  >Optional coretemp (Shows temperatures for cpu cores)
  ```bash
  brew install hacker1024/hacker1024/coretemp
  ```

  >Alternatively install with MacPorts
  ```bash
  port install bpytop
  ```

  OsX on Apple Silicon (arm) requires psutil version 5.8.0 to work and currently has no temperature monitoring.
  Upgrade psutil with `sudo pip3 install psutil --upgrade`



  Available in the Arch Linux [community] repository as `bpytop`

  >Installation

  ```bash
  sudo pacman -S bpytop
  ```



  Available in [official Debian repository](https://tracker.debian.org/pkg/bpytop) since Debian 11

  >Installation

  ```bash
  sudo apt install bpytop
  ```

  Available for debian/ubuntu from [Azlux's repository](http://packages.azlux.fr/)



  Available in [FreeBSD ports](https://www.freshports.org/sysutils/bpytop/)

  >Install pre-built package

  ``` bash
  sudo pkg install bpytop
  ```



  [Available](https://src.fedoraproject.org/rpms/bpytop) in the Fedora and [EPEL-8 repository](https://fedoraproject.org/wiki/EPEL).

  >Installation

  ``` bash
  sudo dnf install bpytop
  ```



  Available from [adrien-overlay](https://github.com/aaaaadrien/adrien-overlay)

  >Installation

  ``` bash
  sudo emerge -av sys-process/bpytop
  ```



  Available in Mageia Cauldron and then Mageia 8 when it is released.

  >Installation

  ``` bash
  sudo urpmi bpytop
  sudo dnf install bpytop
  ```



  Available in the MX Test Repo as `bpytop`
  Please use MX Package Installer MX Test Repo tab to install.

  http://mxrepo.com/mx/testrepo/pool/test/b/bpytop/



  Available in void repo and void-packages ports tree

  >Installation

  ``` bash
  sudo xbps-install bpytop
  ```



  (Note! There is some issues caused by the snap sandboxing)

  by @kz6fittycent

  https://github.com/kz6fittycent/bpytop-snap

  >Install the package
  ``` bash
  sudo snap install bpytop
  ```

  The config folder will be located in `~/snap/bpytop/current/.config/bpytop`





  >Install python3 and git with a package manager of you choice

  >Install psutil python module (sudo might be required)

  ``` bash
  python3 -m pip install psutil
  ```



  >Install homebrew if not already installed

  ``` bash
  /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"
  ```

  >Install python3 if not already installed

  ``` bash
  brew install python3 git
  ```

  >Install psutil python module

  ``` bash
  python3 -m pip install psutil
  ```

  >Install optional dependency coretemp (recommended), or osx-cpu-temp (less accurate)

  ``` bash
  brew install hacker1024/hacker1024/coretemp
  ```

  ``` bash
  brew install osx-cpu-temp
  ```



  >Install with pkg and pip

  ``` bash
  sudo pkg install git python3 py37-psutil
  ```



  >Clone and install

  ``` bash
  git clone https://github.com/aristocratos/bpytop.git
  cd bpytop
  sudo make install
  ```

  >to uninstall it

  ``` bash
  sudo make uninstall
  ```



  All options changeable from within UI.
  Config files stored in "$HOME/.config/bpytop" folder



  "/etc/bpytop.conf" will be used as default seed for config file creation if it exists. ("/usr/local/etc/bpytop.conf" on BSD)

  ```bash




  color_theme="monokai"


  theme_background=False


  truecolor=True


  shown_boxes="cpu mem net proc"


  update_ms=2000



  proc_update_mult=2



  proc_sorting="cpu lazy"


  proc_reversed=False


  proc_tree=False


  tree_depth=3


  proc_colors=True


  proc_gradient=True


  proc_per_core=False


  proc_mem_bytes=True




  cpu_graph_upper="total"




  cpu_graph_lower="total"


  cpu_invert_lower=True


  cpu_single_graph=False


  show_uptime=True


  check_temp=True


  cpu_sensor=Auto


  show_coretemp=True


  temp_scale="celsius"


  show_cpu_freq=True


  draw_clock="%H:%M"


  background_update=True


  custom_cpu_name=""



  disks_filter="exclude=/boot"


  mem_graphs=True


  show_swap=True


  swap_disk=True


  show_disks=True


  only_physical=True


  use_fstab=True


  show_io_stat=True


  io_mode=False


  io_graph_combined=False



  io_graph_speeds=""


  net_download="100Mbit"
  net_upload="100Mbit"


  net_auto=True


  net_sync=False


  net_color_fixed=False


  net_iface="br0"


  show_battery=True


  show_init=False


  update_check=True



  log_level=DEBUG

  ```



  ``` text
  usage: bpytop.py [-h] [-b BOXES] [-lc] [-v] [--debug]

  optional arguments:
    -h, --help            show this help message and exit
    -b BOXES, --boxes BOXES
                          which boxes to show at start, example: -b "cpu mem net proc"
    -lc, --low-color      disable truecolor, converts 24-bit colors to 256-color
    -v, --version         show version info and exit
    --debug               start with loglevel set to DEBUG overriding value set in config
  ```



  [Apache License 2.0](https://github.com/aristocratos/bpytop/blob/master/LICENSE)


pkgId: 5a4a04485e72e47194655584bf5ef74468367db702b7c0828968ce54de85329d
name: python-bq-meta
arch: src
version: 0.9.0
epoch: 0
release: 1
summary: BigQuery metadata
url: https://github.com/martintupy/bq-meta
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bq-meta-0.9.0-1.src.rpm
checksum_type: sha256
description:
  > "Inspect BigQuery metadata faster"

  - Interactive CLI
  - Quick search through available projects, datasets, tables
  - View up to date table's metadata and it's schema
  - Local history of searched tables



  - python >= 3.10

  - fzf - https://github.com/junegunn/fzf (required)

  ```bash
  brew install fzf
  ```

  search through list of values (i.e. project, dataset, tables) is done using `fzf`



  1. Install as python package using [pypi](https://pypi.org/project/bq-meta/), this will create executable in `/usr/local/bin/bq-meta`

     ```bash
     pip install bq-meta
     ```

  2. Initialize `bq-meta`

     ```bash
     bq-meta --init
     ```

  3. Follow on screen prompts

     - create configuration
     - login to the google account using browser (Account is separated from `gcloud` cli)



  To open interactive CLI, simply run

  ```bash
  bq-meta
  ```

  ![cli](https://github.com/martintupy/bq-meta/raw/main/docs/cli.png)



  To view table metadata, press `o` key and select through project, dataset, table.

  ![metadata](https://github.com/martintupy/bq-meta/raw/main/docs/metadata.png)

  Table metadata can be refreshed, press `r` to fetch fresh metadata

  It's also possible to run `bq-meta` directly with `FULL_TABLE_ID`

  ```bash
  bq-meta bigquery-public-data:github_repos.commits
  ```



  Once table metadata is opened, press `s` key to view it's schema

  ![schema](https://github.com/martintupy/bq-meta/raw/main/docs/schema.png)



  You can open table in console.cloud.google.com by pressing `c` key

  ![browser](https://raw.githubusercontent.com/martintupy/bq-meta/main/docs/browser.png)



  Every viewed table is saved to the history. To search through history, press `h` key

  ![history](https://github.com/martintupy/bq-meta/raw/main/docs/history.png)



  ```bash
  Usage: python -m bq_meta [OPTIONS] [FULL_TABLE_ID]

    BiqQuery metadata

  Options:
    --raw             View raw response from the BigQuery for specific 'FULL_TABLE_ID'
    --init            Initialize 'bq-meta' configuration
    --info            Print info of currently used account
    --fetch-projects  Fetch available google projects
    --version         Show the version and exit.
    --help            Show this message and exit.
  ```


pkgId: 3202223b70665630873bea4368fd3e5b18832af47ab6357e3dcbfb3f363f6fff
name: python-bq-validator
arch: src
version: 0.7.2
epoch: 0
release: 1
summary: The `bq-validator` command enables us to validate BigQuery queries.
url: https://pypi.org/project/bq-validator/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bq-validator-0.7.2-1.src.rpm
checksum_type: sha256
description:
  [![Test python](https://github.com/yu-iskw/bq-validator/actions/workflows/test.yml/badge.svg)](https://github.com/yu-iskw/bq-validator/actions/workflows/test.yml)
  <a href="https://pypi.org/project/bq-validator" target="_blank">
      <img src="https://img.shields.io/pypi/v/bq-validator?color=%2334D058&label=pypi%20package" alt="Package version">
  </a>
  <a href="https://pypi.org/project/bq-validator" target="_blank">
      <img src="https://img.shields.io/pypi/pyversions/bq-validator.svg?color=%2334D058" alt="Supported Python versions">
  </a>



  This is a yet another python-based BigQuery query validator.

  The `bq query --dry_run` command enables us to validate queries.
  However, the `bq` command doesn't support service account impersonation, even though it supports workload identity federation credentials at Google Cloud SDK 390.0.0.
  The `bq-validator` command would be useful, when we take advantage of service account impersonation to validate BigQuery queries.


  The package is available on [pypi](https://pypi.org/project/bq-validator/)
  ```bash
  pip install -U bq-validator
  ```



  ```bash
  $ bq-validator --help
  Usage: bq-validator [OPTIONS] PATH

    Validate BigQuery queries

    PATH is either of a SQL file path or a directory. When it is a directory,
    the command recursively validates all SQL files in the directory.

  Options:
    --quota_project TEXT            BigQuery client project ID
    --client_project TEXT           BigQuery client project ID
    --client_location TEXT          BigQuery client location
    --impersonate_service_account TEXT
                                    Impersonate service account email
    --num_parallels INTEGER         Number of parallel query validations
    --verbose                       Enable verbose output
    --version                       Show the version and exit.
    --help                          Show this message and exit.
  ```


pkgId: 9211e184691bc7b82f4f44cc9d732dd502e9c0806867061932542f2c28e54e77
name: python-bqemulatormanager
arch: src
version: 0.2.2
epoch: 0
release: 1
url: https://pypi.org/project/bqemulatormanager/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bqemulatormanager-0.2.2-1.src.rpm
checksum_type: sha256
summary:
  bqemulatormanager is a wrapper of bigquery-emulator which provides us BigQuery mock working in local machine.

description:
  this package is wrapper of [bigquery-emulator](https://github.com/goccy/bigquery-emulator) which provides us BigQuery mock working in local machine.

  using this package, you can

  - do unit test of your sql
  - download the schema of big query, and use it to make test data


  1. following [instruction](https://github.com/goccy/bigquery-emulator#install),  download `bigquery-emulator` command.

  2. install this package.
  ```
  pip install bqemulatormanager
  ```

  3. test your sql.
  ```python
  import bqemulatormanager as bqem
  import pandas as pd

  manager = bqem.Manager(project='test', schema_path='resources/schema_example.yaml')

  with manager:
      data = pd.DataFrame([
          {'id': 1, 'name': 'sato'},
          {'id': 2, 'name': 'yamada'}
      ])

      manager.load(data, 'dataset1.table_a')

      sql = 'SELECT id, name FROM `dataset1.table_a`'

      df = manager.query(sql)
  print(df)
  ```

  unit test example is [here](https://github.com/gyuta/bqemulatormanager/blob/main/examples/testing.py).


  When called `Manager.load`, `SchemaManager` search correspond table schema from `schema_path` (default is `bqem_master_schema.yaml`).

  If schema definition cannot be found, `SchemaManager` request it from BigQuery in production environment and update master schema file.


pkgId: 94216ba7567f76a7b637621a6dab7ebb7230a98bdd921026ec97ff70b4507351
name: python-bqskit
arch: src
version: 1.2.0
epoch: 0
release: 1
summary: Berkeley Quantum Synthesis Toolkit
url: https://github.com/BQSKit/bqskit
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bqskit-1.2.0-1.src.rpm
checksum_type: sha256
description:
  The Berkeley Quantum Synthesis Toolkit (BQSKit) \[bis • kit\] is a powerful
  and portable quantum compiler framework. It can be used with ease to compile
  quantum programs to efficient physical circuits for any QPU.



  BQSKit is available for Python 3.8+ on Linux, macOS, and Windows. BQSKit
  and its dependencies are listed on the [Python Package Index](https://pypi.org),
  and as such, pip can easily install it:

  ```sh
  pip install bqskit
  ```



  A standard BQSKit workflow loads a program into the framework, models the
  target QPU, compiles the program, and exports the resulting circuit. The
  below example uses BQSKit to optimize an input circuit provided by a qasm
  file:

  ```python
  from bqskit import compile, Circuit


  circuit = Circuit.from_file("input.qasm")


  compiled_circuit = compile(circuit)


  compiled_circuit.save("output.qasm")
  ```

  To learn more about BQSKit, follow the
  [tutorial series](https://github.com/BQSKit/bqskit-tutorial/) or refer to
  the [documentation](https://bqskit.readthedocs.io/en/latest/).



  You can use the [software disclosure](https://www.osti.gov/biblio/1785933)
  to cite the BQSKit package.

  Additionally, if you used or extended a specific algorithm, you should cite
  that individually. BQSKit passes will include a relevant reference in
  their documentation.



  The software in this repository is licensed under a **BSD free software
  license** and can be used in source or binary form for any purpose as long
  as the simple licensing requirements are followed. See the
  **[LICENSE](https://github.com/BQSKit/bqskit/blob/master/LICENSE)** file
  for more information.



  Berkeley Quantum Synthesis Toolkit (BQSKit) Copyright (c) 2021,
  The Regents of the University of California, through Lawrence
  Berkeley National Laboratory (subject to receipt of any required
  approvals from the U.S. Dept. of Energy) and Massachusetts
  Institute of Technology (MIT).  All rights reserved.

  If you have questions about your rights to use or distribute this software,
  please contact Berkeley Lab's Intellectual Property Office at IPO@lbl.gov.

  NOTICE.  This Software was developed under funding from the U.S. Department
  of Energy and the U.S. Government consequently retains certain rights.  As
  such, the U.S. Government has been granted for itself and others acting on
  its behalf a paid-up, nonexclusive, irrevocable, worldwide license in the
  Software to reproduce, distribute copies to the public, prepare derivative
  works, and perform publicly and display publicly, and to permit others to
  do so.


pkgId: 283ef6554940c0fdc6d1e7b0a9ace3e5b86f0ff0db53b59118d2b77b2cb5ad04
name: python-bqt
arch: src
version: 1.4.2
epoch: 0
release: 1
summary: Files to help bootstrap PySide2 with an event loop within Blender.
url: https://github.com/techartorg/bqt
rpm_license: Mozilla Public License 2.0 (MPL 2.0)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bqt-1.4.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/bqt)](https://pypi.org/project/bqt/)
  [![latest tag](https://img.shields.io/github/v/tag/techartorg/bqt?label=Github)](https://github.com/techartorg/bqt)
  [![](https://img.shields.io/badge/GitHub-Wiki-blue)](https://github.com/techartorg/bqt/wiki)

  Add QT support to Blender, letting you create custom UI for your addons with PySide2 QtWidgets.
  ![custom ui sample](https://user-images.githubusercontent.com/3758308/192096952-e9ed73be-26e4-4ad8-a85f-be4175cebbda.gif)


  | feature | description|
  |--|--|
  |fully custom UI |Instead of feeling limited by N-Panel only UI. Do whatever you want. |
  | cross app | Qt widgets run nativaly in Krita, 3ds Max, Maya, … and are great to use in cross dcc pipelines |
  | existing community | hundreds of QT widgets on GitHub you can reuse, and lots of stack exchange questions answered regarding qt.|
  |Themed | BQt applies the [blender-qt-stylesheet](https://github.com/hannesdelbeke/blender-qt-stylesheet) so qt widgets will by default look similar to Blender.|



  - Blender `2.83`or higher.
  - Windows or Mac
  - PySide2
  - `PyObjC` & `iterm2` (Mac only)


  1. Install & enable the bqt addon (see [installation docs](https://github.com/techartorg/bqt/wiki/Installation))
  2. Create & show your Qt widget, bqt will automatically register it with it's widget manager.

  - The [bqt env vars](https://github.com/techartorg/bqt/wiki/Environment-variables) let you toggle bqt features on and off
  - sample code: [bqt_demo](bqt_demo) shows you how to use bqt with several qt demos you can run in Blender


  - i'm a technical writer and want to contribute to the docs. see [readme](https://github.com/techartorg/bqt/wiki/README) on the wiki.
  - i'm a dev and want to contribute to bqt code, see [contribute guidelines](https://github.com/techartorg/bqt/wiki/contribute-guidelines).
  - i'm a user or tester and want to report a bug or request a feature, please post [here](https://github.com/techartorg/bqt/issues)


  Discuss BQt on
  - the BlenderArtists [thread](https://blenderartists.org/t/bqt-custom-ui-for-add-ons-tool-in-blender-with-pyqt-or-pyside/1458808)
  - [Ynput  thread](https://community.ynput.io/t/use-bqt-for-blender-qt-integration/127)


pkgId: f3608567209f10092a56f9a2d8aa1f73a7b66a35032a384d023edb9b667c2c16
name: python-bqtools
arch: src
version: 0.6.0
epoch: 0
release: 1
summary: Python Tools for BigQuery
url: https://github.com/42DIGITAL/bqtools
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bqtools-0.6.0-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://travis-ci.org/42DIGITAL/bqtools.svg?branch=master)](https://travis-ci.org/42DIGITAL/bqtools) [![PyPI version](https://badge.fury.io/py/bqtools.svg)](https://badge.fury.io/py/bqtools)




  For data collection and data exploration, we like to work with [BigQuery](https://cloud.google.com/bigquery/). But we have not found a python library, to easily handle recurring tasks like adding new data (of potentially inconsistent schema) and schema migrations. So we took a couple of our solutions for those tasks and put them into this library.


  `bqtools` provides a light-weight solution to explicit schema management with python-native types (unlike pandas dtype) and
  some convenient type checking, inference and conversions. Table-objects created by `bqtools` can be read from BigQuery, stored locally, read from a local file and written to BigQuery. Table schemas can be changed and data can be added or modified.


  ```bash
  pip install --upgrade bqtools
  ```



  ```python
  from fourtytwo import bqtools

  schema = [
      {'name': 'number', 'field_type': 'INTEGER'},
      {'name': 'text', 'field_type': 'STRING'},
      {'name': 'struct', 'field_type':'RECORD', 'mode':'REPEATED',
          'fields': [
              {'name':'integer', 'field_type':'INTEGER'},
              {'name':'text', 'field_type':'STRING'}
          ]
      }
  ]





  table = bqtools.BQTable(
      schema=schema,
      data=[[1, 2, 3, 4], ['a', 'b', 'c', 'd']]
  )


  table = bqtools.BQTable(
      schema=schema,
      data=[
          {'number': 1, 'text': 'a'},
          {'number': 2, 'text': 'b'},
          ...
      ]
  )
  ```


  ```python
  print(table.data)       # list of all columns
  print(table.rows(n=10)) # list of first n rows


  df = table.to_df()


  ```


  ```python
  rows = [{'number': 5, 'text': 'e'}]
  table.append(rows)

  row = [[6, 'f']]
  table.append(rows)
  ```


  ```python


  table = bqtools.read_bq(
      table_ref='project_id.dataset_id.new_table_id',
      limit=10,           # limit query rows
      schema_only=False   # set True to only add data
  )
  ```


  ```python

  new_schema = [
      {'name': 'text', 'field_type': 'STRING'},
      {'name': 'number', 'field_type': 'FLOAT'},
  ]
  table.schema(new_schema)


  table.rename(columns={'number': 'decimal'})
  ```


  ```python


  table.to_bq(table_ref, mode='append')
  ```


  ```python

  table.save('local_table.bqt')


  table = bqtools.load('local_table.bqt')
  ```


pkgId: 09c5cfe2b08b9da7f178e501bff2058ea523faf7ca1ebb3cce0d5e7c15f3da7d
name: python-bqtools-json
arch: src
version: 1.0.8
epoch: 0
release: 1
summary: A Big Query json utility package
url: https://github.com/hsbc/bqtools
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bqtools-json-1.0.8-1.src.rpm
checksum_type: sha256
description:
  This is bqtools a handy set of utils to help create big query tables from json objects and make them into tables (so get the schema) and to create json new line files.
  Plus a set of common functions to ease writing biq query python code

  Goals
  * Simplify handling and move between big query stryuctured data and json data
  * Allow you to create big query table schemas from json structures (as resource or schema objects) uses reflection of types
  * Provides easy generation of views for day partitioned tabled
    * head - latest data
    * diff views for time snap shots of data i.e. each day partition has current view of data
  * Calculate valid json structures from representative json data that can be used as basis of big query schemas
  * Clean json data such that it can be loaded into big query
    * Replace bare lists with dictionaries
    * Replace field  names with valid values that can be column names in big query (removes spaces, characters not allowed in field names using same algorithms big query uses when auto detecting schemas)
    * Encodes json output of dates, datetimes, times, timedeltas encoded in format acceptable for big query corresponding field types
  * Generate code for bq command line tool from bq table structures
  * Simplify common tasks of handling big query data
    * Basic tests on dataset or tables existing
    * Schema patching compare an existing schema to a template json object calculate if changed and generate a merged schema that can be used in a patch
    * Flattening views to avoid view depth limits

  ```
  import bqtools


  foo = {
          "id":1,
          "description":""
          "aboolean":False
        }


  table = {
     "type":"TABLE",
     "location":os.environ["location"],
     "tableReference":{
         "projectId": os.environ["projectid"],
         "datasetId": os.environ["dataset"],
         "tableId": key
     },
     "timePartitioning":{
         "type": "DAY",
         "expirationMs": "94608000000"
     },
     "schema": {}
  }


  table["schema"]["fields"] = bqtools.get_bq_schema_from_json_repr(foo)

  ```

  Demonstrates some of power of tools via [bqsync](https://github.com/hsbc/bqtools/blob/master/BQSYNCUSAGE.md) that is installed if you install via pip.

      pip install bqtools-json

  Or you can find the source for this [here](https://github.com/hsbc/bqtools/blob/master/bqtools/bqsync)

  Also provides means to handle views across environments supports SQL views based upon Jinja templates. So you can "configure" views for different environments.

  Provides support for calculating view dependencies such views can be applied in parallel tranches.

  Provides support for calculating authorised views based on set of views "compiled"

  Compilation flattens views to lower view depth but automatically does not flatten authorised views to keep access to data tight as feasible.

rpm_license:
  Apache License Version 2.0, January 2004 http://www.apache.org/licenses/  TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION  1. Definitions.  "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.  "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.  "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.  "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.  "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.  "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.  "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).  "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.  "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."  "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.  2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.  3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.  4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:  (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and  (b) You must cause any modified files to carry prominent notices stating that You changed the files; and  (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and  (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.  You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.  5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.  6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.  7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.  8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.  9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.  END OF TERMS AND CONDITIONS  APPENDIX: How to apply the Apache License to your work.  To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!)  The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.  Copyright [yyyy] [name of copyright owner]  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at  https://www.apache.org/licenses/LICENSE-2.0  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


pkgId: 24fbcec4bef4a049ec4708a56f9cbdd5d77a1c263f130103a15a76088650ebac
name: python-br4nch
arch: src
version: 2.4
epoch: 0
release: 1
summary: Data Structure Tree Builder for Python.
url: https://github.com/TRSTN4/br4nch
rpm_license: GNU General Public License v3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-br4nch-2.4-1.src.rpm
checksum_type: sha256
description:
  ![logo](https://raw.githubusercontent.com/TRSTN4/br4nch/2.0/assets/images/logo_20.png)

  `br4nch` is a Data Structure Tree Builder for Python. It is built in 100%/Pure Python, which means it does not use 3rd party libraries. We **listen** to our users in [issues](https://github.com/TRSTN4/br4nch/issues), Discord [channel](https://discord.gg/gKASxGEEUC) *and all over the Internet* to create a **fast**, **flexible** and **friendly** Data Structure Tree Builder.



  If you want to see more code examples and guide, please visit our [documentation](https://docs.br4nch.com).

  ```python
  >>> br4nch.create.Tree(tree="Ukraine", header="Ukraine <3")

  >>> br4nch.create.Node(tree="Ukraine", node=["Cities", "Information"])
  >>> br4nch.create.Node(tree="Ukraine", node=["Donetsk Oblast", "Kiev Oblast"], parent="Cities")
  >>> br4nch.create.Node(tree="Ukraine", node="Mariupol", parent="Donetsk")
  >>> br4nch.create.Node(tree="Ukraine", node=["Bucha", "Tsjernobyl"], parent="Kiev")
  >>> br4nch.create.Node(tree="Ukraine", node=["President", "Area", "Population"], parent="Information")
  >>> br4nch.create.Node(tree="Ukraine", node="Zelensky", parent="President")
  >>> br4nch.create.Node(tree="Ukraine", node="603.628 km2", parent="Area")
  >>> br4nch.create.Node(tree="Ukraine", node="44 Million", parent="Population")

  >>> br4nch.display.Tree(tree="Ukraine")
  Ukraine <3
  ┣━ Cities
  ┃  ┣━ Donetsk Oblast
  ┃  ┃  ┗━ Mariupol
  ┃  ┗━ Kiev Oblast
  ┃     ┣━ Bucha
  ┃     ┗━ Tsjernobyl
  ┗━ Information
     ┣━ President
     ┃  ┗━ Zelensky
     ┣━ Area
     ┃  ┗━ 603.628 km2
     ┗━ Population
        ┗━ 44 Million
  ```



  Install `br4nch` with the `pip install` command:

  ```
  pip install br4nch
  ```



  - [Create](https://docs.br4nch.com/functions/create)
  - [Duplicate](https://docs.br4nch.com/functions/duplicate)
  - [Move](https://docs.br4nch.com/functions/move)
  - [Replace](https://docs.br4nch.com/functions/replace)
  - [Delete](https://docs.br4nch.com/functions/delete)
  - [Set](https://docs.br4nch.com/functions/set)
  - [Reset](https://docs.br4nch.com/functions/reset)
  - [Load](https://docs.br4nch.com/functions/load)
  - [Export](https://docs.br4nch.com/functions/export)
  - [Get](https://docs.br4nch.com/functions/get)
  - [Display](https://docs.br4nch.com/functions/display)



  If you want to say **thank you** and/or support the active development of `br4nch`:

  1. Add a [GitHub Star](https://github.com/TRSTN4/br4nch/stargazers) to the project.
  2. Tweet about the project [on your Twitter](https://twitter.com/intent/tweet?text=br4nch%3A%20Data%20Structure%20Tree%20Builder%20for%20Python.%20br4nch%20is%20built%20on%20pure%20%23python.%20That%20means%20that%20it%20does%20not%20require%20any%20other%20libary.%20Its%20designed%20to%20ease%20things%20up%20for%20fast%20data%20structure%20development%F0%9F%9A%80%20https%3A%2F%2Fgithub.com%2FTRSTN4%2Fbr4nch%20%20).
  3. Support the project by donating a [cup of coffee](https://www.buymeacoffee.com/TRSTN4).



  `br4nch` is an open source project that runs on donations to pay the bills e.g. our domain name. If you want to support `br4nch`, you can ☕ [**buy a coffee here**](https://www.buymeacoffee.com/TRSTN4).



  Help in testing, development, documentation and other tasks is highly appreciated and useful to the project. There are tasks for contributors of all experience levels.

  To get started with developing `br4nch`, see [CONTRIBUTING](https://github.com/TRSTN4/br4nch/blob/release/CONTRIBUTING.md).



  `br4nch` is free and open-source software licensed under the [GPL-3.0 License](https://github.com/TRSTN4/br4nch/blob/release/LICENSE).


pkgId: 84ce45397f1bba0a45a15770dbd1bcb52e0ca831ef7f526c76d25792b1b635c7
name: python-braceexpand
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: Bash-style brace expansion for Python
url: https://github.com/trendels/braceexpand
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-braceexpand-0.1.7-1.src.rpm
checksum_type: sha256
description:
  |build-status-img| |PyPI|
  Implements Brace Expansion as described in
  `bash(1) <http://man7.org/linux/man-pages/man1/bash.1.html#EXPANSION>`__,
  with the following limitations:
  -  A pattern containing unbalanced braces will raise an
     ``UnbalancedBracesError`` exception. In bash, unbalanced braces will
     either be partly expanded or ignored.
  -  A mixed-case character range like ``'{Z..a}'`` or ``'{a..Z}'`` will
     not include the characters :literal:`[]^_\`` between ``Z`` and ``a``.
  ``braceexpand`` is tested with Python 2.7, and 3.6+


pkgId: 7393af6917b08b5a01c2cbec43993f1244e07bf04c10a26eaee3f212cb63108e
name: python-bracex
arch: src
version: 2.5
epoch: 0
release: 1
summary: Bash style brace expander.
url: https://github.com/facelessuser/bracex
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bracex-2.5-1.src.rpm
checksum_type: sha256
description:
  [![Donate via PayPal][donate-image]][donate-link]
  [![Discord][discord-image]][discord-link]
  [![Build][github-ci-image]][github-ci-link]
  [![Coverage Status][codecov-image]][codecov-link]
  [![PyPI Version][pypi-image]][pypi-link]
  [![PyPI - Python Version][python-image]][pypi-link]
  ![License][license-image-mit]


  Bracex is a brace expanding library (à la Bash) for Python. Brace expanding is used to generate arbitrary strings.

  ```console
  $ echo {{a,b},c}d
  ad bd cd
  ```

  Bracex adds this ability to Python:

  ```python
  >>> bracex.expand(r'file-{{a,b},c}d.txt')
  ['file-ad.txt', 'file-bd.txt', 'file-cd.txt']
  ```

  and as a command:

  ```console
  $ python3 -m bracex -0 "base/{a,b}/{1..2}" | xargs -0 mkdir -p
  $ tree base/
  base/
  ├── a
  │   ├── 1
  │   └── 2
  └── b
      ├── 1
      └── 2
  ```

  - **Why Bracex over other solutions?**

      Bracex actually follows pretty closely to how Bash processes braces. It is not a 1:1 implementation of how Bash
      handles braces, but generally, it follows very closely. Almost all of the test cases are run through Bash first,
      then our implementation is compared against the results Bash gives. There are a few cases where we have purposely
      deviated. For instance, we are not handling Bash's command line inputs, so we are not giving special meaning to back
      ticks and quotes at this time.

      On the command line Bracex can handle more expansions than Bash itself.



  ```console
  $ pip install bracex
  ```



  Documentation is found here: https://facelessuser.github.io/bracex/.



  MIT License

  [github-ci-image]: https://github.com/facelessuser/bracex/workflows/build/badge.svg?branch=master&event=push
  [github-ci-link]: https://github.com/facelessuser/bracex/actions?query=workflow%3Abuild+branch%3Amaster
  [codecov-image]: https://img.shields.io/codecov/c/github/facelessuser/bracex/master.svg?logo=codecov&logoColor=aaaaaa&labelColor=333333
  [codecov-link]: https://codecov.io/github/facelessuser/bracex
  [pypi-image]: https://img.shields.io/pypi/v/bracex.svg?logo=pypi&logoColor=aaaaaa&labelColor=333333
  [pypi-link]: https://pypi.python.org/pypi/bracex
  [python-image]: https://img.shields.io/pypi/pyversions/bracex?logo=python&logoColor=aaaaaa&labelColor=333333
  [license-image-mit]: https://img.shields.io/badge/license-MIT-blue.svg?labelColor=333333
  [donate-image]: https://img.shields.io/badge/Donate-PayPal-3fabd1?logo=paypal
  [donate-link]: https://www.paypal.me/facelessuser


pkgId: dbf4b7d5c61c6b0934729b0fbdc09121b1d060b7e16493deb4c1804cd92347e1
name: python-bracex
arch: src
version: 2.5.post1
epoch: 0
release: 1
summary: Bash style brace expander.
url: https://github.com/facelessuser/bracex
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bracex-2.5.post1-1.src.rpm
checksum_type: sha256
description:
  [![Donate via PayPal][donate-image]][donate-link]
  [![Build][github-ci-image]][github-ci-link]
  [![Coverage Status][codecov-image]][codecov-link]
  [![PyPI Version][pypi-image]][pypi-link]
  [![PyPI - Python Version][python-image]][pypi-link]
  ![License][license-image-mit]


  Bracex is a brace expanding library (à la Bash) for Python. Brace expanding is used to generate arbitrary strings.

  ```console
  $ echo {{a,b},c}d
  ad bd cd
  ```

  Bracex adds this ability to Python:

  ```python
  >>> bracex.expand(r'file-{{a,b},c}d.txt')
  ['file-ad.txt', 'file-bd.txt', 'file-cd.txt']
  ```

  and as a command:

  ```console
  $ python3 -m bracex -0 "base/{a,b}/{1..2}" | xargs -0 mkdir -p
  $ tree base/
  base/
  ├── a
  │   ├── 1
  │   └── 2
  └── b
      ├── 1
      └── 2
  ```

  - **Why Bracex over other solutions?**

      Bracex actually follows pretty closely to how Bash processes braces. It is not a 1:1 implementation of how Bash
      handles braces, but generally, it follows very closely. Almost all of the test cases are run through Bash first,
      then our implementation is compared against the results Bash gives. There are a few cases where we have purposely
      deviated. For instance, we are not handling Bash's command line inputs, so we are not giving special meaning to back
      ticks and quotes at this time.

      On the command line Bracex can handle more expansions than Bash itself.



  ```console
  $ pip install bracex
  ```



  Documentation is found here: https://facelessuser.github.io/bracex/.



  MIT License

  [github-ci-image]: https://github.com/facelessuser/bracex/actions/workflows/build.yml/badge.svg?branch=master&event=push
  [github-ci-link]: https://github.com/facelessuser/bracex/actions?query=workflow%3Abuild+branch%3Amaster
  [codecov-image]: https://img.shields.io/codecov/c/github/facelessuser/bracex/master.svg?logo=codecov&logoColor=aaaaaa&labelColor=333333
  [codecov-link]: https://codecov.io/github/facelessuser/bracex
  [pypi-image]: https://img.shields.io/pypi/v/bracex.svg?logo=pypi&logoColor=aaaaaa&labelColor=333333
  [pypi-link]: https://pypi.python.org/pypi/bracex
  [python-image]: https://img.shields.io/pypi/pyversions/bracex?logo=python&logoColor=aaaaaa&labelColor=333333
  [license-image-mit]: https://img.shields.io/badge/license-MIT-blue.svg?labelColor=333333
  [donate-image]: https://img.shields.io/badge/Donate-PayPal-3fabd1?logo=paypal
  [donate-link]: https://www.paypal.me/facelessuser


pkgId: 350980ba429f95c8f065ab1a0efb44c6bd05ffa88d6bf921f578cf3b165fc2d4
name: python-brade
arch: src
version: 0.60.2
epoch: 0
release: 1
summary: Brade is Aider with attitude.
url: https://github.com/deansher/brade
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brade-0.60.2-1.src.rpm
checksum_type: sha256
description:
  <!-- Edit README.md, not index.md -->



  I intend to stay very close to the upstream project, but I want to make some changes to suit my needs.

  This project and the programming assistant that it implements are named after a young, smart, angry,
  female villain in a young adult science fiction book series called Skyward, which are among my favorite books.



  Aider lets you pair program with LLMs,
  to edit code in your local git repository.
  Start a new project or work with an existing git repo.
  Aider works best with GPT-4o & Claude 3.5 Sonnet and can
  [connect to almost any LLM](https://aider.chat/docs/llms.html).

  <!-- SCREENCAST START -->
  <p align="center">
    <img
      src="https://aider.chat/assets/screencast.svg"
      alt="aider screencast"
    >
  </p>
  <!-- SCREENCAST END -->

  <!-- VIDEO START
  <p align="center">
    <video style="max-width: 100%; height: auto;" autoplay loop muted playsinline>
      <source src="/assets/shell-cmds-small.mp4" type="video/mp4">
      Your browser does not support the video tag.
    </video>
  </p>
  VIDEO END -->

  <p align="center">
    <a href="https://discord.gg/Tv2uQnR88V">
      <img src="https://img.shields.io/badge/Join-Discord-blue.svg"/>
    </a>
    <a href="https://aider.chat/docs/install.html">
      <img src="https://img.shields.io/badge/Read-Docs-green.svg"/>
    </a>
  </p>


  <!--[[[cog


  cog.out(open("aider/website/_includes/get-started.md").read())
  ]]]-->

  You can get started quickly like this:

  ```
  python -m pip install -U aider-chat


  cd /to/your/git/repo


  export ANTHROPIC_API_KEY=your-key-goes-here
  aider


  export OPENAI_API_KEY=your-key-goes-here
  aider
  ```
  <!--[[[end]]]-->

  See the
  [installation instructions](https://aider.chat/docs/install.html)
  and other
  [documentation](https://aider.chat/docs/usage.html)
  for more details.



  - Run aider with the files you want to edit: `aider <file1> <file2> ...`
  - Ask for changes:
    - Add new features or test cases.
    - Describe a bug.
    - Paste in an error message or or GitHub issue URL.
    - Refactor code.
    - Update docs.
  - Aider will edit your files to complete your request.
  - Aider [automatically git commits](https://aider.chat/docs/git.html) changes with a sensible commit message.
  - Aider works with [most popular languages](https://aider.chat/docs/languages.html): python, javascript, typescript, php, html, css, and more...
  - Aider works best with GPT-4o & Claude 3.5 Sonnet and can [connect to almost any LLM](https://aider.chat/docs/llms.html).
  - Aider can edit multiple files at once for complex requests.
  - Aider uses a [map of your entire git repo](https://aider.chat/docs/repomap.html), which helps it work well in larger codebases.
  - Edit files in your editor while chatting with aider,
  and it will always use the latest version.
  Pair program with AI.
  - [Add images to the chat](https://aider.chat/docs/usage/images-urls.html) (GPT-4o, Claude 3.5 Sonnet, etc).
  - [Add URLs to the chat](https://aider.chat/docs/usage/images-urls.html) and aider will read their content.
  - [Code with your voice](https://aider.chat/docs/usage/voice.html).




  [Aider has one of the top scores on SWE Bench](https://aider.chat/2024/06/02/main-swe-bench.html).
  SWE Bench is a challenging software engineering benchmark where aider
  solved *real* GitHub issues from popular open source
  projects like django, scikitlearn, matplotlib, etc.



  - [Documentation](https://aider.chat/)
  - [Installation](https://aider.chat/docs/install.html)
  - [Usage](https://aider.chat/docs/usage.html)
  - [Tutorial videos](https://aider.chat/docs/usage/tutorials.html)
  - [Connecting to LLMs](https://aider.chat/docs/llms.html)
  - [Configuration](https://aider.chat/docs/config.html)
  - [Troubleshooting](https://aider.chat/docs/troubleshooting.html)
  - [LLM Leaderboards](https://aider.chat/docs/leaderboards/)
  - [GitHub](https://github.com/Aider-AI/aider)
  - [Discord](https://discord.gg/Tv2uQnR88V)
  - [Blog](https://aider.chat/blog/)




  - *The best free open source AI coding assistant.* -- [IndyDevDan](https://youtu.be/YALpX8oOn78)
  - *The best AI coding assistant so far.* -- [Matthew Berman](https://www.youtube.com/watch?v=df8afeb1FY8)
  - *Aider ... has easily quadrupled my coding productivity.* -- [SOLAR_FIELDS](https://news.ycombinator.com/item?id=36212100)
  - *It's a cool workflow... Aider's ergonomics are perfect for me.* -- [qup](https://news.ycombinator.com/item?id=38185326)
  - *It's really like having your senior developer live right in your Git repo - truly amazing!* -- [rappster](https://github.com/Aider-AI/aider/issues/124)
  - *What an amazing tool. It's incredible.* -- [valyagolev](https://github.com/Aider-AI/aider/issues/6#issue-1722897858)
  - *Aider is such an astounding thing!* -- [cgrothaus](https://github.com/Aider-AI/aider/issues/82#issuecomment-1631876700)
  - *It was WAY faster than I would be getting off the ground and making the first few working versions.* -- [Daniel Feldman](https://twitter.com/d_feldman/status/1662295077387923456)
  - *THANK YOU for Aider! It really feels like a glimpse into the future of coding.* -- [derwiki](https://news.ycombinator.com/item?id=38205643)
  - *It's just amazing.  It is freeing me to do things I felt were out my comfort zone before.* -- [Dougie](https://discord.com/channels/1131200896827654144/1174002618058678323/1174084556257775656)
  - *This project is stellar.* -- [funkytaco](https://github.com/Aider-AI/aider/issues/112#issuecomment-1637429008)
  - *Amazing project, definitely the best AI coding assistant I've used.* -- [joshuavial](https://github.com/Aider-AI/aider/issues/84)
  - *I absolutely love using Aider ... It makes software development feel so much lighter as an experience.* -- [principalideal0](https://discord.com/channels/1131200896827654144/1133421607499595858/1229689636012691468)
  - *I have been recovering from multiple shoulder surgeries ... and have used aider extensively. It has allowed me to continue productivity.* -- [codeninja](https://www.reddit.com/r/OpenAI/s/nmNwkHy1zG)
  - *I am an aider addict. I'm getting so much more work done, but in less time.* -- [dandandan](https://discord.com/channels/1131200896827654144/1131200896827654149/1135913253483069470)
  - *After wasting $100 on tokens trying to find something better, I'm back to Aider. It blows everything else out of the water hands down, there's no competition whatsoever.* -- [SystemSculpt](https://discord.com/channels/1131200896827654144/1131200896827654149/1178736602797846548)
  - *Aider is amazing, coupled with Sonnet 3.5 it’s quite mind blowing.* -- [Josh Dingus](https://discord.com/channels/1131200896827654144/1133060684540813372/1262374225298198548)
  - *Hands down, this is the best AI coding assistant tool so far.* -- [IndyDevDan](https://www.youtube.com/watch?v=MPYFPvxfGZs)
  - *[Aider] changed my daily coding workflows. It's mind-blowing how a single Python application can change your life.* -- [maledorak](https://discord.com/channels/1131200896827654144/1131200896827654149/1258453375620747264)
  - *Best agent for actual dev work in existing codebases.* -- [Nick Dobos](https://twitter.com/NickADobos/status/1690408967963652097?s=20)


pkgId: 0d3f3d6845e56d356ef591e318d0a34778d9b2cfdd4bc4b3f2824cd00f6052b6
name: python-bradford-white-connect-client
arch: src
version: 0.0.19
epoch: 0
release: 1
summary: A Python3, async-friendly client library for Bradford White Connect
url: https://github.com/ablyler/bradford_white_connect_client
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bradford-white-connect-client-0.0.19-1.src.rpm
checksum_type: sha256
description:
  Python client for Bradford White Connect



  - The energy usage returned by the API appears to be limited to the last three months


pkgId: 1f2890751ef20bf039ccb48f5d644f72681f6ea0c90f211df60c276d0b86e172
name: python-bradocs4py
arch: src
version: 1.3.1.0
epoch: 0
release: 1
summary: Implementa a funcionalidade validar_inscao_estadual.
url: https://github.com/namio/BRADocs4Py.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bradocs4py-1.3.1.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI](https://img.shields.io/pypi/v/BRADocs4Py.svg)](https://pypi.org/project/bradocs4py/)
  [![GitHub top language](https://img.shields.io/github/languages/top/namio/BRADocs4Py.svg)](https://github.com/namio/BRADocs4Py.git)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/BRADocs4Py.svg)](https://pypi.org/project/bradocs4py/)
  [![PyPI - Wheel](https://img.shields.io/pypi/wheel/BRADocs4Py.svg)](https://pypi.org/project/bradocs4py/)
  [![PyPI - Implementation](https://img.shields.io/pypi/implementation/BRADocs4Py.svg)](https://pypi.org/project/bradocs4py/)
  [![GitHub](https://img.shields.io/github/license/namio/BRADocs4Py.svg)](https://github.com/namio/BRADocs4Py/blob/master/LICENSE)
  [![GitHub last commit](https://img.shields.io/github/last-commit/namio/BRADocs4PY.svg)](https://github.com/namio/BRADocs4Py.git)
  [![Say Thanks!](https://img.shields.io/badge/Say%20Thanks-!-1EAEDB.svg)](https://saythanks.io/to/namio)



  BRADocs4Py é uma biblioteca que visa fornecer componentes para trabalhar com tipos de dados específicos da realidade brasileira.

  Esta biblioteca surgiu mediante a necessidade de se ter tipos específicos que possibilitem lidar com documentos de identificação próprios do Brasil, como é o caso do Cadastro de Pessoa Física (CPF) e do Cadastro Nacional de Pessoa Jurídica (CNPJ).

  Além de conter classes que representam o modelo computacional dos principais documentos brasileiros, esta biblioteca também disponibiliza classes que permitem a validação e a geração de números válidos para estes documentos; sendo estas últimas disponibilizadas exclusivamente para fins de testes computacionais.

  > This software is coded and documented in portuguese only as it is intended to be used to generate the necessary files for the brazilian government regarding to digital bookkeeping.



    * python



      $ pip install bradocs4py



  A ideia inicial do projeto e unificar em uma única biblioteca módulos que permitam representar computacionalmente e validar documentos brasileiros - inicialmente CPF e CNPJ, além de permitir a geração de números válidos para estes documentos.



  O projeto inicialmente suportará apenas Python 3.6.5+.

  Outras linguagens de programação poderão ter versões especificas conforme minha disponibilidade de tempo.



  O projeto está em fase inicial de desenvolvimento.

  | Módulo                              |  Situação       |
  |:------------------------------------|:---------------:|
  | [DocumentoIdentificacao](#di)       |Funcional        |
  | [CPF](#cpf)                         |Funcional        |
  | [ValidadorCpf](#vcpf)               |Funcional        |
  | [GeradorCpf](#gcpf)                 |Funcional        |
  | [Cnpj](#cnpj)                       |Funcional        |
  | [ValidadorCnpj](#vcnpj)             |Funcional        |
  | [GeradorCnpj](#gcnpj)               |Funcional        |
  | [InscricaoEstadual](#ie)            |Funcional        |
  | [ValidadorInscricaoEstadual](#vie)  |Funcional        |
  | [GeradorInscricaoEstadual](#gie)    |Não implementado |
  | [InscricaoSuframa](#is)             |Funcional        |
  | [ValidadorSuframa](#vs)             |Funcional        |
  | [GeradorSuframa](#gs)               |Funcional        |
  | [ChaveAcessoNFe](#chave)            |Funcional        |
  | [ValidadorChaveAcessoNFe](#vchave)  |Funcional        |
  | [GeradorChaveAcessoNFe](#gchave)    |Funcional        |
  | [GTIN](#gtin)                       |Funcional        |
  | [ValidadorGTIN](#vgtin)             |Funcional        |
  | [GeradorGTIN](#ggtin)               |Funcional        |




  Classe abstrata, não podendo ser instanciada diretamente, serve como base para todas as classes que representam um documento de identificação ou qualquer outro documento brasileiro que necessite de validação.



  Classe usada para representar em código Pyhton um _Cadastro de Pessoa Física_ (CPF); permitindo representá-lo textualmente, com a devida formatação e identificar a sua validade.



      >>> cpf = CPF('52513127765')
      >>> cpf
      '525.131.277-65'

      >>> cpf.isValid
      True

      >>> cpf.rawValue
      52513127765

      >>> cpf = CPF('abcdefghijk')
      >>> cpf.isValid
      False

      >>> print(cpf)
      abcdefghijk

      >>> print(cpf.rawValue)
      abcdefghijk

  > Independente do conteúdo passado ao se criar uma instância de CPF, **sempre** obter-se-á uma instância deste. Caberá consultar a propriedade __isValid__ de uma instância de CPF para verificar se esta é válida ou não.

  > A representação textual de uma instância de CPF só será exibida caso esta instância contenha um número válido de CPF; ao contrário será exibida a _string_ utilizada para criá-la.

  > Para obter a _string_ utilizada ao instanciar um CPF, basta acessar a propriedade **rawValue** da instância criada.



  Classe responsável por validar uma instância de CPF ou uma _string_ contendo a representação numérica de um CPF.



      >>> cpf = CPF('abcdefghijk')
      >>> ValidadorCpf.validar(cpf)
      False

      >>> ValidadorCpf.validar('123.456.789-00')
      False

      Foi criado um CPF válido, porém foi digitado um caractere de separação diferente dos caracteres esperados (.-/ ). Mesmo assim, o validador informa tratar-se de um CPF correto
      >>> cpf = CPF('508,697,212-40')
      >>> ValidadorCpf.validar(cpf)
      True



  Classe responsável por gerar aleatoriamente um CPF válido.



      >>> cpf = GeradorCpf.gerar()
      >>> cpf.isValid
      True



  Classe usada para representar em código Pyhton um _Cadastro Nacional de Pessoa Jurídica_ (CNPJ); permitindo representá-lo textualmente, com a devida formatação e identificar a sua validade.



  	>>> cnpj = Cnpj('abcdefghijklmn')
  	>>> cnpj.isValid
  	False

  	>>> cnpj = Cnpj('12345678901234')
  	>>> cnpj.isValid
  	False

  	>>> cnpj = Cnpj('19.658.147/0001-0O')
  	>>> cnpj.isValid
  	False

  	>>> cnpj = Cnpj('19.658.147/0001-00')
  	>>> cnpj.isValid
  	True

  > Independente do conteúdo passado ao se criar uma instância de CNPJ, **sempre** obter-se-á uma instância deste. Caberá consultar a propriedade __isValid__ de uma instância de CNPJ para verificar se esta é válida ou não.

  > A representação textual de uma instância de CNPJ só será exibida caso esta instância contenha um número válido de CNPJ; ao contrário será exibida a _string_ utilizada para criá-la.

  > Para obter a _string_ utilizada ao instanciar um CNPJ, basta acessar a propriedade **rawValue** da instância criada.



  Classe responsável por validar uma instância de CNPJ ou uma _string_ contendo a representação numérica de um CNPJ.



  	>>> cnpj = Cnpj('abcdefghijklmn')
  	>>> ValidadorCnpj.validar(cnpj)
  	False

  	>>> cnpj = Cnpj('19.658.147/0001-0O')
  	>>>ValidadorCnpj.validar(cnpj)
  	False

  	>>> ValidadorCnpj.validar('12345678901234')
  	False

  	>>> cnpj = Cnpj('34  633 423,0001/60')
  	>>> ValidadorCnpj.validar(cnpj)
  	True

  	>>> ValidadorCnpj.validar('05.692.744/0001-38')
  	True



  Classe responsável por gerar aleatoriamente um CNPJ válido.



      >>> cnpj = GeradorCnpj.gerar()
      >>> cnpj.isValid
      True



  Representa o número de inscrição na Superintendência da Zona Franca de Manaus (SUFRAMA)

  > A SUFRAMA mantém controle sobre as empresas com insentivo fiscal, identificando-as através do número de _Inscrição SUFRAMA_.

  A composição deste indicador é: _SS.NNNN.LLD_, onde:

  **SS** representa o __código do setor de atividade__ da empresa, conforme exemplo abaixo:

  | Código  | Descrição                   |
  | :----:  | :---------------------------|
  | 01 e 02 | Cooperativa                 |
  | 10 e 11 | Comércio                    |
  | 20      | Indústria com projeto pleno |
  | 60      | Serviços                    |

  **NNNN** número sequencial

  **LL** representa o código da licalidade da Unidade Administrativa da Suframa que habilitou a empresa, conforme exemplo abaixo:


  | Código | Descrição   |
  | :----: | :-----------|
  |   01   | Manaus      |
  |   10   | Boa Vista   |
  |   30   | Porto Velho |

  **D** dígito verificador



  * Campo numérico com 9 posições (incluindo o dígito verificador).
  * Pode iniciar por 0 (zero), mas não pode iniciar por 00.
  * Dígito verificador calculado por [__módulo 11__](https://pt.wikipedia.org/wiki/D%C3%ADgito_verificador#Módulo_11 "Método de cálculo do dígito verificador usando Módulo 11"), pesos 2 a 9.



      >>> x = InscricaoSuframa('01.1234.129')
      >>> x.rawValue
      '011234129'
      >>> print(x)
      01.1234.129
      >>> x.isValid
      False

      >>> x = InscricaoSuframa('101580100')
      >>> x.rawValue
      '101580100'
      >>> print(x)
      10.1580.100
      >>> x.isValid
      True

      >>> x = InscricaoSuframa('1015801OO')
      >>> x.rawValue
      '1015801OO'
      >>> print(x)
      1015801OO
      >>> x.isValid
      False



  Valida uma instância de InscricaoSuframa ou uma _string_ contendo a representação numérica de uma Inscrição Suframa.



      
      >>> ValidadorSuframa.validar('101580100')
      True

      
      >>> ValidadorSuframa.validar('1015801OO')
      False

      
      >>> x = InscricaoSuframa('01.1234.129')
      >>> ValidadorSuframa.validar(x)
      False



  Gera aleatoriamente uma Inscrição Suframa válida

      >>> x = GeradorSuframa.gerar()
      >>> x.isValid
      True

  > **IMPORTANTE**: O __GeradorSuframa__ tem por objetivo ajudar estudantes, programadores, analistas de sistemas e testadores de código a gerar Inscrições Suframa válidas visando auxiliar as rotinas de testes de softwares em desenvolvimento.

  > A má utilização dos dados gerados pelo __GeradorSuframa__ é de **total responsabilidade do usuário** desta biblioteca.

  > As inscrições são geradas de forma aleatória, respeitando as leis de formação estabelecidas pela SUFRAMA.



  Representa, em código Pyhton, uma _Inscrição Estadual_ (IE), ou o registro do contribuinte no cadastro do ICMS mantido pela Receita Estadual; permitindo representá-lo textualmente, com a devida formatação e identificar a sua validade.



      >>> ie = InscricaoEstadual('613.855.219.926', 'SP')
      >>> ie.isValid
      True
      >>> ie.rawValue
      '613855219926'
      >>> ie.UF
      'SP'
      >>> print(ie)
      613.855.219.926



  Valida a consistência de uma instância de InscricaoEstadual ou uma _string_ contendo a representação numérica de uma Inscrição Estadual para uma determinada Unidade da Federação, informada juntamente com a representação numérica da IE a qual se deseja validar.

  > A validação da Inscrição Estadual para cada Unidade da Federação brasileira, leva em consideração o disposto no [__Convênio 57/59__](http://www.sintegra.gov.br/conv_5795.html "ConvênioICMS 57/59"), como também as orientações e especificidades contidas na página [Conferências de Inscrições Estaduais](http://www.sintegra.gov.br/insc_est.html "Conferência de Inscrições Estaduais") do SINTEGRA.



      >>> ie = InscricaoEstadual('613.855.219.926', 'SP')
      >>> ValidadorInscricaoEstadual.validar(ie)
      True

      >>> ValidadorInscricaoEstadual.validarStr('207653461', 'RN')
      True
      >>> ValidadorInscricaoEstadual.validarStr('209564598', 'TO')
      False

  > **NOTA**: Caso não se deseje utilizar o __ValidadorInscricaoEstadual__, pode-se utilizar o validador específico para uma determinada Unidade da Federação.
  <p>Cada Unidade da Federação brasileira possui o seu próprio validador, definido por: **Validador**XX, onde _XX_ deve ser substituído pela sigla da Unidade da Federação desejada.</p>
  <p>O Exemplo a seguir mostra como utilizar somente o validador específico para o Ceará, visando validar uma Inscrição Estadual deste Estado:</p>

      >>> from bradocs4py.validadoresie import ValidadorCE
      >>> ValidadorCE.validar('1234567')
      False
      >>> ValidadorCE.validar('50374156-6')
      True

  > **IMPORTANTE**: Ao contrário de ValidadorInscricaoEstadual, os validadores específicos de cada UF validam somente uma cadeia de caracteres (_string_) contendo o número representativo da Inscrição Estadual a ser validada.



  Representa a **Chave de Acesso** de uma Nota Fiscal Eletrônica.


  A Chave de Acesso da Nota Fiscal Eletrônica é representada por uma sequência de 44 caracteres numéricos, devendo ser composta pelos seguintes campos que se encontram dispersos no Layout da NF-e:

  * UF - Código da UF do emitente do Documento Fiscal
  * AAMM - Ano e mês da emissão da NF-e
  * CNPJ - CNPJ do emitente do Documento Fiscal
  * Modelo - Modelo do Documento Fiscal
  * Série - Série do Documento Fiscal
  * Número - Número do Documento Fiscal
  * Forma Emissão - Forma de emissão do Documento Fiscal
  * Código Numérico - Código numérico que compõe a Chave de Acesso
  * DV - Dígito verificados

  | Código    |  UF  | AAMM | CNPJ | Modelo | Série | Número | Forma Emissão | Código Numérico |  DV  |
  | :--------:|:----:|:----:|:----:|:------:|:-----:|:------:|:-------------:|:---------------:|:----:|
  |Quantidade de caracteres |02    |04    |14    |02      |03     |09      |01             |08               |01    |




      >>> ca = ChaveAcessoNFe('23 1811 06850713000120 55 001 001766829 1 11103011 2')
      >>> ca
      <BRADocs4Py.bradocs4py.chaveacessonfe.ChaveAcessoNFe('23181106850713000120550010017668291111030112')>
      >>> print(ca)
      2318 1106 8507 1300 0120 5500 1001 7668 2911 1103 0112
      >>> ca.rawValue
      '23181106850713000120550010017668291111030112'
      >>> ca.isValid
      True



  Valida a consistência e a integridade de uma instância de [ChaveAcessoNFe](#chave) ou uma _string_ contendo a representação numérica de uma Chave de Acesso, através do cálculo de seu _dígito verificador_.

  > O **Dígito Verificador** (DV) visa garantir a integridade da Chave de Acesso, protegendo-a principalmente contra digitações erradas.



      >>> chave = ChaveAcessoNFe(35181298957205000164667451830925015791400679)
      >>> validarChaveAcessoNFe(chave)
      True
      >>> ValidadorChaveAcessoNFe.validar(52060433009911002506550120000007800267301615)
      True
      >>> ValidadorChaveAcessoNFe.validar('52060433009911002506550120000007800267301615')
      True
      >>> ValidadorChaveAcessoNFe.validar('52060433009911002506550120000007800267301625')
      False

      ou

      >>> validarChaveAcessoNFe(52060433009911002506550120000007800267301615)
      True
      >>> validarChaveAcessoNFe('52060433009911002506550120000007800267301615')
      True
      >>> validarChaveAcessoNFe('52060433009911002506550120000007800267301625')
      False
      >>> validarChaveAcessoNFe(chave)
      True




  O dígito verificador da chave de acesso da NF-e é baseado em um cálculo do módulo 11. O módulo 11 de um número é calculado multiplicando-se cada algarismo pela sequência de multiplicadores 2,3,4,5,6,7,8,9,2,3, ..., posicionados da direita para a esquerda.

  A somatória dos resultados das ponderações dos algarismos é dividida por 11 e o DV (dígito verificador) será a diferença entre o divisor (11) e o resto da divisão:

  DV = 11 - (resto da divisão)

  > Quando o resto da divisão for 0 (zero) ou 1 (um), o DV deverá ser igual a 0 (zero).

  Exemplo: consideremos a seguinte chave de acesso: _52060433009911002506550120000007800267301615_

  Isolando o _dígito verificador_, temos: _5206043300991100250655012000000780026730161_

  |**Chave** | 5 | 2 | 0 | 6 | 0 | 4 | 3 | 3 | 0 | 0 | 9 | 9 | 1 | 1 | 0 | 0 | 2 | 5 | 0 | 6 | 5 | 5 | 0 | 1 | 2 | 0 | 0 | 0 | 0 | 0 | 0 | 7 | 8 | 0 | 0 | 2 | 6 | 7 | 3 | 0 | 1 | 6 | 1 |
  |:------------------------|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|
  |**Pesos** | 4 | 3 | 2 | 9 | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 9 | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 9 | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 9 | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 9 | 8 | 7 | 6 | 5 | 4 | 3 | 2 |
  |**Ponderação** |20 | 6 | 0 |54 | 0 |28 |18 |15 | 0 | 0 |18 |81 | 8 | 7 | 0 | 0 | 8 |15 | 0 |54 |40 |35 | 0 | 5 | 8 | 0 | 0 | 0 | 0 | 0 | 0 |35 |32 | 0 | 0 |18 |48 |49 |18 | 0 | 4 |18 | 2 |

  **Somatório das ponderações**: _644_

  Dividindo o somatório das ponderações por **11**, temos: 644/11 = 58, restando **6**

  Como o dígito verificador (DV) = 11 - (resto da divisão), temos: **11 - 6 = 5**

  Neste caso o DV da chave de acesso da NF-e é igual a "5".



  Por ter uma [lei de formação](#lfchave) peculiar, o _[ValidadorChaveAcessoNFe](#vchave)_ verifica a consistência de uma determinada chave de acesso, observando:

  * se os dois primeiros dígitos correspondem ao código, segundo o IBGE, de uma Unidade da Federação Brasileira;
  * Se a data de emissão (**mês** e **ano**) *ano* de emissão não é **posterior** à data (mês e ano) atual;
  * Se o *mês* de emissão, que corresponde ao terceiro par de dígitos, corresponde ao valor de um dos meses do ano;
  * Se o *CNPJ* do emitente corresponde a um número de CNPJ válido.

  > Desta forma, para que uma chave de acesso de NF-e seja válida, esta deverá passar pelo cálculo do Dígito Verificador e pelo teste de consistência.



  Gera uma [Chave de Acesso de NF-e](#chave) válida.

  A chave gerada pelo [GeradorChaveAcessoNFe](#gchave) obedece às [regras de consistência](#consistenciachave) anteriormente citadas.



      >>> chave = GeradorChaveAcessoNFe.gerar()
      >>> chave
      <BRADocs4Py.bradocs4py.chaveacessonfe.ChaveAcessoNFe('25181230173834000160651227059459841838300521')>
      >>> print(chave)
      2518 1230 1738 3400 0160 6512 2705 9459 8418 3830 0521
      >>> chave.rawValue
      '25181230173834000160651227059459841838300521'
      >>> chave.isValid
      True

      OU

      >>> chave = gerarChaveAcessoNFe
      >>> chave
      <BRADocs4Py.bradocs4py.chaveacessonfe.ChaveAcessoNFe('11181205001709000125650428522143493956800409')>
      >>> print(chave)
      1118 1205 0017 0900 0125 6504 2852 2143 4939 5680 0409
      >>> chave.rawValue
      '11181205001709000125650428522143493956800409'
      >>> chave.isValid
      True

  É possível passar para o gerador qualquer um dos seguintes parâmetros, ou combinação deles:

  * UF - [Gera de uma chave de acesso para uma determinada Unidade da Federação](#gchaveUF) Brasileira
  * anoEmissao - [Gera uma chave de acesso para um determinado ano de emissão](#gchaveAno)
  * mesEmissao - [Gera uma chave de acesso para um determinado mês de emissão](#gchaveMes)
  * cnpjEmitente - [Gera uma chave de acesso informando o CNPJ do emitente](#gchaveCNPJ)
  * modelo - [Gera uma chame de acesso informando o modelo do documento fiscal](#gchaveModelo)
  * serie - [Gera uma chave de acesso informando a série do Documento Fiscal](#gchaveSerie)
  * numero - [Gera uma chave de acesso informando o núemro do Documento Fiscal](#gchaveNumero)
  * formaEmissao - [Gera uma chave de acesso informando o tipo de emissão da NF-e](#gchaveEmissao)



      >>> chave = GeradorChaveAcessoNFe.gerar(UF=23)
      >>> chave.rawValue
      '23181200840039000117652898295631409915000755'



      >>> chave = GeradorChaveAcessoNFe.gerar(anoEmissao=2015)
      >>> chave.rawValue
      '23151289106950000109651490922639616463100456'



      >>> chave = GeradorChaveAcessoNFe.gerar(mesEmissao=8)
      >>> chave.rawValue
      '15180853477826000102655678711686215463600041'



      >>> chave = GeradorChaveAcessoNFe.gerar(anoEmissao=2015, mesEmissao=1)
      >>> chave.rawValue
      '29150139480855000100653317092547617382300904'



      >>> chave = GeradorChaveAcessoNFe.gerar(cnpjEmitente='64802611000136')
      >>> chave.rawValue
      '13181264802611000136651456599176257515300837'



      >>> chave = GeradorChaveAcessoNFe.gerar(modelo=55)
      >>> chave.rawValue
      '27181282761929000106555079534095503558300935'



      >>> chave = GeradorChaveAcessoNFe.gerar(serie=0)
      >>> chave.rawValue
      '13181202699369000160650006987155021599900654'

  > Nota: A série também pode ser informada como uma cadeia de caracteres numéricos. No exemplo acima, poderia ter sido informado **'000'** para _serie_.



      >>> chave = GeradorChaveAcessoNFe.gerar(numero=1766829)
      >>> chave.rawValue
      '23181241761925000132652850017668297691400378'



      >>> chave = GeradorChaveAcessoNFe.gerar(formaEmissao=2)
      >>> chave.rawValue
      '51181278981604000153656457693627102018200143'

  Isto posto, desejando-se criar uma chave de acesso emitida no Ceará (Código IBGE=23) em Maio de 2016, para o CNPJ 64802611/0001-36, teríamos:

      >>> chave = GeradorChaveAcessoNFe.gerar(formaEmissao=2, UF=23, anoEmissao=2016, mesEmissao=5, cnpjEmitente=64802611000136)
      >>> chave.rawValue
      '23160564802611000136554038699639442073100081'
      >>> chave.isValid
      True

  > **Atenção**: a forma abreviada do gerador _(gerarChaveAcessoNFe)_ não permite a passagem de parâmetros.



  Representa um Número Global do Item Comercial - Global Trade Item Number (GTIN)

  O GTIN é um identificador para itens comerciais desenvolvido e controlado pela [GS1][gs1], antiga EAN/UCC. Os GTINs,
  anteriormente chamados de códigos EAN, são atribuídos para qualquer item (produto ou serviço) que pode ser
  precificado, pedido ou faturado em qualquer ponto da cadeia de suprimentos. O GTIN é utilizado para recuperar
  informação pré-definida e abrange desde as matérias primas até produtos acabados. GTIN é um termo “guarda-chuva”
  para descrever toda a família de identificação das estruturas de dados GS1 para itens comerciais (produtos e serviços).
  Os GTINs podem ter o tamanho de 8, 12, 13 ou 14 dígitos e podem ser construídos utilizando qualquer uma das quatro
  estruturas de numeração dependendo da aplicação. O GTIN-8 é codificado no código de barras EAN-8. O GTIN-12 é mais
  utilizado no código de barras UPC-A, o GTIN-13 é codificado no EAN-13 e o GTIN-14 no ITF-14.





      >>> gtin = GTIN(6291041500213)
      >>> gtin
      <BRADocs4Py.bradocs4py.gtin.GTIN(GTIN-13 '6291041500213')>
      >>> gtin.rawValue
      '6291041500213'
      >>> gtin.isValid
      True



      >>> gtin = GTIN('35723189')
      >>> gtin
      <BRADocs4Py.bradocs4py.gtin.GTIN(GTIN-8 '35723189')>
      >>> gtin.rawValue
      '35723189'
      >>> gtin.isValid
      True



  Valida uma instância de GTIN, um inteiro ou uma cadeia de caracteres numéricos que representa um GTIN, a partir do [cálculo de seu dígito verificador][calculo-digito-gtin], o qual assegura a sua integridade.

  > Nota: Muito embora o ValidadorGTIN valide uma instância de GTIN, a validação desta instância pode ser verificada através da sua propriedade _isValid_, conforme exemplos acima.



      >>> gtin = GTIN('35723189')
      >>> ValidadorGTIN.validar(gtin)
      True
      >>> ValidadorGTIN.validar('3572318')
      False
      >>> ValidadorGTIN.validar('35723189')
      True
      >>> ValidadorGTIN.validar(6291041500213)
      True
      >>> ValidadorGTIN.validar('62910415OO213')
      False

  **OU**

      >>> gtin = GTIN('35723189')
      >>> validar_gtin(gtin)
      True
      >>> validar_gtin('3572318')
      False
      >>> validar_gtin('35723189')
      True
      >>> validar_gtin(6291041500213)
      True
      >>> validar_gtin('62910415OO213')
      False



  Gera uma instância de um [GTIN](#gtin) válido.

  >IMPORTANTE: Este gerador de GTIN tem como intenção ajudar estudantes, programadores, analistas e testadores de sistemas computacionais a gerar GTINs válidas. Normalmente necessárias parar testar seus softwares em desenvolvimento. A má utilização dos dados aqui gerados é de total responsabilidade do usuário. Os números são gerados de forma aleatória, respeitando as regras de criação de um GTIN.



      >>> gtin = GeradorGTIN.gerar()
      >>> gtin
      <BRADocs4Py.bradocs4py.gtin.GTIN(GTIN-8 '93490399')>

  **ou**

      >>> gtin = gerar_gtin()
      >>> gtin
      <BRADocs4Py.bradocs4py.gtin.GTIN(GTIN-8 '33409382')>

  É possível informar ao gerador o tipo de GTIN que se deseja gerar. Para isso, deve-se passar o _GeradorGTIN.TipoGTIN_ desejado.



      >>> gtin = GeradorGTIN.gerar(GeradorGTIN.TipoGTIN.GTIN8)
      >>> gtin
      <BRADocs4Py.bradocs4py.gtin.GTIN(GTIN-8 '33409382')>

  Também é possível gerar GTINs chamando diretamente _gerar_gtin_:

      >>> gtin = gerar_gtin(GeradorGTIN.TipoGTIN.GTIN13)
      >>> gtin
      <BRADocs4Py.bradocs4py.gtin.GTIN(GTIN-13 '4332497941617')>

  Utilize:

  * GeradorGTIN.TipoGTIN.GTIN8 para gerar GTIN-8
  * GeradorGTIN.TipoGTIN.GTIN12 para gerar GTIN-12
  * GeradorGTIN.TipoGTIN.GTIN13 para gerar GTIN-13, ou
  * GeradorGTIN.TipoGTIN.GTIN14 para gerar GTIN-14

  > Se não for passado nenhum tipo para o gerador, este gerará sempre um GTIN-8.

  [gs1]: https://www.gs1br.org
  [calculo-digito-gtin]: https://www.gs1.org/services/how-calculate-check-digit-manually


pkgId: 4a67941e9e646073401b7d68bc8320c4e118d438d66326b3c912a9ab4ace0a22
name: python-bragir
arch: src
version: 1.2.20
epoch: 0
release: 1
summary: bragir translator cli
url: https://pypi.org/project/bragir/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bragir-1.2.20-1.src.rpm
checksum_type: sha256
description:
  ![Authors](https://kajabi-storefronts-production.kajabi-cdn.com/kajabi-storefronts-production/file-uploads/themes/2149113237/settings_images/4adb13d-824c-454-a5c-72b2c6f06e1_Arjan_Codes_-_FInal_Files.png)

  [![License](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)



  The bragir CLI is a command-line application built using Click. Its primary purpose is to handle and generate SubRip Subtitle (SRT) files using ChatGPT and Whisper from Openai.



  - **Translation:** Translate the content of SRT files from one language to another using ChatGPT.
  - **Transcription:** Trancribe the content of video and audio files from one language to another using Whisper.
  - **Batch Processing:** Process a single file, multiple files, or an entire directory, providing flexibility and efficiency.
  - **Easy-to-Use Interface:** Utilize a user-friendly command-line interface powered by Click, making translation tasks straightforward.



  - [Bragir](#bragir)
    - [Description](#description)
    - [Features](#features)
    - [Table of Contents](#table-of-contents)
    - [Installation](#installation)
      - [FFmpeg](#ffmpeg)
        - [Macos](#macos)
        - [Linux](#linux)
        - [Windows](#windows)
      - [OpenAI](#openai)
      - [Bragir](#bragir-1)
  - [Usage](#usage)
      - [Examples](#examples)
  - [Contributing](#contributing)
  - [Commit Message Structure](#commit-message-structure)
    - [Example Commit Messages](#example-commit-messages)
  - [License](#license)



  In order to use the full potential of Bragir, FFmpeg is needed to be installed on the system and you need to obtain an Openai key.



  **Using brew**

  ```zsh
  brew update && brew install ffmpeg
  ```



  Update avaiable linux packages
  ```bash
   sudo apt update
  ```
  Install ffmpeg
  ```bash
   sudo apt install ffmpeg
  ```



  Download the .exe from official [ffmpeg-website](https://ffmpeg.org/download.html)

  Extract the contents of the zip file and rename the file to FFmpeg.

  Move the folder into the main drive (Usually c:/)

  Open command prompt as administrator, and add FFmpeg to your system path

  ```bash
  setx /m PATH "C:\ffmpeg\bin;%PATH%"
  ```

  **Verifyting the installation**
  In order to see if the installation of FFmpeg is correct, run the following command
  ```bash
  ffmpeg --version
  ```

  If a version is displayed, then FFmpeg is installed correctly.



  Currently, this tool relise on OpenAIs API. That means that an OpenAI api-key is crucial. See the following resource of [how to get an OpenAI api-key](https://platform.openai.com/docs/quickstart?context=python)


  Use pip to install Bragir
  ```bash
  pip install bragir
  ```

  Check if installation is complete

  ```
  bragir --version
  ```
  If a version is displayed, then Bragir is installed correctly.




  Bragir comes with two commands, transcribe and translate. Transcribe will always generate an file with extension `.srt`. The translate command has only been tested with SRT-files, however other files would work. However, Bragir is not intended to translate other file types

  In order to use bragir, the api key can be loaded into the session or saved in the config.ini file (Default at `~/.bragir/cli/config.ini`).

  Load Openai key as an enviroment variable into current session
  ```
  export OPENAI_KEY=<VALUE>
  ```


  Translate a single file to one language:

  ```
  bragir translate <FILE_PATH> --language French
  ```

  Translate one file to multiple languages:

  ```
  bragir translate <FILE_PATH> --language French --language German
  ```

  Translate files in a directory to multiple languages:

  ```
  bragir translate <DIRECTORY_PATH> --language French --language German
  ```

  Transcribe file:

  ```
  bragir transcribe <FILE_PATH>
  ```

  Transcribe files in a directory:

  ```
  bragir transcribe <DIRECTORY_PATH>
  ```


  If you want to contribute to this project, please use the following steps:

  1. Fork the project.
  2. Create a new branch (git checkout -b feature/awesome-feature).
  3. Commit your changes (git commit -m 'Add some feature').
  4. Push to the branch (git push origin feature/awesome-feature).
  5. Open a pull request.



  This projects aims to follow the [Conventional Commits](https*://www.conventionalcommits.org/en/v1.0.0/#summary) guidelines.

  When writing commit messages, use one of the following categories to clearly describe the purpose of your commit:

  - **feat** / **feature**: ✨  Introducing new features
  - **fix** / **bugfix**: 🐛  Addressing bug fixes
  - **perf**: 🚀  Enhancing performance
  - **refactor**: 🔄  Refactoring code - **Not displayed in CHANGELOG**
  - **test** / **tests**: ✅  Adding or updating tests - **Not displayed in CHANGELOG**
  - **build** / **ci**: 🛠️  Build system or CI/CD updates - **Not displayed in CHANGELOG**
  - **doc** / **docs**: 📚  Documentation changes - **Not displayed in CHANGELOG**
  - **style**: 🎨  Code style or formatting changes - **Not displayed in CHANGELOG**
  - **chore**: 🔧  Miscellaneous chores
  - **other**: 🌟  Other significant changes



  - `feat: Add cool new feature`
  - `fix: Resolve unexpected behavior with translation`


  This project is licensed under the MIT License.


pkgId: 67976844ff7cb6ed36a0eaa19359dbd318d9cd1c01c4ce6d35491157fe4e2f1a
name: python-brahm-centre-utils
arch: src
version: 1.0.4
epoch: 0
release: 1
summary: Brahm Centre internal utility functions
url: https://github.com/Brahm-Centre-SG/bc-utils-package
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brahm-centre-utils-1.0.4-1.src.rpm
checksum_type: sha256
description:
  Brahm Centre Utils is a collection of internal utility functions designed to facilitate common tasks at Brahm Centre. This package includes functions for Salesforce interactions, data processing, and more.



  You can easily install Brahm Centre Utils using pip:

  ```bash
  pip install brahm-centre-utils
  ```

  It's recommended to install this package in a virtual environment.


  After installing the package, you can use the functions provided by Brahm Centre Utils in your projects. Here are some examples:

  You can import commonly used functions directly from the package:
  ```python
  from brahm_centre_utils import query_salesforce
  ```


  **query_salesforce**
  This function allows you to query Salesforce data using SOQL (Salesforce Object Query Language).
  ```python
  from brahm_centre_utils import query_salesforce
  from simple_salesforce import Salesforce
  from dotenv import load_dotenv


  sf = Salesforce(
      username=os.getenv('SF_USERNAME'),
      password=os.getenv('SF_PASSWORD'),
      security_token=os.getenv('SF_SECURITY_TOKEN'),
      domain=os.getenv('SF_DOMAIN')
  )


  result = query_salesforce("SELECT Id, Name FROM Account")
  print(result)
  ```


  - brahm_centre_utils.query_salesforce
  - brahm_centre_utils.salesforce.get_Id_from_SF_URL
  - brahm_centre_utils.common.normalize_name
  - brahm_centre_utils.common.are_names_similar
  - brahm_centre_utils.common.get_unique_names


  Brahm Centre Utils requires certain environment variables for Salesforce integration. These should be stored in a .env file in the root of your project.


  ```plaintext
  SF_USERNAME=your_salesforce_username
  SF_PASSWORD=your_salesforce_password
  SF_TOKEN=your_salesforce_security_token
  SF_DOMAIN=your_salesforce_domain
  ```


  1. Update the version number in setup.py.
  2. Rebuild the distribution files:
  ```bash
  python setup.py sdist bdist_wheel
  ```
  3. Upload to PyPI
  ```bash
  twine upload dist/*
  ```


pkgId: 6acd00be49ea8bdbb8012508b61135adfe8856624064553d36711b2dbd80dff8
name: python-braian
arch: src
version: 1.0.2
epoch: 0
release: 1
url: https://silvalab.codeberg.page/BraiAn/
rpm_license: LGPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-braian-1.0.2-1.src.rpm
checksum_type: sha256
summary:
  A python library for easy navigation, visualisation, and analysis of whole-brain quantification data.

description:
  <!--
  SPDX-FileCopyrightText: 2024 Carlo Castoldi <carlo.castoldi@outlook.com>

  SPDX-License-Identifier: CC-BY-4.0
  -->


  [![PyPI - Version](https://img.shields.io/pypi/v/braian)](https://pypi.org/project/braian)
  [![status-badge](https://ci.codeberg.org/api/badges/13585/status.svg)](https://ci.codeberg.org/repos/13585)
  <!--mkdocs-start-->
  <!--install-start-->

  Once you are in an active `python>=3.11,<3.13` environment, you can run:
  ```bash
  python3 -m pip install braian
  ```
  <!--install-end-->


  If you use BraiAn in your work, please cite the paper below, currently in pre-print:

  > Chiaruttini, N., Castoldi, C. et al. **ABBA, a novel tool for whole-brain mapping, reveals brain-wide differences in immediate early genes induction following learning**. _bioRxiv_ (2024).\
  > [https://doi.org/10.1101/2024.09.06.611625](https://doi.org/10.1101/2024.09.06.611625)

  <!--build-start-->


  * [python>=3.11](https://www.python.org/downloads/):
    you can use [conda](https://conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html) or [pyenv](https://github.com/pyenv/pyenv)/[pyenv-win](https://pyenv-win.github.io/pyenv-win/#installation) to manage the correct version

  * [Poetry](https://python-poetry.org/docs/#installation): for dependency management


  Create and activate a new `python>=3.11,<3.13` environment.

  <table border="0">
   <tr>
      <td>
        Using <a href="https://docs.continuum.io/anaconda/"><code>conda</code></a>:</p>
        <pre><code class="language-bash">conda create --name braian_env python=3.11
  conda activate braian_env</code></pre>
      </td>
      <td>
        Using python venv:</p>
        <code class="language-bash">python3.11 -m venv /path/to/new/braian_env</code>
        </p>
        and <a href="https://docs.python.org/3/library/venv.html#how-venvs-work">activate it</a>
      </td>
   </tr>
  </table>


  ```bash
  git clone https://codeberg.org/SilvaLab/BraiAn.git /path/to/BraiAn
  ```


  With the environment set and Poetry installed:
  ```bash
  (braian_env) cd /path/to/BraiAn
  (braian_env) poetry install # --with docs, if building the documentation is of your interest
  ```
  <!--build-end-->
  <!--mkdocs-end-->


pkgId: c2125405e8daa6cbd2b607108363e742ceaefb258d85c36932eea67c1679e536
name: python-brain-isotopic-distribution
arch: src
version: 1.5.17
epoch: 0
release: 1
summary: Fast and efficient theoretical isotopic profile generation
url: https://github.com/mobiusklein/brainpy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brain-isotopic-distribution-1.5.17-1.src.rpm
checksum_type: sha256
description:
  of that implementation, and a pure C implementation that releases the :title-reference:`GIL`.
  To install from a package index, you will need to have a C compiler appropriate to your Python
  version to build these extension modules. Additionally, there are prebuilt wheels for Windows
  available on `PyPI <https://pypi.org/project/brain-isotopic-distribution/>`_:
      $ pip install brain-isotopic-distribution
  To build from source, in addition to a C compiler you will also need to install a recent version
  of `Cython <https://pypi.org/project/Cython/>`_ to transpile C code.


pkgId: 734ff110920e9ee5e18431676ab6ffa6c0df5fde0c2f80c51bcab81d3454a604
name: python-brain-pred-toolbox
arch: src
version: 2.3.2
epoch: 0
release: 1
url: http://github.com/sahahn/BPt
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brain-pred-toolbox-2.3.2-1.src.rpm
checksum_type: sha256
summary:
  The Brain Predictability toolbox (BPt) is a Python based machine learning library designed to work with a range of neuroimaging data. Warning: Not actively maintained as of 11/30/22.

description:
  **Note:** *This library is only tested on python versions 3.7+ so while 3.6 might work, for the most reliable performance please use higher versions of python!*
  The easiest way to install the latest stable release of BPt is via pip, just run
  ```
  pip install brain-pred-toolbox
  ```
  The other method, to get the latest stable development version of the library is to clone this repository,
  and then install it locally with once navigated into the main BPt folder
  ```
  pip install .
  ```

  Load a pre-set BPt dataset, then
  run a default 5-fold cross validation.
  ```
  from BPt.datasets import load_cali
  from BPt import evaluate
  data = load_cali()
  results = evaluate('elastic_pipe', data)
  ```
  The returned object, stored in variable results, is an instance of class [EvalResults](https://sahahn.github.io/BPt/reference/api/BPt.EvalResults.html#BPt.EvalResults), which contains all types of information and metrics from the stored evaluation.
  Check out the documentation at <https://sahahn.github.io/BPt/> for more examples on how to get started using BPt!


pkgId: f921862451c6a670f55f82f53eef894ceb8d5ef79047251a40b53182eb5a261a
name: python-brain-slam
arch: src
version: 0.0.5
epoch: 0
release: 1
summary: Surface anaLysis And Modeling
url: https://github.com/brain-slam/slam
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brain-slam-0.0.5-1.src.rpm
checksum_type: sha256
description:
  <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
  [![All Contributors](https://img.shields.io/badge/all_contributors-4-orange.svg?style=flat-square)](#contributors-)
  <!-- ALL-CONTRIBUTORS-BADGE:END -->

  [![Build Status](https://travis-ci.org/gauzias/slam.svg?branch=master)](https://travis-ci.org/gauzias/slam)
  [![Coverage Status](https://coveralls.io/repos/github/gauzias/slam/badge.svg?branch=master)](https://coveralls.io/github/gauzias/slam?branch=master)

  Slam is an open source python package dedicated to the representation of
  neuroanatomical surfaces stemming from MRI data in the form of triangular meshes and to their processing and analysis.
  Slam is an extension of [Trimesh](https://github.com/mikedh/trimesh), an open source python package dedicated to triangular meshes processing.





     Look at the [doc](https://brain-slam.github.io/slam) for a complete overview of available features!

  + ``io``: read/write gifti (and nifti) file format

  + ``generate_parametric_surfaces``: generation of parametric surfaces with random sampling

  + ``geodesics``: geodesic distance computation using tvb-gdist and networkx

  + ``differential_geometry``: several implementations of graph Laplacian (conformal, authalic, FEM...), texture Gradient

  + ``mapping``: several types of mapping between the mesh and a sphere, a disc...

  + ``distortion``: distortion measures between two meshes, for quantitative analysis of mapping properties

  + ``remeshing``: projection of vertex-level information between two meshes based on their spherical representation

  + ``topology``: mesh surgery (boundary indentification, large hole closing)

  + ``vertex_voronoi``: compute the voronoi of each vertex of a mesh, usefull for numerous applications

  + ``texture``: a class to manage properly vertex-level information.

  + ``plot``: extension of pyglet and visbrain viewers to visualize slam objects





  The very first thing to do before contributing is to read our
  [Code of conduct](CODE_OF_CONDUCT.md).


  We are using a github project to organize the code development and maintenance:
  https://github.com/orgs/brain-slam/projects/1

  If you are interested in contributing, please first have a look at it and contact us by creating a new issue.



  1. [Create an account](https://github.com/) on Github if you do not already have one
  2. Sign in GitHub and fork  the [slam GitHub repository](https://github.com/brain-slam/slam)
  3. We highly recommend to rely on a (conda) virtual environment as provided by miniconda.
   See [miniconda installation instructions](https://docs.conda.io/en/latest/miniconda.html)  if you do not already have one.
   Then create a virtual environment by typing the following lines in a terminal:
    ```
      conda create -q -n slam python=3.8
      conda activate slam
    ```
   This creates an empty conda virtual environment with Python 3.8 and basic packages
    (e.g. pip, setuptools) and make it the default python environment.

  1. Clone your personal slam fork in your current local directory
      ```# replace <username> by your Github login
      git clone https://github.com/<username>/slam
      ```
  2. Perform a full slam installation in editable mode
     ```
      pip install -e .['dev']
     ```
  5. Set upstream repository to keep your clone up-to-date
     ```
      git remote add upstream https://github.com/brain-slam/slam.git
     ```
  You are now ready to modify slam code and submit a pull request


  These dependencies, whether mandatory or optional, are managed automatically and transparently for the user during the installation phase and are listed here for the sake of completeness.


  In order to work fine, slam requires:

  + a Python 3.8 installation

  + setuptools

  + pip

  +  numpy

  +  scipy

  +  cython

  +  trimesh

  +  nibabel






  tvb-gdist is recommended for geodesic distance/shortest paths computations






  All contributions are of course much welcome!
  In addition to the global thank you to all contributors to this project, a special big thanks to:

  . https://github.com/alexpron and https://github.com/davidmeunier79 for their precious help for setting up continuous integration tools.

  . https://github.com/EtienneCmb for his help regarding visualization and Visbrain (https://github.com/EtienneCmb/visbrain).

  . https://github.com/aymanesouani for his implementation of a very nice curvature estimation technique.

  . https://github.com/Anthys for implementing the curvature decomposition and many unitests

  .  to be continued...






  Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tr>
      <td align="center"><a href="https://alexpron.github.io/"><img src="https://avatars0.githubusercontent.com/u/45215023?v=4" width="100px;" alt=""/><br /><sub><b>alexpron</b></sub></a><br /><a href="#maintenance-alexpron" title="Maintenance">🚧</a> <a href="#projectManagement-alexpron" title="Project Management">📆</a> <a href="#ideas-alexpron" title="Ideas, Planning, & Feedback">🤔</a> <a href="https://github.com/gauzias/slam/commits?author=alexpron" title="Code">💻</a></td>
      <td align="center"><a href="https://sites.google.com/site/julienlefevreperso/"><img src="https://avatars2.githubusercontent.com/u/19426328?v=4" width="100px;" alt=""/><br /><sub><b>JulienLefevreMars</b></sub></a><br /><a href="https://github.com/gauzias/slam/commits?author=JulienLefevreMars" title="Code">💻</a> <a href="https://github.com/gauzias/slam/commits?author=JulienLefevreMars" title="Documentation">📖</a> <a href="#example-JulienLefevreMars" title="Examples">💡</a> <a href="#ideas-JulienLefevreMars" title="Ideas, Planning, & Feedback">🤔</a> <a href="https://github.com/gauzias/slam/commits?author=JulienLefevreMars" title="Tests">⚠️</a></td>
      <td align="center"><a href="https://github.com/tianqisong0117"><img src="https://avatars2.githubusercontent.com/u/47243851?v=4" width="100px;" alt=""/><br /><sub><b>Tianqi SONG</b></sub></a><br /><a href="https://github.com/gauzias/slam/commits?author=tianqisong0117" title="Code">💻</a> <a href="#example-tianqisong0117" title="Examples">💡</a> <a href="#ideas-tianqisong0117" title="Ideas, Planning, & Feedback">🤔</a></td>
      <td align="center"><a href="https://github.com/EtienneCmb"><img src="https://avatars3.githubusercontent.com/u/15892073?v=4" width="100px;" alt=""/><br /><sub><b>Etienne Combrisson</b></sub></a><br /><a href="https://github.com/gauzias/slam/commits?author=EtienneCmb" title="Code">💻</a> <a href="#tool-EtienneCmb" title="Tools">🔧</a></td>
    </tr>
  </table>

  <!-- markdownlint-enable -->
  <!-- prettier-ignore-end -->
  <!-- ALL-CONTRIBUTORS-LIST:END -->

  This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!


pkgId: d5fcaa8ba0c043370e7fa78e11e005cb47508c050923975b053f12f1125d8713
name: python-brainbow
arch: src
version: 0.1.11
epoch: 0
release: 1
summary: Script for visualizing ICA/ROI brain parcellation
url: https://github.com/neuroneural/brainbow
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brainbow-0.1.11-1.src.rpm
checksum_type: sha256
description:
  Script for visualizing ICA/ROI brain parcellation
  <img src="https://raw.githubusercontent.com/neuroneural/brainbow/main/.github/images/1.png"/>


  ```
  pip install brainbow
  ```


  ```
  brainbow -n {your_brain_map}.nii
  ```


  - provide a path to nifti map (`-n/--nifti` flag) and anatomical underlay (`-a/--anat` flag, optional)
  - control the output with `--sign`, `--thr`, and `--no-norm` flags
  - to plot only certain components use `-c/--component` flag
  - to set cut coordinates manually use `--cut` flag
  - see below for more info



  - `-n/--nifti`
      - path to the nifti file with 4D ICA map to convert to images (last dimension is components), or
      - path to the nifti file with 3D ROI map to convert to images (int values from 0 to `n_regions`);
      - required
  - `-a/--anat`
      - path to the anatomical image to use as an underlay
      - if none is provided, the MNI 152 template is used as an underlay

  - `-o/--output`
      - name of the output file(s)
      - default - `brainbow-output.png/svg`
      - You can specify the exact extension (`png` or `svg`). If none is provided, files with both extensions will be created
  - `--rich`
      - if `--rich` is passed, in addition to the basic output a config file and a csv file containing cut coordinates is generated
  - `-s/--sign`
      - choices: `pos, neg, both`
      - used for leaving only positive (`pos`), only negative (`neg`), or all values (`both`) in the components
      - ALSO controls the colormap
  - `--thr`
      - threshold value for component significance
      - if component is significant, `thr` is used to mask values: `-thr < value < thr`
      - if all abs values in the component are below `thr`, component won't be visualized
      - default - `0.2`
  - `--no-norm`
      - use to disable data normalization
      - normalization includes:
          - centering around median,
          - divsion by the max abs value, and
          - divsion by the sign (`1 or -1`) of this max abs value
  - `--extend`
      - if passed, in addition to overlay+underlay picture each component \
              will also have a row with separate overlay/underlay
      - helpful for QC
  - `--dpi`
      - dpi for png output
      - default - `150`
  - `--annotate`
      - choices: `none, minimal, full`
      - show components indices (`minimal`), components indices and cut coordinates (`full`), or nothing (`none`) on the output figure
      - default - `minimal`
  - `-c/--components`
      - allows to provide a list of components to plot (e.g., '42 4 2')
      - enumeration starts with 1
  - `--cut`
      - allows to set the cut coordinates manually
      - default behavior is to use the coordinates of the max abs value of each component
      - needs to be either:
          - a path to scv file (like the one created by `--rich` flag), or
          - a comma separated list of 3 cooridnates, which will be used for all components.
      - coordinates order should be RAS+
      - be careful when using with `--components` flag: brainbow assumes that the components order in the csv file correspond to the order of the provided components



  <img src="https://raw.githubusercontent.com/neuroneural/brainbow/main/.github/images/brainbow-output.png"/>


pkgId: 34e679cadac22757b15c6eeabc43ecf6a99a16d7f48e5dbb8f13479a74390d95
name: python-braincube-aws-core
arch: src
version: 0.0.29
epoch: 0
release: 1
summary: Microframework for python aws lambdas
url: https://bitbucket.org/braincube-common/core-aws.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-braincube-aws-core-0.0.29-1.src.rpm
checksum_type: sha256
description:
  Microframework for Python AWS lambdas.

  [![Language](https://img.shields.io/badge/language-Python-blue.svg)](https://www.python.org/)
  [![pypi](https://img.shields.io/pypi/v/braincube-aws-core.svg)](https://pypi.org/project/braincube-aws-core/)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)



  ```bash
  pip install braincube-aws-core
  ```



  - [asyncpg](https://github.com/MagicStack/asyncpg) - A fast PostgreSQL Database Client Library for Python/asyncio.
  - [pydantic](https://github.com/pydantic/pydantic) - Data validation using Python type hints.
  - [pypika](https://github.com/kayak/pypika) - Python Query Builder.



  ```python
  import asyncio

  from uuid import uuid4
  from http import HTTPStatus

  from core.app.data import HTTPRequest, HTTPResponse
  from core.app.app_module import AppModule
  from core.app.app_controller import AppController

  from pydantic import BaseModel


  class AccountDto(BaseModel):
      iban: str
      bban: str


  data = {
      "a0a412d9-87ef-474b-9ac8-b682ec5e0fb3": AccountDto(iban="EUR27100777770209299700", bban="EURC12345612345678"),
      "5ebc25bd-e152-4a70-b251-d68e43be581e": AccountDto(iban="GR27100777770209299700", bban="GRC12345612345678"),
  }

  app = AppController("/accounts")


  @app.get("/{id}")
  async def get_account(request: HTTPRequest) -> HTTPResponse:
      account = data.get(request.path_params["id"])
      return HTTPResponse(HTTPStatus.OK if account else HTTPStatus.NO_CONTENT, account)


  @app.post()
  async def create_account(request: HTTPRequest[AccountDto]) -> HTTPResponse:
      data[uuid4()] = request.body
      return HTTPResponse(HTTPStatus.CREATED)


  loop = asyncio.get_event_loop()

  module = AppModule([app])


  def main(event, context):
      return loop.run_until_complete(module.serve(event, context))
  ```



  ```python
  from core.di.injector import inject
  from core.dal.postgres_connection import get_pool, Pool


  @inject("data_warehouse_pool")
  async def provide_warehouse_pool() -> Pool:
      return await get_pool()


  @inject(qualifier="pool:data_warehouse_pool")
  class BankService:

      def __init__(self, pool: Pool):
          self._pool = pool
  ```



  ```python
  from core.app.data import HTTPRequest
  from core.utils.data import Order, OrderType
  from core.dal.data import Key, Schema, Column, Relation, SimpleColumn, JoinType, JoinThrough, StatementField
  from core.dal.postgres_connection import get_pool, Pool
  from core.dal.postgres_repository import PostgresRepository


  equities = Schema(
      table="equities",
      alias="e",
      primary_key=["id"],
      columns=[
          Column("id", updatable=False, insertable=False),
          Column("name"),
          Column("type"),
          Column("issuer_id", alias="issuerId"),
          Column("industry_sector", alias="industrySector"),
          Column("isin"),
          Column("reference"),
          Column("bloomberg_code", alias="bloombergCode"),
          Column("market_symbol", alias="marketSymbol"),
          Column("currency"),
          Column("country", ),
          Column("min_amount", alias="minAmount"),
      ],
      statement_fields=[
          StatementField("isTypeOne", statement="CASE WHEN e.type = 1 then True else False END")
      ],
      order=[
          Order(type=OrderType.asc, alias="name")
      ],
      relations=[
          Relation(
              table="parties",
              alias="p",
              columns=[
                  SimpleColumn("name"),
                  SimpleColumn("short_name", alias="shortName"),
              ],
              join_forced=False,
              join_type=JoinType.left,
              join_through=JoinThrough(from_column_name="issuer_id", to_column_name="id")
          )
      ]
  )



  class EquitiesRepo(PostgresRepository):

      def __init__(self, pool: Pool):
          super().__init__(pool, equities)




  request = HTTPRequest()

  repo = EquitiesRepo(await get_pool())

  await repo.find_by_pk(Key(request.path_params["id"]), request.query_params.fields)

  await repo.exists_by_pk(Key("9448a57b-f686-4935-b152-566baab712db"))

  await repo.find_one(
      request.query_params.fields,
      conditions=request.query_params.conditions,
      order=request.query_params.order)

  await repo.find_all(
      request.query_params.fields,
      conditions=request.query_params.conditions,
      order=request.query_params.order)

  await repo.find_all_by_pk(
      [
          Key("9448a57b-f686-4935-b152-566baab712db"),
          Key("43c8ec37-9a59-44eb-be90-def391ba2f02")
      ],
      aliases=request.query_params.fields,
      order=request.query_params.order)

  await repo.find_many(
      request.query_params.fields,
      conditions=request.query_params.conditions,
      page=request.query_params.page,
      order=request.query_params.order)

  await repo.insert({
      "name": "Bursa de Valori Bucuresti SA",
      "type": 1,
      "industrySector": 40,
      "isin": "ROBVBAACNOR0",
      "bloombergCode": "BBG000BBWMC5",
      "marketSymbol": "BVB RO Equity",
      "currency": "RON",
      "country": "RO",
  })

  await repo.insert_bulk(
      aliases=["name", "type", "industrySector", "isin", "bloombergCode", "marketSymbol", "currency", "country"],
      data=[
          ["Bursa de Valori Bucuresti SA", 1, 40, "ROBVBAACNOR0", "BBG000BBWMC5", "BVB RO Equity", "RON", "RO"],
          ["Citigroup Inc", 1, 40, "US1729674242", "BBG000FY4S11", "C US Equity", "USD", "US"],
          ["Coca-Cola HBC AG", 1, 49, "CH0198251305", "BBG004HJV2T1", "EEE GA Equity", "EUR", "GR"],
      ]
  )

  await repo.update({
      "type": 1,
      "isin": 40,
  }, request.query_params.conditions, request.query_params.fields)

  await repo.update_by_pk(Key("9448a57b-f686-4935-b152-566baab712db"), {
      "type": 1,
      "isin": 40
  })

  await repo.delete(request.query_params.conditions, ["id", "name", "type"])

  await repo.delete_by_pk(Key("9448a57b-f686-4935-b152-566baab712db"), ["id", "name", "type"])

  await repo.fetch("SELECT * FROM equities WHERE type = $1 and isin = $2", [1, "TREEGYO00017"])

  await repo.fetch_one("SELECT * FROM equities WHERE id = $1", ["2b67122a-f47e-41b1-b7f7-53be5ca381a0"])

  await repo.execute("DELETE FROM equities WHERE id = $1", ["2b67122a-f47e-41b1-b7f7-53be5ca381a0"])
  ```



  ```
  fields=name, type, industrySector, isin, bloombergCode, parties_name, parties_shortName
  type=1
  isin=range(40, 49)
  id=any(9448a57b-f686-4935-b152-566baab712db, 43c8ec37-9a59-44eb-be90-def391ba2f02)
  page_no=1
  page_size=50
  top_size=50
  order=name, id DESC
  ```



  To use the SAM CLI, you need the following tools.

  * [SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html)
  * [Python 3](https://www.python.org/downloads/)
  * [Docker](https://hub.docker.com/search/?type=edition&offering=community)



  ```bash

  sudo sh ssh_tunnel_Analog_JBox.sh

  sam-api$ sam build

  sam-api$ sam local start-api --warm-containers EAGER

  sam-api$ sam local invoke ApiFunction --event events/event.json
  ```



  ```bash
  sam build --use-container
  sam deploy --capabilities CAPABILITY_NAMED_IAM --guided --profile analog_user --region eu-west-1
  ```



  ```bash
  python3 -m pip install --upgrade pip
  python3 -m pip install --upgrade build
  python3 -m pip install --upgrade twine
  ```

  ```bash
  python3 -m build
  twine upload --skip-existing dist/*
  ```



  * [SAM template.yml](https://github.com/aws/serverless-application-model/blob/master/docs/internals/generated_resources.rst)
  * [asyncpg driver](https://magicstack.github.io/asyncpg/current/)
  * [PyPika query builder](https://pypika.readthedocs.io/en/latest/)
  * [Pydantic](https://docs.pydantic.dev/)


pkgId: de4c8cca5c025932f6d2ae523a3845f65aaffb2156d8450590ae9e610fc3e51c
name: python-braincube-aws-core-alpha
arch: src
version: 0.0.31
epoch: 0
release: 1
summary: Microframework for python aws lambdas
url: https://bitbucket.org/braincube-common/core-aws.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-braincube-aws-core-alpha-0.0.31-1.src.rpm
checksum_type: sha256
description:
  Microframework for Python AWS lambdas.

  [![Language](https://img.shields.io/badge/language-Python-blue.svg)](https://www.python.org/)
  [![pypi](https://img.shields.io/pypi/v/braincube-aws-core-alpha.svg)](https://pypi.org/project/braincube-aws-core-alpha/)
  [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)



  ```bash
  pip install braincube-aws-core-alpha
  ```



  - [asyncpg](https://github.com/MagicStack/asyncpg) - A fast PostgreSQL Database Client Library for Python/asyncio.
  - [pydantic](https://github.com/pydantic/pydantic) - Data validation using Python type hints.
  - [pypika](https://github.com/kayak/pypika) - Python Query Builder.



  ```python
  import asyncio

  from uuid import uuid4
  from http import HTTPStatus

  from core.rest.data import HTTPRequest, HTTPResponse
  from core.rest.app_module import AppModule
  from core.rest.app_controller import AppController

  from pydantic import BaseModel


  class AccountDto(BaseModel):
      iban: str
      bban: str


  data = {
      "a0a412d9-87ef-474b-9ac8-b682ec5e0fb3": AccountDto(iban="EUR27100777770209299700", bban="EURC12345612345678"),
      "5ebc25bd-e152-4a70-b251-d68e43be581e": AccountDto(iban="GR27100777770209299700", bban="GRC12345612345678"),
  }

  app = AppController("/accounts")


  @app.get("/{id}")
  async def get_account(request: HTTPRequest) -> HTTPResponse:
      account = data.get(request.path_parameters["id"])
      return HTTPResponse(HTTPStatus.OK if account else HTTPStatus.NO_CONTENT, account)


  @app.post()
  async def create_account(request: HTTPRequest[AccountDto]) -> HTTPResponse:
      data[uuid4()] = request.body
      return HTTPResponse(HTTPStatus.CREATED)


  loop = asyncio.get_event_loop()

  module = AppModule([app])


  def main(event, context):
      return loop.run_until_complete(module.serve(event, context))
  ```



  ```python
  from core.di.injector import inject
  from core.dal.postgres_connection import get_pool, Pool


  @inject("data_warehouse_pool")
  async def provide_warehouse_pool() -> Pool:
      return await get_pool()


  @inject(qualifier="pool:data_warehouse_pool")
  class BankService:

      def __init__(self, pool: Pool):
          self._pool = pool
  ```



  ```python
  from core.rest.data import HTTPRequest
  from core.utils.data import Order, OrderType
  from core.dal.data import Key, Schema, Column, Relation, SimpleColumn, JoinType, JoinThrough, StatementField
  from core.dal.postgres_connection import get_pool, Pool
  from core.dal.postgres_repository import PostgresRepository


  equities = Schema(
      table="equities",
      alias="e",
      primary_key=["id"],
      columns=[
          Column("id", updatable=False, insertable=False),
          Column("name"),
          Column("type"),
          Column("issuer_id", alias="issuerId"),
          Column("industry_sector", alias="industrySector"),
          Column("isin"),
          Column("reference"),
          Column("bloomberg_code", alias="bloombergCode"),
          Column("market_symbol", alias="marketSymbol"),
          Column("currency"),
          Column("country", ),
          Column("min_amount", alias="minAmount"),
      ],
      statement_fields=[
          StatementField("isTypeOne", statement="CASE WHEN e.type = 1 then True else False END")
      ],
      order=[
          Order(type=OrderType.asc, alias="name")
      ],
      relations=[
          Relation(
              table="parties",
              alias="p",
              columns=[
                  SimpleColumn("name"),
                  SimpleColumn("short_name", alias="shortName"),
              ],
              join_forced=False,
              join_type=JoinType.left,
              join_through=JoinThrough(from_column_name="issuer_id", to_column_name="id")
          )
      ]
  )



  class EquitiesRepo(PostgresRepository):

      def __init__(self, pool: Pool):
          super().__init__(pool, equities)




  request = HTTPRequest()

  repo = EquitiesRepo(await get_pool())

  await repo.find_by_pk(Key(request.path_parameters["id"]), request.query_parameters.fields)

  await repo.exists_by_pk(Key("9448a57b-f686-4935-b152-566baab712db"))

  await repo.find_one(
      request.query_parameters.fields,
      conditions=request.query_parameters.conditions,
      order=request.query_parameters.order)

  await repo.find_all(
      request.query_parameters.fields,
      conditions=request.query_parameters.conditions,
      order=request.query_parameters.order)

  await repo.find_all_by_pk(
      [
          Key("9448a57b-f686-4935-b152-566baab712db"),
          Key("43c8ec37-9a59-44eb-be90-def391ba2f02")
      ],
      aliases=request.query_parameters.fields,
      order=request.query_parameters.order)

  await repo.find_many(
      request.query_parameters.fields,
      conditions=request.query_parameters.conditions,
      page=request.query_parameters.page,
      order=request.query_parameters.order)

  await repo.insert({
      "name": "Bursa de Valori Bucuresti SA",
      "type": 1,
      "industrySector": 40,
      "isin": "ROBVBAACNOR0",
      "bloombergCode": "BBG000BBWMC5",
      "marketSymbol": "BVB RO Equity",
      "currency": "RON",
      "country": "RO",
  })

  await repo.insert_bulk(
      aliases=["name", "type", "industrySector", "isin", "bloombergCode", "marketSymbol", "currency", "country"],
      data=[
          ["Bursa de Valori Bucuresti SA", 1, 40, "ROBVBAACNOR0", "BBG000BBWMC5", "BVB RO Equity", "RON", "RO"],
          ["Citigroup Inc", 1, 40, "US1729674242", "BBG000FY4S11", "C US Equity", "USD", "US"],
          ["Coca-Cola HBC AG", 1, 49, "CH0198251305", "BBG004HJV2T1", "EEE GA Equity", "EUR", "GR"],
      ]
  )

  await repo.update({
      "type": 1,
      "isin": 40,
  }, request.query_parameters.conditions, request.query_parameters.fields)

  await repo.update_by_pk(Key("9448a57b-f686-4935-b152-566baab712db"), {
      "type": 1,
      "isin": 40
  })

  await repo.delete(request.query_parameters.conditions, ["id", "name", "type"])

  await repo.delete_by_pk(Key("9448a57b-f686-4935-b152-566baab712db"), ["id", "name", "type"])

  await repo.fetch("SELECT * FROM equities WHERE type = $1 and isin = $2", [1, "TREEGYO00017"])

  await repo.fetch_one("SELECT * FROM equities WHERE id = $1", ["2b67122a-f47e-41b1-b7f7-53be5ca381a0"])

  await repo.execute("DELETE FROM equities WHERE id = $1", ["2b67122a-f47e-41b1-b7f7-53be5ca381a0"])
  ```



  ```
  fields=name, type, industrySector, isin, bloombergCode, parties_name, parties_shortName
  type=1
  isin=range(40, 49)
  id=any(9448a57b-f686-4935-b152-566baab712db, 43c8ec37-9a59-44eb-be90-def391ba2f02)
  page_no=1
  page_size=50
  top_size=50
  order=name, id DESC
  ```



  To use the SAM CLI, you need the following tools.

  * [SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html)
  * [Python 3](https://www.python.org/downloads/)
  * [Docker](https://hub.docker.com/search/?type=edition&offering=community)



  ```bash

  sudo sh ssh_tunnel_Analog_JBox.sh

  sam-api$ sam build

  sam-api$ sam local start-api --warm-containers EAGER

  sam-api$ sam local invoke ApiFunction --event events/event.json
  ```



  ```bash
  sam build --use-container
  sam deploy --capabilities CAPABILITY_NAMED_IAM --guided --profile analog_user --region eu-west-1
  ```



  ```bash
  python3 -m pip install --upgrade pip
  python3 -m pip install --upgrade build
  python3 -m pip install --upgrade twine
  ```

  ```bash
  python3 -m build
  twine upload --skip-existing dist/*
  ```



  * [SAM template.yml](https://github.com/aws/serverless-application-model/blob/master/docs/internals/generated_resources.rst)
  * [asyncpg driver](https://magicstack.github.io/asyncpg/current/)
  * [PyPika query builder](https://pypika.readthedocs.io/en/latest/)
  * [Pydantic](https://docs.pydantic.dev/)


pkgId: 72053196d8156bfba402b6598ac4ede925e0d20a7118aab8443e90bb11ee78b0
name: python-braincube-connector
arch: src
version: 2.6.0
epoch: 0
release: 1
summary: python client to the braincube web services
url: https://braincube-io.github.io/python-connector/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-braincube-connector-2.6.0-1.src.rpm
checksum_type: sha256
description:
  The python package `braincube_connector` provides a tool for datascientists to access their data on Braincube directly from python.



  Install with pip:

  ```bash
  pip install braincube_connector
  ```



  Since version `2.2.0`, the authentication uses a personal access token (PAT).

  In order to create a PAT, you need to go in your braincube personal `menu > Account > Access tokens > +/Add`

  The scopes of the token should include `BRAINCUBE` and `SSO_READ`.

  Then two options exist to pass the PAT to the braincube_connector:
   1. Using a configuration dictionary when creating a client:
  ```python
  from braincube_connector import client

  client.get_instance(config_dict={"api_key":"<my_personal_access_token>", "domain":"mybraincube.com"})
  ```
   2. Using a configuration file:
   ```python
   from braincube_connector import client

   client.get_instance("config_file"="myfile.json")
   ```
   *myfile.json*
   ```json
   {"api_key":"<my_personal_access_token>", "domain":"mybraincube.com"}
   ```



  The *braincube_connector* used to support only this type of authentication. This is not the method we encourage
  the most since the PAT is available, because the Oauth2 is obtained with the [braincube-token-getter](https://pypi.org/project/braincube-token-getter/) that is not under active development.
  However if you still want to use this method, you need to setup the configuration file (or dictionary) as follows:
  `config.json`

  ```json
  {
      "client_id": "app id",
      "client_secret": "app key",
      "domain": "mybraincube.com",
      "verify": true,
      "oauth2_token": "token value"
  }
  ```

  By default the connector searches for a PAT and uses the oauth2_token when the PAT is not present in the dictionary.



  Here is a list of the settings available in the configuration file:

  - `domain`(optional if `sso_base_url` and `braincube_base_url` exist): The domain of the braincube to access.
  - `sso_base_url`(optional if `domain` exists): The base URL of the SSO used to check the validity of your access token.
  - `braincube_base_url`(optional if `domain` exists): The base URL of the Braincube API used to fetch data from.
  - `api_key`(optional if `oauth2_token` exists): a personal access token generated in the braincube account configuration.
  - `oauth2_token`(optional if `api_key` exists): an OAuth2 token obtained with the [braincube-token-getter](https://pypi.org/project/braincube-token-getter/). Used only when `api_key` does not exist.
  - `verify`(optional, default is `True`): If `False`, the requests do not verify the SSL certificate.
  > Setting `verify` to false must be used with care, it's a security threat (see [requests documentation](https://requests.readthedocs.io/en/latest/api/#requests.Session.verify)

  The `client_id`,  `client_secret` from the last section are used only by the *braincube_token_getter* when requesting a new OAuth token.


  If the client is not initialized manually or if no configuration is passed to `get_instance`, the package creates a client instance from one of these two files `./config.json`  or `~/.braincube/config.json` (in this priority order) when they exist.







  A client can be inialized manually from a custom configuration file.

  ```python
  from braincube_connector import client

  client.get_instance(config_file="pathto/config.json")
  ```

  **Note:** If the client is not initialized manually, the package creates a client instance from one of these two files `./config.json`  or `~/.braincube/config.json` (in this priority order) if they exist.



  The connector gives access to different entities(described in more details in the following sections) that share multiple methods:

  - `<entity>.get_name()`: Returns the name of the entity.
  - `<entity>.get_bcid()`: Returns the bcId identifier of the entity.
  - `<entity>.get_uuid()`: Returns the braincube unique uuid identifier of the entity.


  To obtain a list of all the available `Braincube` entities with a client:
  ```python
  from braincube_connector import braincube

  braincube.get_braincube_list()
  ```

  Or to select a specific `Braincube` entity from its name:
  ```python
  bc = braincube.get_braincube("demo")
  ```



  The list of all the memory bases available within a `Braincube` is obtained with

  ```python
  mb_list = bc.get_memory_base_list()
  ```

  **Note:** The number of memory bases in a braincube can be numerous,  hence `get_memory_base_list` allows paginated requests `bc.get_memory_base_list(page=0)`

  To select a unique memory base, go with its bcId:

  ```python
  mb = bc.get_memory_base(20)
  ```




  The variable description are linked to a memory base.

  ```python
  var_desc = mb.get_variable(bcid="2000034")
  ```

  For multiple variable descriptions:

  ```python
  mb.get_variable_list(page=0)
  ```

  **Note:** Similarly to memory bases, providing no argument to `get_variable_list` retrieves all the descriptions available in the memory base.

  The type of variable is obtained with the function `get_type`

  ```python
  var_desc.get_type()
  ```


  DataGroup are obtained from a memory base:
  ```python
  datagroup = mb.get_datagroup(bcid="10")
  ```
  The list of the available datagroups can also be obtained with `mb.get_datagroup_list()`.

  A datagroup is a container that includes multiple variables. They are accessed with
  ```python
  datagroup.get_variable_ids() # Gets the variable bcIds
  datagroup.get_variable_list() # Gets the list of VariableDescription objects.
  ```


  An event is a predifined set of conditions in braincube. It is accessed as follows:
  ```python
  event = mb.get_event(bcid="10")
  event_list = mb.get_event_list()
  ```

  The interest of events is that you can access the conditions they contain in order create new [filters](#data-filters) for a `get_data` function:

  ```python
  event.get_conditions()
  ```



  The job desciption contains the settings used to build an analysis and gives a proxy to access these parameters easily. A JobDescription is obtained from a memory base as follows:

  ```python
  job_desc = mb.get_job(bcid="573")
  job_list = mb.get_job_list(page=0)
  ```

  The properties are acced with the following methods:

  - **get_conditions:**
    Gets a list of the conditions used to select the job variables.
    ```python
    job_desc.get_conditions()
    job_desc.get_conditions(combine=True) # Merge the conditions into one
    job_desc.get_conditions(include_events=True) # Includes the conditions from
                                                 
    ```

  - **get_variable_ids:**
    Gets a list of the variables involved in the job, including the target variables and the influence variables.
    ```python
    job_desc.get_variable_ids()
    ```

  - **get_events:**
    Gets a list of the event objects used by the job.
    ```python
    job_desc.get_events()
    ```
  - **get_categories:**
    Gets a list of conditions used to categorise a job's data as *good* or *bad*. You may have a *middle* category, it's an old categorisation which will not be used anymore.
    ```python
    job_desc.get_categories()
    ```

  - **get_data:**
    When a job is created on braincube, a separate copy of the data is made. As for now this copy is not available from the webservices. However the `get_data` method collects the job's data from the memory base using the same filters as when the job was created. Be aware that these data might be different from the job's data if the memory base has been updated since the job creation.

    Similarly to other object `get_data`, a `filters` parameter is available to add additional [filters](#data-filters) to the job's conditions.

    ```python
    job_desc.get_data()
    ```


  The job rule descriptions are obtained with the methods `get_rule` or `get_rule_list` either from a job or a memory base. The only difference being that in the case of a memory base `get_rule_list` gets all the rules existing in the memory base whereas for a job, it gets the rules specific to the job under consideration.

  ```python
  rule = job.get_rule(bcid="200")
  rule_list = job.get_rule_list()
  ```

  To access a `RuleDescription` object's metadata, you can calle the `get_metadata` function
  ```python
  rule.get_metadata()
  ```




  A memory base can also request the data for a custom set of variable ids. Adding [filters](#data-filters) restricts the returned data to a desired subset of the data. The method is called as follows:
  ```python
  data = mb.get_data(["2000001", "2000034"], filters=my_filters, label_type="name", dataframe=True)
  ```

  The output format is a dictionary or a pandas DataFrame when the `dataframe` parameter is set to `True`. The keys/column labels are the variable bcIds or names depending on whether `label_type` is set to `"bcid"` or `"name"` respectively.

  **Note:** By default the dates are not parsed to `datetime` objects in order to speed up the `get_data` function but it is possible to enable the parsing:
  ```python
  from braincube_connector import parameters
  parameters.set_parameter({"parse_date": True})
  ```


  The `get_data` methods have the option to restrict the data that are collected by using a set of filters. The `filters` parameter must be a list conditions (even for a single condition):
  ```python
  object.get_data(filters=[{"BETWEEN": ["mb20/d2000002",0,10]},{"BETWEEN": ["mb20/d2000003", -1, 1]}])
  ```

  Here is a selection of the most common types of filters:
  - **Equals to**
    Selects data when a variable is equal to
    ```json
    {
      "EQUALS": [ "mb20/d2000002", 2.0]
    }
    ```
  - **Between**
    Selects the data when a variable belongs to a range.
    ```json
    {
      "BETWEEN": [ "mb20/d2000003", -1, 1]
    }
    ```
  - **Lower than**
    Selects the data when a variable is lower than a certain value.
    ```json
    {
      "LESS": [ "mb20/d2000003", 10]
    }
    ```
    **Note:** The `LESS_EQUALS` filter also exists.


  - **Greater than**
    Selects the data when a variable is greater than a certain value.
    ```json
    {
      "GREAT": [ "mb20/d2000003", 10]
    }
    ```
    **Note:** The `GREAT_EQUALS` filter also exists.

  - **Not:**
    The `NOT` condition creates the opposite of an existing condition.
    ```json
    {
      "Not": [{"filter":...}]
    }
    ```

  - **And gate**
    It is possible to combine filters using a *and* gate.
    ```json
    {
      "AND": [{"filter1":...}, {"filter2":...}]
    }
    ```
    **Notes:**
      - A `AND` filter can only host two conditions. In order to join more than two filters multiple `AND` conditions should be nested one into another.
      - When multiple filters are provided in the `get_data`'s `filters` parameters, they are joined together within the function using `AND` gates.

  - **Or gate:**
    Similar to `AND` but uses a `OR` gate.
    ```json
    {
      "OR": [{"filter1":...}, {"filter2":...}]
    }
    ```


  The *braincube_connector* provides a simple interface for the most common features of the *braincube web-services* or *braindata* but it is not extensive.

  If you need to access an endpoint of [*braincube webservices*](https://braincube.io/ws-doc/?urls.primaryName=Braincube%20WS) or [*braindata*](https://braincube.io/ws-doc/?urls.primaryName=Braindata%20WS), the `request_ws` function of the library can help you. The function uses the configuration passed to the client creation to manage the authentication.

  ```python
  from braincube_connector import client

  client.get_instance(config_dict={...})
  json_result = client.request_ws("braincube/demo/braindata/mb20/simple")
  ```

  Most braincube requests return a json, but for a few of them it might be better to deactivate the parsing by setting the `response_as_json` parameter to `False`. In the latter case, `request_ws` returns the response object.

  ```python
  json_result = client.request_ws("braincube/demo/braindata/mb20/simple", response_as_json=False)
  ```


  The library parameters can be set to custom values:

  ```python
  from braincube_connector import parameters


  parameters.set_parameter({"page_size": 10})


  parameters.set_parameter({"parse_date": True})



  parameters.set_parameter(({"VariableDescription_name_key": "tag"}))
  ```


pkgId: d34525f832fa2315098e0f70a4e3e88a69be97e66b8281af682e26d7c840a62c
name: python-braindead
arch: src
version: 0.3.13
epoch: 0
release: 1
url: https://grski.pl/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-braindead-0.3.13-1.src.rpm
checksum_type: sha256
summary:
  Braindead is a braindead simple static site generator for minimalists, that has support for markdown and code highlighting.

description:
  Braindead is a braindead simple static site generator for minimalists, that has support for markdown and code highlighting.
  I created this package simply to have a bit of fun and because I'm tired of bloated software.

  You can read more about the idea behind it on [medium](https://medium.com/thirty3hq/how-i-created-my-blogging-system-in-less-than-100-lines-of-code-to-save-the-environment-dd848cc29c02) or [my blog](https://grski.pl/posts/python/creating-braindead.html)

  Can't we just have [simple software nowadays](https://tonsky.me/blog/disenchantment/) that does what it needs to do and nothing more?
  Existing solutions felt like they are too much for my needs. So I built this thing. It's still under active development.

  Live example: [grski.pl](https://grski.pl/)

  One of my main ideals here is to create template that is as fast as it gets. Generated pages take around 10-15 KB in total.
  No JavaScript used here, at least in the base template. Just css/html.

  You are free to change that though by creating your own templates. More on that below.

  Benefits of simple approach:

  ![Google PageSpeed Insights withh 100 score](https://imgur.com/7IwldRE.png)
  ![requests made if loading this template](https://imgur.com/GmYcP08.png)

  Default template scores 100/100 on Google PageSpeed Insights and has very fast load times.

  Default template design looks like this:

  ![Default template of braindead](https://imgur.com/oPdgdvW.png)
  It's based on: [Kiss template](https://github.com/ribice), slightly modified - with minimized styles. In the future I'll probably slim them down even more.

  It's also eco friendly - it uses less power by not being a bloatware. [CarbonReport of the demo](https://www.websitecarbon.com/website/grski-pl/)
  ![Carbon report of the grski.pl blog](https://imgur.com/cfQJqQgl.png)

  ```
  pip install braindead
  ```
  [PyPi page](https://pypi.org/project/braindead/)


  Create `index.md` and run `braindead run` that's it. You'll find your generated site in `dist` directory and the site being served at `localhost:1644`.
  To get more context/help and available commands run `braindead` or `braindead help`.

  Known commands so far: `run`, `build`, `serve`.

  It can be empty or not - your choice. If you want index  to contain just the posts - leave it empty.

  That's the minimal setup you need. That'll generate index.html for you, but well, it's not enough, right?
  More robust structure you can use is:
  ```bash
  pages/
    page.md
  posts/
    post.md
  index.md
  pyproject.toml
  ```

  The url for generated html will be `{DIR_LOCATION}/{FILENAME}.html`,
   so url generated will be `{config.base_url}/{DIR_LOCATION}/{FILENAME}.html` in order to change that, add
  ```markdown
  Slug: custom-location
  ```
  To your post/page header - then the location will be `{BASE_URL}/{SLUG}.html`



  ```markdown
  Title: Title of the post or of the page
  Date: 2018-03-22
  Authors: Olaf Górski
  Description: Description of the post/page. If not provided it'll default to first 140 chars of the content.

  CONTENT GOES HERE...
  ```

  All of the metadata used here will be available during given page rendering. You can add more keys and metadata if you'd like.



  All of the variables that are used to generate the page can be overwritten by creating `pyproject.toml` file, but it's not required to get started.
  Example of your `pyproject` `tool.braindead.site` section (these are also the defaults):

  ```toml
  [tool.braindead.site]
  base_url = "" # give full url ending with slash here - eg. if you host your blog on https://grski.pl/ enter it there.
  author = "Olaf Górski"  # author/owner of the site <- will be appended to the title
  title = "Site generated with braindead"  # base title of the website
  description = "Just a description of site generated in braindead"  # description used in the meta tags
  content = ""  # this will display under heading
  name = "braindeadsite" # og tags
  logo = "logo_url"  # url to the logo for og tags
  heading = "Braindead Example"  # heading at the top of the site
  github = "https://github.com/grski"  # link to your github
  linkedin = "https://linkedin.com/in/olafgorski"  # link to your li
  copy_text = "Olaf Górski"  # copy text in the footer
  copy_link = "https://grski.pl"  # and copy link of the footer
  language = "en"  # default language set in the top level html lang property
  just_titles = 0  # if set to 1 the index page will only display titles without descriptions on default template
  ```

  None of these are required. You can overwrite none, one or more. Your choice.


  Just do
  <pre>
  ```python
  Your code here
  ```</pre>

  [List of languages supported by pygments can be found here.](https://pygments.org/languages/)


  TODO


  This bases on
  [toml](https://github.com/uiri/toml),
  [markdown](https://github.com/Python-Markdown/markdown) and [jinja2](https://github.com/pallets/jinja).

  Toml is used for configuration.
  Markdown to render all the .md and .markdows into proper html.
  Lastly jinja2 to add some contexts here and there.

  Formatting of the code is done using [black](https://github.com/psf/black), [isort](https://github.com/timothycrosley/isort).
  [flake8](https://gitlab.com/pycqa/flake8), [autoflake](https://github.com/myint/autoflake) and [bandit](https://github.com/PyCQA/bandit/) to check for potential vulns.

  Versioning is done with [bumpversion](https://github.com/peritus/bumpversion).
  Patch for merges to develop, minor for merged to master. Merge to master means release to pypi.

  And wonderful [poetry](https://github.com/python-poetry/poetry) as dependency manager. BTW pipenv should die.

  Code highligthing is done with [pygments](https://github.com/pygments/pygments).

  CLI is done with [cleo](https://github.com/sdispater/cleo)

  I use type hinting where it's possible.

  To start developing you need to install poetry
  `pip install poetry==0.1.0` and then just `poetry install`.


  ```bash
  flake
  isort
  isort-inplace
  bandit
  black
  linters
  bumpversion
  black-inplace
  autoflake-inplace
  format-inplace
  ```
  Most important ones are `make linters` and `make format-inplace`. Before each commit it's required to run these checks.


  MIT


pkgId: be82f68a9600d53c10d3af13cf5188e97a860e73ee92e468aa1f4e71666e089d
name: python-braindecode
arch: src
version: 0.8.1
epoch: 0
release: 1
summary: Deep learning software to decode EEG, ECG or MEG signals
url: https://pypi.org/project/braindecode/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-braindecode-0.8.1-1.src.rpm
checksum_type: sha256
description:
  Braindecode is an open-source Python toolbox for decoding raw electrophysiological brain
  data with deep learning models. It includes dataset fetchers, data preprocessing and
  visualization tools, as well as implementations of several deep learning
  architectures and data augmentations for analysis of EEG, ECoG and MEG.
  For neuroscientists who want to work with deep learning and
  deep learning researchers who want to work with neurophysiological data.


pkgId: 0a953e438958e52f4705a70dd14e22dafea8c53297470c34c0cc9e1abfd39e87
name: python-brainglobe-atlasapi
arch: src
version: 2.0.10
epoch: 0
release: 1
summary: A lightweight python module to interact with and generate atlases for systems neuroscience.
url: https://brainglobe.info/documentation/brainglobe-atlasapi/index.html
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brainglobe-atlasapi-2.0.10-1.src.rpm
checksum_type: sha256
description:
  For full instructions to add a new BrainGlobe atlas, please see [here](https://brainglobe.info/documentation/brainglobe-atlasapi/adding-a-new-atlas.html).
  The `brainglobe_atlasapi.atlas_generation` submodule contains code for the generation of cleaned-up data, for the main `brainglobe_atlasapi` module.
  This code was previously the `bg-atlasgen` module.

  1. Fork this repo
  2. Clone your repo
  3. Run `git clone https://github.com/brainglobe/brainglobe-atlasapi`
  4. Install an editable version of the package; by running `pip install -e .` within the cloned directory
  5. Create a script to package your atlas, and place into `brainglobe_atlasapi/atlas_generation/atlas_scripts`. Please see other scripts for examples.
  Your script should contain everything required to run.
  The raw data should be hosted on a publicly accessible repository so that anyone can run the script to recreate the atlas.
  If you need to add any dependencies, please add them as an extra in the `pyproject.toml` file, e.g.:
  ```python
  [project.optional-dependencies]
  allenmouse = ["allensdk"]
  newatlas = ["dependency_1", "dependency_2"]
  ```

rpm_license:
  BSD 3-Clause License  Copyright (c) 2020, BrainGlobe All rights reserved.  Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:  - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. - Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


pkgId: 46e35faf022f8f0b8c914dc6410214af3f7446b8ccaecbb40f27a9ee3104dbb6
name: python-brainglobe-ccf-translator
arch: src
version: 0.21
epoch: 0
release: 1
summary: a package to translate data between common coordinate frameworks
url: https://github.com/brainglobe/brainglobe-ccf-translator
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brainglobe-ccf-translator-0.21-1.src.rpm
checksum_type: sha256
description:
  ![PyPI - Version](https://img.shields.io/pypi/v/CCF-translator)

  CCF translator (brainglobe-ccf-translator) is a tool for translating between common coordinate frameworks using deformation matrices.
  A longstanding problem in NeuroInformatics has been the inability to easily translate data between common coordinate frameworks. CCF translator aims to solve this. By connecting each new space to an existing one, we can construct a graph of deformations. This means that data can be translated as long as there is a route from one space to another, even if that route passes through multiple other spaces. Now, when new templates for new modalities, strains, or ages are released, users will not be subdivided into unrelated spaces. As long as they are connected to a space which exists in our network, they will be fully connected to all other spaces.

  CCF translator can also interpolate between spaces and create a new intermediate space. This is primarily useful for development, where, for instance, the midpoint between day 5 and day 7 can be taken and used as a postnatal day 6 reference. It could also be useful for making references of disease progression.

  ![a graph of all the available spaces and how they are connected. the spaces are nodes with the space name written on top of them, the edges show which spaces are connected to which other spaces.](https://raw.githubusercontent.com/brainglobe/brainglobe-ccf-translator/main/media/graph.png)

  One way you can use CCF translator is to view data from one space, in another space. For instance the allen connectivity dataset shows projections from viral tracing studies in the adult brain. We can take any of these projection datasets and view them in the developing brain, for instance post natal day 9.
  ![an image which shows a viral tracing study overlaid on the allen adult ccfv3 template. it shows that same viral tracing data transformed and overlaid on a post natal day 9 template. between the two images is an arrow pointing from the adult to the post natal day 9 brain, above which is text saying CCF translator, implying that CCF translator was used to transform the data from adult to post natal day 9.](https://raw.githubusercontent.com/brainglobe/brainglobe-ccf-translator/main/media/allen_connectivity_transform.png)

  CCF translator can be installed by running
  ```
  pip install brainglobe-ccf-translator
  ```

  the name in CCF translator aims to copy the name of atlases in the brainglobe_atlasapi when possible.
  | Framework Name | name in api | supported age range
  | -------------- | ----------- | -----------
  | Allen mouse CCFv3 | allen_mouse | 56
  | Demba developmental mouse | demba_dev_mouse| 4-56
  | Gubra lightsheet mouse | perens_lsfm_mouse| 56
  | Gubra MRI mouse | perens_mri_mouse| 56
  | Gubra STPT mouse | perens_stpt_mouse| 56
  | Princeton lighsheet mouse | princeton_mouse| 56

  **Transforming points**
  To take a coordinate in one volume and find the equivalent coordinate in a second volume is quite simple in CCF translator.
  ```python
  import numpy as np
  import brainglobe_ccf_translator

  points = np.array([(286,250,267), (414,247,452)])
  pset = brainglobe_ccf_translator.PointSet(points, 'demba_dev_mouse', voxel_size_micron=20, age_PND=56)
  pset.transform(target_age=56, target_space='allen_mouse')
  print(f"new points are {pset.values}")

  ```
  ```
  new points are [[267 250 286] [452 247 414]]
   ```
  **Transforming volumes**

  To run the volume examples you will want to install brainglobe-atlasapi using the following
  ```
  pip install brainglobe-atlasapi
  ```

  Transforming a volume is equally simple, here we get the volume from the brainglobe api, but you can load it however you like. In the Demba space the valid ages are from 4 to 56, and all of these are valid targets for transformation.
  ```python
  from brainglobe_atlasapi.bg_atlas import BrainGlobeAtlas
  import brainglobe_ccf_translator


  voxel_size_micron = 10
  space_name = r"allen_mouse"
  atlas = BrainGlobeAtlas("{space_name}_{voxel_size_micron}um")
  source_age = 56
  target_age= 32

  ccft_vol = brainglobe_ccf_translator.Volume(
      values = atlas.reference,
      space = 'allen_mouse',
      voxel_size_micron=voxel_size_micron,
      segmentation_file=False,
      age_PND = source_age
  )

  ccft_vol.transform(target_age, 'demba_dev_mouse')
  ccft_vol.save(rf"demo_data/P{target_age}_template_{voxel_size_micron}um.nii.gz")
  ```

  If you would like to add a new space or connect an existing one, please create a deformation matrix and/or describe the required reorientation, flipping, cropping, and padding of the axis between this space and one that already exists in the network, and then open an issue in this repository.  Ideally, choose a space which covers all the areas which are covered in your space. While the Allen CCFv3 is very popular, it is missing the anterior olfactory bulb and the caudal portion of the cerebellum and brain stem, so it is not the optimal choice.


  CCF translator was first described in [DeMBA: a developmental atlas for navigating the mouse brain in space and time](https://www.biorxiv.org/content/10.1101/2024.06.14.598876v1). If you use CCF translator, please cite that paper.


pkgId: 588461c06d1637d0bc122271a6a247037a87b82019f25e7a73b84fcd024b6d37
name: python-brainglobe-napari-io
arch: src
version: 0.3.4
epoch: 0
release: 1
summary: Read and write files from the BrainGlobe computational neuroanatomy suite into napari
url: https://brainglobe.info
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brainglobe-napari-io-0.3.4-1.src.rpm
checksum_type: sha256
description:
  This package is likely already installed
  (e.g. with cellfinder, brainreg or another napari plugin), but if you want to
  install it again, either use the napari plugin install GUI or you can
  install `brainglobe-napari-io` via [pip]:
      pip install brainglobe-napari-io

  * Open napari (however you normally do it, but typically just type `napari` into your terminal, or click on your desktop icon)


  Drag your [brainreg](https://github.com/brainglobe/brainreg) output directory (the one with the log file) onto the napari window.
  Various images should then open, including:
  * `Registered image` - the image used for registration, downsampled to atlas resolution
  * `atlas_name` - e.g. `allen_mouse_25um` the atlas labels, warped to your sample brain
  * `Boundaries` - the boundaries of the atlas regions
  If you downsampled additional channels, these will also be loaded.
  Most of these images will not be visible by default. Click the little eye icon to toggle visibility.
  _N.B. If you use a high resolution atlas (such as `allen_mouse_10um`), then the files can take a little while to load._
  ![sample_space](https://raw.githubusercontent.com/brainglobe/brainglobe-napari-io/master/resources/sample_space.gif)

  `napari-brainreg` also comes with an additional plugin, for visualising your data
  in atlas space.
  This is typically only used in other software, but you can enable it yourself:
  * Open napari
  * Navigate to `Plugins` -> `Plugin Call Order`
  * In the `Plugin Sorter` window, select `napari_get_reader` from the `select hook...` dropdown box
  * Drag `brainreg_read_dir_atlas_space` (the atlas space viewer plugin) above `brainreg_read_dir` (the normal plugin) to ensure that the atlas space plugin is used preferentially.


  * Load your raw data (drag and drop the data directories into napari, one at a time)
  * Drag and drop your cellfinder XML file (e.g. `cell_classification.xml`) into napari.

  * Load your raw data (drag and drop the data directories into napari, one at a time)
  * Drag and drop your cellfinder output directory into napari.
  The plugin will then load your detected cells (in yellow) and the rejected cell
  candidates (in blue). If you carried out registration, then these results will be
  overlaid (similarly to the loading brainreg data, but transformed to the
  coordinate space of your raw data).
  ![load_data](https://raw.githubusercontent.com/brainglobe/brainglobe-napari-io/master/resources/load_data.gif)
  **Loading raw data**
  ![load_data](https://raw.githubusercontent.com/brainglobe/brainglobe-napari-io/master/resources/load_results.gif)
  **Loading cellfinder results**

  Please see the [developers guide](https://brainglobe.info/developers/index.html).

  Distributed under the terms of the [MIT] license,
  "brainglobe-napari-io" is free and open source software

  If you encounter any problems, please [file an issue] along with a detailed description.
  [napari]: https://github.com/napari/napari
  [Cookiecutter]: https://github.com/audreyr/cookiecutter
  [@napari]: https://github.com/napari
  [MIT]: http://opensource.org/licenses/MIT
  [BSD-3]: http://opensource.org/licenses/BSD-3-Clause
  [GNU GPL v3.0]: http://www.gnu.org/licenses/gpl-3.0.txt
  [GNU LGPL v3.0]: http://www.gnu.org/licenses/lgpl-3.0.txt
  [Apache Software License 2.0]: http://www.apache.org/licenses/LICENSE-2.0
  [Mozilla Public License 2.0]: https://www.mozilla.org/media/MPL/2.0/index.txt
  [cookiecutter-napari-plugin]: https://github.com/napari/cookiecutter-napari-plugin
  [file an issue]: https://github.com/brainglobe/brainglobe-napari-io/issues
  [napari]: https://github.com/napari/napari
  [tox]: https://tox.readthedocs.io/en/latest/
  [pip]: https://pypi.org/project/pip/
  [PyPI]: https://pypi.org/


pkgId: 7fbc11dafd74b81560971d043d4e0eb262092307457308518a2efebb74d331fc
name: python-brainglobe-segmentation
arch: src
version: 1.2.6
epoch: 0
release: 1
summary: Segmentation of anatomical structures in a common coordinate space
url: https://brainglobe.info/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brainglobe-segmentation-1.2.6-1.src.rpm
checksum_type: sha256
description:
  [![Python Version](https://img.shields.io/pypi/pyversions/brainglobe-segmentation.svg)](https://pypi.org/project/brainglobe-segmentation)
  [![PyPI](https://img.shields.io/pypi/v/brainglobe-segmentation.svg)](https://pypi.org/project/brainglobe-segmentation)
  [![Wheel](https://img.shields.io/pypi/wheel/brainglobe-segmentation.svg)](https://pypi.org/project/brainglobe-segmentation)
  [![Development Status](https://img.shields.io/pypi/status/brainglobe-segmentation.svg)](https://github.com/brainglobe/brainglobe-segmentation)
  [![Tests](https://img.shields.io/github/actions/workflow/status/brainglobe/brainglobe-segmentation/test_and_deploy.yml?branch=main)](https://github.com/brainglobe/brainglobe-segmentation/actions)
  [![codecov](https://codecov.io/gh/brainglobe/brainglobe-segmentation/graph/badge.svg?token=WP9KTPZE5R)](https://codecov.io/gh/brainglobe/brainglobe-segmentation)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/python/black)
  [![Twitter](https://img.shields.io/twitter/follow/brain_globe?style=social)](https://twitter.com/brain_globe)



  Segmentation of anatomical structures in a common coordinate space


  **PyPI**
  ```
  pip install brainglobe-segmentation
  ```

  **conda**
  ```
  conda install -c conda-forge brainglobe-segmentation
  ```

  N.B. Your data will need to be registered to an anatomical atlas first.


  See [user guide](https://brainglobe.info/documentation/brainglobe-segmentation/index.html).


  We are always happy to help users of our tools, and welcome any contributions. If you would like to get in contact with us for any reason, please see the [contact page of our website](https://brainglobe.info/contact.html).



  If you find brainglobe-segmentation useful, and use it in your research, please let us know and also cite the paper:

  > Tyson, A. L., V&eacute;lez-Fort, M.,  Rousseau, C. V., Cossell, L., Tsitoura, C., Lenzi, S. C., Obenhaus, H. A., Claudi, F., Branco, T.,  Margrie, T. W. (2022). Accurate determination of marker location within whole-brain microscopy images. Scientific Reports, 12, 867 [doi.org/10.1038/s41598-021-04676-9](https://doi.org/10.1038/s41598-021-04676-9)


pkgId: 3b342da27d8275cc556daea00ee45d54c93f190ca99e5d885d001f3646d66653
name: python-brainglobe-utils
arch: src
version: 0.6.2
epoch: 0
release: 1
summary: Shared general purpose tools for the BrainGlobe project
url: https://pypi.org/project/brainglobe-utils/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brainglobe-utils-0.6.2-1.src.rpm
checksum_type: sha256
description:
  Shared general purpose tools for the BrainGlobe project, including [citation generation](#citations-for-brainglobe-tools).



  ```bash
  pip install brainglobe-utils
  ```

  To also include the dependencies required for Qt widgets, use:

  ```bash
  pip install brainglobe-utils[qt]
  ```

  For development, clone this repository and install the dependencies with:

  ```bash
  pip install -e .[dev]
  ```


  We are always happy to help users of our tools, and welcome any contributions. If you would like to get in contact with us for any reason, please see the [contact page of our website](https://brainglobe.info/contact.html).



  `brainglobe-utils` comes with the `cite-brainglobe` command line tool, to write citations for BrainGlobe tools for you so you don't need to worry about fetching the data yourself.
  You can read about [how to use the tool](https://brainglobe.info/documentation/brainglobe-utils/citation-module.html) on the documentation website.

rpm_license:
  MIT License  Copyright (c) 2020 Adam Tyson  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: 2d14df5521ea7c184691f6415fb2d00ea2a7382befee664685b5a5bc533aecaa
name: python-brainiac-model
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: A 3D ResNet50 model for brain MRI analysis
url: https://huggingface.co/Divytak/brainiac
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brainiac-model-0.1.1-1.src.rpm
checksum_type: sha256
description:
  This is the official implementation of the BrainIAC model, a 3D ResNet50-based architecture designed for brain image analysis.



  BrainIAC is built on a modified ResNet50 architecture that processes 3D brain imaging data. The model has been adapted to handle volumetric inputs through 3D convolutions and produces feature vectors that capture relevant brain imaging characteristics.


  - Base Architecture: ResNet50 (modified for 3D)
  - Input: 3D brain volumes [batch_size, 1, D, H, W]
  - Output: Feature vector of dimension 2048
  - First layer: 3D convolution (1 channel input)
  - Final layer: Identity (returns features directly)



  ```python
  from transformers import AutoModel
  import torch


  model = AutoModel.from_pretrained("your-username/brainiac")
  model.eval()



  batch_size = 1
  D, H, W = 16, 224, 224  # Example dimensions
  input_tensor = torch.randn(batch_size, 1, D, H, W)


  with torch.no_grad():
      features = model(input_tensor)

  print(f"Output feature shape: {features.shape}")  # Should be [batch_size, 2048]
  ```


  ```
  torch>=1.9.0
  monai
  transformers
  ```


  If you use this model in your research, please cite:
  [Add your citation information]


  [Add your license information]


pkgId: 6c7a7277fcd195d9652cd150265ddb8de224572a0b0f00ede0abbb160d705d73
name: python-brainrender
arch: src
version: 2.1.15
epoch: 0
release: 1
summary: Visualisation and exploration of brain atlases and other anatomical data
url: https://brainglobe.info/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brainrender-2.1.15-1.src.rpm
checksum_type: sha256
description:
  *A user-friendly python library to create high-quality, 3D neuro-anatomical renderings combining data from publicly available brain atlases with user-generated experimental data.*

  [![Python Version](https://img.shields.io/pypi/pyversions/brainrender.svg)](https://pypi.org/project/brainrender)
  [![PyPI](https://img.shields.io/pypi/v/brainrender.svg)](https://pypi.org/project/brainrender)
  [![tests](https://github.com/brainglobe/brainrender/workflows/tests/badge.svg)](https://github.com/brainglobe/brainrender/actions)
  [![codecov](https://codecov.io/gh/brainglobe/brainrender/graph/badge.svg)](https://codecov.io/gh/brainglobe/brainrender)
  [![Downloads](https://static.pepy.tech/badge/brainrender)](https://pepy.tech/project/brainrender)

  &nbsp;
  &nbsp;

  ![Example gallery](https://iiif.elifesciences.org/lax/65751%2Felife-65751-fig3-v3.tif/full/,1500/0/default.jpg)

  From: Claudi et al. (2021) Visualizing anatomically registered data with brainrender. eLife




  brainrender is a project of the BrainGlobe Initiative, which is a collaborative effort to develop a suite of Python-based software tools for computational neuroanatomy. A comprehensive online documentation for brainrender can be found on the BrainGlobe website [here](https://brainglobe.info/documentation/brainrender/index.html).

  Furthermore, an open-access journal article describing BrainRender has been published in eLife, available [here](https://doi.org/10.7554/eLife.65751).




  From PyPI:

  ```
  pip install brainrender
  ```



  ``` python
  import random

  import numpy as np

  from brainrender import Scene
  from brainrender.actors import Points

  def get_n_random_points_in_region(region, N):
      """
      Gets N random points inside (or on the surface) of a mesh
      """

      region_bounds = region.mesh.bounds()
      X = np.random.randint(region_bounds[0], region_bounds[1], size=10000)
      Y = np.random.randint(region_bounds[2], region_bounds[3], size=10000)
      Z = np.random.randint(region_bounds[4], region_bounds[5], size=10000)
      pts = [[x, y, z] for x, y, z in zip(X, Y, Z)]

      ipts = region.mesh.inside_points(pts).coordinates
      return np.vstack(random.choices(ipts, k=N))



  scene = Scene(atlas_name="allen_mouse_25um", title="Cells in primary visual cortex")


  primary_visual = scene.add_brain_region("VISp", alpha=0.2)


  coordinates = get_n_random_points_in_region(primary_visual, 2000)


  cells = Points(coordinates)


  scene.add(cells)


  scene.add_label(primary_visual, "Primary visual cortex")


  scene.render()

  ```


  We are always happy to help users of our tools, and welcome any contributions. If you would like to get in contact with us for any reason, please see the [contact page of our website](https://brainglobe.info/contact.html).



  If you use brainrender in your scientific work, please cite:
  ```
  Claudi, F., Tyson, A. L., Petrucco, L., Margrie, T.W., Portugues, R.,  Branco, T. (2021) "Visualizing anatomically registered data with Brainrender&quot; <i>eLife</i> 2021;10:e65751 [doi.org/10.7554/eLife.65751](https://doi.org/10.7554/eLife.65751)
  ```

  BibTeX:

  ``` bibtex
  @article{Claudi2021,
  author = {Claudi, Federico and Tyson, Adam L. and Petrucco, Luigi and Margrie, Troy W. and Portugues, Ruben and Branco, Tiago},
  doi = {10.7554/eLife.65751},
  issn = {2050084X},
  journal = {eLife},
  pages = {1--16},
  pmid = {33739286},
  title = {{Visualizing anatomically registered data with brainrender}},
  volume = {10},
  year = {2021}
  }

  ```


pkgId: 33e6a36c6e8184a1501181d2a4332b42b249a5c2e16b49901c7c414c55dc1c32
name: python-brainscore-vision
arch: src
version: 2.2.1
epoch: 0
release: 1
summary: The Brain-Score library enables model comparisons to behavioral and neural experiments
url: https://pypi.org/project/brainscore-vision/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brainscore-vision-2.2.1-1.src.rpm
checksum_type: sha256
description:
  [![Build Status](https://app.travis-ci.com/brain-score/vision.svg?token=vqt7d2yhhpLGwHsiTZvT&branch=master)](https://app.travis-ci.com/brain-score/vision)
  [![Documentation Status](https://readthedocs.org/projects/brain-score/badge/?version=latest)](https://brain-score.readthedocs.io/en/latest/?badge=latest)
  [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](code_of_conduct.md)

  Brain-Score is a platform to evaluate computational models of brain function
  on their match to brain measurements in primate vision.
  The intent of Brain-Score is to adopt many (ideally all) the experimental benchmarks in the field
  for the purpose of model testing, falsification, and comparison.
  To that end, Brain-Score operationalizes experimental data into quantitative benchmarks
  that any model candidate following the [`BrainModel`](brainscore_vision/model_interface.py) interface can be scored on.

  Note that you can only access a limited set of public benchmarks when running locally. To score a model on all benchmarks, submit it via the [brain-score.org website](http://www.brain-score.org).

  See the [documentation](https://brain-score.readthedocs.io) for more details, e.g. for submitting a [model](https://brain-score.readthedocs.io/en/latest/modules/model_tutorial.html) or [benchmark](https://brain-score.readthedocs.io/en/latest/modules/benchmark_tutorial.html) to Brain-Score. For a step-by-step walkthrough on submitting models to the Brain-Score website, see these [web tutorials](https://www.brain-score.org/tutorial/).

  See these [code examples](https://github.com/brain-score/vision/blob/master/examples) on scoring models, retrieving data, using and defining benchmarks and metrics.
  These [previous examples](https://github.com/brain-score/candidate_models/blob/master/examples/score-model.ipynb) might be helpful, but their usage has been deprecated after the 2.0 update.

  Brain-Score is made by and for the community.
  To contribute, please [send in a pull request](https://github.com/brain-score/vision/pulls).




  You will need Python = 3.11 and pip >= 18.1.

  `pip install git+https://github.com/brain-score/vision.git`

  Test if the installation is successful by scoring a model on a public benchmark:

  ```python
  from brainscore_vision.benchmarks import public_benchmark_pool

  benchmark = public_benchmark_pool['dicarlo.MajajHong2015public.IT-pls']
  model = my_model()
  score = benchmark(model)










  ```

  Some steps may take minutes because data has to be downloaded during first-time use.



  | Variable               | Description                                                                                                                           |
  |------------------------|---------------------------------------------------------------------------------------------------------------------------------------|
  | RESULTCACHING_HOME     | directory to cache results (benchmark ceilings) in, `~/.result_caching` by default (see https://github.com/brain-score/result_caching) |




  MIT license




  <details>
  <summary>`ValueError: did not find HDF5 headers` during netcdf4 installation</summary>
  pip seems to fail properly setting up the HDF5_DIR required by netcdf4.
  Use conda: `conda install netcdf4`
  </details>

  <details>
  <summary>repeated runs of a benchmark / model do not change the outcome even though code was changed</summary>
  results (scores, activations) are cached on disk using https://github.com/mschrimpf/result_caching.
  Delete the corresponding file or directory to clear the cache.
  </details>




  Add CI related build commands to `test_setup.sh`. The script is executed in CI environment for unittests.




  If you use Brain-Score in your work, please cite
  ["Brain-Score: Which Artificial Neural Network for Object Recognition is most Brain-Like?"](https://www.biorxiv.org/content/10.1101/407007v2) (technical) and
  ["Integrative Benchmarking to Advance Neurally Mechanistic Models of Human Intelligence"](https://www.cell.com/neuron/fulltext/S0896-6273(20)30605-X) (perspective)
  as well as the respective benchmark sources.

  ```bibtex
  @article{SchrimpfKubilius2018BrainScore,
    title={Brain-Score: Which Artificial Neural Network for Object Recognition is most Brain-Like?},
    author={Martin Schrimpf and Jonas Kubilius and Ha Hong and Najib J. Majaj and Rishi Rajalingham and Elias B. Issa and Kohitij Kar and Pouya Bashivan and Jonathan Prescott-Roy and Franziska Geiger and Kailyn Schmidt and Daniel L. K. Yamins and James J. DiCarlo},
    journal={bioRxiv preprint},
    year={2018},
    url={https://www.biorxiv.org/content/10.1101/407007v2}
  }

  @article{Schrimpf2020integrative,
    title={Integrative Benchmarking to Advance Neurally Mechanistic Models of Human Intelligence},
    author={Schrimpf, Martin and Kubilius, Jonas and Lee, Michael J and Murty, N Apurva Ratan and Ajemian, Robert and DiCarlo, James J},
    journal={Neuron},
    year={2020},
    url={https://www.cell.com/neuron/fulltext/S0896-6273(20)30605-X}
  }
  ```

rpm_license:
  MIT License  Copyright (c) 2017, Martin Schrimpf and Jon Prescott-Roy  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: aaf8861bd6228e1b6c78672d2e7b7cc31a0984b24fdd0841df5956f36380cf67
name: python-brainsmash
arch: src
version: 0.11.0
epoch: 0
release: 1
summary: Brain Surrogate Maps with Autocorrelated Spatial Heterogeneity.
url: https://github.com/murraylab/brainsmash
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brainsmash-0.11.0-1.src.rpm
checksum_type: sha256
description:
  BrainSMASH (Brain Surrogate Maps with Autocorrelated Spatial Heterogeneity) is a
  Python-based computational platform for statistical testing of spatially
  autocorrelated brain maps. At the heart of BrainSMASH is the ability to
  simulate surrogate brain maps with spatial autocorrelation that is matched
  to spatial autocorrelation in a target brain map. Additional utilities are provided
  for users using Connectome Workbench style surface-based neuroimaging files.
  Exhaustive documentation can be found [here](https://brainsmash.readthedocs.io).


pkgId: 8e370a6ee35619978926e23a852197e41652c746dbb4755ad853be03f0649c36
name: python-braintree
arch: src
version: 4.29.0
epoch: 0
release: 1
summary: Braintree Python Library
url: https://developer.paypal.com/braintree/docs/reference/overview
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-braintree-4.29.0-1.src.rpm
checksum_type: sha256
description:
          The Braintree Python SDK provides integration access to the Braintree Gateway.

          1. https://github.com/braintree/braintree_python - README and Samples
          2. https://developer.paypal.com/braintree/docs/reference/overview - API Reference


pkgId: 5634e8b0d1d07ffcecbd02a0479d877ef8965d04b012f301529b19b0ec0ae4a1
name: python-braintrust
arch: src
version: 0.0.163
epoch: 0
release: 1
summary: SDK for integrating Braintrust
url: https://www.braintrust.dev
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-braintrust-0.0.163-1.src.rpm
checksum_type: sha256
description:
  A Python library for logging data to Braintrust. `braintrust` is distributed as
  a [library on PyPI](https://pypi.org/project/braintrust/). It is open source and
  [available on GitHub](https://github.com/braintrustdata/braintrust-sdk/tree/main/py).



  Install the library with pip.

  ```bash
  pip install braintrust
  ```

  Then, run a simple experiment with the following code (replace `YOUR_API_KEY` with
  your Braintrust API key):

  ```python
  from braintrust import Eval

  def is_equal(expected, output):
      return expected == output

  Eval(
    "Say Hi Bot",
    data=lambda: [
        {
            "input": "Foo",
            "expected": "Hi Foo",
        },
        {
            "input": "Bar",
            "expected": "Hello Bar",
        },
    ],  # Replace with your eval dataset
    task=lambda input: "Hi " + input,  # Replace with your LLM call
    scores=[is_equal],
  )
  ```


pkgId: ece7aaf2af862ae3120de15abe779eaa9fd13d2b77725937f350c912927b8f8e
name: python-braintrust-api
arch: src
version: 0.5.0
epoch: 0
release: 1
summary: The official Python library for the braintrust API
url: https://github.com/braintrustdata/braintrust-api-py
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-braintrust-api-0.5.0-1.src.rpm
checksum_type: sha256
description:
  [![PyPI version](https://img.shields.io/pypi/v/braintrust-api.svg)](https://pypi.org/project/braintrust-api/)

  The Braintrust Python library provides convenient access to the Braintrust REST API from any Python 3.7+
  application. The library includes type definitions for all request params and response fields,
  and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx).

  It is generated with [Stainless](https://www.stainlessapi.com/).



  The REST API documentation can be found on [www.braintrustdata.com](https://www.braintrustdata.com/docs/api/spec). The full API of this library can be found in [api.md](https://github.com/braintrustdata/braintrust-api-py/tree/main/api.md).



  ```sh

  pip install braintrust-api
  ```



  The full API of this library can be found in [api.md](https://github.com/braintrustdata/braintrust-api-py/tree/main/api.md).

  ```python
  import os
  from braintrust_api import Braintrust

  client = Braintrust(
      
      api_key=os.environ.get("BRAINTRUST_API_KEY"),
  )

  project = client.projects.create(
      name="foobar",
  )
  print(project.id)
  ```

  While you can provide an `api_key` keyword argument,
  we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/)
  to add `BRAINTRUST_API_KEY="My API Key"` to your `.env` file
  so that your API Key is not stored in source control.



  Simply import `AsyncBraintrust` instead of `Braintrust` and use `await` with each API call:

  ```python
  import os
  import asyncio
  from braintrust_api import AsyncBraintrust

  client = AsyncBraintrust(
      
      api_key=os.environ.get("BRAINTRUST_API_KEY"),
  )


  async def main() -> None:
      project = await client.projects.create(
          name="foobar",
      )
      print(project.id)


  asyncio.run(main())
  ```

  Functionality between the synchronous and asynchronous clients is otherwise identical.



  Nested request parameters are [TypedDicts](https://docs.python.org/3/library/typing.html#typing.TypedDict). Responses are [Pydantic models](https://docs.pydantic.dev) which also provide helper methods for things like:

  - Serializing back into JSON, `model.to_json()`
  - Converting to a dictionary, `model.to_dict()`

  Typed requests and responses provide autocomplete and documentation within your editor. If you would like to see type errors in VS Code to help catch bugs earlier, set `python.analysis.typeCheckingMode` to `basic`.



  List methods in the Braintrust API are paginated.

  This library provides auto-paginating iterators with each list response, so you do not have to request successive pages manually:

  ```python
  from braintrust_api import Braintrust

  client = Braintrust()

  all_projects = []

  for project in client.projects.list():
      
      all_projects.append(project)
  print(all_projects)
  ```

  Or, asynchronously:

  ```python
  import asyncio
  from braintrust_api import AsyncBraintrust

  client = AsyncBraintrust()


  async def main() -> None:
      all_projects = []
      
      async for project in client.projects.list():
          all_projects.append(project)
      print(all_projects)


  asyncio.run(main())
  ```

  Alternatively, you can use the `.has_next_page()`, `.next_page_info()`, or `.get_next_page()` methods for more granular control working with pages:

  ```python
  first_page = await client.projects.list()
  if first_page.has_next_page():
      print(f"will fetch next page using these details: {first_page.next_page_info()}")
      next_page = await first_page.get_next_page()
      print(f"number of items we just fetched: {len(next_page.objects)}")


  ```

  Or just work directly with the returned data:

  ```python
  first_page = await client.projects.list()

  print(f"next page cursor: {first_page.starting_after}")  # => "next page cursor: ..."
  for project in first_page.objects:
      print(project.id)


  ```



  When the library is unable to connect to the API (for example, due to network connection problems or a timeout), a subclass of `braintrust_api.APIConnectionError` is raised.

  When the API returns a non-success status code (that is, 4xx or 5xx
  response), a subclass of `braintrust_api.APIStatusError` is raised, containing `status_code` and `response` properties.

  All errors inherit from `braintrust_api.APIError`.

  ```python
  import braintrust_api
  from braintrust_api import Braintrust

  client = Braintrust()

  try:
      client.projects.create(
          name="foobar",
      )
  except braintrust_api.APIConnectionError as e:
      print("The server could not be reached")
      print(e.__cause__)  # an underlying Exception, likely raised within httpx.
  except braintrust_api.RateLimitError as e:
      print("A 429 status code was received; we should back off a bit.")
  except braintrust_api.APIStatusError as e:
      print("Another non-200-range status code was received")
      print(e.status_code)
      print(e.response)
  ```

  Error codes are as followed:

  | Status Code | Error Type                 |
  | ----------- | -------------------------- |
  | 400         | `BadRequestError`          |
  | 401         | `AuthenticationError`      |
  | 403         | `PermissionDeniedError`    |
  | 404         | `NotFoundError`            |
  | 422         | `UnprocessableEntityError` |
  | 429         | `RateLimitError`           |
  | >=500       | `InternalServerError`      |
  | N/A         | `APIConnectionError`       |



  Certain errors are automatically retried 2 times by default, with a short exponential backoff.
  Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict,
  429 Rate Limit, and >=500 Internal errors are all retried by default.

  You can use the `max_retries` option to configure or disable retry settings:

  ```python
  from braintrust_api import Braintrust


  client = Braintrust(
      
      max_retries=0,
  )


  client.with_options(max_retries=5).projects.create(
      name="foobar",
  )
  ```



  By default requests time out after 1 minute. You can configure this with a `timeout` option,
  which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/#fine-tuning-the-configuration) object:

  ```python
  from braintrust_api import Braintrust


  client = Braintrust(
      
      timeout=20.0,
  )


  client = Braintrust(
      timeout=httpx.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
  )


  client.with_options(timeout=5.0).projects.create(
      name="foobar",
  )
  ```

  On timeout, an `APITimeoutError` is thrown.

  Note that requests that time out are [retried twice by default](https://github.com/braintrustdata/braintrust-api-py/tree/main/#retries).





  We use the standard library [`logging`](https://docs.python.org/3/library/logging.html) module.

  You can enable logging by setting the environment variable `BRAINTRUST_LOG` to `debug`.

  ```shell
  $ export BRAINTRUST_LOG=debug
  ```



  In an API response, a field may be explicitly `null`, or missing entirely; in either case, its value is `None` in this library. You can differentiate the two cases with `.model_fields_set`:

  ```py
  if response.my_field is None:
    if 'my_field' not in response.model_fields_set:
      print('Got json like {}, without a "my_field" key present at all.')
    else:
      print('Got json like {"my_field": null}.')
  ```



  The "raw" Response object can be accessed by prefixing `.with_raw_response.` to any HTTP method call, e.g.,

  ```py
  from braintrust_api import Braintrust

  client = Braintrust()
  response = client.projects.with_raw_response.create(
      name="foobar",
  )
  print(response.headers.get('X-My-Header'))

  project = response.parse()  # get the object that `projects.create()` would have returned
  print(project.id)
  ```

  These methods return an [`APIResponse`](https://github.com/braintrustdata/braintrust-api-py/tree/main/src/braintrust_api/_response.py) object.

  The async client returns an [`AsyncAPIResponse`](https://github.com/braintrustdata/braintrust-api-py/tree/main/src/braintrust_api/_response.py) with the same structure, the only difference being `await`able methods for reading the response content.



  The above interface eagerly reads the full response body when you make the request, which may not always be what you want.

  To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.

  ```python
  with client.projects.with_streaming_response.create(
      name="foobar",
  ) as response:
      print(response.headers.get("X-My-Header"))

      for line in response.iter_lines():
          print(line)
  ```

  The context manager is required so that the response will reliably be closed.



  This library is typed for convenient access to the documented API.

  If you need to access undocumented endpoints, params, or response properties, the library can still be used.



  To make requests to undocumented endpoints, you can make requests using `client.get`, `client.post`, and other
  http verbs. Options on the client will be respected (such as retries) will be respected when making this
  request.

  ```py
  import httpx

  response = client.post(
      "/foo",
      cast_to=httpx.Response,
      body={"my_param": True},
  )

  print(response.headers.get("x-foo"))
  ```



  If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` request
  options.



  To access undocumented response properties, you can access the extra fields like `response.unknown_prop`. You
  can also get all the extra fields on the Pydantic model as a dict with
  [`response.model_extra`](https://docs.pydantic.dev/latest/api/base_model/#pydantic.BaseModel.model_extra).



  You can directly override the [httpx client](https://www.python-httpx.org/api/#client) to customize it for your use case, including:

  - Support for proxies
  - Custom transports
  - Additional [advanced](https://www.python-httpx.org/advanced/clients/) functionality

  ```python
  from braintrust_api import Braintrust, DefaultHttpxClient

  client = Braintrust(
      
      base_url="http://my.test.server.example.com:8083",
      http_client=DefaultHttpxClient(
          proxies="http://my.test.proxy.example.com",
          transport=httpx.HTTPTransport(local_address="0.0.0.0"),
      ),
  )
  ```

  You can also customize the client on a per-request basis by using `with_options()`:

  ```python
  client.with_options(http_client=DefaultHttpxClient(...))
  ```



  By default the library closes underlying HTTP connections whenever the client is [garbage collected](https://docs.python.org/3/reference/datamodel.html#object.__del__). You can manually close the client using the `.close()` method if desired, or with a context manager that closes when exiting.



  This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:

  1. Changes that only affect static types, without breaking runtime behavior.
  2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals)_.
  3. Changes that we do not expect to impact the vast majority of users in practice.

  We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.

  We are keen for your feedback; please open an [issue](https://www.github.com/braintrustdata/braintrust-api-py/issues) with questions, bugs, or suggestions.



  If you've upgraded to the latest version but aren't seeing any new features you were expecting then your python environment is likely still using an older version.

  You can determine the version that is being used at runtime with:

  ```py
  import braintrust_api
  print(braintrust_api.__version__)
  ```



  Python 3.7 or higher.


pkgId: 285f37f176f3d24c035e19d4aa12d98386d047a1ae20e6db2084b6d550f3cdab
name: python-braintrust-core
arch: src
version: 0.0.54
epoch: 0
release: 1
summary: Shared core dependencies for Braintrust packages
url: https://www.braintrust.dev
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-braintrust-core-0.0.54-1.src.rpm
checksum_type: sha256
description:
  This package contains a small set of dependencies shared by various packages in
  the braintrust ecosystem.


pkgId: 4dfb91aa33f421e005bdd5ab3c872e95728e44b85ef77712a0a9b2323d2f3bfb
name: python-brainways
arch: src
version: 0.1.15
epoch: 0
release: 1
summary: Brainways
url: https://github.com/bkntr/brainways
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brainways-0.1.15-1.src.rpm
checksum_type: sha256
description:
  [![DOI](https://img.shields.io/badge/DOI-10.1101/2023.05.25.542252-green.svg)](https://doi.org/10.1101/2023.05.25.542252)
  [![License GNU GPL v3.0](https://img.shields.io/pypi/l/brainways.svg?color=green)](https://github.com/bkntr/brainways/raw/main/LICENSE)
  [![PyPI](https://img.shields.io/pypi/v/brainways.svg?color=green)](https://pypi.org/project/brainways)
  [![Python Version](https://img.shields.io/pypi/pyversions/brainways.svg?color=green)](https://python.org)
  [![tests](https://github.com/bkntr/brainways/workflows/tests/badge.svg)](https://github.com/bkntr/brainways/actions)
  [![codecov](https://codecov.io/gh/bkntr/brainways/branch/main/graph/badge.svg)](https://codecov.io/gh/bkntr/brainways)
  [![Documentation Status](https://readthedocs.org/projects/brainways/badge/?version=latest)](https://brainways.readthedocs.io/en/latest/?badge=latest)
  [![napari hub](https://img.shields.io/endpoint?url=https://api.napari-hub.org/shields/brainways)](https://napari-hub.org/plugins/brainways)

  <!-- markdownlint-disable MD026 -->

  <!-- markdownlint-enable MD026 -->

  Brainways is an AI-based tool for automated registration, quantification and generation of brain-wide activity networks based on fluorescence in coronal slices.

  ![Brainways UI](docs/assets/brainways-ui.gif)

  <!-- markdownlint-disable MD026 -->

  <!-- markdownlint-enable MD026 -->

  Coronal slice registration, cell quantification and whole-brain contrast analysis between experimental conditions should be made easily accessible from a single software, without requiring programming experience.
  Customization should be made easy by having a highly flexible pythonic backend.



  To install and run brainways, run the following in your python environment:

  ```bash
  pip install brainways
  brainways ui
  ```

  Follow our [getting started guide](https://brainways.readthedocs.io/en/latest/getting_started/) for more details.



  Brainways allows users to register, quantify and provide statistical contrast analysis by following several simple steps:

  1. Rigid registration of coronal slices to a 3D atlas.
  1. Non-rigid registration of coronal slices to a 3D atlas, to account for individual difference and imperfections in acquisition procedure.
  1. Cell detection (using [StarDist](https://github.com/stardist/stardist)).
  1. Quantification of cell counts per brain region.
  1. Statistical analysis:
      * ANOVA contrast analysis.
      * PLS (Partial Least Square) analysis.
      * Network graph creation.

  <!-- For a quick 10 minute overview of brainways, check out the demo presented to The Social Club community
  meeting:

  [![Brainways Overview Demo](https://img.youtube.com/vi/aWDIQMbp1cc/0.jpg)](https://youtu.be/aWDIQMbp1cc?t=1m4s) -->



  Brainways is implemented as three modules. `brainways.ui` contains the GUI implementation as a [napari](https://napari.org/stable/) plugin. `brainways.ui` is using `brainways` as its backend. All of the functionality is implemented in the brainways package. This separation was done to guarantee that brainways is a GUI-agnostic software, and can be fully accessed and manipulated through python code to allow custom complex usage scenarios. The code that was used to train, evaluate and run the automatic registration model resides in `brainways-reg-model`.



  Brainways is being actively developed by Ben Kantor of Bartal lab, Tel Aviv University, Israel. Our releases can be found [here](https://github.com/bkntr/brainways/releases).



  If you use brainways, please cite [Kantor and Bartal (2023)](https://doi.org/10.1101/2023.05.25.542252):

      @article{kantor2023brainways,
        title={Brainways: An Open-Source AI-based Software For Registration and Analysis of Fluorescent   Markers on Coronal Brain Slices},
        author={Kantor, Ben and Ben-Ami Bartal, Inbal},
        journal={bioRxiv},
        pages={2023--05},
        year={2023},
        publisher={Cold Spring Harbor Laboratory}
      }



  Distributed under the terms of the [GNU GPL v3.0] license,
  "brainways" is free and open source software



  If you encounter any problems, please [file an issue] along with a detailed description.

  [napari]: https://github.com/napari/napari
  [Cookiecutter]: https://github.com/audreyr/cookiecutter
  [@napari]: https://github.com/napari
  [MIT]: http://opensource.org/licenses/MIT
  [BSD-3]: http://opensource.org/licenses/BSD-3-Clause
  [GNU GPL v3.0]: http://www.gnu.org/licenses/gpl-3.0.txt
  [GNU LGPL v3.0]: http://www.gnu.org/licenses/lgpl-3.0.txt
  [Apache Software License 2.0]: http://www.apache.org/licenses/LICENSE-2.0
  [Mozilla Public License 2.0]: https://www.mozilla.org/media/MPL/2.0/index.txt
  [cookiecutter-napari-plugin]: https://github.com/napari/cookiecutter-napari-plugin

  [file an issue]: https://github.com/bkntr/brainways/issues

  [napari]: https://github.com/napari/napari
  [tox]: https://tox.readthedocs.io/en/latest/
  [pip]: https://pypi.org/project/pip/
  [PyPI]: https://pypi.org/


pkgId: f7aa46d7ac37b401ad0fabb3d6a0f1cba37499f8bfb41fe2e40b4a84e6bcd39b
name: python-brainweb
arch: src
version: 1.6.2
epoch: 0
release: 1
summary: BrainWeb-based multimodal models of 20 normal brains
url: https://github.com/casperdcl/brainweb
rpm_license: MPLv2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brainweb-1.6.2-1.src.rpm
checksum_type: sha256
description:
  This project was initially inspired by "`BrainWeb: 20 Anatomical Models
  of 20 Normal
  Brains <http://brainweb.bic.mni.mcgill.ca/brainweb/anatomic_normal_20.html>`__."
  However there are a number of generally useful tools, image processing &
  display functions included in this project. For example, this includes
  ``volshow()`` for interactive comparison of multiple 3D volumes,
  ``get_file()`` for caching data URLs, and ``register()`` for image
  coregistration.
  |PyPI| |CI| |Quality| |DOI| |LICENCE|
  **Download and Preprocessing for PET-MR Simulations**
  This notebook will not re-download/re-process files if they already
  exist.
  -  Output data
     -  ``~/.brainweb/subject_*.npz``: dtype(shape):
        ``float32(127, 344, 344)``
  -  `Raw data
     source <http://brainweb.bic.mni.mcgill.ca/brainweb/anatomic_normal_20.html>`__
     -  ``~/.brainweb/subject_*.bin.gz``: dtype(shape):
        ``uint16(362, 434, 362)``
  -  Install


pkgId: 4c8cfb583815bc605f822636a035f634789b13afed98f9c154eb55089f84b919
name: python-brainweb-dl
arch: src
version: 0.3.0
epoch: 0
release: 1
summary: Download BrainWeb MRI data
url: https://github.com/paquiteau/brainweb-dl
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brainweb-dl-0.3.0-1.src.rpm
checksum_type: sha256
description:
  Welcome to Brainweb-DL, a powerful Python toolkit for downloading and converting the Brainweb dataset.

  <p align="center">
  <a href=https://github.com/paquiteau/brainweb-dl/blob/master/LICENSE><img src=https://img.shields.io/github/license/paquiteau/brainweb-dl></a>
  <a href=https://www.codefactor.io/repository/github/paquiteau/brainweb-dl><img src=https://www.codefactor.io/repository/github/paquiteau/brainweb-dl/badge></a>
  <a href=https://github.com/psf/black><img src=https://img.shields.io/badge/style-black-black></a>
  <a href=https://pypi.org/project/brainweb-dl><img src=https://img.shields.io/pypi/v/brainweb-dl></a>
  <a href=https://pypi.org/project/brainweb-dl><img src=https://img.shields.io/pypi/pyversions/brainweb-dl></a>
  </p>



  - **Effortless Dataset Management:** Automatically download, cache, and format the Brainweb dataset with ease. Convert it to the convenient nifti format or numpy array hassle-free.

  - **Multiple Image Generation:** Generate high-quality T1, T2, T2*, and PD images directly from the Brainweb dataset. Perfect for testing purposes, although keep in mind that the values provided are approximate.



  The Brainweb project kindly provides:

   - A normal brain phantom (named subject `0` afterwards), with T1, T2 and PD contrasts, with a variety of noise levels and intensity non-uniformities. As well as a anatomical model (in the form of either crisp or fuzzy segmentation of brain tissues, at a fixed resolution of 181x217x181 images).
   - The same for a multiple sclerosis brain phantom (named subject `1` afterwards).
   - A set of 20 normal brains (with ids equal to `[4, 5, 6, 18, 20, 38, 41-54]`) , with a T1 contrast (with 1mm resolution at (181, 217,181)), as well as the crisp and fuzzy segmentation of brain tissues (with a shape of (362, 434,362)) [^1].

  This project provides a **CLI** and a **Python API** to download and convert theses data. On top of that, it can generate new contrasts (e.g. T2*) from the segmentations, and reshape the data to the desired resolution [^2].


  [^1]: Note that the classification of tissue is not the same as for subject 0 and 1
  [^2]: This requires scipy to be installed.





  The cached data directory follows this priority order:

  1. User-specific argument (`brainweb_dir` in most functions)
  2. `BRAINWEB_DIR` environment variable
  3. `~/.cache/brainweb` folder


  ```python
  from brainweb_dl import get_mri


  data = get_mri(sub_id=44, contrast="T1")

  data = get_mri(sub_id="3", contrast="fuzzy")


  ```

  The Brainweb dataset is downloaded and cached by default in the `~/.cache/brainweb` folder.



  ```bash
  brainweb-dl 44 --contrast=T1
  ```

  For more information, see `brainweb-dl --help`.



  Get up and running quickly!

  ```bash
  pip install brainweb-dl
  ```



  Join our community and contribute to Brainweb-DL!

  ```bash
  git clone git@github.com/paquiteau/brainweb-dl
  cd brainweb-dl
  pip install -e .[dev,test,doc]
  ```


  Help us improve and shape the future of Brainweb-DL:

  - [x] Add unit tests.
  - [x] Implement fuzzy search and multiple subjects download in parallel.
  - [x] Develop an interface to generate T1, T2, T2*, and PD images.
  - [x] Enhance the search for the location of the Brainweb dataset (User > Environment Variable > Default Location).
  - [ ] Introduce an interface to download as BIDS format.



  We extend our gratitude to the following for their contributions:

  - [Casper De Clercq](https://github.com/casperdcl/brainweb/) for the preliminary work and original idea. Check out his great work if you are interested in PET imaging and registration functionalities.

  - [BrainWeb](https://brainweb.bic.mni.mcgill.ca/) for providing this valuable dataset to the community.



  <p align=center> :star2: If you like this work, don't forget to star it and share it 🌟 </p>

rpm_license:
  MIT License  Copyright (c) 2023 Pierre-Antoine Comby  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: e8b3e64374a2a365e541e23e68d3b04f28f1874bef74f8b8d7351d0c487e33a3
name: python-branalysis
arch: src
version: 1.0.12
epoch: 0
release: 1
summary: Coleta e facilita a análise de votações nominais do Congresso Nacional
url: https://github.com/mateuskreuch/branalysis
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-branalysis-1.0.12-1.src.rpm
checksum_type: sha256
description:
  Biblioteca Python para coletar e analisar votaÃ§Ãµes nominais do Congresso Nacional.

  ```python
  from branalysis.plenario import Camara
  from datetime import date
  from matplotlib import pyplot as plt
  from statistics import mean

  ANO = 2023

  def calcula_idade(parlamentar):
     return (date(ANO, 12, 31) - parlamentar.data_nascimento).days / 365

  plenario = Camara(ANO)


  partido_idade_media = [
     (partido, mean(calcula_idade(p) for p in parlamentares))
     for partido, parlamentares in plenario.parlamentares_por_partido().items()
  ]


  partido_idade_media.sort(key=lambda x: x[1])


  barras = plt.bar(*zip(*partido_idade_media))

  plt.bar_label(barras, fmt=lambda x: f'{x:.1f}', label_type='edge')
  plt.ylabel('Idade mÃ©dia')
  plt.xticks(rotation=-45, ha='left')
  plt.show()
  ```

  ```python
  from branalysis import Camara, MatrizPolitica, Colorizador, CORES
  from matplotlib.colors import ListedColormap
  from sklearn.decomposition import PCA
  import matplotlib.pyplot as plt

  plenario = Camara(2023)
  parlamentares = plenario.parlamentares()


  matriz = MatrizPolitica(parlamentares, plenario.votacoes()).de_parlamentares()


  modelo = PCA(n_components=2).fit_transform(matriz)


  colorizador = Colorizador(fallback='MAIS DE UM')
  cor_por_parlamentar = [colorizador[p.partidos()] for p in parlamentares]


  grafico = plt.scatter(modelo[:, 0], modelo[:, 1], cmap=ListedColormap(CORES), c=cor_por_parlamentar)
  texto_legenda, cores = colorizador.textos_e_cores()
  cores_legenda = grafico.legend_elements(num=cores)[0]

  plt.legend(cores_legenda, texto_legenda)
  plt.show()
  ```


pkgId: 35ca18e4b3651e2d89f7b6c97068198deeb8fc8eb04d5efedab38645b2d156a0
name: python-branca
arch: src
version: 0.7.2
epoch: 0
release: 1
summary: Generate complex HTML+JS pages with Python
url: https://github.com/python-visualization/branca
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-branca-0.7.2-1.src.rpm
checksum_type: sha256
description:
  [![PyPI Package](https://img.shields.io/pypi/v/branca.svg)](https://pypi.python.org/pypi/branca)
  [![Build Status](https://github.com/python-visualization/branca/actions/workflows/test_code.yml/badge.svg?branch=main)](https://github.com/python-visualization/branca/actions/workflows/test_code.yml)
  [![Gitter](https://badges.gitter.im/python-visualization/folium.svg)](https://gitter.im/python-visualization/folium)



  This library is a spinoff from [folium](https://github.com/python-visualization/folium). It can be used to generate HTML + JS. It is based on Jinja2.

  - Documentation: https://python-visualization.github.io/branca/
  - Examples: https://nbviewer.org/github/python-visualization/branca/tree/main/examples/


pkgId: 92939f811d119283c47cf272c0627cbc31ced9df8f07f1e36a3a61c4c62810dc
name: python-branchkey
arch: src
version: 2.6.2
epoch: 0
release: 1
summary: Client application to interface with the BranchKey system
url: https://branchkey.com
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-branchkey-2.6.2-1.src.rpm
checksum_type: sha256
description:
  ![BK_logo](https://branchkey.com/wp-content/uploads/elementor/thumbs/branchkeytext-q0lwtzdsb6aaj26q2mj2lpksk47abbz9fd1gndr1l0.png)

  This application runs against the BranchKey backend aggregation service for Federated Learning.
  It provides a Python interface to login/logout a client, upload files to the system for aggregation,
  and download aggregated output files.



  - `pip install branchkey`



  - To build the dependencies:
    - `make setup`, or
    - `pip install -r requirements.txt`
  - To run the tests: `make test`
    - `make test`, or
    - python3 -m unittest -v



  - To use a client:

    ```python
    import json
    from branchkey.client import Client

    credentials = {"leaf_name": "leaf-1",
                   "leaf_id": "46780841-9787-41e6-ac14-e3ee160e158a",
                   "leaf_session_token": "46780841-9787-41e6-ac14-e3ee160e158a",
                   "response_host":"response.branchkey.com"}

    host = "https://api.branchkey.com"

    proxy_servers = {
          'http': 'http://user:password@proxyserver.com:8080',
          'https': 'http://user:password@proxyserver.com:8080',
          }

    '''initialise the client
    it implicitly authenticates the leaf_session
    and fetches the run_details of the parent branch

    ssl: Whether to verify the SSL certificates of the
    remote host or not. Default it True

    wait_for_run: When trying to upload file, if the
    run is stopped/paused, this parameter decides whether
    to throw exception and stop the process, or wait for
    the run to be started again. Default is False

    run_check_interval_s: if wait_for_run=True, this
    parameter decides the sleeping interval of the
    program until the run status is checked again.
    Default is 30 seconds
    '''
    c = Client(credentials,host, ssl=True, wait_for_run=True, run_check_interval_s=15, proxies=proxy_servers)

    '''
    upload the file to the system
    '''
    c.file_upload("./file/path.npy")

    '''Download a file with the file_id value
    same as the one received from the consumer
    It downloads the files in the ./aggregated_files directory
    '''
    if not c.queue.empty():
          aggregation_id = c.queue.get(block=False)
          c.file_download(aggregation_id)

          '''To push performance analysis metrics for this aggregation:
          mode can be test, train or non-federated
          '''
          data = json.dumps({"key1":"val1","key2":"val2"})
          mode = "test"
          c.send_performance_metrics(aggregation_id, data, mode)
    ```



  Weights file in a numpy `.npy` format:

  ```python
  with open("./test.npy", "wb") as f:
      np.save(f, parameter_array)
  [num_samples, [n_d parameter matrix]]
  ```

  ```
  num_samples - the number of samples that contributed to this update
  n_d parameter matrix - parameters
  ```



  The required numpy arrays after exports

  ```python
  [1329, list([array([[[[ 1.71775490e-01,    [[[ 8.74867663e-02,  5.19692302e-02, -1.64664671e-01,,          -2.23452481e-03,  1.11475676e-01],,    [-1.75505821e-02, -1...
  ```

  ```python
  (1329, [array([[[[ 1.71775490e-01,  3.02851666e-02,  2.90171858e-02,
            -4.27578250e-03,  1.14474617e-01],
           [-8.07138346e-03,  1.44909814e-01, -5.36724664e-02,
            -3.51673253e-02, -1.82426855e-01],
           [ 6.75795972e-02, -1.72839850e-01, -7.25025982e-02,
            -1.59504730e-02,  1.60634145e-01],
           [ 6.62277341e-02, -2.26575769e-02, -1.65369093e-01,
            -8.67117420e-02,  1.80021569e-01],
           [-6.11407161e-02, -1.59245610e-01,  1.45820528e-01,
            -5.40512279e-02, -5.19061387e-02]]],
          ....
           [-1.44068539e-01,  6.15987852e-02,  1.83321223e-01,
            -1.79076958e-02, -1.53445438e-01],
           [-7.76787996e-02,  7.64556080e-02,  9.43044946e-02,
             1.63337544e-01, -1.69042274e-01],
           [-8.55994076e-02, -1.23661250e-01,  1.48442864e-01,
            -1.35983482e-01,  2.05254350e-02]]]], dtype=float32), array([ 0.13065006,  0.12797254, -0.12818147, -0.09621437,  0.04100017,
         -0.07248228,  0.02753541,  0.00476395, -0.11270998,  0.11353076,
         -0.0167569 ,  0.12654744, -0.05019006, -0.07281244,  0.03892357,
         -0.09698197, -0.06845284, -0.04604543, -0.01372138, -0.052395  ,
          0.04833373,  0.16228785,  0.09982517,  0.19556762,  0.10631064,
          0.02496212, -0.14297573, -0.10442089,  0.01970248, -0.1684099 ,
         -0.05076171,  0.19325127], dtype=float32), array([[[[-3.42470817e-02,  8.76816106e-04, -2.13724039e-02,
            -2.62880027e-02, -1.86583996e-02],
           [ 2.56936941e-02, -1.97169576e-02, -3.45735364e-02,
            -4.32738848e-03, -1.22306980e-02],
           [ 8.36322457e-03,  3.26042138e-02, -1.50063485e-02,
            -1.85401291e-02,  2.39207298e-02],
           [-1.15280924e-02, -3.47947963e-02,  2.17274204e-02,
             1.80862695e-02,  2.19682772e-02],
  ...
  etc
  ```


pkgId: 539a31000f2539fb4b22a4003e96cd532ef428b046c5a1d57a6baedb06d91cbb
name: python-branthebuilder
arch: src
version: 1.0.12
epoch: 0
release: 1
summary: Python package management
url: https://github.com/endremborza/branthebuilder
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-branthebuilder-1.0.12-1.src.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.org/projects/branthebuilder/badge/?version=latest)](https://branthebuilder.readthedocs.io/en/latest)
  [![codeclimate](https://img.shields.io/codeclimate/maintainability/endremborza/branthebuilder.svg)](https://codeclimate.com/github/endremborza/branthebuilder)
  [![codecov](https://img.shields.io/codecov/c/github/endremborza/branthebuilder)](https://codecov.io/gh/endremborza/branthebuilder)
  [![pypi](https://img.shields.io/pypi/v/branthebuilder.svg)](https://pypi.org/project/branthebuilder/)

  Utility CLI for creating, documenting, testing minimal python packages. Uses the a [cookiecutter template](https://github.com/endremborza/python-boilerplate-v2).


pkgId: 0fe2e6113111daa7a8b9ce9fc5e22d11d7e08fdcf0f37198da6b330d07a76d67
name: python-brapi-proxy
arch: src
version: 0.0.16
epoch: 0
release: 1
url: https://github.com/matthijsbrouwer/brapi-proxy
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brapi-proxy-0.0.16-1.src.rpm
checksum_type: sha256
summary:
  A BRAPI server instance that functions as a proxy to merge and combine endpoints from existing BRAPI services

description:
  **BrAPI Versions**
  - version 2.1
  **Endpoints**
  - BrAPI-Core
    - /commoncropnames
    - /lists
    - /lists/{listDbId}
    - /locations
    - /locations/{locationDbId}
    - /people
    - /people/{personDbId}
    - /programs
    - /programs/{programDbId}
    - /seasons
    - /seasons/{seasonDbId}
    - /studies
    - /studies/{studyDbId}
    - /trials
    - /trials/{trialDbId}
  - BrAPI-Phenotyping
    - /ontologies
    - /ontologies/{ontologyDbId}
  - BrAPI-Genotyping
    - /allelematrix
    - /callsets
    - /callsets/{callSetDbId}
    - /plates
    - /plates/{plateDbId}
    - /references
    - /references/{referenceDbId}
    - /referencesets
    - /referencesets/{referenceSetDbId}
    - /samples
    - /samples/{sampleDbId}
    - /variants
    - /variants/{variantDbId}
    - /variantsets
    - /variantsets/{variantSetDbId}
  - BrAPI-Germplasm
    - /attributes
    - /attributes/{attributeDbId}
    - /attributevalues
    - /attributevalues/{attributeValueDbId}
    - /breedingmethods
    - /breedingmethods/{breedingMethodDbId}
    - /germplasm
    - /germplasm/{germplasmDbId}

rpm_license:
  MIT License  Copyright (c) 2024 EU H2020 AGENT project  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: dc7b4dfb6150198477f568c0e70308770be1afbd4d55de46dc45dc155d3ef347
name: python-braq
arch: src
version: 0.0.7
epoch: 0
release: 1
summary: Customizable data format for config files, AI prompts, and more
url: https://github.com/pyrustic/braq
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-braq-0.0.7-1.src.rpm
checksum_type: sha256
description:
  [WEB]
  https://github.com
  https://www.xanadu.net
  https://www.wikipedia.org
  https://news.ycombinator.com
  [HISTORY]
  0 = (dict)
      timestamp = 2024-12-20T13:10:51Z
      input = (raw)
          What is the name of the planet


pkgId: 0589acfe9d0717e7f8bff43b5980fb1f1c7301ab22d2cabd8388b46932f39a75
name: python-braq
arch: src
version: 0.0.8
epoch: 0
release: 1
summary: Customizable data format for config files, AI prompts, and more
url: https://github.com/pyrustic/braq
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-braq-0.0.8-1.src.rpm
checksum_type: sha256
description:
  [WEB]
  https://github.com
  https://www.xanadu.net
  https://www.wikipedia.org
  https://news.ycombinator.com
  [HISTORY]
  0 = (dict)
      timestamp = 2024-12-20T13:10:51Z
      input = (raw)
          What is the name of the planet

rpm_license:
  MIT License  Copyright (c) 2023, 2024 Pyrustic Architect  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: 21c0fcc5dd37b85edd5b6131475462cc719121ede790d5278b5e4df1c0154183
name: python-brasil-data
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Brazilian financial market data sources
url: https://github.com/gabrielguarisa/brdata
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brasil-data-1.0.1-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
    <a href="https://github.com/gabrielguarisa/brdata"><img src="https://raw.githubusercontent.com/gabrielguarisa/brdata/0bd34000bf29bd5b93aee011f368bc0385680c58/logo.png?token=GHSAT0AAAAAABPPKYT7BQBOVDJG3NYYQKNOYQ5JIZA" alt="brdata"></a>
  </p>
  <p align="center">
      <em>Brazilian financial market data sources</em>
  </p>

  <div align="center">

  [![Package version](https://img.shields.io/pypi/v/brasil-data?color=%2334D058&label=pypi%20package)](https://pypi.org/project/brasil-data/)
  [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
  [![Semantic Versions](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--versions-e10079.svg)](https://github.com/gabrielguarisa/brdata/releases)
  [![License](https://img.shields.io/github/license/gabrielguarisa/brdata)](https://github.com/gabrielguarisa/brdata/blob/main/LICENSE)

  </div>



  ```shell
  pip install brasil-data
  ```



  The documentation is available in the [docs folder](https://github.com/gabrielguarisa/brdata/tree/main/docs) or in the [docs website](https://gabrielguarisa.github.io/brdata/).



  To contribute, please read the [CONTRIBUTING.md](https://github.com/gabrielguarisa/brdata/blob/main/CONTRIBUTING.md) file.


pkgId: f15b1feefce2c2b24776fdd2d0c4919715cf5c8318c768bd75c4cd428946dce6
name: python-brational
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: A SageMath package to beautifully format a class of rational functions.
url: https://joshmaglione.com/BRational/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brational-1.1.2-1.src.rpm
checksum_type: sha256
description:
  The default expression for
  $$\dfrac{1 + 26T + 66T^2 + 26T^3 + T^4}{(1 - T)^5}$$
  in SageMath is
  ```python
  (-T^4 - 26*T^3 - 66*T^2 - 26*T - 1)/(T^5 - 5*T^4 + 10*T^3 - 10*T^2 + 5*T - 1)
  ```
  Using `brational`, the default is
  ```python
  (1 + 26*T + 66*T^2 + 26*T^3 + T^4)/(1 - T)^5
  ```


pkgId: 617877aae407cd8ae03396c5e8f01f671725322e4a7d4cd9ad7016e2f3995e64
name: python-bravado-asyncio
arch: src
version: 2.0.2
epoch: 0
release: 1
summary: asyncio powered HTTP client for bravado
url: https://github.com/sjaensch/bravado-asyncio
rpm_license: BSD 3-Clause License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bravado-asyncio-2.0.2-1.src.rpm
checksum_type: sha256
description:
  *Note*: This is not a fork or reimplementation of bravado using asynchronous programming (like aiomysql is for PyMySQL).
  The interface of bravado remains unchanged. If you're developing fully asynchronous applications, you should use
  `aiobravado <https://github.com/sjaensch/aiobravado>`_ instead.
  bravado-asyncio is an asynchronous HTTP client for the `bravado library <https://github.com/Yelp/bravado>`_.
  It uses Python's asyncio and `aiohttp <http://aiohttp.readthedocs.io/en/stable/>`_ internally. It enables
  you to do concurrent network requests with bravado, similar to the `fido client <https://github.com/Yelp/fido>`_.
  Unlike fido, bravado-asyncio does not depend on crochet or twisted and uses Python 3's standard library
  to implement asynchronous behavior.
  `aiobravado <https://github.com/sjaensch/aiobravado>`_, the fully asynchronous version of bravado, uses ``bravado-asyncio`` internally as HTTP client.


pkgId: 93155523060172c8246255d0c38fffa686f33d850915d6984e1e4cc4ff194cc6
name: python-bravaorm
arch: src
version: 0.0.29
epoch: 0
release: 1
summary: Python ORM for MySQL
url: https://github.com/robertons/bravaorm
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bravaorm-0.0.29-1.src.rpm
checksum_type: sha256
description:
  SDK fornece uma série de recursos para aumentar produtividade no desenvolvimento de aplicações com integração a banco de dados relacional MySql/MariaDB.



  Instalação utilizando Pip

  ```bash
  pip install bravaorm
  ```

  Git/Clone
  ```
  git clone https://github.com/robertons/bravaorm
  cd bravaorm
  pip install -r requirements.txt
  python setup.py install
  ```




  | entrada     | default |    tipo     | obrigatório |                  |
  |-------------|---------|-------------|-------------|------------------|
  | db_user     | None    | string      | sim         | Nome Usuário     |
  | db_password | None    | string      | sim         | Senha Usuario    |
  | db_host     | None    | string      | sim         | Host             |
  | db_port     | None    | string      | sim         | Porta            |
  | db_database | None    | string      | sim         | Nome DB          |
  | db_ssl      | False   | boolean     | não         | Conexão Segura   |
  | db_ssl_ca   | None    | string      | não         | Certificado CA   |
  | db_ssl_cert | None    | string      | não         | Certificado      |
  | db_ssl_key  | None    | string      | não         | Chave Certificado|
  | db_charset  | utf8    | string      | não         | Charset DB       |
  | log_level   | error   | string      | não         | Nível log        |



  | método       | aplicável 		    |    resultado
  |--------------|--------------------|--------------------------------------------
  | first    	   |  Conexão           | objeto de um select
  | all    	   |  Conexão           | lista de objetos de um select|
  | fetch   	   |  Conexão           | lista  de um select sem conversão em objeto
  | delete(*obj*)| Conexão    		| exclui um objeto
  | save()  	   | Conexão    		| salva operações no db
  | add(*obj*)   | Objeto, Conexão    | adiciona objeto a uma lista/tabela
  | ToJSON()     | Objeto, Conexão    | resultado em formato dict




  ```python
  import bravaorm

  conn = bravaorm.Connection(db_user="root", db_password="pass", db_host="host", db_port=3306, db_database="dbmae", db_charset="utf8mb4")

  ```



  ```python

  import os
  import bravaorm

  bravaorm.Make(dir = os.path.dirname(os.path.abspath(__file__)), db_user="user", db_password="pass", db_host="host", db_port=3306, db_database="dbname")

  ```

  > O script acima irá gerar na raiz do projeto as classes objetos baseados no Banco de Dados. As tabelas do banco dedos devem seguir os requisitos de pluralização, conforme exemplo abaixo:

  ```bash
  .
  ├── ...
  ├── model                           # Raiz Entidade
  │   ├── __init__.py
  │   ├── categoria.py               # Classe Categoria | Tabela categorias
  │   ├── cliente.py                 # Classe Cliente  	| Tabela clientes
  │   └── compra.py                  # Classe Compra  	| Tabela compras
  │   └── produto.py                 # Classe Produto  	| Tabela produtos
  └── ...
  ```

  Tomando como exemplo a tabela produtos, a classe gerada estará assim:

  ```python

  from bravaorm.entity import *

  class Produto(Entity):

  	def __init__(cls, **kw):
  		cls.__metadata__ = {'pk': ['id']}

  		cls.id = Int(pk=True, auto_increment=True, not_null=True, precision=10, scale=0)
  		cls.id_categoria = Int(fk=True, not_null=True, precision=10, scale=0)
  		cls.prod_nome = String(max=155)
  		cls.prod_preco = Decimal(not_null=True, precision=19, scale=2)
  		cls.prod_data_fabricacao = DateTime(format='%d/%m/%Y')
  		cls.prod_data_modificacao = DateTime(format='%d/%m/%Y HH:MM:SS')

  		
  		cls.categorias = Obj(context=cls, keyname='categorias', name='Categoria', key='id', reference='id_categoria', table='categorias')

  		
  		cls.compras = ObjList(context=cls, keyname='compras',name='Compra', key='id_compra', reference='id', table='compras')

  		super().__init__(**kw)
  ```




  ```python
  produto = conn.produtos.where("id=10").first
  print(produto)
  print(produto.toJSON())
  ```

  **> <model.produto.Produto object at 0x101237c10>**

  **> {'id': 10, 'id_categoria': 10, 'prod_nome': 'Exemplo', 'prod_preco':  Decimal('99.90'), 'prod_data_fabricacao': datetime(2010, 12, 10, 0, 0, 0), 'prod_data_modificacao': 'datetime(2021, 03, 31, 16, 54, 22)}**



  A condição orwhere é dependente de condição where, e cria novos blocos a cada utilização.

  ```python
  produtos = conn.produtos.where("id=10").orwhere("id=12").orwhere("id=14").all
  print(produtos.toJSON())
  ```
  **> [{'id': 10, 'id_categoria': 10,  'prod_nome': 'Exemplo', 'prod_preco':  Decimal('99.90'), 'prod_data_fabricacao': datetime(2010, 12, 10, 0, 0, 0), 'prod_data_modificacao': 'datetime(2021, 03, 31, 16, 54, 22)}, {'id': 12, 'prod_nome': 'Outro Exemplo ', 'prod_preco':  Decimal('88,20'), 'prod_data_fabricacao': datetime(2011, 10, 8, 0, 0, 0), 'prod_data_modificacao': 'datetime(2021, 02, 12, 10, 24, 20)}, {'id': 14, 'prod_nome': 'Novo Exemplo', 'prod_preco':  Decimal('129,90'), 'prod_data_fabricacao': datetime(2009, 11, 7, 0, 0, 0), 'prod_data_modificacao': 'datetime(2021, 01, 10, 14, 34, 15)}]**


  ```python
  produto = conn.produtos.where("id=10").select("id, prod_nome").first
  print(produto.toJSON())
  ```
  **> {'id': 10, 'prod_nome': 'Exemplo'}**


  ```python
  produto = conn.produtos.alias('prod_nome','nome').where("id=10").first
  print(produto['nome'])
  print(produto.prod_nome)
  ```
  **> Exemplo**
  **> Exemplo**

  *Alias são campos não editáveis*




  ```python

  produto = conn.produtos.orderby("prod_nome").all
  produto = conn.produtos.orderby("prod_nome DESC").all

  ```


  ```python

  produto = conn.produtos.groupby("id_categoria").all
  ```



  ```python

  produto = conn.produtos.orderby("prod_nome").limit(0,10).all

  ```



  O métodos "join" e "inner" são recomendados para uso de objetos com relacionamento "um para um",  ou em casos onde o resultado da tabela secundária irá retornar apenas **um resultado.** A utilização desses métodos em casos de seleção "um para vários" o resultado será baseado na tabela secundária, podendo ocorrer a repetição do objeto principal. Neste neste caso é recomendável a utilização do método "include" onde o resultado da lista será com objetos únicos incluindo os vários resultados da tabela secundária.

  **Exemplos:**



  O método join, é equivalente ao "LEFT JOIN" e retorna o objeto principal incluindo a seleção secundária, de duas tabelas.

  ```python
  produto = conn.produtos.join("categegorias").all

  ```

  **> {'id': 10, 'id_categoria': 10, 'prod_nome': 'Exemplo', 'prod_preco':  Decimal('99.90'), 'prod_data_fabricacao': datetime(2010, 12, 10, 0, 0, 0), 'prod_data_modificacao': 'datetime(2021, 03, 31, 16, 54, 22), 'categorias': {'id':1, 'cat_nome':'Categoria Teste'}}**




  O método inner, é equivalente ao "INNER JOIN" e retorna o objeto principal baseado na interceção da tabela secundária.

  ```python
  produto = conn.produtos.inner("categorias").where("categorias.id=1").all

  ```

  **> [{'id': 10, 'id_categoria': 10, 'prod_nome': 'Exemplo', 'prod_preco':  Decimal('99.90'), 'prod_data_fabricacao': datetime(2010, 12, 10, 0, 0, 0), 'prod_data_modificacao': 'datetime(2021, 03, 31, 16, 54, 22), 'categorias': {'id':1, 'cat_nome':'Categoria Teste'}}, {'id': 12, 'prod_nome': 'Outro Exemplo ', 'prod_preco':  Decimal('88,20'), 'prod_data_fabricacao': datetime(2011, 10, 8, 0, 0, 0), 'prod_data_modificacao': 'datetime(2021, 02, 12, 10, 24, 20), 'categorias': {'id':1, 'cat_nome':'Categoria Teste'}}, {'id': 14, 'prod_nome': 'Novo Exemplo', 'prod_preco':  Decimal('129,90'), 'prod_data_fabricacao': datetime(2009, 11, 7, 0, 0, 0), 'prod_data_modificacao': 'datetime(2021, 01, 10, 14, 34, 15), 'categorias': {'id':1, 'cat_nome':'Categoria Teste'}}]**



  O método include, faz seleção de um ou vários objetos relacionados ao objeto principal, recomendado para relacionamento um para vários.

  *este método requer atenção em relação a performance para grandes seleções*

  ```python
  produto = conn.produtos.include("compras").where("id=10, compras.compra_paga=1").all

  ```

  **> [{'id': 10, 'id_categoria': 10, 'prod_nome': 'Exemplo', 'prod_preco':  Decimal('99.90'), 'prod_data_fabricacao': datetime(2010, 12, 10, 0, 0, 0), 'prod_data_modificacao': 'datetime(2021, 03, 31, 16, 54, 22), 'compras': [{'id':1, 'compra_data':datetime(2010, 12, 10, 0, 0, 0), 'id_cliente':12}, {'id':23, 'compra_data':datetime(2017, 11, 13, 0, 0, 0), 'id_cliente':54}, {'id':34, 'compra_data':datetime(2018, 1 11, 0, 0, 0), 'id_cliente':20}, {'id':110, 'compra_data':datetime(2019, 7, 22, 0, 0, 0), 'id_cliente':16}]}]**



  O método on, é possibilidade de escritas de join personalizados com tabelas sem relacionamentos. É possível escrever qualquer condição,  "RIGHT, INNER, LEFT JOIN" e retorna o objeto principal com os campos em alias de acordo com a tabela incluída.

  O método possui 4 parametros de entrada, select ( campos da tabela selecionada), metodo join (left, right, inner), tabela e condição

  No exemplo abaixo, selecionamos produtos com cupons de desconto, onde o preço do produto atinge o limite do preço do cumpom

  ```python
  produto = conn.produtos.on("cupons.cod_cupom, cupons.cup_preco_max", "left", "cupons" , "cupons.cup_preco_max >= produtos.prod_preco").where("NOT cupons.id IS NULL").all

  ```

  **> {'id': 10, 'id_categoria': 10, 'prod_nome': 'Exemplo', 'prod_preco':  Decimal('99.90'), 'prod_data_fabricacao': datetime(2010, 12, 10, 0, 0, 0), 'prod_data_modificacao': 'datetime(2021, 03, 31, 16, 54, 22), 'cod_cupom': 'ACAFS' ,'cup_preco_max': Decimal(19,00)}**




  O método fetch  permite o obter a resposta direta do DB em formato dict a partir de um select, sem a conversão dos dados em classe/objeto. Este método oferece ganho significativo de performance.

  ```python

  produtos = conn.produtos.fetch

  ```

  **> [{'id': 10, 'prod_nome': 'Exemplo', 'prod_preco':  Decimal('99.90'), 'prod_data_fabricacao': datetime(2010, 12, 10, 0, 0, 0), 'prod_data_modificacao': 'datetime(2021, 03, 31, 16, 54, 22)}, {'id': 12, 'prod_nome': 'Outro Exemplo ', 'prod_preco':  Decimal('88,20'), 'prod_data_fabricacao': datetime(2011, 10, 8, 0, 0, 0), 'prod_data_modificacao': 'datetime(2021, 02, 12, 10, 24, 20)}, {'id': 14, 'prod_nome': 'Novo Exemplo', 'prod_preco':  Decimal('129,90'), 'prod_data_fabricacao': datetime(2009, 11, 7, 0, 0, 0), 'prod_data_modificacao': 'datetime(2021, 01, 10, 14, 34, 15)}]**



  O metodo toJSON() retorna o objeto ou lista de resultado em formato dict.

  ```python
  	print(produto)
  	print(produto.toJSON())
  ```
  **> <model.produto.Produto object at 0x107737c10>**

  **> {'id': 10, 'prod_nome': 'Exemplo', 'prod_preco':  Decimal('99.90'), 'prod_data_fabricacao': datetime(2010, 12, 10, 0, 0, 0), 'prod_data_modificacao': 'datetime(2021, 03, 31, 16, 54, 22)}**




  ```python
  from model import *

  produto = Produto()
  produto.prod_nome = 'Exemplo'
  produto.prod_preco = Decimal('99.90')
  produto.prod_data_fabricacao = datetime(2010, 12, 10, 0, 0, 0)
  produto.prod_data_modificacao = '31/03/2021 16:54:22' # Conversão para datetime seguindo formato '%d/%m/%Y HH:MM:SS'

  conn.add(produto)
  conn.save()

  ```

  **OU**

  ```python
  from model import *

  produto = Produto(prod_nome='Exemplo', prod_preco=Decimal('99.90'), prod_data_fabricacao = datetime(2010, 12, 10, 0, 0, 0), prod_data_modificacao = '31/03/2021 16:54:22')

  conn.add(produto)
  conn.save()
  ```

  **OU**

  ```python
  from model import *

  produto = Produto(**{prod_nome:'Exemplo', prod_preco:Decimal('99.90'), prod_data_fabricacao:datetime(2010, 12, 10, 0, 0, 0), prod_data_modificacao :'31/03/2021 16:54:22'})

  conn.add(produto)
  conn.save()
  ```



  No exemplo abaixo, criamos um produto na tabela *produtos* com 3 fotos na tabela *produtos_fotos*

  ```python
  from model import *

  produto = Produto()
  produto.prod_nome = 'Exemplo'
  produto.prod_preco = Decimal('99.90')
  produto.prod_data_fabricacao = datetime(2010, 12, 10, 0, 0, 0)
  produto.prod_data_modificacao = '31/03/2021 16:54:22' # Conversão para datetime seguindo formato '%d/%m/%Y HH:MM:SS'

  foto = ProdutoFoto()
  foto.foto_descricao = 'Vista Frontal'
  foto.foto_arquivo =  'fronta.jpg'
  produto.produtos_fotos.add(foto)

  foto = ProdutoFoto(**{foto_descricao:'Vista Lateral', foto_arquivo:'lateral.jpg'})
  produto.produtos_fotos.add(foto)

  produto.produtos_fotos.add(ProdutoFoto(foto_descricao='Vista Lateral', foto_arquivo='lateral.jpg'))

  conn.add(produto)
  conn.save()

  ```



  ```python
  produto = conn.produtos.where("id=10").first
  produto.prod_preco = Decimal(89.90)
  conn.add(produto).save()
  ```
  **ou vários**

  ```python
  produtos = db.produtos.where("prod_preco>=100").all
  for produto in produtos:
  	produto.prod_preco = produto.prod_preco * 0.9
  	conn.add(produto)
  db.save()
  ```

  **ou relativos**

  ```python
  categoria = db.categorias.include("produtos").where("id=1, produtos.pro_preco>=100").all
  for produto in categoria.produtos:
  	produto.prod_preco = produto.prod_preco * 0.9
  	conn.add(produto)
  db.save()
  ```



  O método requer um objeto de entrada, ou uma condição where definida:

  ```python
  conn.delete(produto).save()
  ```
  ou condicional

  ```python
  conn.produtos.where("prod_preco=100").delete()
  ```



  ```python
  quantidade_produtos = conn.produtos.where("prod_preco=100").count

  print(quantidade_produtos)
  ```

  **> 113 **



  Realizar Atualização de registros com condição.


  Atualizando um campo
  ```python
  conn.produtos.where("prod_active=0").set("prod_active", 1)
  ```

  Atualizando um ou mais campos

  ```python
  conn.produtos.where("prod_active=0").update(**{"prod_active": 1, "prod_promo": 1})
  ```

  OU

  ```python
  conn.produtos.where("prod_active=0").update(prod_active=1, prod_promo=0)
  ```



  É possível executar queries mais complexas e com condicionais específicas, nesse caso é possível escrever a query diretamente na conexão e informar qual o tipo de objeto será retornado a partir dela.

  A definição do objeto é opcional.



  ```python
  produtos = conn.execute("SELECT * FROM produtos WHERE preco > 100", "Produto")
  ```

  A consulta acima irá retornar uma lista de  objetos *Produto*


  ```python
  produtos = conn.execute("SELECT * FROM produtos WHERE preco > 100")
  ```

  A consulta acima irá retornar uma lista com dictionary  com dados de produtos





  MIT

  Copyright (c) 2019-2021 Roberto Neves. All rights reserved. info (at) robertonsilva@gmail.com


pkgId: d1b5dd6fa9f459effc726282d6dfe89dc7a52f210e3e097828c81a5775c6634a
name: python-brawling
arch: src
version: 2.0.2
epoch: 0
release: 1
summary: Brawl stars API wrapper (sync + async + proxy + brawlapi)
url: https://pypi.org/project/brawling/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brawling-2.0.2-1.src.rpm
checksum_type: sha256
description:
  Sync + async wrapper for the Brawl Stars API (additionally via an unofficial proxy) and BrawlAPI by Brawlify



  To install normally (only sync, no cache)

  ```
  pip install brawling
  ```

  There are three additional extras you can install: `async`, `cache`, `acache`

  To install with caching support (only sync, installs `requests-cache`)

  ```
  pip install brawling[cache]
  ```

  To install with async support (will install `aiohttp`)

  ```
  pip install brawling[async]
  ```

  To install with async caching support (will also install `aiohttp`, `aiohttp-client-cache` and `aiosqlite`)

  ```
  pip install brawling[acache]
  ```



  Usage is fairly simple and straightforward:

  ```py
  import brawling


  TOKEN = "..."

  client = brawling.Client(TOKEN)
  player = client.get_player("#YOURTAG")
  print(f"Hi, {player.tag}")



  client = brawling.AsyncClient(TOKEN)
  player = await client.get_player("#YOURTAG")
  print(f"Hi, {player.tag}")
  ```

  If you only need to make one or few calls, you can use a context manager:

  ```py
  with brawling.Client(TOKEN) as client:
      player = client.get_player("#YOURTAG")


  async with brawling.AsyncClient(TOKEN) as client:
      player = await client.get_player("#YOURTAG")
  ```

  If you want to paginate over data, there are also paginator functions available to do exactly that:

  ```py
  pages = client.page_brawler_rankings(
      brawling.BrawlerID.SHELLY,
      per_page=10, region='us', max=200
  )



  for page in pages:
      
      print(page)


  ```

  When initializing a client, there are additional options:

  ```py
  Client(token: str,
         proxy = False,
         strict_errors = True,
         cache = False)
  ```

  `proxy` - uses the Royale API proxy (read [Special thanks](#special-thanks) before using!) to make requests, useful if you don't have a static IP.

  `strict_errors` - throw an error if the API returned one, if set to `False`, will return an `ErrorResponse` object instead.

  `cache` - enables caching of responses, caching period is determined by either the API, or a fallback default value of 10 minutes.



  If you are having troubles with getting the `AsyncClient` to work, make sure that you initialize it inside an asynchronous function, like so:

  ```py
  client = None


  async def init():
      client = brawling.AsyncClient("...")

  asyncio.run(init())


  client = brawling.AsyncClient("...")
  ```



  Thanks to [brawlify](https://brawlify.com) for the amazing project [BrawlAPI](https://brawlapi.com)

  Thanks to [Royale API](https://royaleapi.com/) for providing a [proxy service](https://docs.royaleapi.com/proxy.html#how-to-use-with-the-clash-royale-api) to bypass the static IP limitation

  NOTE: These two tools were made by neither me nor Supercell. They have been included in this module just because of their convenience, I am not responsible for any use of them and cannot guarantee that they are, and will continue complying with Supercell's Terms of Service, and therefore it's not my fault if they turn out to be malicious in any way.



  This content is not affiliated with, endorsed, sponsored, or specifically approved by Supercell and Supercell is not responsible for it. For more information see Supercell’s Fan Content Policy: [www.supercell.com/fan-content-policy.](https://supercell.com/en/fan-content-policy/)


pkgId: 2489d2cf0f4a0e2a80b8f15f9f038e7c8612d8460bd4661df8e20886b6dfb156
name: python-brawlstats
arch: src
version: 4.2.0
epoch: 0
release: 1
url: https://github.com/SharpBit/brawlstats
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brawlstats-4.2.0-1.src.rpm
checksum_type: sha256
summary:
  BrawlStats is an easy-to-use sync and async Python API wrapperto fetch statistics from the official Brawl Stars API

description:
  - BrawlStats is a sync and async Python API wrapper to fetch statistics from the official Brawl Stars API.
  - Python 3.9 or later is required.
  Features
  ~~~~~~~~
  - Easy to use with an object oriented design.
  - Use the same client for sync and async usage.
  - Get a player profile and battlelog.
  - Get a club and its members.
  - Get the top 200 rankings for players, clubs, or a specific brawler.
  - Get information about all the brawlers in the game.
  - Get information about the current event rotation!
  Installation
  ~~~~~~~~~~~~
  Install the latest stable build:
     pip install brawlstats
  Install the development build:
     pip install git+https://github.com/SharpBit/brawlstats@development
  Documentation
  ~~~~~~~~~~~~~
  Documentation is being hosted on `Read the Docs`_.
  Examples
  ~~~~~~~~
  Examples are in the `examples folder`_.
  - ``sync.py`` shows you basic sync usage
  - ``async.py`` shows you basic async usage
  - ``discord_cog.py`` shows an example Discord Bot cog using `discord.py`_
  Misc
  ~~~~
  - If you are currently using this wrapper, please star this repository :)
  - If you come across an issue in the wrapper, please `create an issue`_.
  - If you need an API key, visit https://developer.brawlstars.com
  Contributing
  ~~~~~~~~~~~~
  Special thanks to this project's contributors ❤️
  - `erickang21`_
  - `fourjr`_
  - `golbu`_
  - `kjkui`_
  - `kyb3r`_
  - `Papiersnipper`_
  - `OrangutanGaming`_
  - `Stitch`_
  If you want to contribute, whether it be a bug fix or new feature, make sure to follow the `contributing guidelines`_.
  This project is no longer actively maintained. No new features will be added, only bugfixes and security fixes will be accepted.


pkgId: 9564f98f5e54cb006e2cc118650f2c296b45d86baba9d8f018ee127b6a0a8bbe
name: python-brawn
arch: src
version: 1.0.2
epoch: 0
release: 1
summary: A tool for handling repetitive insertions into sequence alignments
url: https://github.com/SJShaw/brawn
rpm_license: GPLv3+
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brawn-1.0.2-1.src.rpm
checksum_type: sha256
description:
  A python port of [MUSCLE](https://drive5.com/muscle/downloads_v3.htm)'s
  profile-profile mode for aligning sequences.

  Brawn was specifically designed with repetitive insertions of query sequences
  into reference alignments in mind.

  Brawn takes advantage of that repetitive nature by using cache files to remove
  the calculations that would need to be repeated over and over for the reference
  alignments. This counters the speed loss of moving from C to python. Initially
  building these cache files will take about 10 times longer than an equivalent
  single run.

  While results are often identical to those from MUSCLE, there will occasionally
  be some minor variations. If an alignment would be very poor in the best case,
  this variation will be more pronounced.

  Only protein sequences are explicitly supported at the moment, full DNA/RNA
  support may follow later.



  ```
  pip install brawn
  ```

  ```
  pip install .
  ```

  ```
  pip install .[testing]
  ```


  For speed, using a cache file is extremely important. They can be built and used
  both programatically and the command line. They are also optional, if required.



  To load an alignment from a FASTA file, use:
  ```
  from brawn import Alignment

  with open("some.fasta") as handle:
      alignment = Alignment.from_file(handle)
  ```

  Or, to build from an existing dictionary (even if it's just one element), use:
  ```
  name_to_sequence = {
      "A": "GT-DVG",
      "B": "GTK-VG",
  }
  alignment = Alignment(name_to_sequence)
  ```

  Or, to load cached calculations directly (this is the preferable option for large alignments):
  ```
  with open("reference.cache") as handle:
      alignment = Alignment.from_cache_file(handle)
  ```

  As a sidenote, to build a cache for the reference alignment:
  ```
  with open("reference.cache", "w") as handle:
      alignment.to_cache_file(handle)
  ```
  This will add any needed computational steps prior to writing.

  Once two alignments have been created/loaded, they can be combined with:
  ```
  from brawn import combine_alignments

  result = combine_alignments(alignment1, alignment2)
  ```

  And the resulting alignment can be output to file:
  ```
  with open("output.fasta", "w") as handle:
      result.to_file(handle=handle)


  results.to_file()
  ```



  For the use case that brawn was designed for, only a single sequence is being
  inserted into a reference alignment at a time. This is usually paired with
  fetching a single reference sequence, and finding the matching sites.

  ```


  aligned_query, aligned_reference = get_aligned_pair(query_sequence, reference_name,
                                                      reference_alignment)

  ```

  Or, if you prefer to have the full set of newly aligned reference sequences as a dictionary:
  ```
  aligned_query, aligned_refs_by_name = insert_into_alignment(query_sequence, alignment)
  ```


  Brawn can function as a drop-in replacement for MUSCLE's `-profile` mode, complete
  command line argument conversion.

  To take advantage of cached alignment calculations, first build a cache of your
  alignment, with:
  ```
  brawn input.fasta --build-cache desired_cache_path
  ```

  From that point, you can use cached files and plain FASTA files interchangeably.
  E.g.
  ```
  brawn query.fasta --reference-alignment some_fasta_file
  ```
  and
  ```
  brawn query.fasta --reference-alignment some_cache_file
  ```
  will both work as expected.

  For the command line, the resulting FASTA output will to be stdout.


pkgId: ed7718e6e7ff229c9b8bc97fd63667a65b7bbb25c6245d06564c4462327b5b2b
name: python-brax
arch: src
version: 0.11.0
epoch: 0
release: 1
summary: A differentiable physics engine written in JAX.
url: http://github.com/google/brax
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brax-0.11.0-1.src.rpm
checksum_type: sha256
description:
  <img src="https://github.com/google/brax/raw/main/docs/img/brax_logo.gif" width="336" height="80" alt="BRAX"/>

  Brax is a fast and fully differentiable physics engine used for research and
  development of robotics, human perception, materials science, reinforcement
  learning, and other simulation-heavy applications.

  Brax is written in [JAX](https://github.com/google/jax) and is designed for use
  on acceleration hardware. It is both efficient for single-device simulation, and
  scalable to massively parallel simulation on multiple devices, without the need
  for pesky datacenters.

  <img src="https://github.com/google/brax/raw/main/docs/img/humanoid_v2.gif" width="160" height="160"/><img src="https://github.com/google/brax/raw/main/docs/img/a1.gif" width="160" height="160"/><img src="https://github.com/google/brax/raw/main/docs/img/ant_v2.gif" width="160" height="160"/><img src="https://github.com/google/brax/raw/main/docs/img/ur5e.gif" width="160" height="160"/>

  Brax simulates environments at millions of physics steps per second on TPU, and includes a suite of learning algorithms that train agents in seconds
  to minutes:

  *   Baseline learning algorithms such as
      [PPO](https://github.com/google/brax/blob/main/brax/training/agents/ppo),
      [SAC](https://github.com/google/brax/blob/main/brax/training/agents/sac),
      [ARS](https://github.com/google/brax/blob/main/brax/training/agents/ars), and
      [evolutionary strategies](https://github.com/google/brax/blob/main/brax/training/agents/es).
  *   Learning algorithms that leverage the differentiability of the simulator, such as [analytic policy gradients](https://github.com/google/brax/blob/main/brax/training/agents/apg).



  Brax offers four distinct physics pipelines that are easy to swap:

  * [MuJoCo XLA - MJX](https://mujoco.readthedocs.io/en/stable/mjx.html) - a JAX
  reimplementation of the MuJoCo physics engine.
  * [Generalized](https://github.com/google/brax/blob/main/brax/generalized/)
  calculates motion in [generalized coordinates](https://en.wikipedia.org/wiki/Generalized_coordinates)
  using dynamics algorithms similar to [MuJoCo](https://mujoco.org/) and [TDS](https://github.com/erwincoumans/tiny-differentiable-simulator).
  * [Positional](https://github.com/google/brax/blob/main/brax/positional/)
  uses [Position Based Dynamics](https://matthias-research.github.io/pages/publications/posBasedDyn.pdf),
  a fast but stable method of resolving joint and collision constraints.
  * [Spring](https://github.com/google/brax/blob/main/brax/spring/) provides
  fast and cheap simulation for rapid experimentation, using simple impulse-based
  methods often found in video games.

  These pipelines share the same API and can run side-by-side within the same
  simulation.  This makes Brax well suited for experiments in transfer learning
  and closing the gap between simulation and the real world.



  Explore Brax easily and quickly through a series of colab notebooks:

  * [Brax Basics](https://colab.research.google.com/github/google/brax/blob/main/notebooks/basics.ipynb) introduces the Brax API, and shows how to simulate basic physics primitives.
  * [Brax Training](https://colab.research.google.com/github/google/brax/blob/main/notebooks/training.ipynb) introduces Brax's training algorithms, and lets you train your own policies directly within the colab. It also demonstrates loading and saving policies.
  * [Brax Training with MuJoCo XLA - MJX](https://colab.sandbox.google.com/github/google-deepmind/mujoco/blob/main/mjx/tutorial.ipynb) demonstrates training in Brax using the `MJX` physics simulator.
  * [Brax Training with PyTorch on GPU](https://colab.research.google.com/github/google/brax/blob/main/notebooks/training_torch.ipynb) demonstrates how Brax can be used in other ML frameworks for fast training, in this case PyTorch.



  To install Brax from pypi, install it with:

  ```
  python3 -m venv env
  source env/bin/activate
  pip install --upgrade pip
  pip install brax
  ```

  You may also install from [Conda](https://docs.conda.io/en/latest/) or [Mamba](https://github.com/mamba-org/mamba):

  ```
  conda install -c conda-forge brax  # s/conda/mamba for mamba
  ```

  Alternatively, to install Brax from source, clone this repo, `cd` to it, and then:

  ```
  python3 -m venv env
  source env/bin/activate
  pip install --upgrade pip
  pip install -e .
  ```

  To train a model:

  ```
  learn
  ```

  Training on NVidia GPU is supported, but you must first install
  [CUDA, CuDNN, and JAX with GPU support](https://github.com/google/jax#installation).



  For a deep dive into Brax's design and performance characteristics, please see
  our paper, [Brax -- A Differentiable Physics Engine for Large Scale Rigid Body Simulation
  ](https://arxiv.org/abs/2106.13281), which appeared in the [Datasets and Benchmarks Track](https://neurips.cc/Conferences/2021/CallForDatasetsBenchmarks) at [NeurIPS 2021](https://nips.cc/Conferences/2021).



  If you would like to reference Brax in a publication, please use:

  ```
  @software{brax2021github,
    author = {C. Daniel Freeman and Erik Frey and Anton Raichuk and Sertan Girgin and Igor Mordatch and Olivier Bachem},
    title = {Brax - A Differentiable Physics Engine for Large Scale Rigid Body Simulation},
    url = {http://github.com/google/brax},
    version = {0.11.0},
    year = {2021},
  }
  ```



  Brax has come a long way since its original publication.  We offer gratitude and
  effusive praise to the following people:

  * Manu Orsini and Nikola Momchev who provided a major refactor of Brax's
  training algorithms to make them more accessible and reusable.
  * Erwin Coumans who has graciously offered advice and mentorship, and many
  useful references from [Tiny Differentiable Simulator](https://github.com/erwincoumans/tiny-differentiable-simulator).
  * Baruch Tabanpour, a colleague who helped launch brax v2 and overhauled the contact library.
  * [Shixiang Shane Gu](https://sites.google.com/corp/view/gugurus) and [Hiroki Furuta](https://frt03.github.io/), who contributed BIG-Gym and Braxlines, and a scene composer to Brax.
  * Our awesome [open source collaborators and contributors](https://github.com/google/brax/graphs/contributors).  Thank you!


pkgId: 390cd84a3dd9db266e3d5be082b4b2c49478789cf2a1daac6a95d0b57c1d712e
name: python-brax
arch: src
version: 0.12.0
epoch: 0
release: 1
summary: A differentiable physics engine written in JAX.
url: http://github.com/google/brax
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brax-0.12.0-1.src.rpm
checksum_type: sha256
description:
  <img src="https://github.com/google/brax/raw/main/docs/img/brax_logo.gif" width="336" height="80" alt="BRAX"/>

  Brax is a fast and fully differentiable physics engine used for research and
  development of robotics, human perception, materials science, reinforcement
  learning, and other simulation-heavy applications.

  Brax is written in [JAX](https://github.com/google/jax) and is designed for use
  on acceleration hardware. It is both efficient for single-device simulation, and
  scalable to massively parallel simulation on multiple devices, without the need
  for pesky datacenters.

  <img src="https://github.com/google/brax/raw/main/docs/img/humanoid_v2.gif" width="160" height="160"/><img src="https://github.com/google/brax/raw/main/docs/img/a1.gif" width="160" height="160"/><img src="https://github.com/google/brax/raw/main/docs/img/ant_v2.gif" width="160" height="160"/><img src="https://github.com/google/brax/raw/main/docs/img/ur5e.gif" width="160" height="160"/>

  Brax simulates environments at millions of physics steps per second on TPU, and includes a suite of learning algorithms that train agents in seconds
  to minutes:

  *   Baseline learning algorithms such as
      [PPO](https://github.com/google/brax/blob/main/brax/training/agents/ppo),
      [SAC](https://github.com/google/brax/blob/main/brax/training/agents/sac),
      [ARS](https://github.com/google/brax/blob/main/brax/training/agents/ars), and
      [evolutionary strategies](https://github.com/google/brax/blob/main/brax/training/agents/es).
  *   Learning algorithms that leverage the differentiability of the simulator, such as [analytic policy gradients](https://github.com/google/brax/blob/main/brax/training/agents/apg).



  Brax offers four distinct physics pipelines that are easy to swap:

  * [MuJoCo XLA - MJX](https://mujoco.readthedocs.io/en/stable/mjx.html) - a JAX
  reimplementation of the MuJoCo physics engine.
  * [Generalized](https://github.com/google/brax/blob/main/brax/generalized/)
  calculates motion in [generalized coordinates](https://en.wikipedia.org/wiki/Generalized_coordinates)
  using dynamics algorithms similar to [MuJoCo](https://mujoco.org/) and [TDS](https://github.com/erwincoumans/tiny-differentiable-simulator).
  * [Positional](https://github.com/google/brax/blob/main/brax/positional/)
  uses [Position Based Dynamics](https://matthias-research.github.io/pages/publications/posBasedDyn.pdf),
  a fast but stable method of resolving joint and collision constraints.
  * [Spring](https://github.com/google/brax/blob/main/brax/spring/) provides
  fast and cheap simulation for rapid experimentation, using simple impulse-based
  methods often found in video games.

  These pipelines share the same API and can run side-by-side within the same
  simulation.  This makes Brax well suited for experiments in transfer learning
  and closing the gap between simulation and the real world.



  Explore Brax easily and quickly through a series of colab notebooks:

  * [Brax Basics](https://colab.research.google.com/github/google/brax/blob/main/notebooks/basics.ipynb) introduces the Brax API, and shows how to simulate basic physics primitives.
  * [Brax Training](https://colab.research.google.com/github/google/brax/blob/main/notebooks/training.ipynb) introduces Brax's training algorithms, and lets you train your own policies directly within the colab. It also demonstrates loading and saving policies.
  * [Brax Training with MuJoCo XLA - MJX](https://colab.sandbox.google.com/github/google-deepmind/mujoco/blob/main/mjx/tutorial.ipynb) demonstrates training in Brax using the `MJX` physics simulator.
  * [Brax Training with PyTorch on GPU](https://colab.research.google.com/github/google/brax/blob/main/notebooks/training_torch.ipynb) demonstrates how Brax can be used in other ML frameworks for fast training, in this case PyTorch.



  To install Brax from pypi, install it with:

  ```
  python3 -m venv env
  source env/bin/activate
  pip install --upgrade pip
  pip install brax
  ```

  You may also install from [Conda](https://docs.conda.io/en/latest/) or [Mamba](https://github.com/mamba-org/mamba):

  ```
  conda install -c conda-forge brax  # s/conda/mamba for mamba
  ```

  Alternatively, to install Brax from source, clone this repo, `cd` to it, and then:

  ```
  python3 -m venv env
  source env/bin/activate
  pip install --upgrade pip
  pip install -e .
  ```

  To train a model:

  ```
  learn
  ```

  Training on NVidia GPU is supported, but you must first install
  [CUDA, CuDNN, and JAX with GPU support](https://github.com/google/jax#installation).



  For a deep dive into Brax's design and performance characteristics, please see
  our paper, [Brax -- A Differentiable Physics Engine for Large Scale Rigid Body Simulation
  ](https://arxiv.org/abs/2106.13281), which appeared in the [Datasets and Benchmarks Track](https://neurips.cc/Conferences/2021/CallForDatasetsBenchmarks) at [NeurIPS 2021](https://nips.cc/Conferences/2021).



  If you would like to reference Brax in a publication, please use:

  ```
  @software{brax2021github,
    author = {C. Daniel Freeman and Erik Frey and Anton Raichuk and Sertan Girgin and Igor Mordatch and Olivier Bachem},
    title = {Brax - A Differentiable Physics Engine for Large Scale Rigid Body Simulation},
    url = {http://github.com/google/brax},
    version = {0.12.0},
    year = {2021},
  }
  ```



  Brax has come a long way since its original publication.  We offer gratitude and
  effusive praise to the following people:

  * Manu Orsini and Nikola Momchev who provided a major refactor of Brax's
  training algorithms to make them more accessible and reusable.
  * Erwin Coumans who has graciously offered advice and mentorship, and many
  useful references from [Tiny Differentiable Simulator](https://github.com/erwincoumans/tiny-differentiable-simulator).
  * Baruch Tabanpour, a colleague who helped launch brax v2 and overhauled the contact library.
  * [Shixiang Shane Gu](https://sites.google.com/corp/view/gugurus) and [Hiroki Furuta](https://frt03.github.io/), who contributed BIG-Gym and Braxlines, and a scene composer to Brax.
  * Our awesome [open source collaborators and contributors](https://github.com/google/brax/graphs/contributors).  Thank you!


pkgId: ad3d62f2a5d9a6666d129e6445ad65227fdc4c29a58f1af0c8486099b33a8311
name: python-brayns
arch: src
version: 3.10.0
epoch: 0
release: 1
summary: Brayns Python API
url: https://github.com/BlueBrain/Brayns
rpm_license: LGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brayns-3.10.0-1.src.rpm
checksum_type: sha256
description:
  You can install this package from [PyPI](https://pypi.org/):
  ```bash
  pip install brayns
  ```
  Or from source:
  ```bash
  git clone https://github.com/BlueBrain/Brayns.git
  cd Brayns/python
  python setup.py sdist
  pip install dist/* # Output in dist folder
  ```


pkgId: d78e51a3e9f64a5c3d2b99c001a1cea2ee11a6142ef819756649eed8da398e03
name: python-braze-client
arch: src
version: 2.3.3
epoch: 0
release: 1
summary: Braze Python Client
url: https://github.com/dtatarkin/braze-client
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-braze-client-2.3.3-1.src.rpm
checksum_type: sha256
description:
  A Python client for the Braze REST API

  [![Build Status](https://travis-ci.com/dtatarkin/braze-client.svg?branch=master)](https://travis-ci.com/dtatarkin/braze-client)
  [![Coverage](https://codecov.io/gh/dtatarkin/braze-client/branch/master/graph/badge.svg)](https://codecov.io/gh/dtatarkin/braze-client)



  Make sure you have Python 2.7+ or 3.6+ installed and run:

  ```
  $ git clone https://github.com/dtatarkin/braze-client
  $ cd braze-client
  $ python setup.py install
  ```



  ```python
  from braze.client import BrazeClient
  client = BrazeClient(api_key='YOUR_API_KEY', use_auth_header=True)

  r = client.user_track(
      attributes=[{
          'external_id': '1',
          'first_name': 'First name',
          'last_name': 'Last name',
          'email': 'email@example.com',
          'status': 'Active',
          
      }],
      events=None,
      purchases=None,
  )
  if r['success']:
      
      print('Success!')
      print(r)
  else:
      print(r['client_error'])
      print(r['errors'])

  ```
  For more examples, check `examples.py`.



  To run the unit tests, make sure you have the [tox](https://tox.readthedocs.io/en/latest/) module installed
  and run the following from the repository root directory:

  `$ tox`


pkgId: d75057fd483d781620f6ddbd6b700159f371546edcd37181d0a40fcbf25523fa
name: python-braze-sdk
arch: src
version: 1.0.1
epoch: 0
release: 1
summary: Braze Python 3 SDK.
url: https://github.com/paulokuong/braze
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-braze-sdk-1.0.1-1.src.rpm
checksum_type: sha256
description:
  SDK for Braze API
      | SDK for Braze API.
      | https://www.braze.com/docs/api/basics/
      | https://github.com/paulokuong/braze


pkgId: 779ce3a72101715316bfa6883b6c931b11db4a555468b2767d15b35980dc323b
name: python-brazilcep
arch: src
version: 6.5.0
epoch: 0
release: 1
summary: Minimalist and easy-to-use python library designed to query CEP (brazilian zip codes) data
url: https://pypi.org/project/brazilcep/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brazilcep-6.5.0-1.src.rpm
checksum_type: sha256
description:
  <h2 align="center">
    <a href="https://pypi.org/project/brazilcep/">
      <img src="https://github.com/mstuttgart/brazilcep/assets/8174740/fb7c86c8-6261-4300-b2e0-65877084d865" width="15%">
    </a>
    <br>
        BrazilCEP
  </h2>

  <p align="center">

    <a href="https://github.com/mstuttgart/brazilcep/actions?query=workflow%3A%22Github+CI%22">
      <img alt="GitHub Workflow Status" src="https://img.shields.io/github/actions/workflow/status/mstuttgart/brazilcep/test.yml?color=fcd800&branch=main">
    </a>

   <a href="https://codecov.io/gh/mstuttgart/brazilcep" >
   <img alt="Codecov" src="https://img.shields.io/codecov/c/github/mstuttgart/brazilcep?color=fcd800">
   </a>

    <a href="https://pypi.org/project/brazilcep">
      <img src="https://img.shields.io/pypi/dm/brazilcep?color=fcd800" alt="Downloads">
    </a>

    <a href="https://pypi.org/project/brazilcep">
      <img src="https://img.shields.io/pypi/v/brazilcep.svg?" alt="Ratings">
    </a>

    <a href="https://pypi.org/project/brazilcep/">
      <img src="https://img.shields.io/pypi/pyversions/brazilcep.svg" alt="Version">
    </a>

  </p>

  <p align="center">
    <a href="#about">About</a> |
    <a href="#install">Install</a> |
    <a href="#how-to-use">How to Use</a> |
    <a href="#documentation">Documentation</a> |
    <a href="#contribute">Contribute</a> |
    <a href="#credits">Credits</a>
  </p>



  **BrazilCEP** is a minimalist and easy-to-use python library designed to query CEP (Postal Address Code) data.

  Its objective is to provide a common query interface to all these search services, facilitating the integration of Python applications with these services.

  Currently supports several CEP API's:

  - [ViaCEP](https://viacep.com.br)
  - [ApiCEP (WideNet)](https://apicep.com)
  - [OpenCEP](https://opencep.com/)

  > [!NOTE]
  > **BrazilCEP** is the new name of former **PyCEPCorreio** python library.
    If you want to migrate the old code to the new version, please see the [migrate](https://brazilcep.readthedocs.io/en/latest/migrate/) section in docs.

  > [!TIP]
  > **CEP** or **Código de Endereçamento Postal** (*Postal Address Code*), as it is also known, is a system of numeric codes, created, maintained and organized by *Correios do Brazil* for
  > organizing addresses and deliveries of letters and parcels.




  The recommended way to get BrazilCEP is to **install the latest stable release**
  via [pip](http://pip-installer.org>):

  ```sh
  pip install brazilcep
  ```

  > [!IMPORTANT]
  > We currently support **Python 3.8+ only**. Users on older interpreter versions are urged to upgrade.



  Making a request is very simple. Begin by importing the BrazilCEP module:

  ```python
  >>> import brazilcep
  ```

  Now, call the `get_address_from_cep` to query any CEP:

  ```python
  >>> address = brazilcep.get_address_from_cep('37503-130')
  ```

  Now, we have a *dict* object called ``address``. We can
  get all the address information we need from this object:

  ```python
   >>> address
  {
      'district': 'rua abc',
      'cep': '37503130',
      'city': 'city ABC',
      'street': 'str',
      'uf': 'str',
      'complement': 'str',
  }
  ```

  The CEP always must be a string.

  > [!TIP]
  > BrazilCEP was developed to integrate on-demand queries into web pages.
  > Querying CEP in bulk through scripts or any other means is not recommended.

  > [!IMPORTANT]
  > BrazilCEP is not responsible for the functioning, availability and support of any of these query API's.
  > All of them are provided by third parties, and this library just provides a handy way to centralize the CEP search on these services.



  Documentation for the current version of BrazilCEP is available from the official docs [here](https://brazilcep.readthedocs.io/en/stable).



  See this *guideline* [here](https://github.com/mstuttgart/brazilcep/blob/develop/CONTRIBUTING.md).



  Copyright (C) 2016-2024 by Michell Stuttgart

rpm_license:
  MIT License  Copyright (c) 2016-2024, Michell Stuttgart  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: 4bd8c24e46210cd989d0bb1532ddc8d5fd59172019800b2c5354993d5e449120
name: python-brazilcep
arch: src
version: 6.6.1
epoch: 0
release: 1
summary: Minimalist and easy-to-use python library designed to query CEP (brazilian zip codes) data
url: https://pypi.org/project/brazilcep/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brazilcep-6.6.1-1.src.rpm
checksum_type: sha256
description:
  <h2 align="center">
    <a href="https://pypi.org/project/brazilcep/">
      <img src="https://github.com/mstuttgart/brazilcep/assets/8174740/fb7c86c8-6261-4300-b2e0-65877084d865" width="15%">
    </a>
    <br>
        BrazilCEP
  </h2>

  <p align="center">

    <a href="https://github.com/mstuttgart/brazilcep/actions?query=workflow%3A%22Github+CI%22">
      <img alt="GitHub Workflow Status" src="https://img.shields.io/github/actions/workflow/status/mstuttgart/brazilcep/test.yml?color=fcd800&branch=main">
    </a>

   <a href="https://codecov.io/gh/mstuttgart/brazilcep" >
    <img alt="Codecov" src="https://img.shields.io/codecov/c/github/mstuttgart/brazilcep?color=fcd800">
   </a>

  <a href="https://brazilcep.readthedocs.io/" >
    <img alt="readthedocs" src="https://img.shields.io/readthedocs/brazilcep?color=fcd800">
   </a>

    <a href="https://pypi.org/project/brazilcep">
      <img src="https://img.shields.io/pypi/dm/brazilcep?color=fcd800" alt="Downloads">
    </a>

    <a href="https://pypi.org/project/brazilcep">
      <img src="https://img.shields.io/pypi/v/brazilcep.svg?" alt="Ratings">
    </a>

    <a href="https://pypi.org/project/brazilcep/">
      <img src="https://img.shields.io/pypi/pyversions/brazilcep.svg" alt="Version">
    </a>

  </p>

  <p align="center">
    <a href="#about">About</a> |
    <a href="#install">Install</a> |
    <a href="#quick-start">How to Use</a> |
    <a href="#documentation">Documentation</a> |
    <a href="#contribute">Contribute</a> |
    <a href="#credits">Credits</a>
  </p>



  **BrazilCEP** is a minimalist and easy-to-use Python library designed to query CEP (Postal Address Code) data.

  Its objective is to provide a common query interface to all these search services, facilitating the integration of Python applications with these services.

  Currently supports several CEP API's:

  - [ViaCEP](https://viacep.com.br)
  - [ApiCEP (WideNet)](https://apicep.com)
  - [OpenCEP](https://opencep.com/)

  > [!NOTE]
  > **BrazilCEP** is the new name of former **PyCEPCorreio** Python library.
  > If you want to migrate the old code to the new version, please see the [migrate](https://brazilcep.readthedocs.io/api.html#migrate-from-pycepcorreios) section in docs.

  > [!TIP]
  > **CEP** or **Código de Endereçamento Postal** (_Postal Address Code_), as it is also known, is a system of numeric codes, created, maintained and organized by _Correios do Brazil_ for
  > organizing addresses and deliveries of letters and parcels.



  The recommended way to get BrazilCEP is to **install the latest stable release**
  via [pip](http://pip-installer.org>):

  ```sh
  pip install brazilcep
  ```



  Making a request is very simple. Begin by importing the BrazilCEP module:

  ```python
  >>> import brazilcep
  ```

  Now, call the `get_address_from_cep` to query any CEP:

  ```python
  >>> address = brazilcep.get_address_from_cep('37503-130')
  ```

  Now, we have a _dict_ object called `address`. We can
  get all the address information we need from this object:

  ```python
   >>> address
  {
      'district': 'rua abc',
      'cep': '37503130',
      'city': 'city ABC',
      'street': 'str',
      'uf': 'str',
      'complement': 'str',
  }
  ```

  The CEP always must be a string.

  > [!TIP]
  > BrazilCEP was developed to integrate on-demand queries into web pages.
  > Querying CEP in bulk through scripts or any other means is not recommended.

  > [!IMPORTANT]
  > BrazilCEP is not responsible for the functioning, availability and support of any of these query API's.
  > All of them are provided by third parties, and this library just provides a handy way to centralize the CEP search on these services.



  Documentation for the current version of BrazilCEP is available [here](https://brazilcep.readthedocs.io/).



  See this _guideline_ [here](https://brazilcep.readthedocs.io/contributing.html).



  Copyright (C) 2016-2024 by Michell Stuttgart

rpm_license:
  MIT License  Copyright (c) 2016-2024, Michell Stuttgart  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


pkgId: 20e126b34e6762248305661d919c9be8b55f4e0b1d20d17d3bc6f5db6401566e
name: python-brazilnum
arch: src
version: 0.8.8
epoch: 0
release: 1
summary: Validate Brazilian CNPJ, CEI, CPF, PIS/PASEP, CEP, and municipal numbers
url: https://github.com/poliquin/brazilnum
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brazilnum-0.8.8-1.src.rpm
checksum_type: sha256
description:
  Python functions for working with CNPJ, CEI, CPF, PIS/PASEP, CEP, and municipal
  (município) codes, which identify firms, people, and places in Brazil.


pkgId: 9158c9b1877746f714f89046d2db949d2da125145e5d109dd42913b63f80d3c6
name: python-brdata-rag-tools
arch: src
version: 0.1.5.2
epoch: 0
release: 1
url: https://github.com/br-data/rag-tools-library
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brdata-rag-tools-0.1.5.2-1.src.rpm
checksum_type: sha256
summary:
  Improve development of retrieval augmented generation (RAG) applications at the BR AI + Automation Lab.

description:
  Library to support common tasks in retrieval augmented generation (RAG).

  This library is in a very early stage and all the documentation is AI generated.



  You find a brief tutorial and the documentation under [br-data.github.io/rag-tools-library](https://br-data.github.io/rag-tools-library/).



  - [ ] Add Google Bison to available LLMs
  - [x] Add an offline database alternative
    - [x] FAISS and SQLite
  - [x] Allow users to register their own LLMs
  - [x] Allow users to register their own Embedding models
  - [ ] Support Semantic Scholar endpoint to generate embeddings for scientific papers.
  - [x] Support chat functionality; e.g. let the user give feedback on the result to the LLM.



  Run the `build_and_deploy.sh` script in the root folder. Once prompted for the username, pass `__token__` and the pypi API
  token you've received. If you don't have an API token and feel like you should, feel free to contact the maintainers.



  Marco Lehner

  [marco.lehner@br.de](mailto:marco.lehner@br.de)


pkgId: f3f8761b894e05057f1fa7f59d7b8f157e9ffc532cd374028de9f1081a51d6d2
name: python-breache
arch: src
version: 0.0.1
epoch: 0
release: 1
summary: The Breache Python SDK
url: https://breache.com
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-breache-0.0.1-1.src.rpm
checksum_type: sha256
description:
  The official Python SDK for Breache - a powerful data management and analytics platform.



  You can install the Breache Python SDK using pip:


pkgId: bfffbf6bfdf2b71844898b9bd9f448b95fb28707fe30cb20387a76383c52bacf
name: python-breadability
arch: src
version: 0.1.20
epoch: 0
release: 1
summary: Port of Readability HTML parser in Python
url: https://github.com/bookieio/breadability
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-breadability-0.1.20-1.src.rpm
checksum_type: sha256
description:
  I've tried to work with the various forks of some ancient codebase that ported
  `readability`_ to Python. The lack of tests, unused regex's, and commented out
  sections of code in other Python ports just drove me nuts.
  I put forth an effort to bring in several of the better forks into one
  code base, but they've diverged so much that I just can't work with it.
  So what's any sane person to do? Re-port it with my own repo, add some tests,
  infrastructure, and try to make this port better. OSS FTW (and yea, NIH FML,
  but oh well I did try)
  This is a pretty straight port of the JS here:
  - http://code.google.com/p/arc90labs-readability/source/browse/trunk/js/readability.js#82
  - http://www.minvolai.com/blog/decruft-arc90s-readability-in-python/


pkgId: 0a16732592511574989e8a9788c745717b5337e24a0fffda4896a2d601dcd734
name: python-breakfast
arch: src
version: 0.4.5
epoch: 0
release: 1
summary: breakfast: fast putative outbreak cluster and infection chain detection using SNPs
url: https://github.com/rki-mf1/breakfast
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-breakfast-0.4.5-1.src.rpm
checksum_type: sha256
description:
  [![Tests](https://github.com/rki-mf1/breakfast/workflows/Tests/badge.svg)](https://github.com/rki-mf1/breakfast/actions?workflow=Tests)

  `breakfast` is a simple and fast script developed for clustering SARS-CoV-2 genomes using precalculated sequence features (e.g. nucleotide substitutions) from [covSonar](https://github.com/rki-mf1/covsonar) or [Nextclade](https://clades.nextstrain.org/).

  **This project is under development and in experimental stage**

  <img src="/img/breakfast_logo_2.png" width="300">





  Breakfast is available in [bioconda](http://bioconda.github.io/recipes/breakfast/README.html). You can install it using either the conda command, or if you've installed [mamba](https://github.com/mamba-org/mamba) you can use that:

  ```
  $ conda install -c bioconda breakfast

  $ mamba install -c bioconda breakfast
  ```



  Conda is available from [PyPI](https://pypi.org/project/breakfast/) and can be installed using pip:

  ```
  $ pip install breakfast
  ```





  ```
  breakfast \
     --input-file breakfast/test/testfile.tsv  \
     --max-dist 1 \
     --outdir test-run/
  ```

  You will find your results in `test-run/cluster.tsv`, which should be identical to `breakfast/test/expected_clusters_dist1.tsv`



  breakfast uses pre-calculated sequence features (= mutations) as input rather than raw sequences. These features can be calculated with several different programs, but the one we mainly use is [covsonar](https://github.com/rki-mf1/covsonar). It can be used to maintain a database of mutations for a large number of sequences, which can then be easily queried.

  ```
  conda activate sonar
  covsonar/sonar.py add -f genomes.fasta --db mydb --cpus 8
  covsonar/sonar.py match --tsv --db mydb > genomic_profiles.tsv
  ```

  Clustering with a maximum SNP-distance of 1 and excluding clusters below a size of 5 sequences:

  ```
  breakfast \
     --input-file genomic_profiles.tsv \
     --max-dist 1 \
     --min-cluster-size 5 \
     --outdir covsonar-breakfast-results/
  ```



  An alternative to covsonar that is commonly used is [Nextclade CLI](https://clades.nextstrain.org/).

  ```
  conda install -c bioconda nextclade  # If nextclade isn't already installed
  nextclade dataset get --name 'sars-cov-2' --output-dir 'data/sars-cov-2'
  nextclade \
     --in-order \
     --input-fasta genomes.fasta \
     --input-dataset data/sars-cov-2 \
     --output-tsv output/nextclade.tsv \
     --output-tree output/nextclade.auspice.json \
     --output-dir output/ \
     --output-basename nextclade
  ```

  Alternatively, you can also use [Nextclade Web](https://clades.nextstrain.org/) to process your fasta and export the genomic profile as "nextclade.tsv".

  Clustering with a maximum SNP-distance of 1 and excluding clusters below a size of 5 sequences. Since the input tsv of Nextclade looks a little different from the covSonar tsv, you need to specify the additional parameters `--id-col`, `--clust-col` and `--sep2` for identifying the correct columns.

  ```
  breakfast \
     --input-file output/nextclade.tsv \
     --max-dist 1 \
     --min-cluster-size 5 \
     --id-col "seqName" \
     --clust-col "substitutions" \
     --sep2 "," \
     --outdir nextclade-breakfast-results/
  ```



  Typical input data to breakfast looks something like the following table (example from covsonar with unnecessary columns removed):

  ```
  accession	dna_profile
  example1	C241T T606C C913T C3037T del:11288:9 C13515T
  example2	C241T T606C del:1000:10
  example3	C241T T606C del:1001:20
  ```

  breakfast has parameters to allow the user to ignore deletions (`--skip-del`), insertions (`--skip-ins`) or mutations at the end of the sequences (which can sometimes be error-prone) when calculating the distance between sequences. To be able to do this, we need to know what kind of input is being provided (using the `--var-type` option), and then parse the mutations themselves. Since the format of how mutations are represented by upstream programs differs, we have implemented program-specific parsers for covsonar DNA and AA, as well as nextclade DNA and AA. Examples are shown below, in case you want to use some other program as input to breakfast you can see if the format matches one of the existing feature formats. As a fallback, you can use the "raw" format, which disables parsing and does not allow you to use breakfast's indel skipping or trimming features.



  | mutation type | DNA (`covsonar_dna`) | AA (`covsonar_aa`) |
  | ------------ | ----- | ------- |
  | substitution | C241T | S:N501Y |
  | deletion | del:11288:9 | ORF1:del:12:7 |
  | insertion | C241TAT | N:A34AK |



  | mutation type | DNA (`nextclade_dna`) | AA (`nextclade_aa`) |
  | ------------ | ----- | ------- |
  | substitution | C241T | S:N501Y |
  | deletion | 11288-11297 or 22492 | S:V70- |
  | insertion | 273:CTTCGA | (not provided) |



  Features will not be parsed. Skipping inserts (`--skip-ins`) and/or deletions (`--skip-del`) and the trimming options are not supported with this feature type.



  | Parameter              | Type    	| Required | Default 	| Description                                |
  |----------------------- |---------	|----------|----------|------------------------------------------  |
  | --input-file           | String     	|✅	     | 'genomic_profiles.tsv.gz'    	| Path of the input file (in tsv format)     |
  | --max-dist              | Integer  	|	     | 1     	| Two sequences will be grouped together, if their pairwise edit distance does not exceed this threshold |
  | --min-cluster-size  | Integer  	|      | 2     	| Minimum number of sequences a cluster needs to include to be defined in the result file      |
  | --id-col    | String 	|     | 'accession'      	| Name of the sequence identifier column of the input file          |
  | --clust-col              | String 	|     | 'dna_profile'      | Name of the mutation profile column of the input file         |
  | --var-type              | String 	|     | 'covsonar_dna'       | Mutuation format (e.g. for DNA mutations from covsonar, use covsonar_dna). Possible values: [covsonar_dna|covsonar_aa|nextclade_dna|nextclade_aa|raw] |
  | --sep              | String 	|     | '\t'      | Input file separator       |
  | --sep2              | String 	|     | ' '      | Secondary clustering column separator (between each mutation)        |
  | --outdir              | String 	|     | 'output/'       | Path of output directory        |
  | --trim-start               | Integer 	|     | 264       | Bases to trim from the beginning         |
  | --trim-end               | Integer 	|     | 228       | Bases to trim from the end         |
  | --reference-length              | Integer 	|     | 29903      | Length of reference genome (defaults to NC_045512.2)        |
  | --skip-del               | Bool 	|     | TRUE       | Deletions will be skipped for calculating the pairwise distance of your input sequences.|
  | --skip-ins               | Bool 	|     | TRUE       | Insertions will be skipped for calculating the pairwise distance of your input sequences.         |
  | --input-cache           | Integer 	|     | None   | Path to import results from previous run |
  | --output-cache              | String 	|     | None       | Path to export results which can be used in the next run to decrease runtime.  |
  | --jobs              | Integer 	|     | 1       | The number of jobs (=threads) to run simultaneously |
  | --help                   | N/A     	|	   | N/A     	| Show this help message and exit            |
  | --version                | N/A     	|	   | N/A     	| Show version and exit            |



  `breakfast` runs under Python 3.10 and later. We rely heavily on some excellent open source python libraries: networkx, pandas, numpy, scikit-learn, click, and scipy.


pkgId: aff558fca07606a836ecedf152739b0f0c91f5e74637bb1309df1f60538a894f
name: python-breakword
arch: src
version: 0.3.2
epoch: 0
release: 1
summary: Mixing breakpoints with print debugging.
url: https://github.com/breuleux/breakword
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-breakword-0.3.2-1.src.rpm
checksum_type: sha256
description:
  `breakword` is a small debugging utility that combines print debugging with breakpoint debugging. It aims to facilitate debugging the kind of problem where you might use print statements to quickly spot where something seems to be off, and then switch to a step by step debugger.

  `breakword` normally requires running your program twice and will only work properly if it is deterministic.




  1. Set the `PYTHONBREAKPOINT` environment variable to `breakword.breakpoint`.

  2. Use `breakpoint` like a `print` statement:

  ```python
  for i in range(10):
      breakpoint(i)
  ```

  This will print out something like this:

  ```
  $ python example.py
  ⏎ standard 0
  ⏎ sound 1
  ⏎ character 2
  ⏎ thank 3
  ⏎ play 4
  ⏎ however 5
  ⏎ fish 6
  ⏎ cultural 7
  ⏎ either 8
  ⏎ and 9
  ```

  3. Use the `BREAKWORD` environment variable to set a breakpoint to what you want to investigate further. For instance, if you want to stop when `i == 6` in the above program, you can run the following command:


  ```
  $ env BREAKWORD=fish python example.py
  ⏎ standard 0
  ⏎ sound 1
  ⏎ character 2
  ⏎ thank 3
  ⏎ play 4
  ⏎ however 5
  ⏎ fish 6
  > example.py(2)<module>()
  -> for i in range(10):
  (Pdb) i
  6
  ```

  You can also give a comma-separated list of words, e.g. `BREAKWORD=sound,fish`.

  **Note:** `breakpoint()` with no arguments retains the normal behavior.

  ![demo](https://raw.githubusercontent.com/breuleux/breakword/master/media/demo.png)




  * `breakword.log(*things, **config)`: Print a word and optionally other things after it.

  * `breakword.brk(watch=None, **config)`: Sets a breakpoint to trigger after `log` printed out the given word. If `watch` is `None` or not given, the `BREAKWORD` environment variable is consulted. If the variable is not set, nothing will happen.
    * This is equivalent to `breakword.after(word).breakpoint()`.

  * `breakword.after(watch=None, **config)`: Returns an object that evaluates to `True` right after `log` printed out the given watch word. As with `brk`, if `watch` is `None` or not given, the `BREAKWORD` environment variable is consulted.

  * `breakword.word(**config)`: Returns the next word as a string. You can print it yourself, in which case it's basically like `log`, or you can store it in an object.

  * `breakword.logbrk(**config)`: Calls `log` and then `brk`.

  * `breakword.wordbrk(**config)`: Calls `word` and then `brk`. The word is returned.

  * `breakword.set_default_logger(logger)`: Set the logging function to use (defaults to `print`)




  * `breakword.track(obj, all=False)` will set the `breakword` attribute in the object to the next word in the list. By setting the `BREAKWORD` environment variable, you will set a breakpoint to the corresponding call to `track`. Set the `all` argument to `True` and the attribute will contain a list. Note: this will not work if `obj` is an integer or string, in those cases track will print a warning.

  * `breakword.track_creation(*classes)` will set the `breakword` attribute on all instances of the given classes, when they are created. That way, you can set a breakpoint back to the creation of some object of interest.




  Use `breakword.groups.<name>` to get a "word group" with the given name. Each group generates words independently and will therefore not interfere with each other. They have `log`, `brk`, `after`, `word`, etc. as methods. The default group is `groups[""]`.


  ```python
  from breakword import groups

  assert groups.aardvark == groups["aardvark"]


  groups.aardvark.log("a")


  groups.pelican.log("b")


  word = groups.pelican.word()


  if groups.pelican.after("cherry"):
      print("blah")
  ```


pkgId: 633d247a910d88f630f033a694902d8b580e7f1226675d350ca25482fdabf7b2
name: python-breba-docs
arch: src
version: 0.1.7
epoch: 0
release: 1
summary: Documentation assistant will proof read your docs
url: https://github.com/breba-apps/breba-docs
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-breba-docs-0.1.7-1.src.rpm
checksum_type: sha256
description:
  _AI documentation validator_

  [![workflow](https://github.com/breba-apps/breba-docs/actions/workflows/test.yaml/badge.svg?branch=main)](https://github.com/breba-apps/breba-docs/actions/workflows/test.yaml?query=branch%3Amain)


  Scans your documentation file and executes commands in the documentation
  to make sure that it is possible to follow the documentation.




  Docker engine needs to be installed and running. Use docker installation instructions for your system.

  Get an OpenAI API Key and set environment variable like this:
  ```bash
  export OPENAI_API_KEY=[your_open_ai_api_key]
  ```


  To install and run breba-docs, run the following commands:

  ```bash
  pip install breba-docs
  breba_docs
  ```

  Then you will need to provide location of a documentation file.
  For example: `breba_docs/sample_doc.md`

  The software will then analyze the documentation and run the commands found in the documentation
  inside a docker container with python installed.

  The AI will then provide feedback regarding how it was able to follow the instructions.


  For contributing to the project, please refer to [Contribution Guide](docs/CONTRIBUTING.md).


pkgId: 9752b07fadb576c9ee03338e94b66a777ee0b6293a8e2a82cbb9962273204706
name: python-breez-sdk-lib
arch: src
version: 0.2.12
epoch: 0
release: 1
summary: Python language bindings for the Breez SDK
url: https://github.com/breez/breez-sdk
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-breez-sdk-lib-0.2.12-1.src.rpm
checksum_type: sha256
description:
  Python language bindings for the [Breez SDK](https://github.com/breez/breez-sdk).



  ```shell
  pip install breez_sdk_lib
  ```



  See [sdk-doc.breez.technology](https://sdk-doc.breez.technology).


pkgId: de7c4765b2363ce4b15922184c548944731c6ad47216275d589f9b50c6f7ed8c
name: python-breeze-dbt-cli
arch: src
version: 0.2.5
epoch: 0
release: 1
summary: A CLI tool to streamline dbt project development.
url: https://github.com/alecab94/breeze-dbt-cli
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-breeze-dbt-cli-0.2.5-1.src.rpm
checksum_type: sha256
description:
  **Breeze** is a command-line interface (CLI) tool designed to streamline the development of dbt (Data Build Tool) projects. It automates the creation and management of dbt models, sources, and their associated YAML files. Additionally, it provides utilities to add tests to models and sources efficiently.



  1. [Installation](#installation)
  2. [Command Overview](#command-overview)
  3. [Build Commands](#build-commands)
     - [`breeze build model`](#breeze-build-model)
     - [`breeze build yml`](#breeze-build-yml)
     - [`breeze build source`](#breeze-build-source)
  4. [Add Commands](#add-commands)
     - [`breeze add test`](#breeze-add-test)
  5. [Templates](#templates)
     - [Template Placeholders](#template-placeholders)
     - [Example Templates](#example-templates)
  6. [Examples](#examples)
  7. [Best Practices](#best-practices)
  8. [Support and Contributions](#support-and-contributions)
  9. [Conclusion](#conclusion)



  run `pip install breeze-dbt-cli` in your dbt projects virtual environment.



  Breeze organizes its functionality into several command groups:

  - **build**: Commands to generate models, YAML files, and sources.
  - **add**: Commands to add tests to models or sources.

  Use `breeze --help` to display the help message and list of available commands.



  Commands under the `build` group help in creating models, YAML files, and sources.



  Generate `.sql` files with a boilerplate `SELECT` statement for each model under `models/folder_name/model_name/model_name.sql`.



  ```bash
  breeze build model [OPTIONS] PATH MODEL_NAMES...
  ```



  - **PATH** *(required)*: The folder path where the models .sql files will be created. By default, .sql files get created under their own subdirectory named after the model within the path provided. To omit this behaviour and create .sql files directly in the path provided, use `--no-subfolder` or `-n` flag.
  - **MODEL_NAMES** *(required)*: One or more model names for which to generate `.sql` files.



  - **--force, -f**: Overwrite existing `.sql` files if they exist.
  - **--template, -t**: Path to a custom SQL template file.
  - **--no-subfolder, -n**: If specified, the `.sql` file will be created directly in the provided path instead of a subfolder named after the model.



  - Generate `.sql` files for `model1` and `model2` in `models/stg/model1/` and `models/stg/model2/` respectively:

  ```bash
  breeze build model stg model1 model2
  ```

  -  Generate `.sql` files for `model1` and `model2` in in `models/stg/`, without creating separate subfolders for each model:

  ```bash
  breeze build model staging model1 model2 --no-subfolder
  ```

  - Generate `.sql` file for `model1` in `models/stg/model1/` using a custom template located in `templates/model1_template.sql` and overwrite existing file:

  ```bash
  breeze build model stg model1 --template templates/model1_template.sql --force
  ```



  Generate YAML files for one or more models. The YAML file will be created in the same directory as the corresponding `.sql` file for the model.



  ```bash
  breeze build yml [OPTIONS] MODEL_NAMES...
  ```



  - **MODEL_NAMES** *(required)*: One or more model names for which to generate YAML files.



  - **--force, -f**: Overwrite existing files if they exist.
  - **--template, -t**: Path to a custom YAML template file.



  - Generate YAML files for `model1` and `model2`:

  ```bash
  breeze build yml model1 model2
  ```

  - Generate `.yml` file for `model1` using a custom template located in `templates/model1_template.yml` and overwrite existing file:

  ```bash
  breeze build yml model1 --template templates/model1_template.yml --force
  ```



  Generate YAML files for one or more sources. By default, the YAML file is created under `models/schema_name/source_name.yml`. However, you can specify a custom path using the `--path` flag.



  ```bash
  breeze build source [OPTIONS] SCHEMA_NAME SOURCE_NAMES...
  ```



  - **SCHEMA_NAME** *(required)*: The schema name of the sources.
  - **SOURCE_NAMES** *(required)*: One or more source names for which to generate YAML files.



  - **--force, -f**: Overwrite existing files if they exist.
  - **--template, -t**: Path to a custom YAML template file.
  - **--path, -p**: Specify a custom directory where the source YAML file will be saved. If the path does not exist, it will be created.



  - Generate source YAML files for `source1` and `source2` under `models/schema_name/`:

  ```bash
  breeze build source my_schema source1 source2
  ```

  - Generate source YAML file for `source1` using a custom template located in `tempaltes/source1_template.yml` and save it in `models/sources/postgres/`:

  ```bash
  breeze build source my_schema source1 --template tempaltes/source1_template.yml --path sources/postgres
  ```

  - Force overwrite an existing YAML for `source1` in `models/schema_name/source1.yml`:

  ```bash
  breeze build source raw source1 --force
  ```



  Commands under the `add` group assist in adding tests to models or sources.



  Add one or more tests to a model or source. If columns are specified, the tests are added to those columns. If no columns are specified, the tests are added at the model or source level.



  ```bash
  breeze add test [OPTIONS] TEST_NAMES...
  ```



  - **TEST_NAMES** *(required)*: One or more test names to add (e.g., `not_null`, `unique`).



  - **--model, -m**: The model name to add the test(s) to.
  - **--source, -s**: The source name to add the test(s) to.
  - **--columns, -c**: Comma-separated column names to add the test(s) to.



  - Add multiple tests to specific columns in a model:

  ```bash
  breeze add test not_null unique --model customers --columns "customer_id, email"
  ```

  - Add a test at the model level:

  ```bash
  breeze add test unique --model orders
  ```

  - Add multiple tests to specific columns in a source:

  ```bash
  breeze add test not_null accepted_values --source status --columns status_code
  ```



  Breeze allows you to use custom templates for generating `.sql` and `.yml` files. You can specify a custom template using the `--template` option with the `build` commands.



  You can include the following placeholders in your templates:

  - **{{ model_name }}**: Name of the model.
  - **{{ source_name }}**: Name of the source table.
  - **{{ schema_name }}**: Name of the schema.
  - **{{ database }}**: Name of the database.
  - **{{ columns }}**: List of columns (used in loops).

  Within loops, each column has:

  - **{{ column.name }}**: Column name.
  - **{{ column.data_type }}**: Data type of the column.





  ```yaml
  version: 2

  models:
    - name: {{ model_name }}
      description: 'Describe {{ model_name }} here.'
      tags: []
      columns:
      {% for column in columns %}
        - name: {{ column.name }}
          data_type: {{ column.data_type }}
          description: ''
          
          
      {% endfor %}
  ```



  ```yaml
  version: 2

  sources:
    - name: {{ schema_name }}
      description: ''
      database: {{ database }}
      schema: {{ schema_name }}
      tables:
      - name: {{ source_name }}
        description: ''
        tags: []
        columns:
        {% for column in columns %}
          - name: {{ column.name }}
            data_type: {{ column.data_type }}
            description: ''
            
            
        {% endfor %}
  ```



  ```sql
  -- Custom SQL Template stg tables
  WITH

  source AS (
      SELECT *
      FROM {{ source('raw', 'source_name') }}
  ),

  SELECT * FROM source
  ```



  - **Run `dbt compile` or `dbt build` before generating YAML files**: This ensures that the `manifest.json` is up-to-date, which Breeze uses to gather model information.

  - **Use the `--force` flag cautiously**: Overwriting existing files can lead to loss of manual changes. Ensure you have backups or use version control.

  - **Validate Generated Files**: After generating or modifying files, validate the YAML syntax and dbt configurations.

  - **Enclose Columns with Spaces in Quotes**: When specifying columns with spaces in their names or spaces after commas, enclose the columns in quotes.



  If you encounter issues or have suggestions for new features, please consider contributing to the project or opening an issue on the project's repository.



  Breeze simplifies dbt project development by automating repetitive tasks and enforcing consistency across models and sources. By leveraging custom templates and automated test additions, you can focus on developing robust data transformations.


pkgId: 22992f7f8e587e44a33d347444a713ad753001c765b07705d26fa203dc942716
name: python-brei
arch: src
version: 0.2.4
epoch: 0
release: 1
summary: A minimal build system.
url: https://pypi.org/project/brei/
rpm_license: Apache 2
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brei-0.2.4-1.src.rpm
checksum_type: sha256
description:
  [![GitHub Org's stars](https://img.shields.io/github/stars/entangled)](https://github.com/entangled/brei)
  [![Python package](https://github.com/entangled/brei/actions/workflows/python-package.yml/badge.svg)](https://github.com/entangled/brei/actions/workflows/python-package.yml)
  [![PyPI - Version](https://img.shields.io/pypi/v/brei)](https://pypi.org/project/brei)
  [![Entangled badge](https://img.shields.io/badge/entangled-Use%20the%20source!-%2300aeff)](https://entangled.github.io/)

  Minimal workflow system and alternative to Make.

  - Read from TOML or JSON (also `pyproject.toml` in `[tool.brei]` section)
  - Only Python &ge; 3.11 required
  - Runs task lazily and in parallel
  - Supports variables, templates, includes and custom runners

  Read more: [documentation](https://entangled.github.io/brei)


  This tool was developed as part of the Entangled project, but can be used on its own. Brei is meant to perform small scale automisations for literate programming in Entangled, like generating figures, and performing computations locally. It requires no setup to work with and workflows are easy to understand by novice users. If you have any more serious needs than that, we'd recommend to use a more tried and proven system, of which there are too many to count.


  You're running a project, there's lots of odds and ends that need automisation. You'd use a `Makefile` but your friend is on Windows and doesn't have GNU Make installed. You try to ship a product that needs this, but don't want to confront people trying it for the first time with a tonne of stuff they've never heard of.


  To install, you may:

  ```
  pip install brei
  ```

  Or you use a tool for virtual environments, we recommend [Poetry](https://python-poetry.org/), after creating a new project with `poetry init`:

  ```
  poetry add brei
  ```


  To run unit tests and type checker:

  ```
  poetry install
  poetry shell
  brei test
  ```

  To build the documentation, run the `brei weave` workflow:

  ```

  brei weave
  ```

  Some parts of Brei are literate. Run the entangled watch daemon while editing code,

  ```
  entangled watch
  ```

  or else, as a batch job, stitch changes before committing:

  ```
  entangled stitch
  ```


  Copyright Netherlands eScience Center, Apache License, see LICENSE.


pkgId: 41dd9249462024bf98ee48e67ff2cbce23f69b93a20cbf03cf372a1df560a436
name: python-brent-search
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: Brent''s method for univariate function optimization
url: https://github.com/limix/brent-search
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brent-search-2.0.1-1.src.rpm
checksum_type: sha256
description:
  Brent's method for univariate function optimization.



  ```python
  from brent_search import brent

  def func(x, s):
    return (x - s)**2 - 0.8

  r = brent(lambda x: func(x, 0), -10, 10)
  print(r)
  ```

  The output should be

  ```python
  (0.0, -0.8, 6)
  ```



  From command line, enter

  ```bash
  pip install brent-search
  ```



  ```python
  python -c "import brent_search; brent_search.test()"
  ```



  [Documentation](https://brent-search.readthedocs.io/en/latest/)



  * [Danilo Horta](https://github.com/horta)



  - http://people.sc.fsu.edu/~jburkardt/c_src/brent/brent.c
  - Numerical Recipes 3rd Edition: The Art of Scientific Computing
  - https://en.wikipedia.org/wiki/Brent%27s_method




  This project is licensed under the [MIT License](https://raw.githubusercontent.com/limix/brent-search/master/LICENSE.md).


pkgId: b52c2fa5fe714f36e6d86910c9b65d5b7819d5b47584bb3f930f02f763cfc20b
name: python-bresenham
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: An implementation of Bresenham's line drawing algorithm
url: https://github.com/encukou/bresenham
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-bresenham-0.2.1-1.src.rpm
checksum_type: sha256
description:
  A simple implementation of Bresenham's line drawing algorithm.
  See `the Wikipedia entry`_ for details on what that is.
  Note that this is a simple implementation.
  It is written in Pure Python (without e.g. `numpy`), so it is relatively slow.
  I found some beauty in combining the classic algorithm (whose ingenuity lies in
  using only integers – a constraint that isn't really as relevant now)
  with a Python generator (a modern device that follows the spirit of
  “executable pseudocode”, abstracting away the output subroutine).
  I hope others can appreciate the code as well.
  For serious use, look at these:
  * `skimage.draw.line`_, which solves the same problem *fast*.
  * A `Numpy-based recipe`_ that generalizes the solution to <var>N</var>
    dimensions.


pkgId: a824a17984a9e069881839e60da0e76b25912b4e9569ae376f549dacb1fb6bef
name: python-brevitas
arch: src
version: 0.11.0
epoch: 0
release: 1
summary: Quantization-aware training in PyTorch
url: https://github.com/Xilinx/brevitas
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brevitas-0.11.0-1.src.rpm
checksum_type: sha256
description:
  [![Downloads](https://pepy.tech/badge/brevitas)](https://pepy.tech/project/brevitas)
  [![Pytest](https://github.com/Xilinx/brevitas/actions/workflows/pytest.yml/badge.svg?branch=master)](https://github.com/Xilinx/brevitas/actions/workflows/pytest.yml)
  [![Examples Pytest](https://github.com/Xilinx/brevitas/actions/workflows/examples_pytest.yml/badge.svg?branch=master)](https://github.com/Xilinx/brevitas/actions/workflows/examples_pytest.yml)
  [![DOI](https://zenodo.org/badge/140494324.svg)](https://zenodo.org/badge/latestdoi/140494324)

  Brevitas is a PyTorch library for neural network quantization, with support for both *post-training quantization (PTQ)* and *quantization-aware training (QAT)*.

  **Please note that Brevitas is a research project and not an official Xilinx product.**

  If you like this project please consider ⭐ this repo, as it is the simplest and best way to support it.



  * Python >= 3.8.
  * [Pytorch](https://pytorch.org) >= 1.9.1, <= 2.1 (more recent versions would be untested).
  * Windows, Linux or macOS.
  * GPU training-time acceleration (*Optional* but recommended).



  You can install the latest release from PyPI:
  ```bash
  pip install brevitas
  ```



  Brevitas currently offers quantized implementations of the most common PyTorch layers used in DNN under `brevitas.nn`, such as `QuantConv1d`, `QuantConv2d`, `QuantConvTranspose1d`, `QuantConvTranspose2d`, `QuantMultiheadAttention`, `QuantRNN`, `QuantLSTM` etc., for adoption within PTQ and/or QAT.
  For each one of these layers, quantization of different tensors (inputs, weights, bias, outputs, etc) can be individually tuned according to a wide range of quantization settings.

  As a reference for PTQ, Brevitas provides an example user flow for ImageNet classification models under [`brevitas_examples.imagenet_classification.ptq`](https://github.com/Xilinx/brevitas/blob/master/src/brevitas_examples/imagenet_classification/ptq/ptq_evaluate.py) that quantizes an input torchvision model using PTQ under different quantization configurations (e.g. bit-width, granularity of scale, etc).

  For more info, checkout our [getting started guide](https://xilinx.github.io/brevitas/getting_started).



  If you adopt Brevitas in your work, please cite it as:
  ```
  @software{brevitas,
    author       = {Alessandro Pappalardo},
    title        = {Xilinx/brevitas},
    year         = {2023},
    publisher    = {Zenodo},
    doi          = {10.5281/zenodo.3333552},
    url          = {https://doi.org/10.5281/zenodo.3333552}
  }
  ```



  - *2024/10/10* - Release version 0.11.0, see the [release notes](https://github.com/Xilinx/brevitas/releases/tag/v0.11.0).
  - *2024/07/23* - Minor release version 0.10.3, see the [release notes](https://github.com/Xilinx/brevitas/releases/tag/v0.10.3).
  - *2024/02/19* - Minor release version 0.10.2, see the [release notes](https://github.com/Xilinx/brevitas/releases/tag/v0.10.2).
  - *2024/02/15* - Minor release version 0.10.1, see the [release notes](https://github.com/Xilinx/brevitas/releases/tag/v0.10.1).
  - *2023/12/08* - Release version 0.10.0, see the [release notes](https://github.com/Xilinx/brevitas/releases/tag/v0.10.0).
  - *2023/04/28* - Minor release version 0.9.1, see the [release notes](https://github.com/Xilinx/brevitas/releases/tag/v0.9.1).
  - *2023/04/21* - Release version 0.9.0, see the [release notes](https://github.com/Xilinx/brevitas/releases/tag/v0.9.0).
  - *2023/01/10* - Release version 0.8.0, see the [release notes](https://github.com/Xilinx/brevitas/releases/tag/v0.8.0).
  - *2021/12/13* - Release version 0.7.1, fix a bunch of issues. Added TVMCon 2021 tutorial notebook.
  - *2021/11/03* - Re-release version 0.7.0 (build 1) on PyPI to fix a packaging issue.
  - *2021/10/29* - Release version 0.7.0, see the [release notes](https://github.com/Xilinx/brevitas/releases/tag/v0.7.0).
  - *2021/06/04* - Release version 0.6.0, see the [release notes](https://github.com/Xilinx/brevitas/releases/tag/v0.6.0).
  - *2021/05/24* - Release version 0.5.1, fix a bunch of minor issues. See [release notes](https://github.com/Xilinx/brevitas/releases/tag/v0.5.1).
  - *2021/05/06* - Release version 0.5.0, see the [release notes](https://github.com/Xilinx/brevitas/releases/tag/v0.5.0).
  - *2021/03/15* - Release version 0.4.0, add support for \_\_torch_function\_\_ to QuantTensor.
  - *2021/03/04* - Release version 0.3.1, fix bug w/ act initialization from statistics w/ IGNORE_MISSING_KEYS=1.
  - *2021/03/01* - Release version 0.3.0, implements enum and shape solvers within extended dependency injectors. This allows declarative quantizers to be self-contained.
  - *2021/02/04* - Release version 0.2.1, includes various bugfixes of QuantTensor w/ zero-point.
  - *2021/01/30* - First release version 0.2.0 on PyPI.


pkgId: d08a14af732427b591c4da968343f92e1108ecaa52c48a889ad48fd1b9fae91e
name: python-brevity
arch: src
version: 0.2.17
epoch: 0
release: 1
summary: Tweet shortening and autolinking utility
url: http://indiewebcamp.com/brevity
rpm_license: CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brevity-0.2.17-1.src.rpm
checksum_type: sha256
description:
  A small utility to shorten https://indiewebcamp.com/note posts to an
  acceptable tweet-length summary. Appends an optional permalink or
  citation.

  Also supports autolinking web addresses in text.

  Brevity checks URLs against the full list of ICANN TLDs, to avoid
  linking things that look like web addresses but aren't.

  Documentation and source on GitHub: https://github.com/kylewm/brevity


pkgId: 41631e782d4dc98a42fd17108709282bdfb04382576a25d9093ede78fc74df2e
name: python-brevo-python
arch: src
version: 1.1.2
epoch: 0
release: 1
summary: Brevo API
url: https://pypi.org/project/brevo-python/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brevo-python-1.1.2-1.src.rpm
checksum_type: sha256
description:
      Brevo provide a RESTFul API that can be used with any languages. With this API, you will be able to :   - Manage your campaigns and get the statistics   - Manage your contacts   - Send transactional Emails and SMS   - and much more...  You can download our wrappers at https://github.com/orgs/brevo  **Possible responses**   | Code | Message |   | :-------------: | ------------- |   | 200  | OK. Successful Request  |   | 201  | OK. Successful Creation |   | 202  | OK. Request accepted |   | 204  | OK. Successful Update/Deletion  |   | 400  | Error. Bad Request  |   | 401  | Error. Authentication Needed  |   | 402  | Error. Not enough credit, plan upgrade needed  |   | 403  | Error. Permission denied  |   | 404  | Error. Object does not exist |   | 405  | Error. Method not allowed  |   | 406  | Error. Not Acceptable  |   | 422  | Error. Unprocessable Entity |   # noqa: E501


pkgId: 9aa06ae4a62fde760ee492a2684de277293d937ff02bf2d1dd69e3217b97083f
name: python-brewblox-ctl
arch: src
version: 0.27.0
epoch: 0
release: 1
summary: Brewblox management tool
url: https://pypi.org/project/brewblox-ctl/
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brewblox-ctl-0.27.0-1.src.rpm
checksum_type: sha256
description:
  The primary tool for installing and managing BrewBlox. Uses Click.

  Install-specific commands are defined in [brewblox-ctl-lib](https://github.com/BrewBlox/brewblox-ctl-lib).

  Wraps multiple docker-compose commands to provide a one-stop tool.

  Provides the `http` CLI utility tool as a more specific and less cryptic alternative to `curl`.


pkgId: a70cfb267386e9c5293c59b13d1cd9ab69a126e3bf208edb3fbe8b00d949dd3a
name: python-brewblox-devcon-spark
arch: src
version: 0.5.2
epoch: 0
release: 1
summary: Communication with Spark controllers
url: https://github.com/BrewBlox/brewblox-devcon-spark
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brewblox-devcon-spark-0.5.2-1.src.rpm
checksum_type: sha256
description:
  ![build status](https://travis-ci.org/BrewBlox/brewblox-devcon-spark.svg?branch=develop)



  The Spark service handles connectivity for the BrewPi Spark controller.

  This includes USB/TCP communication with the controller, but also encoding, decoding, and broadcasting data.

  ![Command Transformation](http://www.plantuml.com/plantuml/png/dLPDZ-Cs3BtdLn2vJ59aaalHmw0eTfC9q2tQpc2JOe-58jDZxSYIAyepOnJzxwKasx7piOjTdsnza7oFZwJVaHVErwM6ZIrBOJBOEs4ejwuKNbapcLIyhy8hJ4MbbbKpXNydmC_iXpdStlu2quyeKRqW_BhVFuB3VseaFur7ulQZS8GWt5DTel44kRFbw2pCQgU1VQ-iWuFDclbqShp-XwZ07ZwZz2jgo6EvgfpDbKROVFph7lBQo1YTjx3ZM9z19Y2KGZ3M8pZrLFZu6PxjcoWhZNVm-B3Rmuh2hLLoGJ4cvP10iFtj-_tsxuVrRzlDlZExwCq4iWHamWiWRns2T2WyndtalU1vae0CECpmHKaSqDW3tLZpWiu3eGj7uCDzm2IjySvgZOuNflsD2x32i-llCW0EYRnJveaMCLWf31mup4AO9ypWq80l46hsjnmPsGnT9ZkA4vUCXAyCFRfIcQEHOvHdfXWJ1UIA8BC6mutCSb1ihStha4DjxNDTBISZA-yDu9l4ohTsd534lbNED8m9ugzQPm5bRckJ7OCv9gHR6UH4sWmbfmHcQCBxV9YRFZ_Rk0S7RULp37awEdCb8qSMV52BOhWs7rG3f_ZHMMyFTNwRl0TIFTBopCpEbfYuyas5lLJPRENmbgj28b5WbglabCAUnYZzGEA3mKzyUrtJtTd9BYBET8Y8G76aDoBBk33e1dA5JF8iXZa7GN0GX3_zsAdjFFArmzUrjc_mAYBc0akcWYej6eRB57H23COA3fBzgbBewnRtXOeduMTEJUjUdejDcSJE2JbXFP4zcuzjzphf5lwxefZO35ZkuqBknRAk5LFKzjHl4GeZhbaZGUL85N-hWmvgTYqy7p2aaalzUYIbLZbdXlzadtSWfBGkYmPYtIHVYu6aGMXkObaJ_Dz4OpTN-3c7l0jxBU85yFYG1RmgNp2GIZVJ2pVIPFXMalOCdfgoHDQ6P8tOghAa-3ZNrGdloskbs4wXY32GSQ4oBx2uFl94NcaTM18TJrqpAz3XTsggwqAfwYvteNlytYwqkyRPLnhRby8V3QxHt8Zpk9z6NnrSltFV9wWhvdCu_mhXavAGJkOCRvzaw5E1NFW-54PAAW-lnUajpbWGlkBI3PqdICdMJaOYk1fyCKxTXpXY1X6rCpHEbmN45aFjuC_IW2JnadhQSQfT64C37jj_A5yxS_8BDU4Jx_WA_vxz3m00 "Command Transformation")





  Direct communication with the Spark is handled here, for both USB and TCP connections. Data is not decoded or interpreted, but passed on to the `SparkCommander`.



  The Spark communicates using the [Controlbox protocol](https://brewblox.netlify.com/dev/reference/spark_commands.html). A set of commands is defined to manage blocks on the controller.

  In the commands module, this protocol of bits and bytes is encapsulated by `Command` classes. They are capable of converting a Python dict to a hexadecimal byte string, and vice versa.



  Serial communication is asynchronous: requests and responses are not linked at the transport layer.

  `SparkCommander` is responsible for building and sending a command, and then matching it with a subsequently received response.



  For when using an actual Spark is inconvenient, there is a simulation version. It serves as a drop-in replacement for the real commander: it handles commands, and returns sensible values.
  Commands are encoded/decoded, to closely match the real situation.



  The service must keep track of object metadata not directly persisted by the controller. This includes user-defined object names and descriptions.

  Services are capable of interacting with a BrewPi Spark that has pre-existing blocks, but will be unable to display objects with a human-meaningful name.

  Object metadata is persisted to files. This does not include object settings - these are the responsibility of the Spark itself.



  While the controller <-> service communication uses the Controlbox protocol, individual objects are encoded separately, using Google's [Protocol Buffers](https://developers.google.com/protocol-buffers/).

  The codec is responsible for converting JSON-serializable dicts to byte arrays, and vice versa. A specific transcoder is defined for each object.

  For this reason, the object payload in Controlbox consists of two parts: a numerical `object_type` ID, and the `object_data` bytes.



  `SparkController` combines the functionality of `commands`, `commander`, `datastore`, and `codec` to allow interaction with the Spark using Pythonic functions.

  Any command is modified both incoming and outgoing: ID's are converted using the datastore, data is sent to codec, and everything is wrapped in the correct command before it is sent to `SparkCommander`.



  The Spark service is not responsible for retaining any object data. Any requests are encoded and forwarded to the Spark.

  To reduce the impact of this bottleneck, and to persist historic data, `Broadcaster` reads all objects every few seconds, and broadcasts their values to the eventbus.

  Here, the data will likely be picked up by the [History Service](https://github.com/BrewBlox/brewblox-history).




  Some actions are required when connecting to a (new) Spark controller.
  The Seeder feature waits for a connection to be made, and then performs these one-time tasks.

  Examples are:
  * Setting Spark system clock
  * Reading controller-specific data from the remote datastore





  Offers full CRUD (Create, Read, Update, Delete) functionality for Spark objects.



  System objects are distinct from normal objects in that they can't be created or deleted by the user.



  Occasionally, it is desirable for multiple Sparks to work in concert. One might be connected to a temperature sensor, while the other controls a heater.

  Remote blocks allow synchronization between master and slave blocks.

  In the sensor/heater example, the Spark with the heater would be configured to have a dummy sensor object linked to the heater.

  Instead of directly reading a sensor, this dummy object is updated by the service whenever it receives an update from the master object (the real sensor).



  All objects can have user-defined names. The AliasAPI allows users to set or change those names.


pkgId: 703fe3fe63e78ea852f1975f0f9d330f4d287a80eb7c9908124e12bb822861d0
name: python-brewblox-service
arch: src
version: 3.3.2
epoch: 0
release: 1
summary: Scaffolding for Brewblox backend services
url: https://pypi.org/project/brewblox-service/
rpm_license: GPL-3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brewblox-service-3.3.2-1.src.rpm
checksum_type: sha256
description:
  In order to reduce code duplication between services, generic functionality is implemented here.

  For an example on how to implement your own service based on `brewblox-service`, see <https://github.com/brewblox/brewblox-boilerplate>.



  Small generic tools are defined here.

  `brewblox_logger` can be used for creating module-specific loggers. It is not required, but will play a bit nicer with default formatting of the log.

  Example:

  ```python
  from brewblox_service import brewblox_logger

  LOGGER = brewblox_logger(__name__)
  LOGGER.info('hello')
  ```



  Parses commandline arguments, creates an `aiohttp` application object, and runs it.

  The shortest implementation is:

  ```python
  parser = service.create_parser('my_service')
  config = service.create_config(parser)
  app = service.create_app(config)
  service.run_app(app)
  ```

  This will get you a working web application, but it will not have any endpoints.

  Applications can configure their own features, and add new commandline arguments.

  Example:

  ```python
  class ExtendedConfig(models.BaseServiceConfig):
      my_arg: str


  parser = service.create_parser('my_service')
  parser.add_argument('--my-arg')


  config = service.create_config(parser, model=ExtendedConfig)


  app = service.create_app(config)

  async def setup():
      
      
      device.setup(app)
      api.setup(app)


  service.run_app(app, setup())
  ```



  Many service features are application-scoped. Their lifecycle should span multiple requests, either because they are not request-driven, or because they manage asynchronous I/O operations (such as listening to AMQP messages).

  The `ServiceFeature` class offers an abstract base class for this behavior. Implementing classes should define `startup(app)` and `shutdown(app)` functions, and those will be automatically called when the application starts up and shuts down.

  Both `startup()` and `shutdown()` are called in an async context, making them the async counterparts of `__init__()` and `__del__()` functions.

  Features must be constructed after the app is created, but before it starts running. (`service.create_app()` and `service.run_app(app)`).
  It is recommended but not required to add features in an async setup function.

  The `add()` and `get()` functions make it easy to centrally declare a feature, and then use it in any function that has a reference to the aiohttp app.



  A very common use case for features is to have the equivalent of a `while True` loop.
  The `RepeaterFeature` class handles the boilerplate involved in setting this up in an async context.



  Basic MQTT messaging: publish and listen to events.
  To publish data, all you need is the `publish(topic, message)` function.

  To listen to incoming messages, you can combine `subscribe(topic)` with one or more calls to `listen(topic, callback)`.
  The subscribe/listen functions allow for + and # wildcards to be used.

  For a detailed explanation of how to use MQTT topics, see <http://www.steves-internet-guide.com/understanding-mqtt-topics/>.

  For the Brewblox spec on how and where to publish data, see <https://brewblox.com/dev/reference/events.html>.

  Includes top-level convenience functions for `publish(topic, message)`, `listen(topic, callback)` and `subscribe(topic)`.


pkgId: 22d45d3dd3c1fe2c51ad7c70d8a1fcc075bee0ee1b80345a0d0b9556d276de2c
name: python-brewify
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: A Python library for interacting with various APIs including Google Search, IMDb, and Discord.
url: https://github.com/opexdeveloper/brewify
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brewify-0.1.5-1.src.rpm
checksum_type: sha256
description:
  ![Brew](https://images-ext-1.discordapp.net/external/qG41hZHbsmNVc9WSE6aX3oVWi_LP39dQZjxZgdIdFLI/%3Fsize%3D1024/https/cdn.discordapp.com/avatars/1076140187471593492/bfea312390b3b52773f1358457d7261b.png?format=webp&quality=lossless&width=427&height=427)

  Brewify is a Python library that provides a simple interface to interact
  with various APIs, including Google Search, IMDb, Discord, and more. It
  is designed to be easy to use while allowing you to extend its
  functionality.



  -   **API Requests**: Make GET requests to various endpoints.
  -   **Error Handling**: Custom exceptions for better error management.
  -   **Multiple Services**: Access Google Images, IMDb, Discord, and
      more.
  -   **Sentiment Analysis**: Analyze the sentiment of text.
  -   **Chatbot Functionality**: Engage in simple conversations.
  -   **Joke Generator**: Get a random joke.



  You can install Brewify via pip:

  ``` bash
  pip install brewify
  ```



  **Initialize the Brewify Class**

  To get started, initialize the [Brewify]{.title-ref} class with your API
  key:

  ``` python
  from brewify import Brewify

  brewify = Brewify("YOUR_API_KEY")
  ```

  **Example Methods**

  *Get Google Images*

  ``` python
  image_response = brewify.get_google_image(query="cats")
  print(image_response.link)
  ```

  *Search Google*

  ``` python
  text_response = brewify.search_google(query="Python programming")
  print(text_response.title, text_response.link, text_response.snippet)
  ```

  *IMDb Search*

  ``` python
  imdb_response = brewify.imdb_search(query="Inception")
  print(imdb_response.plot)
  ```

  *Discord Guild Search*

  ``` python
  guild_response = brewify.discord_guild_search(invite_code="your_invite_code")
  print(guild_response.id)
  ```

  *Sentiment Analysis*

  ``` python
  sentiment_response = brewify.sentiment_analysis(sentence="I love Python!")
  print(sentiment_response.negative, sentiment_response.positive, sentiment_response.neutral)
  ```

  *Get a Joke*

  ``` python
  joke_response = brewify.joke()
  print(f"{joke_response.setup} {joke_response.punchline}")
  ```



  Brewify raises a custom exception called [Brexception]{.title-ref} for
  handling errors. You can catch it as follows:

  ``` python
  try:
      brewify.some_method()
  except Brexception as e:
      print(f"An error occurred: {e}")
  ```



  Contributions are welcome! Feel free to submit a pull request or open an
  issue.



  This project is licensed under the MIT License - see the
  [LICENSE] file for details.



  -   Thanks to the developers of the APIs used in this library.
  -   Special thanks to [FastAPI](https://fastapi.tiangolo.com/) for
      making API development a breeze.


pkgId: 5bbf246d0833bb27b4675b0ff4c380c01c6a9e8bda91ae38a3063326fdb9fc92
name: python-brewse
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: An interactive TUI browser for Homebrew packages
url: https://pypi.org/project/brewse/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brewse-0.1.1-1.src.rpm
checksum_type: sha256
description:
  An interactive TUI (Terminal User Interface) browser for Homebrew packages. Brewse provides a fast, user-friendly way to search, view, and install or uninstall Homebrew packages.



  - Interactive search interface for both Formulae and Casks
  - Detailed package information including:
    - Version
    - Description
    - Homepage
    - Installation status
    - Installation analytics (30/90/365 days)
  - Quick installation/uninstallation of packages
  - Keyboard-driven navigation
  - Local caching of package data for faster subsequent searches



  Install via pip:

  ```
  pip install brewse
  ```



  Launch Brewse in one of two ways:

  1. Interactive search mode:
  ```
  brewse
  ```

  2. Direct search mode:
  ```
  brewse <search-term>
  ```



  - Python 3.6+
  - Homebrew
  - Internet connection



  Brewse caches package data in `~/.cache/brewse/` to improve performance. Cache entries expire after 24 hours.



  This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.


pkgId: a870411324b9da4db134c44c7cd3704f7788e2b4d0329a208ec0e8700a1568dd
name: python-brian2tools
arch: src
version: 0.3
epoch: 0
release: 1
summary: Tools for the Brian 2 simulator
url: https://github.com/brian-team/brian2tools
rpm_license: CeCILL-2.1
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-brian2tools-0.3-1.src.rpm
checksum_type: sha256
description:
  Tools to use with the `Brian 2 simulator <http://briansimulator.org>`_. The `brian2tools` package aims to be a
  collection of useful tools for simulating spiking neural networks with ``brian2`` and for analyzing the results from
  those simulations.


