# packages

pkgId: 5a5879212e98f10f58fef062f3d9f761aaacd8a5960c634aaf30ffdf189415fb
name: python-AppleAPI
arch: src
version: 1.0.9
epoch: 0
release: 1
summary: App Store Connect API
url: https://github.com/yingguqing/AppleAPI
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AppleAPI-1.0.9-1.src.rpm
checksum_type: sha256
description:
      XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
      XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
      XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX


pkgId: b3d5bdea0751c02d97726af72d555d254a0076ffe698214f07063411142598ff
name: python-Apycula
arch: src
version: 0.15
epoch: 0
release: 1
summary: Open Source tools for Gowin FPGAs
url: https://github.com/YosysHQ/apicula
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Apycula-0.15-1.src.rpm
checksum_type: sha256
description:
  <img src="apicula.svg" width="250" />

  Documentation and open source tools for the Gowin FPGA bitstream format.

  Project Apicula uses a combination of fuzzing and parsing of the vendor data files to provide Python tools for generating bitstreams.

  This project is supported by our generous sponsors. Have a look at our [contributors](https://github.com/YosysHQ/apicula/graphs/contributors) and sponsor them with via the various platforms linked on our [github](https://github.com/YosysHQ/apicula).



  Install the latest git [yosys](https://github.com/yosyshq/yosys#setup), [nextpnr-himbaechel](https://github.com/YosysHQ/nextpnr#gowin), [openFPGALoader](https://github.com/trabucayre/openFPGALoader), and Python 3.8 or higher. [Yowasp](http://yowasp.org/) versions of Yosys and Nextpnr are also supported.

  Currently supported boards are
   * Trenz TEC0117: GW1NR-UV9QN881C6/I5
   * Sipeed Tang Nano: GW1N-LV1QN48C6/I5
   * Sipeed Tang Nano 1K: GW1NZ-LV1QN48C6/I5
   * Sipeed Tang Nano 4K: GW1NSR-LV4CQN48PC7/I6
   * Sipeed Tang Nano 9K: GW1NR-LV9QN88PC6/I5 [^1]
   * Sipeed Tang Nano 20K: GW2AR-LV18QN88C8/I7
   * Sipeed Tang Primer 20K: GW2A-LV18PG256C8/I7
   * Seeed RUNBER: GW1N-UV4LQ144C6/I5
   * @Disasm honeycomb: GW1NS-UX2CQN48C5/I4
   * szfpga: GW1NR-LV9LQ144PC6/I5

  [^1]: `C` devices require passing the `--family` flag as well as `--device` to Nextpnr, and stating the family in place of device when passing `-d` to `gowin_pack` because the C isn't part of the device ID but only present in the date code. Check `examples/Makefile` for the correct command.

  Install the tools with pip.

  ```bash
  pip install apycula
  ```

  Note that on some systems the installed binaries might not be on the path. Either add the binaries to the path, or use the path of the _installed binary_ directly. (running the source files will lead to import errors)

  ```bash
  which gowin_bba # check if binaries are on the path
  python -m site --user-base # find the site packages base directory
  ls $HOME/.local/bin # confirm the binaries are installed in this folder
  export PATH="$HOME/.local/bin:$PATH" # add binaries to the path
  ```

  From there, compile a blinky.

  The example below is for the Trenz TEC0117. For other devices, use the model numbers listed above for `--device`, and replace `tec0117` with `runber`, `tangnano`, `tangnano4k` or `honeycomb` accordingly. Also note the number of LEDs on your board: 8 for tec0117 and runber, 3 for honeycomb and tangnano.
  You can also use the Makefile in the examples folder to build the examples.

  ```bash
  cd examples
  yosys -D LEDS_NR=8 -p "read_verilog blinky.v; synth_gowin -json blinky.json"
  DEVICE='GW1NR-UV9QN881C6/I5'  # change to your device
  BOARD='tec0117' # change to your board
  nextpnr-himbaechel --json blinky.json \
                     --write pnrblinky.json \
                     --device $DEVICE \
                     --vopt cst=$BOARD.cst
  gowin_pack -d $DEVICE -o pack.fs pnrblinky.json # chango to your device


  openFPGALoader -b $BOARD pack.fs
  ```

  For the Tangnano9k board, you need to call nextpnr and gowin_pack with the chip family as follows:
  ```
  nextpnr-himbaechel --json blinky.json \
                     --write pnrblinky.json \
                     --device $DEVICE \
                     --vopt family=GW1N-9C \
                     --vopt cst=$BOARD.cst
  gowin_pack -d GW1N-9C -o pack.fs pnrblinky.json
  ```



  In addition to the above, to run the fuzzers and build the ChipDB, the following additional dependencies are needed.

  Version 1.9.8 of the Gowin vendor tools. Newer versions may work, but have not been tested.

  Alternatively, you can use the `Dockerfile` to run the fuzzers in a container.

  To run the fuzzers, do the following in a checkout of this repo

  ```bash
  pip install -e .
  export GOWINHOME=/gowin/installation
  make
  ```



  Check out the `doc` folder for documentation about the FPGA architecture, vendor file structure, and bitstream structure.

  My internship report about this project [can be downloaded here](https://github.com/pepijndevos/internshipreport).

  My presentations at [FPT2020](https://www.youtube.com/watch?v=kyQLtBh6h0U) and [RC3](https://media.ccc.de/v/rc3-739325-how_to_fuzz_an_fpga_my_experience_documenting_gowin_fpgas).

  I did a few [livestreams on twitch](https://www.twitch.tv/pepijnthefox) working on this project, which are collected [on this playlist](https://www.youtube.com/playlist?list=PLIYslVBAlKZad3tjr5Y4gqBV3QKQ5_tPw) I've also started to write Jupyter notebooks of my explorations that are more condensed than a video.

  You can also come chat on [Matrix](https://matrix.to/#/#apicula:matrix.org) or [IRC](https://web.libera.chat/#yosys-apicula)



  There is a lot of work left to do before this is a mature and complete FPGA flow.
  The upside is that there is something for people from all skill levels and backgrounds.



  This project partially relies on the data files provided by the vendor to work.
  However, the exact meaning of these files is often not completely understood.
  Fuzzing can be used to discover the meaning of the vendor files.

  `tiled_fuzzer.py` is a fuzzer that uses vendor files to find bits in a specific tile type. Adding code for a new primitive or tile type is relatively easy. All that is neede is a function that uses `codegen.py` to generate the primitive of interest, which has to be added to the `fuzzers` list. Then the output at the bottom of the script can be adjusted to your needs.

  There is a `fuse_h4x.parse_tile` function which uses our understanding of the vendor files to look for matching items. On the other hand `fuse_h4x.scan_fuses` will just give you a list of fuses that were set in the tile, and `fuse_h4x.scan_tables` will go through *all* vendor data tables and spit out even a partial match. The latter will give false positives, but is helpful when discovering new tables.

  `fuzzer.py` is a bit more complex to write new fuzzers for, but could be usefull in some cases. It is for example much more efficient in fuzzing array parameters such as LUT bits, BRAM contents, and PLL settings. Have a look at `Lut4BitsFuzzer` for ideas about how to fuzz BRAM and DRAM for example.

  Things that could be fuzzed:

  * DRAM modes and bits
  * BRAM modes and bits
  * IO logic (LVDS etc.), expected to be complex.
  * PLL settings



  For each FPGA, the vendor provides `.dat`, `.fse`, `.ini`, `.pwr`, and `.tm` files. Of these, parsers for `.dat`, `.fse`, `.ini` and `.tm` have been written.

  The format of the `.pwr` file is unknown, you're on your own here. I could only offer you some vague pointers based on experience from the other two files.

  For a description of the known file formats, [see the documentation](doc/filestructure.md).

  The parser for the `.fse` format is fairly robust and complete, but vendor software updates sometimes add new file and table types.
  The main thing lacking here is a better understanding of the meaning of all these tables. Part of this can be done with [fuzzing](#fuzzing), but another large part is just looking at the data for patterns and correlations. For example, some numbers might be indices into other tables, wire IDs, fuse IDs, or encoded X/Y positions.

  The parser for the `.dat` file is more fragile and incomplete. This is mainly because it just appears to be a fixed format struct with array fields. New vendor software versions sometimes add new fields, breaking the parser. Here there are actually a few gaps in the data that have not been decoded and named. It is suspected that at least some of these gaps are related to pinouts and packaging.

  The format of the '.tm' appears to be just a big collection of floats. Not all of them have a meaning that is well understood, but the parser itself is fairly complete.

  The `.ini` file is a table of IO configuration options. The format of these files appears to be fairly stable across IDE versions and the current parser is able to handle the vast majority of available files.





  There are quite a few sketchy places in the code that could use some tender loving care, without taking a deep dive into FPGA documenting.

  The `.dat` parser was sort of patched to output a JSON file, but it would be a lot nicer if one could just import it as a library and get Python datastructures back directly. Both parsers could optionally be extended to map known IDs to more human readable values (`wirenames.py` for example), provide a more convenient structure, and chomp of padding values.

  The fuzzers should be extended so that they run against all FPGA types. This is important to detect differences between FPGAs and generate ChipDBs for all of them. This does not require much in-depth knowledge. Just adding parameters for all FPGA types. A bit more involved is extending the fuzzer to fuzz global settings and constraints, these would need to be assigned config bits and toggle them accordingly.

  This project was funded through the <a href="/PET">NGI0 PET</a> Fund, a fund established by <a href="https://nlnet.nl">NLnet</a> with financial support from the European Commission's <a href="https://ngi.eu">Next Generation Internet</a> programme, under the aegis of DG Communications Networks, Content and Technology under grant agreement N<sup>o</sup> 825310.


pkgId: 65e8aaad3ffd6402270bc85b19521a07478528c2f89a92ffaec0d9f66d868fc2
name: python-AqEquil
arch: src
version: 0.19.0
epoch: 0
release: 1
summary: Python tools for aqueous chemical speciation.
url: https://pypi.org/project/AqEquil/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AqEquil-0.19.0-1.src.rpm
checksum_type: sha256
description:
  [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.10476850.svg)](https://doi.org/10.5281/zenodo.10476850)

  Boyer, G., Robare, J., Park, N., Ely, T., Shock, E.L.



  AqEquil is a Python 3 package that enables users to rapidly perform aqueous speciation calculations of water chemistry data for multiple samples by interfacing with [geochemical speciation software EQ3/6](https://github.com/LLNL/EQ3_6) (Wolery 2013, [Wolery 1979](https://inis.iaea.org/collection/NCLCollectionStore/_Public/10/474/10474294.pdf)).

  Water sample data in CSV format is automatically converted to a format readable by EQ3 and then speciated. Distributions of aqueous species, mineral saturation indices, oxidation reduction potentials, and more are data-mined and returned as Pandas tables and interactive Plotly visualizations.

  Speciated fluids can be further reacted with minerals or other fluids in mass transfer calculations to produce tables and interactive diagrams of reaction paths and composition changes as a function of reaction progress.



  AqEquil has only been tested with Ubuntu 22.04.3 LTS.

  This installation requires the Linux version of EQ3/6 v8.0a, which can downloaded [here](https://github.com/LLNL/EQ3_6). Installation instructions are provided there.

  AqEquil must be installed into an environment with an R installation. See [these instructions](https://docs.anaconda.com/anaconda/user-guide/tasks/using-r-language/) for installing R with Anaconda.

  Additionally, the CHNOSZ package must be installed in R (see instructions below).





  I recommend using [this github version of EQ3/6 v.8.0a adapted by the 39Alpha team](https://github.com/39alpha/eq3_6/tree/main). Installation instructions are found there.

  Create an environment variable called `EQ36DO` and set it to wherever you installed EQ3/6. (`/usr/local/bin` by default). Set another environment variable called `EQ36DA` to the directory containing your data1 thermodynamic database files (if you have one).



  Open an R session. Install CHNOSZ version 1.4.3 package with:

  ```install.packages('http://cran.r-project.org/src/contrib/Archive/CHNOSZ/CHNOSZ_1.4.3.tar.gz', repos=NULL, type='source')```

  Once CHNOSZ is installed you can quit the R session.

  Compatibility with CHNOSZ v.2.0.0 is forthcoming.



  Install AqEquil using pip:

  ```pip install AqEquil```



  See this [demo notebook](https://nbviewer.jupyter.org/github/worm-portal/WORM-Library/blob/master/3-Aqueous-Speciation/1-Introduction-to-Aq-Speciation/2-Intro-to-Multi-Aq-Speciation.ipynb) for usage examples.


pkgId: 15944a02d42e9ae107e1cde6f9b3646a49325b5a641421cd66dedcf8ea277188
name: python-ArabicTagger
arch: src
version: 0.1.1
epoch: 0
release: 1
url: https://github.com/EslamTarekFarouk/ArabicTagger
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ArabicTagger-0.1.1-1.src.rpm
checksum_type: sha256
summary:
  A CRF, Encoder-Transformer layers, and BI-LSTM+CRF model were implemented in Keras with other modules.

description:
  V   | Verb        | فعل (fi'l) - to do, to make
  ADJ | Adjective   | صفة (sifa) - describing word
  PART| Particle    | حرف (harf) - small word with grammatical function
  PRON| Pronoun     | ضمير (ḍamīr) - word used instead of a noun
  NUM | number      | رقم (raqm) - numeral
  PREP|Preposition  | حرف جر (harf jar) - word used before a noun to show relationship
  PUNC|punctuation  | علامة ترقيم (ʿalamāt tarqīm) - punctuation mark
  DET | Determiner  | أل (al) - definite article
  O   | object      | Outside of any named entity
  ADV | Adverb      | ظرف (ẓarf) - word that modifies a verb, adjective, or adverb
  CONJ| Conjunction | حرف عطف (harf ʿaṭf) - word that connects words or sentences
  NOUN| Noun        | اسم (ism) - word that names a person, place, thing, or idea
  2- CRF_model_2 (Named entity model has 7 tags)
  | Tag     | Description                                                                 |
  |---------|-----------------------------------------------------------------------------|
  | I-LOC   | Inside a location entity, such as a country, city, or landmark.             |
  | B-LOC   | Beginning of a location entity.                                             |
  | I-PER   | Inside a person entity, such as a first name or last name.                  |
  | B-PERS  | Beginning of a person entity.                                               |
  | I-ORG   | Inside an organization entity, such as a company or institution.            |
  | B-ORG   | Beginning of an organization entity.                                        |
  | O       | Outside of any named entity, not part of any location, person, or organization. |
  the following data set has been sampled then splited for training :-
  <br>
  - <a href = "https://sourceforge.net/projects/kalimat/files/kalimat/Corpus_Name_Entity_Recognition/">KALIMAT a Multipurpose Arabic Corpus(NER)</a>
  </p>
  <br>
  <p style = "font-family:Cursive">Evaluation Results for Food Extraction
  The proposed method was evaluated on a dataset of 600 food extraction examples. Using the first model, we achieved the following results:
  <br>
  Training: Accuracy: 0.9797, udt_accuracy: 0.9589
  <br>
  Testing: Accuracy: 0.9429, udt_accuracy: 0.9291
  <br>
  When using the second model, the results were:
  <br>
  Training: Accuracy: 0.9596, udt_accuracy: 0.9611
  <br>
  Testing: Accuracy: 0.9526, udt_accuracy: 0.9223
  <br>
  Overall, both models demonstrated strong performance in extracting food-related entities from the given dataset.
  <br>
  </p>


  <br>
   1- https://aclanthology.org/J96-1002.pdf
   <br>
   2- https://cseweb.ucsd.edu/~elkan/250Bfall2007/loglinear.pdf
   <br>

  <p style = "font-family:Cursive">
   The custom Transformer encoder layer in Keras is designed for tagging problems where each input sequence is associated with a single tag. It processes token embeddings and applies the Transformer encoding mechanism to capture relevant sequence patterns and relationships between tokens. It's particularly effective for tasks involving tagging or classification of sequences. It is optimized using the Adam optimizer with binary cross-entropy loss, which is ideal for binary or multi-label classification. However, it performs best with large datasets due to the Transformer model's complexity
  </p>
  <br>
   
  **TextMatcher** is a module designed to address a common problem in
  Arabic NLP:
  Suppose you’re building a model to handle customer orders and process
  transactions automatically. You've implemented a Named Entity
  Recognition (NER) model to extract device names in Arabic, such as
  (<span dir="rtl">غسالة, تلفاز, شاشة, مروحة</span>). After identifying
  these devices, you need to match them with entries in your database to
  check stock availability.
  However, issues arise when there's a spelling variation. For instance, a
  customer might type "<span dir="rtl">غساله</span>," but in your
  database, the device is listed as "<span dir="rtl">غسالة</span>." A
  standard search would fail to match these two, even though they
  represent the same item.
  This issue is known as **orthographic** or **spelling variation** and is
  a challenge for information retrieval in Arabic. Many approaches exist
  to address this, and in the **ArabicTagger** package, I approached the
  problem with a learnable weighted similarity. This method reduces the
  number of parameters and shortens training time while improving matching
  accuracy across spelling variations.


pkgId: 1120920d5970034070d445620c9dcdcc7a3b516331c7d7c999d6b445de1a2f7f
name: python-ArbolBinarioBusqueda
arch: src
version: 0.2.6
epoch: 0
release: 1
summary: Mostrar una implementación simple y totalmente en español con fines académicos
url: https://github.com/felipemoralesquerol/arbolbinariobusqueda
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ArbolBinarioBusqueda-0.2.6-1.src.rpm
checksum_type: sha256
description:
  Mostrar una implementación simple y totalmente en español con fines académicos.

  TODO: Agregar nuevas funcionalidades como parte de la cursada.


pkgId: f44b0b512567c38b8700cacde9f3369c4202e5e93d6f4ebca32e00fb82b1cc01
name: python-ArchiTop
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Archidekt to TableTop export cli
url: https://github.com/Julian-Brendel/archiTop
rpm_license: LICENSE
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ArchiTop-0.3.1-1.src.rpm
checksum_type: sha256
description:
  This project aims to smoothen the export process from a constructed [Magic the Gathering](https://magic.wizards.com/en) card deck in [Archidekt](https://archidekt.com/) to the game [TableTop Simulator](https://store.steampowered.com/app/286160/Tabletop_Simulator/).

  Currently, third third party tools do exist to aid with this process, but these are neither smooth to use
  nor do they fulfill all the features that would smoothen the magic experience.
  The two most noteworthy alternatives are:
  1. **[Frogtown](https://www.frogtown.me/)**
      - Doesn't allow to import directly from tabletop, requiring user to export and import
      - Doesn't keep track of the card versions used in the deck (basic lands will update to the most recent)
      - Usage is slow, two step process required to generate and download deck
      - Doesn't separate commander cards from main deck
  2. **[Tabletop scryfall importer](https://steamcommunity.com/sharedfiles/filedetails/?id=1838051922)**
      - Unexpected behaviour when multiple people import at the same time
      - Doesn't include tokens in the exported deck
      - Doesn't separate commander cards from main deck

  This tool converts an Archidekt deck into Tabletop Simulator json format, able to be imported onto any tabletop board.
  The cards contained, deck-name and thumbnail will be extracted for given Archidekt deck-id.

  The package is being hosted in PyPy, install using
  `pip install architop`

  The tool is used via the commandline, runnable with
  `architop <deckID>`
  Additional usage information can be acquired via the help command
  `architop -h`

  Let's take one of my decks as example.
  Exporting the deck https://archidekt.com/decks/94674#Maximum_Borkdrive is as simple as copying the deck-id `94674`.
  By running the tool with the given deck-id:
  `archiDekt 94674`, archiTop will export the deck as TableTop Simulator compatible file, alongside the thumbnail used for the deck in Archidekt.
  Both files created will be named accordingly to the deck name in Archidekt:
  ![Output Example](https://archi-top.s3.eu-west-2.amazonaws.com/architop-output-example.png)
  Now all that's left to do is to move the two files into the TableTop Objects folder.
  The directory can vary for your Tabletop installation, based on OS.
  You can find the path via the Tabletop Simulator game configurations:
  ![Tabletop Objects](https://archi-top.s3.eu-west-2.amazonaws.com/tabletop-save-location.png)

  You can optionally configure the tool to load alternate art versions of cards, by executing architop with the `-a` option:
  `architop <deckId> -a <path to .json file>`
  The altered art json file, follows the format below:
  ```json
  example_altered_cards.json
  {
    "Pyroblast": "https://architop-altered.s3.eu-west-2.amazonaws.com/Pyroblast.png",
    "Red Elemental Blast": "https://architop-altered.s3.eu-west-2.amazonaws.com/Red+Elemental+Blast.png",
    "Aetherflux Reservoir": "https://architop-altered.s3.eu-west-2.amazonaws.com/Aetherflux+Reservoir.png",
    "Chaos Warp": "https://architop-altered.s3.eu-west-2.amazonaws.com/Chaos+Warp.png",
    "Dockside Extortionist": "https://architop-altered.s3.eu-west-2.amazonaws.com/Dockside+Extortionist.png",
    "Sol Ring": "https://architop-altered.s3.eu-west-2.amazonaws.com/Sol+Ring.png"
  }
  ```
  Have fun playing 🎉

  The current plans for the repository are being tracked via [github issues](https://github.com/Julian-Brendel/archiTop/issues).


pkgId: 0497c5f17e56e0c486d24ede2a6fd638b0989049aee850838d79af3d4e2e4e51
name: python-Ardi
arch: src
version: 1.4.1
epoch: 0
release: 1
url: https://github.com/MuhammadArdiPutra
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Ardi-1.4.1-1.src.rpm
checksum_type: sha256
summary:
  A Python module created by Muhammad Ardi Putra. Currently working on machine learning and computer vision

description:
  The documentation of this package can be seen in https://github.com/MuhammadArdiPutra/ModuleByArdi. The line-by-line code explanation is shown in the "Documentation" folder.


pkgId: 3f88490947fc5d107935c43fe08ac756db166822668ca1c41611336d40fc3098
name: python-Arduino-Master-Delta
arch: src
version: 404
epoch: 0
release: 1
url: https://github.com/SayadPervez/Arduino_Master_Delta
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Arduino-Master-Delta-404-1.src.rpm
checksum_type: sha256
summary:
  Data Science enabled Data extraction and control library for Arduino with accurate Data Visualizations !.

description:
  ___
  ![intropic](https://github.com/SayadPervez/AMD--TUTORIAL/blob/master/IntroPic.png?raw=true)
  ___


pkgId: d76ba476b52dcaf86931244ad51aed0e9498f71dfdad1210b67029c95191e32e
name: python-Areix-IO
arch: src
version: 0.1.20
epoch: 0
release: 1
summary: Areix IO Backtesting Framework
url: https://alphagen.areix-ai.com
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Areix-IO-0.1.20-1.src.rpm
checksum_type: sha256
description:
  [Documentation](http://alphagen.areix-ai.com/doc)


  Create a virtual environment
  ```
  virtualenv venv --python=python3
  ```
  Activate the virtual environment
  ```python

  source venv/bin/activate


  venv/Scripts/activate
  ```
  Deactivate
  ```
  deactivate
  ```
  Install Areix-IO package
  ```
  pip install areix_io
  ```



  Define your strategy class:
  ```python

  from areix_io import (
      create_report_folder, Side,
      Strategy, BinanceSpotDataFeed, BackTest,
      BackTestBroker, CommissionScheme
  )

  from sklearn.neighbors import KNeighborsClassifier
  from sklearn.model_selection import train_test_split
  from sklearn.metrics import accuracy_score, f1_score
  import pandas as pd
  import numpy as np

  PRED_DAYS = 2
  PCT_CHANGE = 0.004
  """
  Data pre processing step
  """
  def bollinger_band(data, n_lookback, n_std):
      hlc3 = (data['high'] + data['low'] + data['close']) / 3
      mean, std = hlc3.rolling(n_lookback).mean(), hlc3.rolling(n_lookback).std()
      upper = mean + n_std*std
      lower = mean - n_std*std
      return upper, lower

  def update_df(df):
      upper, lower = bollinger_band(df, 20, 2)

      df['ma10'] = df.close.rolling(10).mean()
      df['ma20'] = df.close.rolling(20).mean()
      df['ma50'] = df.close.rolling(50).mean()
      df['ma100'] = df.close.rolling(100).mean()

      df['x_ma10'] = (df.close - df.ma10) / df.close
      df['x_ma20'] = (df.close - df.ma20) / df.close
      df['x_ma50'] = (df.close - df.ma50) / df.close
      df['x_ma100'] = (df.close - df.ma100) / df.close

      df['x_delta_10'] = (df.ma10 - df.ma20) / df.close
      df['x_delta_20'] = (df.ma20 - df.ma50) / df.close
      df['x_delta_50'] = (df.ma50 - df.ma100) / df.close

      df['x_mom'] = df.close.pct_change(periods=2)
      df['x_bb_upper'] = (upper - df.close) / df.close
      df['x_bb_lower'] = (lower - df.close) / df.close
      df['x_bb_width'] = (upper - lower) / df.close

      
      return df

  def get_X(data):
      return data.filter(like='x_').values

  def get_y(data):
      y = data.close.pct_change(PRED_DAYS).shift(-PRED_DAYS)  # Returns after roughly two days
      y[y.between(-PCT_CHANGE, PCT_CHANGE)] = 0             # Devalue returns smaller than 0.4%
      y[y > 0] = 1
      y[y < 0] = -1
      return y

  def get_clean_Xy(df):
      X = get_X(df)
      y = get_y(df).values
      isnan = np.isnan(y)
      X = X[~isnan]
      y = y[~isnan]
      return X, y

  class MLStrategy(Strategy):
      num_pre_train = 300

      def initialize(self):
          """
          Model training step
          """
          self.info('initialize')
          self.code = list(self.ctx.feed.keys())[0]
          df = self.ctx.feed[self.code].data
          self.ctx.feed[self.code].data = update_df(df)

          self.y = get_y(df[self.num_pre_train-1:])
          self.y_true = self.y.values

          self.clf = KNeighborsClassifier(7)

          df = df.dropna()
          X, y = get_clean_Xy(df[:self.num_pre_train])
          self.clf.fit(X, y)

          self.y_pred = []

      def before_trade(self, order):
          return True

      def on_order_ok(self, order):
          self.my_quantity = self.ctx.get_quantity(order['code'])
          self.info(
              f"{order['side'].name} order [number {order['id']}] ({order['order_type'].name}) executed [quantity {order['quantity']}] {order['code']} [price ${order['price']:2f}] [Cost ${order['gross_amount']:2f}] [Commission: ${order['commission']}] [Available Cash: ${self.available_cash}] [Position: #{self.ctx.get_quantity(order['code'])}] [Gross P&L: ${order['pnl']}] [Net P&L: ${order['pnl_net']}]"
          )

          if not order['is_open']:
              self.info(f"Trade closed, pnl: {order['pnl']}========")

      def on_market_start(self):
          
          pass

      def on_market_close(self):
          
          pass

      def on_order_timeout(self, order):
          self.info(f'on_order_timeout. Order: {order}')
          pass

      def finish(self):
          self.info('finish')

      def on_bar(self, tick):
          """
          Model scoring and decisioning step
          """
          bar_data = self.ctx.bar_data[self.code]

          X = get_X(bar_data)
          if bar_data.x_ma100 != bar_data.x_ma100:
              return
          forecast = self.clf.predict([X])[0]
          self.y_pred.append(forecast)

          open, high, low, close = bar_data.open, bar_data.high, bar_data.low, bar_data.close

          upper, lower = close * (1 + np.r_[1, -1]*PCT_CHANGE)

          if forecast == 1 and not self.ctx.get_quantity(self.code):
              o1 = self.order_amount(code=self.code,amount=self.available_cash,side=Side.BUY)
              self.info(f"BUY order [number {o1['id']}] created, [quantity {o1['quantity']}] [price {o1['price']}] [balance: {self.available_cash}]")

              osl = self.sell(code=self.code,quantity=o1['quantity'], price=lower, stop_price=lower)
              self.info(f"STOPLOSS order [number {osl['id']}] created, [quantity {osl['quantity']}] [price {osl['price']}] [balance: {self.available_cash}]")

          elif forecast == -1 and self.ctx.get_quantity(self.code):
              o2 = self.close(code=self.code, price=upper)
              self.info(f"SELL order [number {o2['id']}] created, [quantity {o2['quantity']}] [price {o2['price']}] [balance: {self.available_cash}]")

  ```

  Run your strategy:
  ```python

  if __name__ == '__main__':

      base = create_report_folder()

      start_date = '2021-01-01'
      end_date = '2021-07-01'
      interval = '4h'

      code = 'XRP/USDT'
      benchmark_code = 'BTC/USDT'

      cs = CommissionScheme(
          commission_rate=0.001,
          min_commission=None,
          is_contract = False
      )
      broker = BackTestBroker(
          commission_scheme=cs,
          trade_at='close',
          
          cash=1000,
          short_cash=False,
          slippage=0.0)

      btc = BinanceSpotDataFeed(
          symbol=benchmark_code,
          start_date=start_date,
          end_date=end_date,
          interval=interval,
          min_volume = 0.00001,
          order_ascending=True,
          store_path=base
      )
      datefeed = BinanceSpotDataFeed(
          symbol=code,
          start_date=start_date,
          end_date=end_date,
          interval=interval,
          min_volume = 0.0001,
          order_ascending=True,
          store_path=base
      )

      mytest = BackTest(
          [ datefeed ],
          MLStrategy,
          benchmark=btc,
          store_path=base,
          broker=broker
      )

      mytest.start()


  ```

  Retrieve statistic results:
  ```python
      prefix = ''
      stats = mytest.ctx.statistic.stats(pprint=True, annualization=252, risk_free=0.0442)
      stats['model_name'] = 'Simple KNN Signal Generation Strategy'
      stats['algorithm'] = ['KNN', 'Simple Moving Average', 'Bollinger Band']
      print(stats)
      mytest.contest_output(is_plot=True)
  ```
  Result:
  ```
  start                                                2021-01-01 00:00:00+08:00
  end                                                  2021-07-01 00:00:00+08:00
  duration                                                     181 days 00:00:00
  trading_pairs                                                        [XRPUSDT]
  benchmark                                                              BTCUSDT
  beginning_balance                                                         1000
  ending_balance                                                     6374.787763
  total_net_profit                                                   5374.787763
  gross_profit                                                       9919.319576
  gross_loss                                                        -4544.531813
  profit_factor                                                         2.182693
  return_on_initial_capital                                             5.374788
  annualized_return                                                     0.536384
  total_return                                                          5.374788
  max_return                                                            5.401244
  min_return                                                           -0.004806
  number_trades                                                              630
  number_winning_trades                                                      317
  number_losing_trades                                                       220
  avg_daily_trades                                                      6.899160
  avg_weekly_trades                                                    32.840000
  avg_monthly_trades                                                  136.833333
  win_ratio                                                             0.503175
  loss_ratio                                                            0.349206
  win_days                                                                    64
  loss_days                                                                   18
  max_win_in_day                                                      701.189561
  max_loss_in_day                                                     -51.928662
  max_consecutive_win_days                                                    22
  max_consecutive_loss_days                                                    2
  avg_profit_per_trade                                                 13.209755
  trading_period                                         0 years 6 months 0 days
  avg_daily_pnl($)                                                      4.949160
  avg_daily_pnl                                                         0.001784
  avg_weekly_pnl($)                                                   206.722606
  avg_weekly_pnl                                                        0.080719
  avg_monthly_pnl($)                                                  868.835518
  avg_monthly_pnl                                                       0.398852
  avg_quarterly_pnl($)                                               1532.511026
  avg_quarterly_pnl                                                     0.463027
  avg_annualy_pnl($)                                                         NaN
  avg_annualy_pnl                                                            NaN
  sharpe_ratio                                                          2.022460
  sortino_ratio                                                         6.971285
  annualized_volatility                                                 0.200512
  omega_ratio                                                           0.011848
  downside_risk                                                         0.064485
  information_ratio                                                     0.058498
  beta                                                                  0.105311
  alpha                                                                -0.999939
  calmar_ratio                                                          5.527284
  tail_ratio                                                            9.548038
  max_drawdown                                                          0.097043
  max_drawdown_period          (2021-06-21 04:00:00+08:00, 2021-06-28 08:00:0...
  max_drawdown_duration                                          7 days 04:00:00
  sqn                                                                   5.283288
  model_name                               Simple KNN Signal Generation Strategy
  algorithm                         [KNN, Simple Moving Average, Bollinger Band]

  ```


pkgId: 6069dc32a28451d154421c1bd3a2ec75e6ff55c6fbd9417cf3707fe5462c022b
name: python-Arenz-Group-Python
arch: src
version: 0.3.9
epoch: 0
release: 1
summary: a pip-installable package with function for Arenz Group
url: https://github.com/NanoElectroCatalysis/Arenz_Group_Python
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Arenz-Group-Python-0.3.9-1.src.rpm
checksum_type: sha256
description:
  Python libs for NanoElectroCatalysis.


   - Create a standard project folder structure.
   - Easy transfer of data from server to local folder for work-up
   - Load and save key-values-pairs
   - Load and save key-values-pairs into tables.
   - Path constants for easy access to data folders.






  https://nanoelectrocatalysis.github.io/Arenz_Group_Python/


  In the project root folder, create a jupyter file.



  In order to install this package use the following line in a jupyter notebook:
  ```python
  %pip install arenz_group_python
  ```
  In order to upgrade this package use the following line in a jupyter notebook:

  ```python
  %pip install arenz_group_python -U
  ```

  Restart the kernal.



  ```python
  from arenz_group_python import Project_Paths
  pp = Project_Paths()
  pp.create_project_structure()
  ```


  Make sure that all the folders you want to import as a file called:
  <IDENTIFYIER>.tag
  where <IDENTIFYIER> can be a project name, example: "project.tag"

  ```python
  from arenz_group_python import Project_Paths
  pp = Project_Paths()
  project_name = 'projectname'
  user_initials = '' #This is optional, but it can speed up things
  path_to_server = 'X:/EXP_DB'
  pp.copyDirs(project_name, user_initials , path_to_server)
  ```


  See documentation.

rpm_license:
  MIT License  Copyright (c) 2024 Gustav Wiberg  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: ca6735a4f1974549302b1219a76ade4e7770921307947fb6ec0dfe5935cc84c5
name: python-ArgParseDecorator
arch: src
version: 1.4.0
epoch: 0
release: 1
summary: A tool to easily build command line interpreters
url: https://github.com/innot/argparseDecorator
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ArgParseDecorator-1.4.0-1.src.rpm
checksum_type: sha256
description:
  [![License](https://img.shields.io/github/license/innot/ArgParseDecorator)](https://github.com/innot/argparseDecorator/blob/master/LICENSE.txt)
  ![Python Version](https://img.shields.io/pypi/pyversions/ArgParseDecorator)
  [![pypi](https://img.shields.io/pypi/v/ArgParseDecorator.svg)](https://pypi.org/project/ArgParseDecorator)
  [![Documentation Status](https://readthedocs.org/projects/argparsedecorator/badge/?version=latest)](https://argparsedecorator.readthedocs.io/en/latest/?badge=latest)
  [![Build](https://github.com/innot/argparseDecorator/actions/workflows/ci.yaml/badge.svg)](https://github.com/innot/argparseDecorator/actions/workflows/ci.yaml)
  [![codecov](https://codecov.io/gh/innot/argparseDecorator/branch/master/graph/badge.svg?token=IPZB3RQUXD)](https://codecov.io/gh/innot/argparseDecorator)




  argparseDecorator is a tool to ease working with the [argparse](https://docs.python.org/3/library/argparse.html)
  library to build custom command line interpreters.

  Instead of setting up the [ArgumentParser](https://docs.python.org/3/library/argparse.html#argumentparser-objects)
  object by hand and then adding subcommands and all the required arguments the argparseDecorator supplies a
  custom [decorator](https://docs.python.org/3/glossary.html#term-decorator)
  to mark any function as a command and to generate the ArgumentParser from the function signature.

  With this it is quite easy to make command line interfaces like, for example, a shell like cli:

  ```python
  from argparsedecorator import *

  cli = ArgParseDecorator()


  @cli.command
  def ls(arg1, arg2, arg3):
      ...


  @cli.command
  def mv(...):
      ...


  @cli.command
  def cp(...):
      ...

  cmdline = input()
  cli.execute(cmdline)
  ```

  The ArgParseDecorator uses both the signature of the decorated function and its
  [docstring](https://peps.python.org/pep-0257/) to infer information, metadata and description of the function arguments
  and passes them to the underlying ArgumentParser.

  Here is an example for using ArgParseDecorator to create a hypothetical 'ls' command:

  ```python

  from __future__ import annotations  # required for Python 3.8 and 3.9. Not required for Python 3.10+
  from argparsedecorator import *  # import the ArgParseDecorator API

  cli = ArgParseDecorator()


  @cli.command
  def ls(
          files: ZeroOrMore[str],
          a: Flag = False,  # create '-a' flag that is 'False' if '-a' is not in the command line.
          ignore: Option | Exactly1[str] = "",  # create optional '--ignore PATTERN' argument
          columns: Option | int | Choices[Literal["range(1,5)"]] = 1,  # valid input for '--columns' is 1 to 4
          sort: Option | Choices[Literal["fwd", "rev"]] = "fwd",  # '--sort {fwd,rev}' with default 'fwd'
  ):
      """
      List information about files (the current directory by default).
      :param files: List of files, may be empty.

      :param a: do not ignore entries strating with '.'
      :alias a: --all

      :param ignore: do not list entries matching PATTERN
      :metavar ignore: PATTERN

      :param columns: number of output columns, must be between 1 and 4. Default is 1
      :alias columns: -c

      :param sort: alphabetic direction of output, either 'fwd' (default) or 'rev'
      :alias sort: -s
      """
      
      return {"files": files, "a": a, "ignore": ignore, "columns": columns, "sort": sort}
  ```

  This example shows how annotations are used to add some metadata to the arguments which will be used by the argparse
  library to interpret the command line input. Take a look at the
  [documentation](https://argparsedecorator.readthedocs.io/en/latest/usage.html#function-signature)
  to learn more about the supported annotations.

  Now a command line can be parsed and executed like this:

  ```python
  result = cli.execute("ls -a -c 2 --sort rev --ignore *.log")
  ```

  ArgParseDecorator uses the docstring of the decorated function to get a help string for the command, and it also parses
  [Sphinx](https://sphinx-rtd-tutorial.readthedocs.io/en/latest/docstrings.html) style directives to provide help strings
  for arguments as well as additional metadata that can not be written as annotations.

  The information provided by the docstring is used by the built-in help command:

  ```python
  parser.execute("help ls")
  ```

  ```
  usage:  ls [-a] [--ignore PATTERN] [--columns {1,2,3,4}] [--sort {fwd,rev}] [files ...]

  List information about files (the current directory by default).

  positional arguments:
    files                 List of files, may be empty.

  options:
    -a, --all             do not ignore entries strating with '.'
    --ignore PATTERN      do not list entries matching PATTERN
    --columns {1,2,3,4}, -c {1,2,3,4}
                          number of output columns, must be between 1 and 4
    --sort {fwd,rev}, -s {fwd,rev}
                          alphabetic direction of output, either 'fwd' (default) or 'rev'
  ```



  * Works best with Python 3.10 or higher
      - the new type unions with '|' make the annotations much more readable

  * Works with Python 3.8+
      - some features require the use of 'from \_\_future\_\_ import annotations'

  * No other dependencies



  If the requirements are met, then a simple

  ```bash
   $ pip import argparseDecorator
  ```

  will install the argParseDecorator module.



  Comprehensive documentation is available at https://argparseDecorator.readthedocs.io/.


  * 1.4.0
    * added ``ignore_annotations`` and ``ignore_docstring`` flags
  * 1.3.1
    * Fixed some bugs in the documentation
  * 1.3.0
    * Added support for command aliases
    * New Annotations: ``RequiredFlag``, ``RequiredOption``
  * 1.2.0
    * Added support for sys.argv argument lists in execute()
    * Using shlex to split commandlines into tokens
    * Numerous minor bug fixes
  * 1.1.0
    * Added support for execute_async()
  * 1.0.2
    * Added support for quoted input to the execute method
  * 1.0.1
    * first release


pkgId: d80feb4b0e7f0b69432c23303b2f09f94ec5ca5c37173083faa53bb69be4b815
name: python-Argumental
arch: src
version: 1.13
epoch: 0
release: 1
summary: please add a summary manually as the author left a blank one
url: https://github.com/eddo888/argumental
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Argumental-1.13-1.src.rpm
checksum_type: sha256
description:
  annotation descripters to put closuer on classes and objects to allow argparse to be easy to use



  A tool to decorate a python class to create an argparse ready command line application

  Here is an example application

  ```python


  import os,re,sys,json

  from Argumental.Argue import Argue


  args = Argue()


  @args.argument(short='v', flag=True)
  def verbose():
  	"""
  	detailed output mode
  	"""
  	return False







  @args.command(name="class", single=False) # True to bypass to methods
  class MyClass(object):
  	"""
  	My Class
  	"""

  	
  	@args.property(
  		short='v',
  		default='abc123',
  		help='with built in setter and deleter'
  	)
  	def value(self): return

  	
  	@args.operation(
  		name='method'
  	)
  	@args.parameter(
  		param='myParameter',
  		short='p',
  		name='parameter',
  		required=True,
  		help='My Parameter'
  	)
  	@args.returns(
  		type=dict,
  		help='test values'
  	)
  	def myOperation(self, myParameter=None):
  		"""
  		My Operation
  		"""
  		return dict(
  			myParameter=myParameter,
  			value=self.value
  		)


  if __name__ == '__main__': args.execute()
  ```




  ```bash
  $ ./MyClass.py -h

  usage: Argue.py [-h] [-v] {class,args} ...

  positional arguments:
    {class,args}   commands
      class        My Class
      args         print the values for the args

  optional arguments:
    -h, --help     show this help message and exit
    -v, --verbose  detailed output mode
  ```



  ```bash
  $ ./MyClass.py class -h

  usage: Argue.py class [-h] [-v VALUE] {method} ...

  positional arguments:
    {method}              operations
      method              My Operation

  optional arguments:
    -h, --help            show this help message and exit
    -v VALUE, --value VALUE
                          with built in setter and deleter, default=abc123

  ```



  ```bash
  $ ./MyClass.py class method -h

  usage: Argue.py class method [-h] -p PARAMETER

  optional arguments:
    -h, --help            show this help message and exit
    -p PARAMETER, --parameter PARAMETER
                          My Parameter

  ```



  ```bash
  $ ./MyClass.py class -v myv method -p myp

  {
      "myParameter": "myp",
      "value": "myv"
  }

  ```


pkgId: 52d08919cc996668c7c53063f093e74d34ade22ef7f411e6e5bfa1c6ae065d0c
name: python-ArmaQDL
arch: src
version: 1.0.0
epoch: 0
release: 1
url: https://github.com/jonpas/Arma-QDL
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ArmaQDL-1.0.0-1.src.rpm
checksum_type: sha256
summary:
  Python program for quick launching various mod development configurations for Arma through a simple CLI.

description:
  [![CI Test](https://github.com/jonpas/ArmaQDL/actions/workflows/test.yml/badge.svg)](https://github.com/jonpas/ArmaQDL/actions/workflows/test.yml)
  [![PyPI](https://img.shields.io/pypi/v/ArmaQDL.svg?logo=pypi&label=PyPI&logoColor=gold)](https://pypi.org/project/ArmaQDL)
  [![PyPI Python](https://img.shields.io/pypi/pyversions/ArmaQDL.svg?logo=python&label=Python&logoColor=gold)](https://pypi.org/project/ArmaQDL)
  [![winstall](https://img.shields.io/badge/WinGet-lightblue.svg)](https://winstall.app/apps/jonpas.ArmaQDL)

  Quick launching various mod development configurations for Arma through a simple CLI.

  Through easily-identifiable preset locations, this program can provide a fast and developer-friendly CLI with some additional optional features, such as building mods and opening the last log file. It is designed around easily modifiable location groups and build tools.



  - Easy **mod launching** from different **preset locations**
  - **Load mission** via mission name only or specifying profile name
  - **Build** development **mods**
  - Open the last log file
  - Select the profile to start with
  - Toggle file patching, script errors, signature check and windowed mode
  - Mod location wildcards (`glob` pattern matching)
  - Easy **dedicated server and headless client launching**
  - Load mission on dedicated server (by manipulating `server.cfg`)
  - Join server




  ArmaQDL is distributed on [PyPI](https://pypi.org/) as well as a Standalone executable (Windows only).
  - Use [WinGet (recommended)](#winget-(recommended)) or [Standalone](#standalone) if you are on Windows and don't have Python installed.
  - Use [PyPI](#pypi) if you have Python installed or are not using Windows.

  PyPI provides easier updating of ArmaQDL, while Standalone requires manual updates.



  Open Command Prompt, PowerShell or any other terminal application and install ArmaQDL.

  ```sh
  $ winget install armaqdl
  ```



  Download `armaqdl.exe` from [latest release](https://github.com/jonpas/ArmaQDL/releases/latest) and place it in a convenient location.

  _Note: Add location directory to `PATH` environmental variable to use it directly._



  Installation as a user is recommended to avoid permission issues with CLI script installation.

  ```
  $ pip install --user ArmaQDL
  ```
  _Note: Add pip installation directory to `PATH` environmental variable to use it directly._




  Open Command Prompt, PowerShell or any other terminal application, and run ArmaQDL once to generate the configuration files (this will not launch Arma).

  ```sh

  $ armaqdl


  $ python -m armaqdl
  ```
  _Note: Add `.exe` if `armaqdl` is not enough to find the executable._

  You should modify the [default settings](https://github.com/jonpas/ArmaQDL/blob/master/config/settings.toml) to your needs. Launching without setup may create a new profile and result in failed launches.

  Settings file can be found in your operating system's standard configuration directory, usually:
  - Windows: `%AppData%\ArmaQDL\settings.toml`
  - Linux: `~/.config/ArmaQDL/settings.toml`

  Settings are in [TOML](https://toml.io/en/) format and can be edited with any text editor.



  Loading a mission on dedicated server automatically requires `server.cfg` to be present next to `arma3_x64.exe` with at least the following mission and Headless Client entries.

  ```cpp
  // Automatically load the first mission in rotation
  class Missions {
      class Test {
          template = "mission.vr";
      };
  };

  // Allow Headless Clients from local machine
  headlessClients[] = {"127.0.0.1"};
  localClient[] = {"127.0.0.1"};

  // Allow multiple connections, unsigned mods and file patching (as needed)
  kickDuplicate = 0;
  verifySignatures = 0;
  allowedFilePatching = 2;
  ```

  ArmaQDL copies the mission from used profile's missions folder and updates the mission name in `server.cfg` to make the server automatically load it.




  ArmaQDL is a CLI script, view all the options with the `--help` flag.

  ```sh
  $ armaqdl -h
  ```
  _Note: All examples use `armaqdl` to launch ArmaQDL, replace it appropriately depending on your install._

  **Example 1:** _(launching and building mods)_

  Launches Arma with CBA from main location, ACE3 from Workshop install and ACRE2 from local development folder. Additionally builds ACRE2 mod and opens the latest log file. Loads Arma directly into the editor using the specified mission from the "Soldier" profile.

  ```sh
  $ armaqdl main:cba workshop:@ace dev:acre2:b -m Soldier:test.vr
  ```

  Specific build tool can also be specified, such as HEMTT.

  ```sh
  $ armaqdl main:cba workshop:@ace dev:acre2:bhemtt -m Soldier:test.vr
  ```

  **Example 2:** _(server and mission handling)_

  Launches Arma Server with CBA from local development folder and loads specified mission from default profile's missions folder, copying it to the server in the process.

  ```sh
  $ armaqdl dev:cba -m test.vr -s
  ```

  Launches Arma with CBA from local development folder and connects to the given server with the given password (`-j` defaults to the settings file).

  ```sh
  $ armaqdl dev:cba -j 192.168.1.1:2302:test
  ```

  **Example 3:** _(glob and skipping)_

  Launches Arma with all mods in a folder `modpack` from main location, skipping ACE3 in the same folder and instead loading ACE3 from a local development folder. This is useful for replacing a subset of mods from a bigger modpack.

  ```sh
  $ armaqdl main:modpack\* main:modpack\ace:s dev:ace
  ```

  **Example 4:** _(launch types)_

  Launches Arma with mods from local development folder, CBA using HEMTT release build, ACE3 using automatic launch type determination and ACRE2 using non-HEMTT build. Available launch types are `dev`, `build`, `release` for HEMTT or none for non-HEMTT `addons/`. Automatic determination uses HEMTT if `.hemttout` folder exists with launch type as specified in settings file, or `dev` if not specified.


  ```sh
  $ armaqdl dev:cba:trelease dev:ace dev:acre2:t
  ```

  Build type for HEMTT can also be specified using the same flag in addition to build flag.

  ```sh
  $ armaqdl dev:cba:bhemtt:trelease dev:ace:b:tbuild
  ```

  **Example 5:** _(optionals)_

  _Note: Only optionals inside `optionals` folder in a full `@mod` folder structure (such as HEMTT produces) are supported._

  Launches Arma with Theseus Services from local development folder and its MELB Variants optional skipping the prefix using glob pattern matching. `@` must still be used for each optional (or pattern) specified.

  ```sh
  $ armaqdl dev:TheseusServices:o@*variants_melb
  ```

  Glob pattern matching may also be used to match multiple optionals.

  ```sh
  $ armaqdl dev:TheseusServices:o@*variants*
  ```




  ArmaQDL uses [Hatchling](https://hatch.pypa.io/latest/) as a build backend and [flake8](https://flake8.pycqa.org/en/latest/) as a style guide.

  ```sh
  $ pip install --user -e .
  ```

  [Hatch](https://hatch.pypa.io/latest/) is the primary project manager of choice, but any project adhering to PEP 621 (`pyproject.toml` specification) can be used.

  ```sh

  $ hatch run armaqdl

  $ hatch run lint

  $ hatch run test

  $ hatch run static:bundle
  ```

  Limited Linux support exists for testing purposes, but launching Arma or opening the last log file is not supported. Contributions are welcome!


pkgId: 268e8c7d2b5fc8463dec50774fa6da30c53d1dd893d5e80183562c275856cab2
name: python-ArraySplitter
arch: src
version: 1.2.3
epoch: 0
release: 1
summary: De Novo Decomposition of Satellite DNA Arrays into Monomers within Telomere-to-Telomere Assemblies
url: https://github.com/aglabx/ArraySplitter
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ArraySplitter-1.2.3-1.src.rpm
checksum_type: sha256
description:
  Decomposes satellite DNA arrays into monomers within telomere-to-telomere (T2T) assemblies. Ideal for analyzing centromeric and pericentromeric regions on monomeric level.

  **Status:** In development. Optimized for 100Kb scale arrays; longer arrays will work but may take longer to process. Signigicanlty longer time.

  **Update:** From 1.1.6, ArraySplitter now successfully decomposes arrays on megabase scale. Largest arrays takes around 5 minutes to process. Fortunatelly, there are only 41 arrays large 1 Mb in CHM13v20 assembly. And I'm going to add parallel processing to speed up singificantly the process. Currently, it is single-threaded.

  **Update:** Monomers are required some polising of borders, I am working on it.

  **Update:** To test ArraySplitter, I used CHM13v20 assembly, it takes around 3 hours, to decompose all arrays longer than 1 Kb (13K arrays).



  **Prerequisites**

  * Python 3.6 or later

  **Installation with pip:**

  ```bash
  pip install arraysplitter
  ```



  **Basic Example**

  ```bash
  time arraysplitter -i chr1.arrays.fa -o chr1.arrays
  ```

  It will create a FASTA file with monomers separated by spaces.

  **Explanation**

  * **`-i chr1.arrays.fa`:**  FASTA file of satDNA arrays.
  * **`-o chr1.arrays`:** Prefix for the output FASTA containing decomposed monomers (separated by spaces).

  **All Options**

  ```bash
  arraysplitter --help
  ```



  We found that different arrays of the same repeat family can be decomposed sligtly differently. To make them comparable, ArraySplitter can rotate monomers to start with the same sequence.

  ```bash
  arraysplitter_rotate -i arrays.fa -o arrays.norm.fa
  ```

  And you can give the sequence to start with:

  ```bash
  arraysplitter_rotate -i arrays.fa -o arrays.norm.fa -s TTTC
  ```

  **Explanation**

  * **`-i arrays.fa`:**  FASTA file of monomers.
  * **`-o arrays.norm.fa`:** Output FASTA file with rotated monomers.



  And finally, you can extract and count monomers from the arrays:

  ```bash
  arraysplitter_extract -i arrays.norm.fa -o arrays.norm
  ```

  It will create a file with monomer length, monomer frequency, and monomer sequence (ordered by frequency). For example, for the arrays.norm.fa file above, the output will be like this:

  ```bash
  514     10      ATCCCATTCC
  514     10      GATTGGAGTG
  514     6       TCCTTT
  514     5       TGCTG
  514     10      ATTGAATGGA
  514     10      ATGCAATGGA
  514     5       TCCTA
  ```




  For questions or support: ad3002@gmail.com


pkgId: 30d561deb85b867bfcff92d258edc78f02fcc344209ca5345c8f8803e956aef4
name: python-ArseinRubika
arch: src
version: 7.5.1
epoch: 0
release: 1
summary: library Robot Rubika
url: https://github.com/Arseinlibrary/Arsein__library.git
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-ArseinRubika-7.5.1-1.src.rpm
checksum_type: sha256
description:
  > Elegant, modern and asynchronous Rubika MTProto API framework in Python for users and bots

  <p align="center">
      <img src="https://s6.uupload.ir/files/img_20240111_123815_369_5ni9.jpg" alt="ArseinRubika" width="128">
      <br>
      <b>library Arsein Rubika</b>
      <br>
  </p>






  ``` bash
  from arsein import Messenger

  Or

  from arsein import Robot_Rubika
  ```



  ``` bash
  from arsein.Zedcontent import Antiadvertisement
  ```



  ``` bash
  pip install ArseinRubika==7.5.1
  ```



  ``` bash
  @Team_Arsein
  ```

  ``` python
  from arsein import Messenger

  bot = Messenger("Your Auth Account"," key Account")

  gap = "your guid or gap or pv or channel"

  bot.sendMessage(gap,"libraryArsein")
  ```


  ``` python
  from arsein import Robot_Rubika

  bot = Robot_Rubika("Your Auth Account"," key Account")

  gap = "your guid or gap or pv or channel"

  bot.sendMessage(gap,"libraryArsein")
  ```
  Made by Team ArianBot

  Address of our team's GitHub :

  https://github.com/Arseinlibrary/Arsein__library.git




  - **Ready**: Install ArseinRubika with pip and start building your applications right away.
  - **Easy**: Makes the Rubika API simple and intuitive, while still allowing advanced usages.
  - **Elegant**: Low-level details are abstracted and re-presented in a more convenient way.
  - **Fast**: Boosted up by pycryptodome, a high-performance cryptography library written in C.
  - **Async**: Fully asynchronous (also usable synchronously if wanted, for convenience).
  - **Powerful**: Full access to Rubika's API to execute any official client action and more.




  ``` bash
  Our channel in Ita

  https://eitaa.com/ArseinTeam

  Our channel in Soroush Plus

  https://splus.ir/ArseinTeam

  Our channel in Rubika

  https://rubika.ir/Support_libdaryArseinRubika

  Our channel in the Gap

  https://gap.im/ArseinTeam

  Our channel on Telegram

  https://t.me/ArseinTeam
  ```


pkgId: 7110dd3e0c05c5b96748e351186ca9bb17469436ab17361e617ffcd0de671bc1
name: python-Artec
arch: src
version: 0.3.1
epoch: 0
release: 1
summary: Creates a configurable python project template in a given directory.
url: https://github.com/HushmKun/Artec
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Artec-0.3.1-1.src.rpm
checksum_type: sha256
description:
  ![Logo](img/Artec.png)

  A python application that creates a configurable python project template in a given directory.<br>
  _It's a maintained version of PyBoiler_



  Download from pip

  ```bash
  $ pip install Artec
  ```

  or Install manually
  ```bash
  $ git clone https://github.com/HushmKun/Artec
  $ cd Artec
  $ pip install -U .
  ```

  Create a JSON file to match the folder structure you desire
  ```
  $ vim structure.json


  {
      "folders": [
          "{}",
          "test"
      ],
      "files": [
          "{}/__init__.py",
          "test/__init__.py",
          "README.md",
          "LICENSE",
          "setup.py",
          "pyproject.toml"
      ]
  }

  ```
  How to execute
  ```
  $ artec -h
  usage: artec [OPTIONS] -o [DEST]

  Artec is a python application that creates a configurable python project template in a given directory.

  options:
    -h, --help            show this help message and exit
    -s SOURCE, --source-file SOURCE
                          Source JSON file containing structure to be created
    -t TEMPLATE, --template TEMPLATE
                          Uses ready-made templates.
    -o TARGET, --output-directory TARGET
                          Target output path where the structure will be created
    -ls, --list-template  lists all ready-made templates.
    -v, --verbose         Runs Artec in verbose mode.
    -g, --git-init        Creates a git Repo for the project.
    -V, --version         Display current version of Artec

  Examples:
          artec -h
          artec -o dest
          artec -o dest -t python
          artec -o dest -s structure.json
          artec -o dest -s structure.json -v
  ```


  - Python
  - Flask
  - Node.Js
  - Data_Science



      0.3.1


  Please refer to [Here](CONTRIBUTING.md) for contributing.
  Any help that can contribute to the templates will be really appreciated.

  * Big Thanks to [Link-](https://github.com/Link-) for jump starting the project.
  * Thanks for [Narayandas Akhil Achary](https://github.com/0018akhil) for various fixes & features.


  Since this project is intended as a learning project, It helps me figure out what is the best practices of X, How to use Y, etc...

  If you come here to learn, Read [this](LEARN.md), I will be glad if it helped you learn something new.


  [GNU GPLv3.0](https://choosealicense.com/licenses/gpl-3.0/)

rpm_license:
  GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/> Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.  Preamble  The GNU General Public License is a free, copyleft license for software and other kinds of works.  The licenses for most software and other practical works are designed to take away your freedom to share and change the works.  By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users.  We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors.  You can apply it to your programs, too.  When we speak of free software, we are referring to freedom, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.  To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights.  Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others.  For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received.  You must make sure that they, too, receive or can get the source code.  And you must show them these terms so they know their rights.  Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it.  For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software.  For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions.  Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so.  This is fundamentally incompatible with the aim of protecting users' freedom to change the software.  The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable.  Therefore, we have designed this version of the GPL to prohibit the practice for those products.  If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users.  Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary.  To prevent this, the GPL assures that patents cannot be used to render the program non-free.  The precise terms and conditions for copying, distribution and modification follow.  TERMS AND CONDITIONS  0. Definitions.  "This License" refers to version 3 of the GNU General Public License.  "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.  "The Program" refers to any copyrightable work licensed under this License.  Each licensee is addressed as "you".  "Licensees" and "recipients" may be individuals or organizations.  To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy.  The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work.  A "covered work" means either the unmodified Program or a work based on the Program.  To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy.  Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.  To "convey" a work means any kind of propagation that enables other parties to make or receive copies.  Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.  An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License.  If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.  1. Source Code.  The "source code" for a work means the preferred form of the work for making modifications to it.  "Object code" means any non-source form of a work.  A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.  The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form.  A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.  The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities.  However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work.  For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work.  The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.  The Corresponding Source for a work in source code form is that same work.  2. Basic Permissions.  All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met.  This License explicitly affirms your unlimited permission to run the unmodified Program.  The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work.  This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.  You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force.  You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright.  Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.  Conveying under any other circumstances is permitted solely under the conditions stated below.  Sublicensing is not allowed; section 10 makes it unnecessary.  3. Protecting Users' Legal Rights From Anti-Circumvention Law.  No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.  When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.  4. Conveying Verbatim Copies.  You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.  You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.  5. Conveying Modified Source Versions.  You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:  a) The work must carry prominent notices stating that you modified it, and giving a relevant date.  b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7.  This requirement modifies the requirement in section 4 to "keep intact all notices".  c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy.  This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged.  This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.  d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.  A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit.  Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.  6. Conveying Non-Source Forms.  You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:  a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange.  b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.  c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source.  This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.  d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge.  You need not require recipients to copy the Corresponding Source along with the object code.  If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source.  Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.  e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.  A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.  A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling.  In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage.  For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product.  A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.  "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source.  The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.  If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information.  But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).  The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed.  Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.  Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.  7. Additional Terms.  "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law.  If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.  When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it.  (Additional permissions may be written to require their own removal in certain cases when you modify the work.)  You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.  Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:  a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or  b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or  c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or  d) Limiting the use for publicity purposes of names of licensors or authors of the material; or  e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or  f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.  All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10.  If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term.  If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.  If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.  Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.  8. Termination.  You may not propagate or modify a covered work except as expressly provided under this License.  Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).  However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.  Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.  Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License.  If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10.  9. Acceptance Not Required for Having Copies.  You are not required to accept this License in order to receive or run a copy of the Program.  Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance.  However, nothing other than this License grants you permission to propagate or modify any covered work.  These actions infringe copyright if you do not accept this License.  Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.  10. Automatic Licensing of Downstream Recipients.  Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License.  You are not responsible for enforcing compliance by third parties with this License.  An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations.  If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.  You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License.  For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.  11. Patents.  A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based.  The work thus licensed is called the contributor's "contributor version".  A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version.  For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.  Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.  In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement).  To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.  If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients.  "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.  If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.  A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License.  You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.  Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.  12. No Surrender of Others' Freedom.  If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all.  For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.  13. Use with the GNU Affero General Public License.  Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work.  The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such.  14. Revised Versions of this License.  The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time.  Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.  Each version is given a distinguishing version number.  If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation.  If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation.  If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.  Later license versions may give you additional or different permissions.  However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.  15. Disclaimer of Warranty.  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.  16. Limitation of Liability.  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  17. Interpretation of Sections 15 and 16.  If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee.  END OF TERMS AND CONDITIONS  How to Apply These Terms to Your New Programs  If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.  To do so, attach the following notices to the program.  It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.  <one line to give the program's name and a brief idea of what it does.> Copyright (C) <year>  <name of author>  This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.  You should have received a copy of the GNU General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.  Also add information on how to contact you by electronic and paper mail.  If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode:  <program>  Copyright (C) <year>  <name of author> This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.  The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License.  Of course, your program's commands might be different; for a GUI interface, you would use an "about box".  You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see <https://www.gnu.org/licenses/>.  The GNU General Public License does not permit incorporating your program into proprietary programs.  If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library.  If this is what you want to do, use the GNU Lesser General Public License instead of this License.  But first, please read <https://www.gnu.org/licenses/why-not-lgpl.html>.


pkgId: 209c4af3384a19b2e6b33c68a6c53f7d7ca1ade16bc906ddf89422ecdc006e16
name: python-Artificial-Neural-Network-Classifier
arch: src
version: 1.0.22
epoch: 0
release: 1
summary: Artificial Neural Network, is a deep learning API written in Python.
url: https://github.com/somkietacode/Artificial_Neural_Network
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Artificial-Neural-Network-Classifier-1.0.22-1.src.rpm
checksum_type: sha256
description:
  337	| 118| 	4	| 4.5	| 4.5	| 9.65	| 1
  324	| 107	| 4	| 4	| 4.5	| 8.87	| 1
  316	| 104 | 3	| 3	| 3.5 | 	8	| 1
  322	| 110	| 3	| 3.5	| 2.5	| 8.67	| 1
  314	| 103	| 2	| 2	| 3	| 8.21	| 0
  330	| 115	| 5	| 4.5	| 3	| 9.34	| 1
  321	| 109	| 3	| 3	| 4	| 8.2	| 1
  308	| 101	| 2	| 3	| 4	| 7.9	| 0
  302	| 102	| 1	| 2	| 1.5	| 8	| 0


pkgId: 26fe4effd00041bf6bee1315cf51eeeea5e869dd1fabcc03830382547b0e6c3e
name: python-Artist-Engineering-Geek
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A bunch of GANs and data downloaders to make a custom AI artist
url: https://github.com/Fatima-x-Nikhil/Artist
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Artist-Engineering-Geek-0.1.0-1.src.rpm
checksum_type: sha256
description:
  - An easy to edit codebase for Progressive GAN originally published by this [research paper][Progressive GAN Research Paper] and other GANs
  - Supplement my personal projects
  - Resume builder
  - For fun and to understand state-of-the-art AI



  Ensure you have a GPU if you want to train in any reasonable amount of time.
  - [Install CUDA here][CUDA Install]
  - [Install cuDNN here][cuDNN Install]

  ```sh
  pip install Artist-Engineering-Geek


  pip install --no-cache-dir --pre torch torchvision torchaudio -f https://download.pytorch.org/whl/nightly/cu112/torch_nightly.html
  ```


  To train the program, run the "Train.ipynb" notebook and alter your parameters at will on GitHub.
  There should be sufficient in-code documentation for you to understand what the hell is going on

     [CUDA Install]: <https://developer.nvidia.com/cuda-downloads>
     [cuDNN Install]: <https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html>
     [Progressive GAN Research Paper]: <https://arxiv.org/abs/1710.10196>


pkgId: 24878551b05b1a42cacd11852142c34433ebc5c78e23020de4a5bbd5a6adb584
name: python-Aruna-Python-API
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: Aruna Object Storage Python API builds
url: https://github.com/ArunaStorage/python-api
rpm_license: Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Aruna-Python-API-2.0.1-1.src.rpm
checksum_type: sha256
description:
  This repo contains the Python API builds for the Aruna storage. It is derived from the language agnostic Protocol Buffers [API Definitions](https://github.com/ArunaStorage/api).




  The API contains three main sections:

  - [Storage section](#storage): This is the main section for external use. It contains a basic set of services and models that describe the interfaces with the storage system.

  - [Notification section](#notifications): This section contains a set of services and models that describe the interfaces with the notification system.

  - [Hooks](#hooks): This section contains the service that can be used to extend Aruna with external functionality or automate internal processes.




  The storage section is divided in two sub-sections:

  - [Models](https://github.com/ArunaStorage/api/tree/main/aruna/api/storage/models/v2): This section contains the models that are used by the storage system.

  - [Storage services](https://github.com/ArunaStorage/api/tree/main/aruna/api/storage/services/v2/): This section contains all services that are used to interact with the storage system. Services are defined as RPCs and are grouped by object type.



  The Notification section provides a set of RPCs that are used to interact with the notification system. The notification system uses [nats.io](https://nats.io/) as its underlying service. The service definition can be found [here](https://github.com/ArunaStorage/api/tree/main/aruna/api/notification/services/v2/notification_service.proto).




  Hooks are the way to automate internal processes in Aruna and/or to integrate external services to extend functionality. Once created, they're available globally in Aruna, and Projects must be associated with them to be included in their trigger cycle. The action that triggers the specific hook is defined by its trigger type.





  The API is licensed under either of

   * Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
   * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)

  at your option. Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.


pkgId: 2f6fe71076bc0b13686ebdb96c89db710cacb25e4c382797260270cadcd678a0
name: python-AsicVerifier
arch: src
version: 0.2.4
epoch: 0
release: 1
summary: Asic Verifier for X-Road
url: https://github.com/pipinfitriadi/asicverifier
rpm_license: AGPL-3.0-only
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AsicVerifier-0.2.4-1.src.rpm
checksum_type: sha256
description:
  <!--
  Copyright (c) Free Software Foundation, Inc. All rights reserved.
  Licensed under the AGPL-3.0-only License. See LICENSE in the project root for license information.
  -->



  [![License](https://img.shields.io/github/license/pipinfitriadi/asicverifier?logoColor=black&label=License&labelColor=black&color=brightgreen)](https://github.com/pipinfitriadi/asicverifier/blob/main/LICENSE)
  [![Java - Version](https://img.shields.io/badge/8-ED8B00?logo=openjdk&logoColor=ED8B00&label=Java&labelColor=black)](https://openjdk.org/projects/jdk8/)
  [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/asicverifier?logo=python&label=Python&labelColor=black)](https://pypi.org/project/asicverifier/)
  [![PyPI - Version](https://img.shields.io/pypi/v/asicverifier?logo=pypi&label=PyPI&labelColor=black)](https://pypi.org/project/asicverifier/)
  [![Docker Image Size (tag)](https://img.shields.io/docker/image-size/pipinfitriadi/asicverifier/latest?logo=Docker&label=latest&labelColor=black)](https://hub.docker.com/r/pipinfitriadi/asicverifier)
  [![GitHub Action](https://img.shields.io/github/actions/workflow/status/pipinfitriadi/asicverifier/ci-cd.yml?logo=GitHub&label=CI/CD&labelColor=black)](https://github.com/pipinfitriadi/asicverifier/actions/workflows/ci-cd.yml)
  [![Codecov](https://img.shields.io/codecov/c/github/pipinfitriadi/asicverifier?logo=codecov&label=Coverage&labelColor=black)](https://app.codecov.io/github/pipinfitriadi/asicverifier)

  Asic Verifier for X-Road

  > **Note**
  >
  > This service require [Docker](https://docs.docker.com/get-docker/)



  | Name               | Type             | Default                 |
  |--------------------|------------------|-------------------------|
  | `RESTFUL_API_PATH` | String URL Path  | `/`                     |
  | `JAR_PATH`         | String File Path | `/lib/asicverifier.jar` |
  | `DEV_MODE`         | Bool             | `false`                 |



  - Start up:

      ```sh
      docker run -d --rm --platform linux/amd64 -p '80:80' --name asicverifier pipinfitriadi/asicverifier
      ```

      > RESTful API's docs should be available at [http://0.0.0.0/](http://0.0.0.0/)

  - Shut down:

      ```sh
      docker stop asicverifier
      ```

  - Help:

      ```sh
      docker run --rm --platform linux/amd64 pipinfitriadi/asicverifier --help
      ```



  `docker-compose.yml`:

  ```yml
  version: '3.7'
  services:
  asicverifier:
      image: pipinfitriadi/asicverifier
      container_name: asicverifier
      platform: linux/amd64
      ports:
          - '80:80'
  ```

  - Start up:

      ```sh
      docker compose up -d
      ```

      > RESTful API's docs should be available at [http://0.0.0.0/](http://0.0.0.0/)

  - Shut down:

      ```sh
      docker compose down
      ```

  - Help:

      ```sh
      docker compose run --rm asicverifier --help && docker compose down
      ```


pkgId: 15d082897eb868e0e1168ab311da71e972a0b1d82058869ce1754208aaded57b
name: python-AspireTUI
arch: src
version: 0.5.1
epoch: 0
release: 1
summary: Achieving Seamless Performance In Real-time Environments : A framework for a line based TUI
url: https://github.com/sri-arjuna/ASPIRE
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AspireTUI-0.5.1-1.src.rpm
checksum_type: sha256
description:
  > **Note:** \
  > This is the official rewrite of TUI/SWARM by the original inventor/author Simon Arjuna Erat. \
  > Please be aware that this is an unstable work in progress, and some references in this text may refer to habits/behaviour based on the original BASH source code.
  * This software/framework is running under [MIT License](https://github.com/sri-arjuna/Aspire/blob/master/docs/LICENSE.txt)
  * For recent updates, please see the [ChangeLog](https://github.com/sri-arjuna/Aspire/blob/master/docs/ChangeLog.md)
  * You can install this as a [PyPi Package](https://pypi.org/project/AspireTUI/) --> ``pip install AspireTUI``
  * Documentation and Source Code can be found on the [GitHub repo](https://github.com/sri-arjuna/Aspire)
  * This framework has currently [![Downloads Month](https://static.pepy.tech/badge/AspireTUI/month)](https://pepy.tech/project/AspireTUI) with a total of [![Downloads](https://static.pepy.tech/badge/AspireTUI)](https://pepy.tech/project/AspireTUI) so far. (stats from pypi)
  >> __Please report bugs and/or inconsistencies!__ \
  >> --> [GitHub Issues](https://github.com/sri-arjuna/ASPIRE/issues) <--

rpm_license:
  MIT License  Copyright 2023 Simon Arjuna Erat, Switzerland  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: 3ec18714d06e72b79c6e7c8a94651cb275e23b4edf39f1f4bb0018adfa5d05dd
name: python-Assembly
arch: src
version: 1.3.0
epoch: 0
release: 1
url: https://github.com/mardix/assembly
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Assembly-1.3.0-1.src.rpm
checksum_type: sha256
summary:
  Assembly is a pythonic object-oriented, mid stack, batteries included framework built on Flask, that adds structure to your Flask application, and group your routes by class.Assembly allows developers to build web applications in much the same way they would build any other object-oriented Python program.Assembly Makes Flask Great Again!

description:
  **Assembly** is a pythonic object-oriented, mid stack, batteries included framework built on Flask, that adds structure to your Flask application, and group your routes by class.
  **Assembly** allows you to build web applications in much the same way you would build any other object-oriented Python program.
  **Assembly** helps you create small to enterprise level applications easily.


pkgId: ebea6b1bd3e551b9c234f165dafabfb1bef7bf7e86656eae70b3c52680412943
name: python-AssemblyTron
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: A package for automating DNA assembly with an Opentrons liquid handling robot
url: https://github.com/PlantSynBioLab/opentrons
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AssemblyTron-0.1.0-1.src.rpm
checksum_type: sha256
description:
  AssemblyTron is a package for automating DNA assembly with an Opentrons liquid handling robot. DNA-Assembly line implements combinatorial DNA assemblies based on designs created with j5 (Hillson, N.J., Rosengarten, R.D., and Keasling J.D. (2012) j5 DNA Assembly Design Automation Software. ACS Synthetic Biology 1 (1), 14-21. DOI: 10.1021/sb2000116), currently accessibe via: https://public-diva.jbei.org/.
  The AssemblyTron vignette is hosted at: https://plantsynbiolab.github.io/AssemblyTron-vignette/ and is intended to guide a novice user through installation and use of AssemblyTron to build DNA constructs via Golden Gate assembly in the Opentrons OT-2 robot. We assume that the user has a folder/directory containing the results of a j5 combinatorial assembly design on the computer connected to their OT-2 robot. AssemblyTron then operates on the files within this folder to generate specific assembly instructions for the user and the OT-2 robot which are saved in this folder. The vignette is also available on our Github.
  Technical documentation is stored on our Github and hosted at: https://assemblytron.readthedocs.io/en/latest/AssemblyTron.html


pkgId: de4e53efd9a9aa825eb571442a50a9f95377c745d5fadcc4501cec1fb160c13b
name: python-AssetsStore
arch: src
version: 1.4.2
epoch: 0
release: 1
summary: Python package for managing file upload/download via selected file system.
url: https://pypi.org/project/AssetsStore/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AssetsStore-1.4.2-1.src.rpm
checksum_type: sha256
description:
  This library was created to simplify the upload/download of files from/to S3, Azure Storage, or your desired server.



  The project is using python 3.12, it relies on boto3 lib for S3, azure-storage-blob for AzureStorage, and paramiko for server connections.

  - [Python 3.12](python.org/downloads/)
  - [boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)
  - [azure-storage-blob](https://pypi.org/project/azure-storage-blob/)
  - [paramiko](https://www.paramiko.org/)



  Install with pip depending on which type of storage do you use (s3,server,azure,minio are choices):

  `pip install AssetsStore[s3]`

  Set environment variables dependent on what upload you are using:

  - AzureStorage

  ```
  ASSET_STORE=AzureFiles
  ASSET_ACCESS_KEY="put_access_key"
  ASSET_SECRET_ACCESS_KEY="put_access_key_secret"
  ASSET_LOCATION="name_of_the_blob"
  ASSET_PUBLIC_URL="blob_public_url"
  LOCAL_STORE=path_to_download_folder
  ```

  - S3

  ```
  ASSET_STORE=S3Files
  ASSET_ACCESS_KEY="put_access_key"
  ASSET_SECRET_ACCESS_KEY="put_access_key_secret"
  ASSET_LOCATION="name_of_the_bucket"
  ASSET_PUBLIC_URL="blob_public_url"
  ASSET_REGION="s3_region"
  LOCAL_STORE=path_to_download_folder
  ```

  - for local development

  ```
  ASSET_STORE=LocalFiles
  ASSET_LOCATION="path_to_folder"
  ASSET_PUBLIC_URL="local_url_if_folder_hosted"
  LOCAL_STORE=path_to_download_folder
  ```

  The library has the ability to use Rebrand and to use it add these envs:

  ```
  REBRAND_KEY="rebrand_key"
  REBRAND_DOMAIN='rebrand_domain'
  ```



  ```python

  from assetsstore.assets import FileAssets

  assets = FileAssets.get_asset()  # setup asset store
  assets.put_file("some_file.txt")  # Upload file from local download folder
  assets.get_file("some_file.txt")  # Download file to local download folder
  assets.del_local_file("some_file.txt")  # Delete file from local download folder
  assets.del_file("some_file.txt")  # Deletes file from server
  ```



  - [@nmrkic](https://github.com/nmrkic)



  ```bash
  flit build
  flit publish
  ```



  Contributions are always welcome! :)


pkgId: 4236bd2fbf134af20ff6c59e82891082baf638d0d324ab1608bb2e64538e2965
name: python-AsthoUpdater
arch: src
version: 0.2.6
epoch: 0
release: 1
summary: A lib for update files written in Python.
url: https://github.com/Asthowen/AsthoUpdater
rpm_license: GNU v3.0
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AsthoUpdater-0.2.6-1.src.rpm
checksum_type: sha256
description:
  <h1 align="center">
    AsthoUpdater
  </h1>
  <p align="center">
      <a href="https://www.python.org/">
          <img src="https://img.shields.io/badge/Python-3776AB?style=for-the-badge&logo=python&logoColor=white" alt="Made With Python">
      </a>
      <a href="https://github.com/Asthowen/AsthoUpdater">
          <img src="https://img.shields.io/badge/Git-F05032?style=for-the-badge&logo=git&logoColor=white" alt="Use git">
      </a>
      <br>
        <a href="https://github.com/Asthowen/AsthoUpdater">
          <img src="https://img.shields.io/pypi/v/AsthoUpdater?style=for-the-badge" alt="PyPI version">
      </a>
      <a href="https://github.com/Asthowen/AsthoUpdater/blob/main/LICENSE">
          <img src="https://img.shields.io/github/license/Asthowen/AsthoUpdater?style=for-the-badge" alt="License">
      </a>
      <a href="https://github.com/Asthowen/AsthoUpdater/stargazers">
          <img src="https://img.shields.io/github/stars/Asthowen/AsthoUpdater?style=for-the-badge" alt="Stars">
      </a>
  </p>
  <h3 align="center">
      <strong>A lib for update files written in Python.</strong>
  </h3>


  * [**async-timeout**](https://pypi.org/project/async-timeout/)
  * [**aiofiles**](https://pypi.org/project/aiofiles/)
  * [**aiohttp**](https://pypi.org/project/aiohttp/)


  Execute the command:
  ```bash
  pip3 install AsthoUpdater
  ```



  By default, the verification algorithm is sha512, you can choose another one with the `algorithm` parameter, available: sha256, sha512, crc32, md5.
  If you want to use another one you can contact me.

  ```python
  from astho_updater import AsthoUpdater

  async with AsthoUpdater("jsonUrl", "pathToUpdate") as a:
      await a.download()
  ```


  ```yaml
  json_url: Your json url, required (str)
  download_path: The download path, required (str)
  download_timeout: The timeout to download file, optionnal, 12 at default (int)
  overwrite_files: If you want re-download all files, optionnal, False at default (bool)
  file_deleter: If you want dl older files, optionnal, False at default (bool)
  logger_status: If you want enable/disable the logger, optionnal, True at default (bool)
  logger_name: If you want set the logger name, optionnal, 'astho_updater' at default (str)
  logger_date_format: If you want set the logger name format, optionnal, '%H:%M:%SOURCE-
  algorithm: If you want set the used algorithm, optionnal, 'sha512' at default (str)
  download_limit: Limit the number of files that can be downloaded simultaneously, optionnal, 10 at default (int)
  ```


  ```yaml
  get_total_files_to_download: Return total file to download (int)
  get_total_files_downloaded: Return total files downloaded (int)
  ```


  ```json
  {
    "maintenance": "off",
    "files": [
        {
          "checksum": "theChecksum",
          "name": "filename",
          "url": "linkOfFile",
          "path": "pathOfFile"
        },
        {
          "checksum": "theChecksum",
          "name": "filename",
          "url": "linkOfFile",
          "path": "pathOfFile"
        }
    ]
  }
  ```


  [<img width="45" src="https://avatars3.githubusercontent.com/u/59535754?s=400&u=48aecdd175dd2dd8867ae063f1973b64d298220b&v=4" alt="Asthowen">](https://github.com/Asthowen)


  **[AsthoUpdater](https://github.com/Asthowen/AsthoUpdater) | [GNU General Public License v3.0](https://github.com/Asthowen/AsthoUpdater/blob/main/LICENSE)**


pkgId: 0006eaa72bd15fe880842f8239df2da06ee171066ba350fe05e7a3fb19119375
name: python-AstraCarta
arch: src
version: 1.0.39
epoch: 0
release: 1
summary: Perform astroquery with useful options
url: https://github.com/user29A/astracarta
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AstraCarta-1.0.39-1.src.rpm
checksum_type: sha256
description:
  See https://github.com/user29A/astracarta

  Searches a catalogue using AstroQuery for bright sources in an image field with useful search parameters.

  See the Github Wiki for details on usage and options:

  https://github.com/user29A/AstraCarta/wiki

  Install with pip:

  pip install astracarta

  This project was undertaken with the financial support of the Canadian Space Agency.


pkgId: fd5ac4893ddea569a141d311ca036a20259074c21d7c470a857032c4661a387e
name: python-AstroPT
arch: src
version: 1.0.0
epoch: 0
release: 1
summary: Transformer for galaxy images (and general astronomy)
url: https://github.com/smith42/astropt
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AstroPT-1.0.0-1.src.rpm
checksum_type: sha256
description:
  <div align="center">

  <img src="assets/emoji.png" alt="earthPT" width="150"/>

  [![ICML](https://img.shields.io/badge/AI4Science@ICML-2024---?logo=https%3A%2F%2Fneurips.cc%2Fstatic%2Fcore%2Fimg%2FNeurIPS-logo.svg&labelColor=68448B&color=b3b3b3)](https://openreview.net/forum?id=aOLuuLxqav)
  [![arXiv](https://img.shields.io/badge/arXiv-2405.14930---?logo=arXiv&labelColor=b31b1b&color=grey)](https://arxiv.org/abs/2405.14930)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![All Contributors](https://img.shields.io/badge/all_contributors-4-orange.svg?style=flat-square)](#contributors-)
  </div>




  Welcome to our simple repository for training astronomical large observation
  models. This repository began its life as Andrej Karpathy's
  [nanoGPT](https://github.com/karpathy/nanoGPT), and has been altered so that it
  is usable for imagery data.  Within `train.py` you will find a ~300-line
  boilerplate training loop and within `model.py` you will find a ~300-line GPT
  model definition with an MLP tokeniser and a regressive loss.

  Check out the [UniverseTBD](https://universetbd.org/) Discord for updates:
  [https://discord.gg/MNEVegvfJq](https://discord.gg/MNEVegvfJq)



  Dependencies:

  - `pip install -r requirements.txt`



  AstroPT v1.0.0 has been trained on 8.6M galaxy grz band `*.png` postage stamps
  downloaded from DESI-LS DR8 to see if neural scaling laws apply to galaxian
  data (in other words, to see if `more galaxy data == more better model`).
  We tried to make the astroPT model as simple as possible so that other
  modalities can be easily folded in. We also choose to use a causally trained
  autoregressive transformer model as our backbone so that our work can more
  easily integrate the wider deep learning FOSS community.

  Our pretraining task is feeding in our galaxy images patch-by-patch and
  predicting the next patch in our galaxy patch sequence. We follow ViT
  and define a patch as a 16 by 16 pixel square, and feed the galaxy patches
  in a spiral order:

  <p align="center">
      <img src="explore/galaxy.png" alt="galaxy" width="128"/>
  </p>

  The trained model results are promising -- below we show our full training run
  validation losses across a parameter sweep of `{1,5,12,21,89,309,830,2100}M`
  trainable parameters:

  <p align="center">
      <img src="explore/scaling_xkcd.png" alt="scaling" width="512"/>
  </p>

  We also test our astroPT models on some scientifically-useful downstream tasks by
  taking the models' penultimate layer outputs and finetuning linear probes to
  predict emergent physical properties of the galaxies:

  <p align="center">
      <img src="explore/downstream_xkcd.png" alt="downstream" width="512"/>
  </p>

  In the above pic, $M_g$ and $M_z$ are the absolute magnitudes (or brightness at
  a fixed distance) of the galaxies, $g - r$ and $r - z$ are the differences
  between the observations of different telescope filter bands, redshift is the
  distance to the galaxies, sSFR is the total mass of new stars born each year in
  the galaxies per total galaxy mass, and $M_{\*}$ is the total mass of stars within
  the galaxies. "smooth?", "disc?", "artefact?", "edge on?" and "tight spiral?" are
  morphological properties of the galaxies as described by citizen scientists.

  The cool thing to take away from these plots is that the surrogate task loss
  (predicting the next patch in a sequence of ViT-like galaxy image patches)
  is correlated with astronomically "useful" downstream tasks 🤯🚀.

  Finally, check out our UMAP projection of astroPT-87M's penultimate layer
  outputs of our validation set. We colour each point with an emergent physical
  galaxy property described above. The structure suggests that the model has
  learnt some knowledge about physics simply from our next-token prediction
  pretraining task!

  <p align="center">
      <img src="explore/hexbin_xkcd.png" alt="hexbin" width="512"/>
  </p>



  Check out the paper here: [https://arxiv.org/abs/2405.14930](https://arxiv.org/abs/2405.14930).

  We of course release all our model weights checkpointed across our full training runs on [HuggingFace 🤗 here](https://huggingface.co/Smith42/astroPT).

  We also release our full dataset and galaxy metadata on [HuggingFace 🔥](https://huggingface.co/datasets/Smith42/galaxies).



  <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
  <!-- prettier-ignore-start -->
  <!-- markdownlint-disable -->
  <table>
    <tbody>
      <tr>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/RJ-Roberts"><img src="https://avatars.githubusercontent.com/u/131991163?v=4?s=100" width="100px;" alt="Ryan Roberts"/><br /><sub><b>Ryan Roberts</b></sub></a><br /><a href="https://github.com/Smith42/astroPT/commits?author=RJ-Roberts" title="Code">💻</a> <a href="#ideas-RJ-Roberts" title="Ideas, Planning, & Feedback">🤔</a> <a href="#content-RJ-Roberts" title="Content">🖋</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://mjjsmith.com/"><img src="https://avatars.githubusercontent.com/u/8194280?v=4?s=100" width="100px;" alt="Mike Smith"/><br /><sub><b>Mike Smith</b></sub></a><br /><a href="https://github.com/Smith42/astroPT/commits?author=Smith42" title="Code">💻</a> <a href="#ideas-Smith42" title="Ideas, Planning, & Feedback">🤔</a> <a href="#content-Smith42" title="Content">🖋</a> <a href="#data-Smith42" title="Data">🔣</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/mhuertascompany"><img src="https://avatars.githubusercontent.com/u/22987973?v=4?s=100" width="100px;" alt="mhuertascompany"/><br /><sub><b>mhuertascompany</b></sub></a><br /><a href="#ideas-mhuertascompany" title="Ideas, Planning, & Feedback">🤔</a> <a href="#content-mhuertascompany" title="Content">🖋</a></td>
        <td align="center" valign="top" width="14.28%"><a href="https://github.com/msiudek"><img src="https://avatars.githubusercontent.com/u/53626980?v=4?s=100" width="100px;" alt="Malgorzata Siudek"/><br /><sub><b>Malgorzata Siudek</b></sub></a><br /><a href="#ideas-msiudek" title="Ideas, Planning, & Feedback">🤔</a> <a href="#content-msiudek" title="Content">🖋</a> <a href="https://github.com/Smith42/astroPT/commits?author=msiudek" title="Code">💻</a> <a href="#data-msiudek" title="Data">🔣</a></td>
      </tr>
    </tbody>
    <tfoot>
      <tr>
        <td align="center" size="13px" colspan="7">
          <img src="https://raw.githubusercontent.com/all-contributors/all-contributors-cli/1b8533af435da9854653492b1327a23a4dbd0a10/assets/logo-small.svg">
            <a href="https://all-contributors.js.org/docs/en/bot/usage">Add your contributions</a>
          </img>
        </td>
      </tr>
    </tfoot>
  </table>

  <!-- markdownlint-restore -->
  <!-- prettier-ignore-end -->

  <!-- ALL-CONTRIBUTORS-LIST:END -->


pkgId: 637bd526d87b15cb18501b9b9f8e712707ce317c013212dc615ac5acf2b42606
name: python-Async-OAuthlib
arch: src
version: 0.0.9
epoch: 0
release: 1
summary: OAuthlib authentication support for Aiohttp.
url: https://github.com/thec0sm0s/Async-OAuthlib
rpm_license: ISC
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Async-OAuthlib-0.0.9-1.src.rpm
checksum_type: sha256
description:
  This project provides first-class OAuth library support for `Aiohttp <https://github.com/aio-libs/aiohttp>`_.


pkgId: e69f54b6bceb3a8804635c0df824368618ad1e9cbab91b1e425dc24639e6f750
name: python-AsyncGear
arch: src
version: 4.7.2
epoch: 0
release: 1
url: https://github.com/monk-after-90s/AsyncGear
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AsyncGear-4.7.2-1.src.rpm
checksum_type: sha256
summary:
  Think about such scene, some object has different state or periods, well we call periods.Among these periods, there can't be any two that could be both the present period. The object could be in only one period. For example, a human can only be one period of baby, youth, adult, old man and dead..


pkgId: 226b361902169c6fbe3e9aba917a667d228ec0027076d2c84c3ed27a2cde750c
name: python-AsyncProcessScheduler
arch: src
version: 0.9.0b1
epoch: 0
release: 1
summary: GUI-friendly library for scheduling processes using coroutines.
url: https://github.com/CabbageDevelopment/async-process-scheduler
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AsyncProcessScheduler-0.9.0b1-1.src.rpm
checksum_type: sha256
description:
  [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
  [![PyPI](https://img.shields.io/pypi/v/AsyncProcessScheduler)](https://pypi.org/project/AsyncProcessScheduler)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/AsyncProcessScheduler)
  [![Build Status](https://travis-ci.org/CabbageDevelopment/async-process-scheduler.svg?branch=master)](https://travis-ci.org/CabbageDevelopment/async-process-scheduler)

  *Current status: beta. Breaking changes may occur before v1.0.0.*



  Async Process Scheduler is a small Python library which provides a simple, GUI-friendly way to efficiently run many processes while avoiding a callback-based data flow.

  Async Process Scheduler is compatible with `multiprocessing` from the standard library, and equivalent implementations such as `multiprocess`.

  > **Note:** To use Async Process Scheduler in a GUI program, you'll need a library which implements a compatible event loop. For example, [qasync](https://github.com/CabbageDevelopment/qasync) can be used with PyQt5.



  To install Async Process Scheduler, use `pip`:

  ```bash
  pip install AsyncProcessScheduler
  ```



  Detailed examples are in the [examples](/examples) folder, including a [GUI example](/examples/gui/gui.py) using PyQt5. Here is a code snippet which shows the general workflow:

  ```python
  from scheduler.Scheduler import Scheduler

  def long_calculation(x: int, y: int) -> Tuple[int, int]:
      """Simulates a long calculation and returns two numbers."""
      time.sleep(5)
      return x, y

  async def run() -> None:
      """Runs 16 processes with the scheduler and prints the results."""
      scheduler = Scheduler()

      
      num_processes = 16
      args = [(i, i+1) for i in range(num_processes)]

      
      results: List[Tuple] = await scheduler.map(target=long_calculation, args=args)

      
      print(results)


  loop = asyncio.get_event_loop()
  loop.run_until_complete(run())
  ```

  > **Note:** GUI programs would use `asyncio.ensure_future(run())` to start the coroutine without blocking.



  This guide explains the basic usage of Async Process Scheduler.



  To use `Scheduler` in Python, import from `scheduler`:

  ```python
  from scheduler.Scheduler import Scheduler
  ```



  Scheduler instances can be created with or without a progress callback. The progress callback is a function which takes the number of tasks completed and the total number of tasks.

  ```python
  def on_progress(finished: int, total: int) -> None:
      print(f"{finished} of {total} tasks are complete.")


  scheduler = Scheduler()


  scheduler = Scheduler(on_progress)


  scheduler = Scheduler(progress_callback=on_progress)
  ```

  The progress callback is called on the thread which the coroutine runs in, and can be used to modify the GUI.

  > :warning: This functionality may change before v1.0.0.



  The easiest way to run code using a Scheduler is to map an iterable of inputs over a function.

  This allows you to supply a function, and a list of tuples containing the inputs to the function. The output will be calculated in a separate process for each set of inputs.



  ```python
  """
  Snippet which demonstrates mapping values over a function.
  """

  def my_calculation(x: int, y: float, z: str) -> Tuple[int, float, str]:
      """Simulates a long calculation and returns the function parameters."""
      time.sleep(5)
      return x, y, z

  scheduler = Scheduler()
  args = [
      (1, 3.14, "test1"),  # Args for first process.
      (0, 2.10, "test2"),  # Args for second process.
      (5, 10.0, "test3"),  # Args for third process.
  ]
  ```

  The results can then be computed in a coroutine:

  ```python
  results: List = await scheduler.map(target=my_calculation, args=args)
  ```



  ```python
  results: List = scheduler.map_blocking(target=my_calculation, args=args)
  ```



  Instead of using `map()`, tasks can individually be added to a scheduler. After adding all tasks, the scheduler can be started with `run()`.

  You can add normal functions to a scheduler. If you're migrating from process-oriented code, you may find it easier to add processes and queues to a scheduler instead.

  Every task added to a scheduler will be run as a separate process. For maximum efficiency, you should aim to add a number of tasks greater than the number of logical cores. The optimal number for the current CPU is returned by the static method `Scheduler.optimal_process_count()`.

  For simplicity, the examples below only add one task to the scheduler.



  `add()` can be used to add a function to the scheduler. `add()` is similar to the constructor of `Process`.

  ```python
  """
  Snippet which demonstrates adding functions to a scheduler.
  """

  def my_calculation(x: int, y: float, z: str) -> Tuple[int, float, str]:
      """Simulates a long calculation and returns the function parameters."""
      time.sleep(5)
      return x, y, z

  scheduler = Scheduler()
  args = (1, 3.14, "test",)


  scheduler.add(my_calculation, args)


  scheduler.add(target=my_calculation, args=args)
  ```

  Internally, `add()` creates a process and queue which will be used to run your function and get the results. To use types other than those from `multiprocessing`, you can specify them with the `process_type` and `queue_type` arguments.

  ```python
  """
  Snippet which demonstrates adding a function to scheduler using Processes and Queues
  from `multiprocess` instead of `multiprocessing`.
  """
  from multiprocess import Process, Queue

  scheduler = Scheduler()
  scheduler.add(
      target=my_function,
      args=(1,2,3,),
      process_type=Process,
      queue_type=Queue
  )
  ```



  `add_process()` can be used to add a process and queue to the scheduler.

  ```python
  """
  Snippet which demonstrates adding processes and queues to a scheduler.
  """

  def my_calculation(queue: Queue, x: int, y: int) -> None:
      """Function which will be run using a process."""
      time.sleep(5)

      
      queue.put((
          x, y
      ))

  scheduler = Scheduler()

  queue = Queue()
  process = Process(target=my_calculation, args=(queue, 1, 2))

  scheduler.add_process(process, queue)
  ```

  > :warning: When adding processes, ensure that the queue instance passed to the function is the same as the queue added to the scheduler. Also take care that the function puts its output in the queue instead of returning it.



  The functions above take an optional `subtasks` parameter. `subtasks` is used to hint to the scheduler that each process may create its own processes; this will be taken into account when scheduling processes.

  For example, if each process creates 4 processes you could use `scheduler.add(target=my_process, args=my_args, subtasks=4)`.



  When a scheduler runs, it will run all tasks until complete and then return an ordered list containing the output from each task.



  ```python
  results: List = await scheduler.run()
  ```



  ```python
  results: List = scheduler.run_blocking()
  ```



  To cancel a scheduler, use `terminate()`:

  ```python
  scheduler.terminate()
  ```

  A terminated scheduler will always return an empty list.



  When the scheduler starts, it will simultaneously run a number of processes up to the value returned by `Scheduler.optimal_process_count()`. When a process finishes, another is started to take its place.

  If `dynamic` is enabled, the scheduler will check the CPU usage periodically and increase the number of concurrent processes if the CPU usage is below the threshold.

  This diagram demonstrates the implementation of `Scheduler`:

  ![Image demonstrating the implementation of Scheduler.](/docs/images/scheduler.png)





  From the [documentation](https://packaging.python.org/guides/distributing-packages-using-setuptools/#packaging-your-project):

  ```
  rm -r dist/
  python setup.py sdist
  python setup.py bdist_wheel
  twine upload dist/*
  ```


pkgId: afad88834c29cb33ea7c96e4a8a54246c27b5056986d9e26b045f42c22318acc
name: python-AsyncPywhatKit
arch: src
version: 2.2.7.3
epoch: 0
release: 1
summary: AsyncPywhatKit is a Simple and Powerful WhatsApp Automation Library with many useful Features
url: https://github.com/SigireddyBalasai/AsyncPywhatKit
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AsyncPywhatKit-2.2.7.3-1.src.rpm
checksum_type: sha256
description:
  [![image](https://raw.githubusercontent.com/SigireddyBalasai/AsyncPywhatKit/main/logo.png)](https://raw.githubusercontent.com/SigireddyBalasai/AsyncPywhatKit/main/logo.png)

  [![image](https://flat.badgen.net/github/stars/SigireddyBalasai/AsyncPywhatKit)](https://github.com/SigireddyBalasai/AsyncPywhatKit/stargazers)
  [![image](https://flat.badgen.net/github/forks/SigireddyBalasai/AsyncPywhatKit)](https://github.com/SigireddyBalasai/AsyncPywhatKit/network/members)
  [![image](https://flat.badgen.net/github/open-issues/SigireddyBalasai/AsyncPywhatKit)](https://github.com/SigireddyBalasai/AsyncPywhatKit/issues)
  [![image](https://flat.badgen.net/github/open-prs/SigireddyBalasai/AsyncPywhatKit)](https://github.com/SigireddyBalasai/AsyncPywhatKit/pulls)
  [![image](https://flat.badgen.net/github/commits/SigireddyBalasai/AsyncPywhatKit)](https://github.com/SigireddyBalasai/AsyncPywhatKit/commits/master)
  [![image](https://flat.badgen.net/github/license/SigireddyBalasai/AsyncPywhatKit)](https://github.com/SigireddyBalasai/AsyncPywhatKit/LICENCE)
  [![image](https://flat.badgen.net/github/contributors/SigireddyBalasai/AsyncPywhatKit)](https://github.com/SigireddyBalasai/AsyncPywhatKit/graphs/contributors)
  [![image](https://flat.badgen.net/github/release/SigireddyBalasai/AsyncPywhatKit)](https://github.com/SigireddyBalasai/AsyncPywhatKit/releases)
  ![image](https://img.shields.io/github/languages/count/SigireddyBalasai/AsyncPywhatKit)
  ![image](https://img.shields.io/github/languages/top/SigireddyBalasai/AsyncPywhatKit)
  ![image](https://img.shields.io/librariesio/release/pypi/AsyncPywhatKit)
  ![image](https://img.shields.io/github/repo-size/SigireddyBalasai/AsyncPywhatKit)
  [![Hits](https://hits.seeyoufarm.com/api/count/incr/badge.svg?url=https%3A%2F%2Fgithub.com%2FSigireddyBalasai%2FAsyncpywhatkit&count_bg=%2379C83D&title_bg=%23555555&icon=&icon_color=%23E7E7E7&title=hits&edge_flat=false)](https://hits.seeyoufarm.com)
  <a href="https://scan.coverity.com/projects/sigireddybalasai-asyncpywhatkit">
    <img alt="Coverity Scan Build Status"
         src="https://img.shields.io/coverity/scan/27211.svg"/>
  </a>


  [AsyncPywhatKit](https://pypi.org/project/AsyncPywhatKit/) is a Python library with various helpful features. It's easy-to-use and does not require you to do any additional setup. Currently, it is one of the most popular library for WhatsApp and YouTube automation. New updates are released frequently with new features and bug fixes.



  - **Join our discord server - https://discord.gg/NDXdB6tNwa**
  - **Documentation - [Wiki](https://github.com/SigireddyBalasai/AsyncPywhatKit/wiki/)**



  AsyncPywhatKit is available on PyPi:

  ```bash
  python3 -m pip install AsyncPywhatKit
  ```

  ```bash
  pip3 install AsyncPywhatKit
  ```

  PyWhatKit officially supports Python 3.8+.



  ```bash
  git clone https://github.com/SigireddyBalasai/AsyncPywhatKit
  ```
  ```py
  import asyncio
  import AsyncPywhatKit


  async def main():
      
      await AsyncPywhatKit.sendwhatmsg("+910123456789", "Hi", 13, 30)

      
      await AsyncPywhatKit.src.sendwhatmsg("+910123456789", "Hi", 13, 30, 15, True, 2)

      
      await AsyncPywhatKit.src.sendwhats_image("AB123CDEFGHijklmn", "Images/Hello.png", "Hello")

      
      await AsyncPywhatKit.src.sendwhats_image("+910123456789", "Images/Hello.png")

      
      await AsyncPywhatKit.src.sendwhatmsg_to_group("AB123CDEFGHijklmn", "Hey All!", 0, 0)

      
      await AsyncPywhatKit.src.sendwhatmsg_to_group_instantly("AB123CDEFGHijklmn", "Hey All!")


  asyncio.run(main())
  ```

  For more Examples and Functions, have a look at the [Wiki](https://github.com/SigireddyBalasai/AsyncPywhatKit/wiki/).



  Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
  Be sure to read the [Guidelines](https://github.com/SigireddyBalasai/AsyncPywhatKit/blob/main/CONTRIBUTING.md) before Contributing.



  Apache license 2.0
  For more information see [this](https://github.com/SigireddyBalasai/AsyncPywhatKit/blob/main/LICENSE)


pkgId: f8de48573a75c4bd01af58b81de3b802bbafac88ce201d5a05faadea169a39ea
name: python-AthenaCSS
arch: src
version: 0.8.0
epoch: 0
release: 1
summary: CSS generator for Python
url: https://github.com/DirectiveAthena/VerSC-AthenaCSS
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AthenaCSS-0.8.0-1.src.rpm
checksum_type: sha256
description:
  - A Python package which allows CSS to be written as a Python script
  - CSS output to file, string or console from the Python script

  - Supported Python versions: **3.10**
    - Other older versions of Python are not currently supported.


pkgId: d4ff5b0c053a5e04ea8473201bb97c6b864b3cb4407a84a7c0079a6780522ef2
name: python-AthenaColor
arch: src
version: 7.0.2
epoch: 0
release: 1
summary: Package to support full usage of RGB colors in the console
url: https://github.com/DirectiveAthena/AthenaColor
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AthenaColor-7.0.2-1.src.rpm
checksum_type: sha256
description:
  A *No Dependency* Python package do display text styling in a console.
  - Next to the full ability to use ANSI styling options, commonly used HTML color names are defined as default colors for Fore- and Background color styling
    - The color option are available permitting the console can take advantage of RGB ANSI codes
    - For a full list of all 140 out of the box available colors, go to [the full documentation](https://publish.obsidian.md/directiveathena/Content/Programming/AthenaColor/Documentation/HTML+Named+Colors)
    - By using the `RGB` object, you have access to print any RGB color to the console you desire
  - Uses a similar syntax to Colorama, but also allows for nested function patterns

  - Supported Python versions: **3.7**, **3.8**, **3.9**, **3.10**
    - Other older versions of Python are not currently supported.


pkgId: 73da97f961c4814d7420e6980e16bab8d879e5108cb2f3e4e8895a00b37af63a
name: python-Atrajit
arch: src
version: 3.0
epoch: 0
release: 1
summary: A Python package that includes Cryptography, Maths, and Telebot modules
url: https://github.com/atrajit-sarkar/Atr
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Atrajit-3.0-1.src.rpm
checksum_type: sha256
description:
  - Maths: Different maths topics are here....
  - Telebot: Telebot Api and other useful functions are here.....


  - open cmd and type the following:
  ```cmd
  C:\Users\atraj>where python
  ```
  and hit enter.\
  The out put will be something as follows:
  ```cmd
  C:\Users\atraj>where python
  D:\downloads\Python\python.exe
  C:\Users\atraj\AppData\Local\Microsoft\WindowsApps\python.exe

  C:\Users\atraj>
  ```
  Then open powershell and do the following:
  ```shell
  PS C:\Users\atraj> cd D:\downloads\Python
  PS D:\downloads\Python> git clone https://github.com/atrajit-sarkar/Atr.git
  ```
  After hitting enter you now can use Atr module in your projects........



  ```cmd
  C:\Users\atraj>where python
  ```






  ```python
  from Atr.Maths import numbertheory as nt

  print(f"The GCD(12,16) is {nt.gcd(12,16)}")
  ```

  ```python
  from Atr.Maths import linear_alg as la
  from Atr.Maths import switch
  from Atr.Telebot import TELEBOT_API

  ```


  ```bash
  atrajit@Atrajit:~$ sudo su
  [sudo] password for atrajit:
  root@Atrajit:/home/atrajit# ls
  Insta-Cypher  SocialMediaHackingToolkit  hydra.restore  main.py  myC  password.txt
  root@Atrajit:/home/atrajit# mkdir myPython
  root@Atrajit:/home/atrajit# ls
  Insta-Cypher  SocialMediaHackingToolkit  hydra.restore  main.py  myC  myPython  password.txt
  root@Atrajit:/home/atrajit# cd myPython/
  root@Atrajit:/home/atrajit/myPython# git clone https://github.com/atrajit-sarkar/Atr.git
  Cloning into 'Atr'...
  remote: Enumerating objects: 12, done.
  remote: Counting objects: 100% (12/12), done.
  remote: Compressing objects: 100% (10/10), done.
  remote: Total 12 (delta 0), reused 12 (delta 0), pack-reused 0
  Receiving objects: 100% (12/12), done.
  root@Atrajit:/home/atrajit/myPython# ls
  Atr
  root@Atrajit:/home/atrajit/myPython# nano main.py
  root@Atrajit:/home/atrajit/myPython# python3 main.py
  The GCD(12,16) is 4
  root@Atrajit:/home/atrajit/myPython#
  ```


pkgId: ece9e9db3dde521d790f7bcc67407e5af306d90576ed0a4d730fde4f57b6367a
name: python-AuToGraFS
arch: src
version: 2.3.2
epoch: 0
release: 1
summary: Generator for topological frameworks and chemical structures.
url: https://github.com/DCoupry/autografs
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AuToGraFS-2.3.2-1.src.rpm
checksum_type: sha256
description:
  Original publication: `"Automatic Topological Generator for Framework Structures"`__.
  __ here_
  *This version is under active development*. Bug hunting is very much going on, and there are still some old funtionalities that are not yet reimplemented.


pkgId: e36498f769f6bc17a634f608171ce8d4ef6507d96e342c6de733029e768b35b7
name: python-AudioAugmentor
arch: src
version: 0.1.1
epoch: 0
release: 1
summary: Python package for simple application of wide range of audio augmentations.
url: https://github.com/LadislavVasina1/AudioAugmentor_public
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AudioAugmentor-0.1.1-1.src.rpm
checksum_type: sha256
description:
  [![EXAMPLE 1](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1IMVLl6LCUU5gaYAz0IMSAcHh7Iq7NZr7?usp=sharing)


  This library is designed to augment audio data for machine learning purposes.
  It combines several tools and libraries for audio data augmentation and provides a unified interface that can be used to apply a large set of audio augmentations in one place.

  The library is designed to be used with the [PyTorch](https://pytorch.org) machine learning framework.
  It can also work solely on just simple audio waveforms and augment just those.
  Additionally it can also augment local audio datasets.

  This library specifically combines these libraries and tools:

  - [torchaudio](https://pytorch.org/audio/stable/index.html)
  - [audiomentations](https://github.com/iver56/audiomentations)
  - [torch-audiomentations](https://github.com/asteroid-team/torch-audiomentations)
  - [pyroomacoustics](https://pyroomacoustics.readthedocs.io/en/pypi-release/index.html)
  - [ffmpeg-python](https://github.com/kkroening/ffmpeg-python)



  Table below shows which library was used to apply specific audio augmentation/codec.

  |                                                                      | [audiomentations](https://iver56.github.io/audiomentations/) | [torch-audiomentations](https://github.com/asteroid-team/torch-audiomentations) | [torchaudio](https://pytorch.org/audio/stable/index.html) | [pyroomacoustics](https://pyroomacoustics.readthedocs.io/en/pypi-release/index.html) | [ffmpeg-python](https://github.com/kkroening/ffmpeg-python) |
  |----------------------------------------------------------------------|:---------------:|:---------------------:|:----------:|:---------------:|:------:|
  | [AddBackgroundNoise](#addbackgroundnoise)                            |                 |           ✅          |            |                 |        |
  | [AddColoredNoise](#addcolorednoise) |                 |           ✅          |            |                 |        |
  | [AddGaussianNoise](#addgaussiannoise)                                |        ✅       |                       |            |                 |        |
  | [AddShortNoises](#addshortnoises)                                    |        ✅       |                       |            |                 |        |
  | [AdjustDuration](#adjustduration)                                    |        ✅       |                       |            |                 |        |
  | [AirAbsorption](#airabsorption)                                      |        ✅       |                       |            |                 |        |
  | [ApplyImpulseResponse](#applyimpulseresponse)                        |                 |           ✅          |            |                 |        |
  | [BandPassFilter](#bandpassfilter)                                    |                 |           ✅          |            |                 |        |
  | [BandStopFilter](#bandstopfilter)                                    |                 |           ✅          |            |                 |        |
  | [ClippingDistortion](#clippingdistortion)                            |        ✅       |                       |            |                 |        |
  | [FrequencyMasking](#frequencymasking)                                |                 |                       |     ✅     |                 |        |
  | [Volume / Gain](#volume--gain)                                       |                 |                       |     ✅     |                 |        |
  | [GainTransition](#gaintransition)                                    |        ✅       |                       |            |                 |        |
  | [HighPassFilter](#highpassfilter)                                    |                 |           ✅          |            |                 |        |
  | [HighShelfFilter](#highshelffilter)                                  |        ✅       |                       |            |                 |        |
  | [Limiter](#limiter)                                                  |        ✅       |                       |            |                 |        |
  | [LoudnessNormalization](#loudnessnormalization)                      |        ✅       |                       |            |                 |        |
  | [LowPassFilter](#lowpassfilter)                                      |                 |           ✅          |            |                 |        |
  | [LowShelfFilter](#lowshelffilter)                                    |        ✅       |                       |            |                 |        |
  | [Mp3Compression](#mp3compression)                                    |        ✅       |                       |            |                 |        |
  | [MelSpectrogram](#melspectrogram)                                    |                 |                       |     ✅     |                 |        |
  | [Normalize](#normalize)                                              |        ✅       |                       |            |                 |        |
  | [Padding](#padding)                                                  |        ✅       |                       |            |                 |        |
  | [PeakNormalization](#peaknormalization)                              |                 |           ✅          |            |                 |        |
  | [PeakingFilter](#peakingfilter)                                      |        ✅       |                       |            |                 |        |
  | [PitchShift](#pitchshift)                                            |                 |                       |     ✅     |                 |        |
  | [PolarityInversion](#polarityinversion)                              |                 |           ✅          |            |                 |        |
  | [Time inversion](#time-inversion)                                    |                 |           ✅          |            |                 |        |
  | [ApplyRIR (RoomSimulator)](#applyrir)                                |                 |                       |            |        ✅       |        |
  | [SevenBandParametricEQ](#sevenbandparametriceq)                      |       ✅        |                       |            |                 |        |
  | [Shift](#shift)                                                      |                 |           ✅          |            |                 |        |
  | [Speed](#speed)                                                      |                 |                       |     ✅     |                 |        |
  | [Spectrogram](#spectrogram)                                          |                 |                       |     ✅     |                 |        |
  | [TanhDistortion](#tanhdistortion)                                    |       ✅        |                       |            |                 |        |
  | [TimeMasking](#timemasking)                                          |                 |                       |     ✅     |                 |        |
  | [TimeStretch](#timestretch)                                          |       ✅        |                       |            |                 |        |
  | [ac3](#codecs-using-torchaudio)                                      |                 |                       |     ✅     |                 |        |
  | [adpcm_ima_wav](#codecs-using-torchaudio)                            |                 |                       |     ✅     |                 |        |
  | [adpcm_ms](#codecs-using-torchaudio)                                 |                 |                       |     ✅     |                 |        |
  | [adpcm_yamaha](#codecs-using-torchaudio)                             |                 |                       |     ✅     |                 |        |
  | [eac3](#codecs-using-torchaudio)                                     |                 |                       |     ✅     |                 |        |
  | [flac](#codecs-using-torchaudio)                                     |                 |                       |     ✅     |                 |        |
  | [libmp3lame](#codecs-using-torchaudio)                               |                 |                       |     ✅     |                 |        |
  | [mp2](#codecs-using-torchaudio)                                      |                 |                       |     ✅     |                 |        |
  | [pcm_alaw](#codecs-using-torchaudio)                                 |                 |                       |     ✅     |                 |        |
  | [pcm_f32le](#codecs-using-torchaudio)                                |                 |                       |     ✅     |                 |        |
  | [pcm_mulaw](#codecs-using-torchaudio)                                |                 |                       |     ✅     |                 |        |
  | [pcm_s16le](#codecs-using-torchaudio)                                |                 |                       |     ✅     |                 |        |
  | [pcm_s24le](#codecs-using-torchaudio)                                |                 |                       |     ✅     |                 |        |
  | [pcm_s32le](#codecs-using-torchaudio)                                |                 |                       |     ✅     |                 |        |
  | [pcm_u8](#codecs-using-torchaudio)                                   |                 |                       |     ✅     |                 |        |
  | [wmav1](#codecs-using-torchaudio)                                    |                 |                       |     ✅     |                 |        |
  | [wmav2](#codecs-using-torchaudio)                                    |                 |                       |     ✅     |                 |        |
  | [g726](#g726)                                                        |                 |                       |            |                 |   ✅   |
  | [gsm](#gsm)                                                          |                 |                       |            |                 |   ✅   |
  | [amr](#amr)                                                          |                 |                       |            |                 |   ✅   |



  For a more complex example see [example colab notebook above](#python-library-for-augmenting-audio-data).
  Or see jupyter notebook `AudioAugmentor_Usage_Example.ipynb` in the `examples` directory within the public repositry.

  `Note: AudioAugmentor was mainly tested using Python 3.11.8 and Fedora 38 (Google Colab uses Python 3.10 and Ubuntu)`


  **0. You need to install the library and necessary packages first**

  **!!!You may need to run the following commands with sudo!!!**

  If so install these packages manually in terminal.
  ```bash
  pip install -U pip
  pip install AudioAugmentor
  dnf install -y sox                # FEDORA
  dnf install -y sox-devel          # FEDORA
  dnf install -y ffmpeg             # FEDORA



  ```

  **1. Import necessary libraries**
  ```python
  import torch
  import torchaudio
  import numpy as np
  import audiomentations as AA
  from IPython.display import Audio, display

  from AudioAugmentor import transf_gen
  from AudioAugmentor import sox_parser
  from AudioAugmentor import core
  from AudioAugmentor import rir_setup
  from AudioAugmentor import torchaudio_transf_wrapper as TTW
  ```
  **2. Define the augmentations you want to apply to your audio data.**

  You have **3** options of how to define the augmentations:

  **a)** Use `transf_gen.transf_gen` function to generate list of transformations.

  See [supported transformation table](#available-augmentations) and examples of every augmentation, so you know what parameters are needed for each augmentation method.

  You can enter augmentation parameters as a string or as a dictionary.

  `PitchShift='sample_rate=16000, n_steps=[1, 1.5, 0.1], p=1.0'`

  `PitchShift={'sample_rate': 16000, 'n_steps': [1, 1.5, 0.1], 'p': 1.0}`
  ```php
  transformations = transf_gen.transf_gen(verbose=True,
                                          PitchShift='sample_rate=16000, n_steps=[1, 1.5, 0.1], p=1.0',
                                          Speed={'orig_freq': 16000, 'factor': [0.9, 1.5, 0.1], 'p': 1},
                                          LowPassFilter={'min_cutoff_freq': 700, 'max_cutoff_freq': 800, 'sample_rate': sampling_rate, 'p': 1},
  )
  ```
  **b)** Use pseudo SoX command.
  SoX command **must** be in this format:

  `--sox="norm gain 0 highpass 1000 phaser 0.5 0.6 1 0.45 0.6 -s"`

  (When you don't want to apply some codec after applying SoX effects)

  OR

  `--sox="norm gain 20 highpass 300 phaser 0.5 0.6 1 0.45 0.6 -s" amr audio_bitrate 4.75k`

  (In this case, you want to apply codec after applying SoX effects -> Codec is entered in the form `codec_name` `codec_parameter_name` `codec_parameter_value` directly after the SoX effects command)
  ```python
  example_sox = '--sox="norm gain 20 highpass 300 phaser 0.5 0.6 1 0.45 0.6 -s" amr audio_bitrate 4.75k'
  ```

  **c)** Use a file with multiple pseudo SoX commands. Random SoX command from this file will be chosen and applied to your data.

  File **must** to be loaded using `sox_parser.load_sox_file` function.
  ```php
  sox_file_content_to_write = '''--sox="norm gain 0 highpass 1000 phaser 0.5 0.6 1 0.45 0.6 -s"

  --sox="norm gain 20 highpass 300 phaser 0.5 0.6 1 0.45 0.6 -s" gsm
  --sox="norm gain 20 highpass 300 phaser 0.5 0.6 1 0.45 0.6 -s" amr audio_bitrate 4.75k
  '''
  with open('sox_file_example.txt', 'w') as f:
      f.write(sox_file_content_to_write)

  sox_file_content = sox_parser.load_sox_file('sox_file_example.txt')
  print('SOX FILE LOADED:', sox_file_content, type(sox_file_content))
  ```



  **3. Apply augmentations**

  **a)** Use generated the `transformations` list, `single SoX command` or `loaded SoX file content` while initializing `Collator` class.

  Use this initiated class as an argument for the `collate_fn` parameter of PyTorch's dataloader.
  ```php
  collate_fn = core.Collator(
      transformations=transformations, device='cpu', sox_effects=None, sample_rate=sampling_rate, verbose=True,
      
      
  )

  dataset = torchaudio.datasets.LIBRISPEECH("../data", url="train-clean-100", download=True)
  aug_dataloader = torch.utils.data.DataLoader(
      dataset,
      batch_size=1,
      num_workers=0,
      collate_fn=collate_fn,
  )
  augmented_record_from_dataset = next(iter(aug_dataloader))
  display(Audio(augmented_record_from_dataset[0].squeeze(0).squeeze(0).squeeze(0).cpu(), rate=sampling_rate))
  ```
  `OR`

  **b)** Use generated the `transformations` list, `single SoX command` or `loaded SoX file content` while initializing `AugmentWaveform` class and apply the augmentations to the audio signal.
  ```php
  augment = core.AugmentWaveform(
      transformations=transformations, device='cpu', sox_effects=None, sample_rate=16000, verbose=False,
      
      
  )

  signal, fs = torchaudio.load('../data/test.wav')

  waveform = augment(signal.numpy()[0])
  display(Audio(waveform, rate=fs))
  ```

  **c)** Use generated the `transformations` list, `single SoX command` or `loaded SoX file content` while initializing `AugmentLocalAudioDataset` class and apply the augmentations to the local audio dataset.
  ```php
  augment = core.AugmentLocalAudioDataset(
      transformations=transformations, device='cpu', sox_effects=None, sample_rate=16000, verbose=False,
      
      
  )
  augment(input_dir='../data/test-input-folder', output_dir='../data/test-output-folder')
  ```





  Like this:
  ```php
  transformations = transf_gen.transf_gen(verbose=True,
                                          AddBackgroundNoise=f'background_paths="../data/musan/noise/free-sound", min_snr_in_db=10, max_snr_in_db=20, p=1, sample_rate={sampling_rate}',
                                          AddColoredNoise=f'min_snr_in_db=9, max_snr_in_db=10, p=1, sample_rate={sampling_rate}',
                                          )
  ```
  You can enter augmentation parameters as a string or as a dictionary.

  `PitchShift='sample_rate=16000, n_steps=[1, 1.5, 0.1], p=1.0'`

  `PitchShift={'sample_rate': 16000, 'n_steps': [1, 1.5, 0.1], 'p': 1.0}`

  <a id="addbackgroundnoise"></a>

  ```python
  AddBackgroundNoise=f'''background_paths="../data/musan/noise/free-sound",
                         min_snr_in_db=10,
                         max_snr_in_db=20,
                         p=1,
                         sample_rate={sampling_rate}''',
  ```
  <a id="addcolorednoise"></a>

  ```python
  AddColoredNoise=f'''min_snr_in_db=9,
                      max_snr_in_db=10,
                      p=1,
                      sample_rate={sampling_rate}''',
  ```
  <a id="addgaussiannoise"></a>

  ```python
  AddGaussianNoise={'min_amplitude': 0.001,
                    'max_amplitude': 0.015,
                    'p': 1},
  ```
  <a id="addshortnoises"></a>

  ```python
  AddShortNoises={'sounds_path': "../data/musan/noise/free-sound",
                  'min_snr_in_db': 3.0,
                  'max_snr_in_db': 30.0,
                  'noise_rms': "relative_to_whole_input",
                  'min_time_between_sounds': 2.0,
                  'max_time_between_sounds': 8.0,
                  'noise_transform': AA.PolarityInversion(),
                  'p': 1.0},
  ```
  <a id="adjustduration"></a>

  ```python
  AdjustDuration={'duration_seconds': 3.5,
                  'padding_mode': 'silence',
                  'p': 1},
  ```
  <a id="airabsorption"></a>

  ```python
  AirAbsorption={'min_distance': 10.0,
                 'max_distance': 50.0,
                 'min_humidity': 80.0,
                 'max_humidity': 90.0,
                 'min_temperature': 10.0,
                 'max_temperature': 20.0,
                 'p': 1.0},
  ```
  <a id="applyimpulseresponse"></a>

  ```python
  ApplyImpulseResponse=f'''ir_paths="../data/Rir.wav",
                           p=1,
                           sample_rate={sampling_rate}''',
  ```
  <a id="bandpassfilter"></a>

  ```python
  BandPassFilter=f'''min_center_frequency=200,
                     max_center_frequency=4000,
                     min_bandwidth_fraction=0.5,
                     max_bandwidth_fraction=1.99,
                     sample_rate={sampling_rate},
                     p=1''',
  ```
  <a id="bandstopfilter"></a>

  ```python
  BandStopFilter=f'''min_center_frequency=200,
                     max_center_frequency=4000,
                     min_bandwidth_fraction=0.5,
                     max_bandwidth_fraction=1.99,
                     sample_rate={sampling_rate},
                     p=1''',
  ```
  <a id="clippingdistortion"></a>

  ```python
  ClippingDistortion={'min_percentile_threshold': 10,
                      'max_percentile_threshold': 30,
                      'p': 1},
  ```
  <a id="frequencymasking"></a>

  ```python
  FrequencyMasking={'freq_mask_param': 80},
  ```
  <a id="volume--gain"></a>

  ```python
  Vol={'gain': [2.5, 3, 0.1],
       'p': 1.0},
  ```
  <a id="gaintransition"></a>

  ```python
  GainTransition={'min_gain_db': 30,
                  'max_gain_db': 40,
                  'min_duration': 5,
                  'max_duration': 16,
                  'duration_unit': 'seconds',
                  'p': 1},
  ```
  <a id="highpassfilter"></a>

  ```python
  HighPassFilter=f'''min_cutoff_freq=700,
                     max_cutoff_freq=800,
                     sample_rate={sampling_rate},
                     p=1''',
  ```
  <a id="highshelffilter"></a>

  ```python
  HighShelfFilter={'min_center_freq': 2000,
                   'max_center_freq': 5000,
                   'min_gain_db': 10.0,
                   'max_gain_db': 16.0,
                   'min_q': 0.5,
                   'max_q': 1.0,
                   'p': 1},
  ```
  <a id="limiter"></a>

  ```python
  Limiter='''min_threshold_db=-24,
             max_threshold_db=-2,
             min_attack=0.0005,
             max_attack=0.025,
             min_release=0.05,
             max_release=0.7,
             threshold_mode="relative_to_signal_peak",
             p=1''',
  ```
  <a id="loudnessnormalization"></a>

  ```python
  LoudnessNormalization={'min_lufs': -31,
                         'max_lufs': -13,
                         'p': 1},
  ```
  <a id="lowpassfilter"></a>

  ```python
  LowPassFilter={'min_cutoff_freq': 700,
                 'max_cutoff_freq': 800,
                 'sample_rate': sampling_rate,
                 'p': 1},
  ```
  <a id="lowshelffilter"></a>

  ```python
  LowShelfFilter={'min_center_freq': 20,
                  'max_center_freq': 600,
                  'min_gain_db': -16.0,
                  'max_gain_db': 16.0,
                  'min_q': 0.5,
                  'max_q': 1.0,
                  'p': 1},
  ```
  <a id="mp3compression"></a>

  ```python
  Mp3Compression={'min_bitrate': 8,
                  'max_bitrate': 8,
                  'backend': 'pydub',
                  'p': 1},
  ```
  <a id="melspectrogram"></a>

  ```python
  MelSpectrogram={'sample_rate': 16000},
  ```
  <a id="normalize"></a>

  ```python
  Normalize={'p': 1},
  ```
  <a id="padding"></a>

  ```python
  Padding={'mode': 'silence',
           'min_fraction': 0.02,
           'max_fraction': 0.8,
           'pad_section': 'start',
           'p': 1},
  ```
  <a id="peaknormalization"></a>

  ```python
  PeakNormalization={'p': 1,
                     'sample_rate': sampling_rate},
  ```
  <a id="peakingfilter"></a>

  ```python
  PeakingFilter={'min_center_freq': 51,
                 'max_center_freq': 7400,
                 'min_gain_db': -22,
                 'max_gain_db': 22,
                 'min_q': 0.5,
                 'max_q': 1.0,
                 'p': 1},
  ```
  <a id="pitchshift"></a>

  ```python
  PitchShift={'sample_rate': 16000,
              'n_steps': [1, 1.5, 0.1],
              'bins_per_octave': 12,
              'n_fft': 512,
              'win_length':512,
              'hop_length': 512//4,
              'p': 1.0},
  ```
  <a id="polarityinversion"></a>

  ```python
  PolarityInversion={'p': 1,
                     'sample_rate': sampling_rate},
  ```
  <a id="time-inversion"></a>

  ```python
  TimeInversion={'p': 1,
                 'sample_rate': sampling_rate},
  ```
  <a id="applyrir"></a>

  ```php





  rir_kwargs = {
      'audio_sample_rate': 16000,
      'x_range': (0, 100),
      'y_range': (0, 100),
      'num_vertices_range': (3, 6),
      'mic_height': 1.5,
      'source_height': 1.5,
      'walls_mat': 'curtains_cotton_0.5',
      'room_height': 2.0,
      'max_order': 3,
      'floor_mat': 'carpet_cotton',
      'ceiling_mat': 'hard_surface',
      'ray_tracing': True,
      'air_absorption': True,
  }

  rir_kwargs = {
      'audio_sample_rate': 16000,
      'corners_coord': [[0, 0], [0, 3], [5, 3], [5, 1], [3, 1], [3, 0]],
      'walls_mat': 'curtains_cotton_0.5',
      'room_height': 2.0,
      'max_order': 3,
      'floor_mat': 'carpet_cotton',
      'ceiling_mat': 'hard_surface',
      'ray_tracing': True,
      'air_absorption': True,
      'source_coord': [[1.0], [1.0], [0.5]],
      'microphones_coord': [[3.5], [2.0], [0.5]],
  }
  transformations = transf_gen.transf_gen(verbose=True,
                                          ApplyRIR=rir_kwargs,
                                          )
  ```
  <a id="sevenbandparametriceq"></a>

  ```python
  SevenBandParametricEQ={'min_gain_db': -10,
                         'max_gain_db': 10,
                         'p': 1},
  ```
  <a id="shift"></a>

  ```python
  Shift={'min_shift': 1,
         'max_shift': 2,
         'p': 1,
         'sample_rate': sampling_rate},
  ```
  <a id="speed"></a>

  ```python
  Speed={'orig_freq': 16000,
         'factor': [0.9, 1.5, 0.1],
         'p': 1},
  ```
  <a id="spectrogram"></a>

  ```python
  Spectrogram={'sample_rate': 16000},
  ```
  <a id="tanhdistortion"></a>

  ```python
  TanhDistortion={'min_distortion': 0.1,
                  'max_distortion': 0.8,
                  'p': 1},
  ```
  <a id="timemasking"></a>

  ```python
  TimeMasking={'time_mask_param': 80},
  ```
  <a id="timestretch"></a>

  ```python
  TimeStretch='''min_rate=0.9,
                 max_rate=1.1,
                 p=0.2,
                 leave_length_unchanged=False''',
  ```
  <a id="codecs-using-torchaudio"></a>

  You can select just one. No need to use them all. :)
  ```php
  transformations = transf_gen.transf_gen(verbose=True,
                                          ac3=True,
                                          adpcm_ima_wav=True,
                                          adpcm_ms=True,
                                          adpcm_yamaha=True,
                                          eac3=True,
                                          flac=True,
                                          libmp3lame=True,
                                          mp2=True,
                                          pcm_alaw=True,
                                          pcm_f32le=True,
                                          pcm_mulaw=True,
                                          pcm_s16le=True,
                                          pcm_s24le=True,
                                          pcm_s32le=True,
                                          pcm_u8=True,
                                          wmav1=True,
                                          wmav2=True,
                                          )
  ```
  <a id="g726"></a>

  ```python
  g726={'audio_bitrate': '40k'},
  ```
  <a id="gsm"></a>

  ```python
  gsm=True,
  ```
  <a id="amr"></a>

  ```python
  amr={'audio_bitrate': '4.75k'},
  ```

rpm_license:
  MIT License  Copyright (c) [2024] [Ladislav Vašina]  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: d174213514b2bbd836ca0e21fa821145c4b3759643bbcea21c865532953d3482
name: python-AudioFusion
arch: src
version: 0.1.5
epoch: 0
release: 1
url: https://github.com/MineisZarox/AudioFusion
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AudioFusion-0.1.5-1.src.rpm
checksum_type: sha256
summary:
  Enhance your music experience – effortlessly add immersive 8D, slowed, and reverb effects to any song.

description:
  <div align="center">
  <h1>AudioFusion</h1>
  Python music editor
  </div>

  <i>A package that allows to edit your music file however you want with effects like slowed reverb and 8d.</i>

  <h2>Installation:</h2>

  ```bash
  >>> python3 -m pip install AudioFusion
  ```

  <h2>Usage:</h2>

  ```python
  >>> from AudioFusion import Fusion
  >>> # from AudioFusion.async import Fusion

  >>> # Load your music file
  >>> music = Fusion.loadSound("/path/to/your/music.mp3")

  >>> # Add effects
  >>> music = Fusion.effect8D(music)
  >>> music = Fusion.effectSlowed(music)
  >>> music = Fusion.effectReverb(music)

  >>> # Save your edited music file
  >>> Fusion.saveSound(music, "finalMusic")


  ```
  <p>More effects and method will be added soon</p>
  <p>PR in github repository are always welcome.</p>

  <h2>Detailed Usage:</h2>

  ```python
  >>> from AudioFusion import Fusion


  >>> # Load your music file
  >>> music = Fusion.loadSound("/path/to/your/music.mp3")

  >>> # Add effects
  >>> music = Fusion.effect8D(
          music,
          panBoundary = 100,  # Perctange of dist from center that audio source can go
          jumpPercentage = 5,  # Percentage of dist b/w L-R to jump at a time
          timeLtoR = 10000,  # Time taken for audio source to move from left to right in ms
          volumeMultiplier = 6  # Max volume DB increase at edges
  )

  >>> music = Fusion.effectSlowed(music, speedMultiplier: float = 0.92 ): # Slowdown audio, 1.0 means original speed, 0.5 half speed etc

  >>> music = Fusion.effectReverb(
          music,
          roomSize = 0.8,
          damping = 1,
          width = 0.5,
          wetLevel = 0.3,
          dryLevel = 0.8,
          tempFile = "tempWavFileForReverb"
      )

  >>> # Save your edited music file
  >>> Fusion.saveSound(music, "finalMusic")


  ```


pkgId: 84880d52a2753520aab7b3c838b4ad0a1913fc7becc7e80c5f0351ccf06a2796
name: python-AuroraSolarClient
arch: src
version: 2.0.1
epoch: 0
release: 1
summary: A python client for Aurora Solar
url: https://github.com/chaosinside/python-aurora-solar-client
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AuroraSolarClient-2.0.1-1.src.rpm
checksum_type: sha256
description:
  A python client for the Aurora Solar API.


  * requests



  	pip install AuroraSolarClient




  AuroraSolarClient supports both API versions 2018.01 and v2022.09 as well as HMAC and Bearer token authentication. Instantiation of the client requires `tenant_id` and `credentials`. The third `version` parameter is optional and if not provided, then API v2022.09 is assumed.

  	client = AuroraSolarClient(tenant_id, credentials, version)

  __tenant_id__ (string)
  : The tenant Id assigned to you by Aurora Solar.

  __credentials__ (object)
  : JSON object containting either `api_token` (for bearer authentication), or `api_key` and `api_secret` (for HMAC authentication). If `api_token` exists, the client will automatically use the preferred bearer authentication.

  __version__ (string) (optional)
  : The version of AuroraSolar API you wish to use. If not provided, the default is "2022.09". The only other acceptable version is "2018.01".


  ```python
  from AuroraSolarClient import AuroraSolarClient

  tenant_id = "my_tenant_id"
  credentials = { "api_token": "sk_prod_1234abc4321cba" }

  client = AuroraSolarClient(tenant_id, credentials)
  print("Aurora Solar Client", client.version, client.auth_type)
  response = client.get_versions()
  print("response:", response.text)
  ```


  ```python
  from AuroraSolarClient import AuroraSolarClient

  tenant_id = "my_tenant_id"
  credentials = {
  	api_key: "my_api_key",
  	api_secret: "my_api_secret"
  }

  client = AuroraSolarClient(tenant_id, credentials, "2018.01")
  print("Aurora Solar Client", client.version, client.auth_type)
  response = client.get_versions()
  print("response:", response.text)
  ```


  AuroraSolarClient only supports API v2018.01, uses HMAC authentication only, and must be initialized with a `tenant_id`, `api_key`, and `api_secret`. Once intialized, you can use any of the provided functions to return a requests response object.

  	client = AuroraSolarClient(tenant_id, api_key, api_secret)

  __tenant_id__ (string)
  : The tenant Id assigned to you by Aurora Solar.

  __api_key__ (string)
  : The API key assigned to you by Aurora Solar.

  __api_secret__ (string)
  : The API secret assigned to you by Aurora Solar.


  ```python
  from AuroraSolarClient import AuroraSolarClient

  client = AuroraSolarClient("my_tenant_id", "my_api_key", "my_api_secret")
  response = client.get_project("aurora_project_id")
  print("response:", response.text)
  ```



  __Note__: v2.0.1 is initialized with different parameters from v1.0.4. __Upgrading from v1.0.4 to v2.0.1 is a breaking change__.

  __v2.0.1__
  - Added support for API version 2022.09 while retaining support for 2018.01
  - Added support for bearer authentication while retaining support for HMAC authentication
  - Added more supported endpoints

  __v1.0.4__
  - original build out for API version 2018.01
  - pre-official documentation
  - only HMAC authentication supported
  - limited endpoints


pkgId: 18fc52778fad44dd26bfdf159d0c00c4b2738e82e6cbd63f2dd45f2c44af735b
name: python-AuthEncoding
arch: src
version: 5.0
epoch: 0
release: 1
summary: Framework for handling LDAP style password hashes.
url: https://github.com/zopefoundation/AuthEncoding
rpm_license: ZPL 2.1
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AuthEncoding-5.0-1.src.rpm
checksum_type: sha256
description:
  AuthEncoding is a framework for handling LDAP style password hashes.
  It is used in Zope but does not depend on any other Zope package.


pkgId: 14c73340509048f882473fb0723aa26ce47671db05bead65d12f0d7699532426
name: python-Authlib
arch: src
version: 1.3.2
epoch: 0
release: 1
summary: The ultimate Python library in building OAuth and OpenID Connect servers and clients.
url: https://pypi.org/project/Authlib/
rpm_license: BSD-3-Clause
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Authlib-1.3.2-1.src.rpm
checksum_type: sha256
description:
  The ultimate Python library in building OAuth and OpenID Connect servers.
  JWS, JWK, JWA, JWT are included.


pkgId: a6ef6bb91ae59fd99eb9e2b152dddd7a62f92471e9367dd7f9cb3782d048e2d4
name: python-Auto3D
arch: src
version: 2.3.1
epoch: 0
release: 1
summary: Generating Low-energy 3D Conformers from SMILES/SDF
url: https://github.com/isayevlab/Auto3D_pkg
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Auto3D-2.3.1-1.src.rpm
checksum_type: sha256
description:
  <a href="https://pypi.org/project/Auto3D/" target="_blank"><img src="https://img.shields.io/badge/pypi-url-informational" alt="pypi_link"></a>
  ![PyPI](https://img.shields.io/pypi/v/Auto3D)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/Auto3D)
  ![PyPI - License](https://img.shields.io/pypi/l/Auto3D)

  ![auto3d-white](https://github.com/user-attachments/assets/3184d31b-fb21-42d5-a1e0-611ccbf66ad2)

  **Auto3D** is a Python package for generating low-energy conformers from SMILES/SDF. Over the development process, we also added the APIs for computing single point energies, optimizing geometries, find stable tautomers. Auto3D can be imported as a Python library, or be excuted from the terminal.

  Please check out the information at [**documentation**](https://auto3d.readthedocs.io/en/latest/index.html), including [installation](https://auto3d.readthedocs.io/en/latest/installation.html), [usage](https://auto3d.readthedocs.io/en/latest/usage.html), [API](https://auto3d.readthedocs.io/en/latest/api.html) and [citation](https://auto3d.readthedocs.io/en/latest/citation.html).

  - **Jupyter notebook examples** can be found [here](https://github.com/isayevlab/Auto3D_pkg/tree/main/example)
  - To-do list for **improvement and new features** can be found [here](https://github.com/isayevlab/Auto3D_pkg/discussions). You are welcomed to share your thoughts.
  - Bugs go to the [issues](https://github.com/isayevlab/Auto3D_pkg/issues)
  - **AIMNet2**: The default model in Auto3D is AIMNet2 since 2.2.1. If you specify optimizing_engine="AIMNET", it actually uses AIMNet2. The old AIMNet model has been deprecated since Auto3D 2.2.1, and every call to “AIMNET” refers to the AIMNet2 model.


pkgId: 0b1162f90b09902cc2b14cf5b0e3182165b4dd0449a77d2d91ef78bc224d35b2
name: python-AutoClassifierRegressor
arch: src
version: 0.0.6
epoch: 0
release: 1
summary: Tools for getting analysis of all classifiers and regressors
url: https://github.com/anagha-bhople/auto_classifier_regressor
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AutoClassifierRegressor-0.0.6-1.src.rpm
checksum_type: sha256
description:
          pip install AutoClassifierRegressor



          from AutoClassifierRegressor import regression_report_generation

          from AutoClassifierRegressor import classification_report_generation



      regression_report_generation(dataframe, "target name", path="desired folder name", saveModel=True, normalisation=True, preprocessing=True)



          1. Dataframe name (required)
          2. Target variable for regression (required)
          3. path = name of folder (optional)
          4. saveModel = if set as True then all ML models will be saved in "Models" folder (optional)
          5. normalisation = if set as True data will be normalised (optional)
          6. preprocessing = if set as True then data will be preprocessed, which includes fillna and label encoding for categorical variables



          df=pd.read_csv("/content/sample_data/california_housing_train.csv")
          regression_report_generation(df, "median_house_value", path="Housing_data", saveModel=True, normalisation=True)



      classification_report_generation(dataframe, "target label", n= no classes, path="desired folder name", saveModel=True, preprocessing=True)



          1. Dataframe name (required)
          2. Target variable for classification (required)
          3. n=2 for binary classification (required) and n=no of classes for multiclass classification (required)
          4. path = name of folder (optional)
          5. saveModel = if set as True then all ML models will be saved in "Models" folder (optional)
          6. preprocessing = if set as True then data will be preprocessed, which includes fillna and label encoding for categorical variables



          df=pd.read_csv("data.csv")
          classification_report_generation(df, "diagnosis", n=2, path="binary_classification_reports", saveModel=True)

          df = pd.read_csv('Iris.csv')
          classification_report_generation(df, "Species", n=3, path="classification_model_Multiclass", saveModel=True)



          1. Output will be in the form of html file with tabular analyis of all important classifiers or regressors along with poular evaluation metrics.
          2. Html file will be saved in current or in given path.
          3. All ML models will be saved in /Models folder in current or in given path.



      1. Do necessary data processing for better results
      2. Install all dependancies

rpm_license:
  MIT License Copyright (c) [2022] [Anagha Bhople] 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: ffcac2c5b52c5fd45d70a372ba0d8d19173fc2720174f94b718a546e1a8bd442
name: python-AutoDiffCC
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: An AutoDifferentiation Library
url: https://github.com/Crimson-Computing/cs207-FinalProject
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AutoDiffCC-1.1.1-1.src.rpm
checksum_type: sha256
description:
  <img align="right" width="100" height="100" src="https://user-images.githubusercontent.com/43005886/70481100-8919f480-1aaf-11ea-8b0e-f8a8bde5c6ef.png">

  <img align="right" width="150" height="100" src="https://user-images.githubusercontent.com/43005886/70541950-ed7f9700-1b35-11ea-8148-1add138908bf.png">

  [![Build Status](https://travis-ci.org/Crimson-Computing/cs207-FinalProject.svg?branch=master)](https://travis-ci.org/Crimson-Computing/cs207-FinalProject)

  [![codecov](https://codecov.io/gh/Crimson-Computing/cs207-FinalProject/branch/master/graph/badge.svg)](https://codecov.io/gh/Crimson-Computing/cs207-FinalProject)




  Click [here](https://github.com/Crimson-Computing/cs207-FinalProject/blob/master/docs/documentation.md) to see full documentation





  - Alex Spiride
  - Maja Garbulinska
  - Matthew Finney
  - Zhiying Xu



  With the evolution of science and the growing computational possibilities, differentiation plays a critical role in a wide range of scientific and industrial applications of computer science. However, the precise computation of symbolic derivatives is computationally expensive, and not even possible in all situations, whereas the finite differencing method is not always accurate or stable. Automatic differentiation, however, provides a computationally efficient way to calculate derivatives, particularly of complex functions, for applications where accuracy and performance at scale are important.

  Our package **AutoDiffCC** provides is an easy to use package that computes derivates of scalar and vector functions using the concept of automatic differentation.

  We invite you to take a look at our repo and use **AutoDiffCC**!



  AutoDiffCC supports package installation via `pip`. Users can install the package in the command line with the following command.

  ```buildoutcfg
  pip install autodiffcc
  ```


  To use **AutoDiffCC** you first have to import it. If you already have it installed, you can do it by just running:

  ``` python

  >>> import autodiffcc as ad
  ```


  There are several ways in which you can take advantage of **AutoDiffCC**. Below we present some examples.


  A simple example using overloaded operators is described below. If you would like to evaluate ``f = x * x`` at ``x = 2``, first initiate an AD object ``x`` with ``x = ad.AD(val=2.0, der=1.0)``, where ``2`` is the value and ``1`` is the derivative. Then simply define your function ``f = x * x`` and enjoy the results. You can see this example implemented below.

  ``` python

  >>> x = ad.AD(val=2.0, der=1.0)
  >>> f = x * x
  >>> print(f.val, f.der)
  4.0 4.0
  ```

  Alternatively, you can just proceed as follows:

  ``` python
  >>> def f(x):
  >>>   return x*x
  >>> dfdx = differentiate(f)
  >>> dfdx(x=2.0)
  4.0 # this is the derivative value at x=2
  ```



  To use more complex function like cos(x) follow this example using our built-in module ADmath:

  ``` python
  >>> x = AD(val=3.0, der=1.0)
  >>> ADmath.cos(x)
  (array(-0.9899924966004454), array(-0.1411200080598672))
   ```

   Again, you can also do:

  ``` python
  >>> def f(x):
  >>>   return ADmath.cos(x)
  >>> dfdx = differentiate(f)
  >>> dfdx( x=3.0)
  -0.1411200080598672 # this is the derivative value evaluated at 3.0.
  ```




  Our package offers three root finding methods. The bisection method, the newton-fourier method and the newton-raphson method.



  ``` python RootFinder example for the bisection method

  >>> import autodiffcc as ad



  >>> def f(x, y):
  >>>    return x + y - 100
  >>> interval = [[1, 2], [3, 100]]
  >>> my_root = ad.find_root(function=f, method='bisection', interval=interval)
  >>> print(my_root)
  [1.999999999999993, 98.0]
  ```



  ``` python

  >>> import autodiffcc as ad
      >>> interval = [[3, -3], [3, -3]]
      >>> my_root = ad.find_root(lambda x, y: (2 * x + y - 2, y + 2), interval=interval, method='newton-fourier', max_iter=150)
      >>> print(my_root)
      [ 2. -2.]
  ```



  ``` python

  >>> import autodiffcc as ad
      >>> def f1var(x):
      >>>     return (x + 2) * (x - 3)

      >>> my_root = ad.find_root(function=f1var, method='newton', start_values=1, threshold=1e-8)
      >>> print(my_root)
      3.
  ```





  Another extension we offer is expression parsing. The below are two examples of parsing string expressions to function objects `fn` corresponding to the expressions.

  ``` python

  >>> import autodiffcc as ad
  >>> from autodiffcc.parser import expressioncc

  >>> x = ad.AD(2, der = [1, 0])
  >>> y = ad.AD(3, der = [0, 1])


  >>> fn = expressioncc('x+y+1', ['x', 'y']).get_fn()
  >>> print(fn(x,y).val)
  6.0
  >>> print(fn(x,y).der)
  [1. 1.]


  >>> fn = expressioncc('x = -y-1', ['x', 'y']).get_fn()
  >>> print(fn(x,y).val)
  6.0
  >>> print(fn(x,y).der)
  [1. 1.]
  ```




  We would like to acknowledge Glenfletcher as his contribution was used in our package.
  * Glenfletcher 2014. , DOI: https://github.com/glenfletcher/Equation/tree/master/Equation


pkgId: eea12a62596b3cfb6d6366b6af6c85bb5e44b260daa4aa7979d1d311792c26ad
name: python-AutoFeatSelect
arch: src
version: 0.1.5
epoch: 0
release: 1
summary: Automated Feature Selection & Feature Importance Calculation Framework
url: https://github.com/dorukcanga/AutoFeatSelect
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AutoFeatSelect-0.1.5-1.src.rpm
checksum_type: sha256
description:
  `autofeatselect` is a python library that automates and accelerates feature selection processes for machine learning projects.

  It helps to calculate feature importance scores & rankings with several methods and also helps to detect and remove highly correlated variables.



  You can install from PyPI:

  ```shell
  pip install autofeatselect
  ```



  `autofeatselect` offers a wide range of features to support feature selection and importance analysis:

  * Automated Feature Selection: Various automated feature selection methods, such as LGBM Importance, XGBoost Importance, RFECV so on.
  * Feature Importance Analysis: Calculation and visualization of feature importance scores for different algorithms seperately.
  * Correlation Analysis: Perform correlation analysis to identify and drop correlated features automatically.



  __Correlation Calculation Methods__
  * Pearson, Spearman & Kendall Correlation Coefficients for Continuous Variables
  * Cramer's V Scores for Categorical Variables

  __Feature Selection Methods__
  * LightGBM Feature Importance Scores
  * XGBoost Feature Importance Scores (with Target Encoding for Categorical Variables)
  * Random Forest Feature Importance Scores (with Target Encoding for Categorical Variables)
  * LassoCV Coefficients (with One Hot Encoding for Categorical Variables)
  * Permutation Importance Scores (LightGBM as the estimator)
  * RFECV Rankings (LightGBM as the estimator)
  * Boruta Rankings (Random Forest as the estimator)




  * Calculating Correlations & Detecting Highly Correlated Features

  ```python
  num_static_feats = ['x1', 'x2'] #Static features to be kept regardless of the correlation results.

  corr_df_num, remove_list_num = CorrelationCalculator.numeric_correlations(X=X_train,
                                                                            features=num_feats, #List of continuous features
                                                                            static_features=num_static_feats,
                                                                            corr_method='pearson',
                                                                            threshold=0.9)

  corr_df_cat, remove_list_cat = CorrelationCalculator.categorical_correlations(X=X_train,
                                                                                features=cat_feats, #List of categorical features
                                                                                static_features=None,
                                                                                threshold=0.9)
  ```

  * Calculating Single Feature Importance Score & Plot Results

  ```python

  feat_selector = FeatureSelector(modeling_type='classification', # 'classification' or 'regression'
                                  X_train=X_train,
                                  y_train=y_train,
                                  X_test=None,
                                  y_test=None,
                                  numeric_columns=num_feats,
                                  categorical_columns=cat_feats,
                                  seed=24)


  lgbm_importance_df = feat_selector.lgbm_importance(hyperparam_dict=None,
                                                     objective=None,
                                                     return_plot=True)



  lgbm_hyperparams = {'learning_rate': 0.01, 'max_depth': 6, 'n_estimators': 400,
                      'num_leaves': 30, 'random_state':24, 'importance_type':'gain'
                     }
  rfecv_hyperparams = {'step':3, 'min_features_to_select':5, 'cv':5}

  rfecv_importance_df = feat_selector.rfecv_importance(lgbm_hyperparams=lgbm_hyperparams,
                                                       rfecv_hyperparams=rfecv_hyperparams,
                                                       return_plot=False)
  ```

  * Calculating Single Feature Importance Score & Plot Results

  ```python

  feat_selector = AutoFeatureSelect(modeling_type='classification',
                                    X_train=X_train,
                                    y_train=y_train,
                                    X_test=X_test,
                                    y_test=y_test,
                                    numeric_columns=num_feats,
                                    categorical_columns=cat_feats,
                                    seed=24)

  corr_features = feat_selector.calculate_correlated_features(static_features=None,
                                                              num_threshold=0.9,
                                                              cat_threshold=0.9)

  feat_selector.drop_correlated_features()

  final_importance_df = feat_selector.apply_feature_selection(selection_methods=['lgbm', 'xgb', 'perimp', 'rfecv', 'boruta'])
  ```



  This project is completely free, open-source and licensed under the MIT license.


pkgId: 35d65a709501fff6b3333c856e679e2db9bbc14c7b850920d10086327aa7479e
name: python-AutoLogging-ML
arch: src
version: 1.2.4
epoch: 0
release: 1
url: https://pypi.org/project/AutoLogging-ML/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AutoLogging-ML-1.2.4-1.src.rpm
checksum_type: sha256
summary:
  This is a python package useful for the automated logging and visulaization of metrics for machine learning tasks.

description:
  This project is about a python package for automated logging and visualization of metrics of classfication and regression algorithms in machine learning.

  Features
  * The module covers both regression and classification tasks.
  * The module integrates a wide range of metrics related to classification and regression
  * The module can provide a barplot of the specified metrics from the specified subset of data
  * The module can provide the confusion matrix for all the different ML algorithms
  * The module can save automatically save the best model (highest validation accuracy for classification and lowest validation mse for regression)
  * The module can arrange the results table based on the user of the request
  * The module can provide the classification reports for all the different ML algorithms


  Functions
  * Train and log for classification. All the classifiers are trained on the datasets and the results (accuracy, precision, recall, F1) are logged onto a dataframe which is displayed to the user. This function applies around 16 different classification algorithms as mentioned below:-
  'svm-linear'

  'svm-rbf'

  'svm-poly'

  'knn'

  'naive bayes'

  'decision tree'

  'random forest'

  'adaboost'

  'gradient boost'

  'xgboost'

  'logistic regression'

  'bagging classifier'

  'extra tree classifier'

  'linear discriminant analysis'

  'quadratic discriminant analysis'

  'cat boost classifier'

  returns- best model and result table


  * Get confusion matrix. This function helps to get the confusion matrices for all the classification algorithms on the specified set (training/validation)

  * Get classification report. This function helps to get the classification reports for all the classification algorithms on the specified set (training/validation)

  * Sort table by metric. This function helps to arrange the result table as per the metric requested by the user.

  * Display metric plots. This function plots a barplot for the comparative analysis of the classication algorithms on the specified metric and on the specified subset.

  * Train and log for regression. All the regressors are trained on the datasets and the results (mae, mse, msle, median error, mape, max error) are logged onto a dataframe which is displayed to the user. This function applies around 13 different regression algorithms as mentioned below:-
  'linear regression'

  'sgd regression'

  'ridge regression'

  'elastic net'

  'decision tree regression'

  'random forest regression'

  'adaboost regression'

  'gradient boost regression'

  'xgboost regression'

  'bagging regression'

  'hist gradient boosting regression'

  'extra tree regression'

  'cat boost regression'

  Syntax

  from AutoLogging_ML import AutoLogger



  a= AutoLogger.train_and_log_classification(x_train,x_test,y_train,y_test)
  print(a)

  a stores the dataframe comprising of all the metric values for the training and validation datasets.



  AutoLogger.get_metric_plots_classification(a,subset='None',metric='None')

  returns the barplot of all the algorithms on the mentioned metric and mentioned subset.

  subset= 'training' , 'validation'

  metric= 'accuracy' , 'precision', 'recall', 'f1', 'msle', 'median absolute error', 'maximum error'



  AutoLogger.get_confusion_matrix(a,subset='None')

  returns the confusion matrix of all the classification algorithms on the specified subset

  subset= 'training'. 'validation'



  AutoLogger.get_classification_report(a,subset='None')

  returns the classification reports of all the classification algorithms on the specified subset

  subset= 'training'. 'validation'



  b= AutoLogger.train_and_log_regression(x_train, x_test, y_train, y_test)

  print(b)


  b stores the dataframe comprising of all the metric values for the training and validation datasets.



  AutoLogger.get_metric_plots_regression(b,subset=None,metric=None)


  returns the barplot of all the algorithms on the mentioned metric and mentioned subset.

  subset= 'training' , 'validation'

  metric= 'mae' , 'mse', 'mape', 'r2', 'msle', 'median absolute error', 'maximum error'



  AutoLogger.sort_table_by_metric


pkgId: 13f89f5cb74e7a89108828b725bf6571c8a3643b9ccb8709b4f0c39d712aaa63
name: python-AutoMD
arch: src
version: 1.10.0
epoch: 0
release: 1
summary: AutoMD is a documentation library for Flask APIs build with FlaskRESTful and Webargs.
url: https://github.com/cliftbar/automd
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AutoMD-1.10.0-1.src.rpm
checksum_type: sha256
description:
  AutoMD is a documentation library for Flask APIs build with FlaskRESTful and Webargs.
  Endpoint parameters and basic responses are automatically parsed into the OpenAPI specification,
  using Type Hints and introspection, and a endpoints registered to serve the specification.


  Documentation libraries tend to rely heavily on elaborate docstrings and static generation from source code.
  This library requires minimal changes to existing code, and most information (especially parameter specs)
  doesn't rely on keeping docstrings up to date.


  AutoMD is available through PyPi.  AutoMD requires Python >= 3.6 (f-strings are too convenient to ignore)
  Install using pip:
  ```
  pip install automd
  ```

  AutoMD also install the following dependencies:
  - flask
  - flask-restful
  - webargs
  - apispec
  - pyyaml
  - marshmallow
  - werkzeug



  The first step is to initialize the AutoMD app from a FlaskRESTful Api.

  ```python
  from flask import Flask
  from flask_restful import Api
  from automd.registration import AutoMDApp


  app: Flask = Flask(__name__)
  api: Api = Api(app)

  spec: AutoMDApp = AutoMDApp(api, title="AutoMD Test App", app_version="1.0.0", openapi_version="3.0.0")
  ```

  After that, all that is *required* is adding the `@automd` decorator to an existing Resource endpoint.

  ```python
  from flask_restful import Resource
  from marshmallow import fields
  from webargs.flaskparser import use_kwargs
  from automd.decorators import automd


  class MinimalStatus(Resource):
      get_query_arguments = {
          "text": fields.String(required=False)
      }

      @automd()
      @use_kwargs(get_query_arguments)
      def get(self, text):
          return text
  ```
  which will mark the endpoint for inclusion in the OpenAPI spec.  In this example, the spec information
  will be pretty limited, but will still have the API url, argument, and a default value.

  With more complete python annotations, more information can be gleaned:
  ```python
  from flask_restful import Resource
  from marshmallow import fields
  from webargs.flaskparser import use_kwargs
  from automd.decorators import automd


  class IntrospectionStatus(Resource):
      post_query_arguments = {
          "text": fields.String(required=False)
      }

      @automd()
      @use_kwargs(post_query_arguments, location="json")
      def post(self, text: str = "Hello AutoMD") -> str:
          ret_text: str = "status check OK"

          if text is not None:
              ret_text = f"{ret_text}: {text}"

          return ret_text
  ```
  From this the APISpec also get the parameter type, default value, and API response type.  It does not get the parameter
  location yet though, that takes more aguements to automd.

  Filling in more information in the webargs fields, automd decorator, use_kwargs decorator, and using one of the
  AutoMD response classes for type annotation and  gives even better information:
  ```python
  from flask_restful import Resource
  from marshmallow import fields
  from webargs.flaskparser import use_kwargs
  from automd.decorators import automd
  from automd.responses import ValueResponse

  class Status(Resource):
      get_query_arguments = {
          "text": fields.String(required=False, description='Text to return', doc_default="Hello AutoMD")
      }

      @automd(parameter_schema=get_query_arguments,
               summary="Status Endpoint",
               description="Status Endpoint, responds with a message made from the input string")
      @use_kwargs(get_query_arguments, location="query")
      def get(self, text: str = None) -> ValueResponse:
          log_text: str = "status check OK"

          log_text = f"{log_text}: {text or 'Hello AutoMD'}"

          return ValueResponse(log_text)
  ```

  With this information, argument types, return types, summaries, descriptions, detailed default
  information, and parameter location info (body, query, etc) is included.  Summary and description
  are the only "magic strings" needed, and those will generally not change much or be onerous to
  keep up to date compared to the automatically grabbed information.

  An example Flask API app is provided to showcase some functionality.  Start it using `run.py`.
  A sample of the OpenAPI spec generated is [here](https://cliftbar.github.io/automd/documentation/sample_spec.html).


pkgId: 7db29d1927d6665fd500c8fdb92795420abe54629f4e720f041541c61d8de091
name: python-AutoMLApp
arch: src
version: 0.1.73
epoch: 0
release: 1
url: https://pypi.org/project/AutoMLApp/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AutoMLApp-0.1.73-1.src.rpm
checksum_type: sha256
summary:
  An automated machine learning application designed for efficient model training, evaluation, and hyperparameter tuning.

description:
  **Overview**

  The AutoML Web App revolutionizes the credit underwriting process by automating critical steps, including data preprocessing, model fitting, and hyperparameter tuning, to ensure accurate risk assessments. Designed to streamline the workflow, it significantly enhances efficiency and precision in lending risk management for both individuals and businesses.

  **Features**

  - **Streamlined Credit Underwriting**: Traditionally, credit underwriting is a meticulous process essential for evaluating lending risks. This app simplifies these complexities, transforming how risk assessments are conducted.
  - **Overcoming Manual Constraints**: The manual fitting of models for credit underwriting is both time-consuming and prone to human error, potentially leading to suboptimal algorithm selection and overlooked risks. Our app addresses these challenges by automating model selection.
  - **Efficient Model Selection**: The AutoML Web App stands out by enabling the efficient selection of machine learning models tailored to specific tasks. It sifts through a targeted set of algorithms to find the best fit, balancing automation with user control to achieve optimal outcomes.
  - **No-Code Solution**: With the goal of democratizing technology, the app eliminates the need for intricate coding. It offers a user-friendly interface where complex underwriting tasks can be executed with just a few clicks, making sophisticated data analysis accessible to all.
  - **Precision and Efficiency**: By offering a carefully curated selection of options at each stage of the underwriting process, the app ensures that both efficiency and precision are not just promised but delivered. This meticulous approach guarantees that every dataset is handled with the optimal blend of speed and accuracy.



  Welcome to the AutoML Web App for credit underwriting. This section will guide you through the initial steps needed to get the app up and running on your system.



  Before proceeding with the installation of the AutoML Web App, ensure your system meets the following requirements:

  - **Python 3.10**: The application is developed in Python, requiring Python 3.10 to function correctly. Python 3.10 can be downloaded from [the official Python website](https://www.python.org/downloads/).
  - **PIP**: PIP, the Python package installer, must be available on your system to install the Python packages the app depends on.
  - **Internet Connection**: An active internet connection is necessary during the installation process for downloading required Python packages.

  A basic understanding of Python and the use of virtual environments for managing package dependencies is also recommended.



  To install the AutoML Web App, follow these steps:

  1. **Navigate to Local Directory**: Begin by navigating to Local Directory on your local machine cli:
     ```bash
     cd "direcoty"
     ```

  2. **Create a Virtual Environment** (Optional but Recommended): To prevent potential conflicts with existing Python packages on your system, it is advisable to create a virtual environment within the cloned directory:
     ```bash
     python3 -m venv venv
     
     
     venv\Scripts\activate
     
     source venv/bin/activate
     ```

  3. **Install Wheel File**: Install all necessary Python packages using the provided `AuotMLApp.whl` file or directly installing the python package:
     ```bash
     pip install AutoMLApp
     pip install "path to wheelfile"
     ```

  4. **Check Package**: After installing the package, you can see the properties by executing:
     ```bash
     pip show AutoMLApp
     ```

  5. **Change the directory to Application's directory**: After copying the dependencies, you need to navigate to the AutoML Web App by executing:
     ```bash
     cd "copied location"
     cd automlapp
     ```

  6. **Start the App**: After installing the dependencies, you can launch the AutoML Web App by executing:
     ```bash
     streamlit run app.py
     ```

     This command initiates the app and should automatically open it in your default web browser. If the app does not open automatically, a URL will be displayed in your terminal, which you can use to access the app manually.


pkgId: 8f41c0683edc067d60714c0bb119626fe80d42790366679d785bc4998f6004ab
name: python-AutoMonkey
arch: src
version: 0.2.1
epoch: 0
release: 1
summary: Python Automation using Mouse and Keyboard, for the masses
url: https://github.com/MihailCosmin/AutoMonkey
rpm_license: GNU General Public License v3
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AutoMonkey-0.2.1-1.src.rpm
checksum_type: sha256
description:
  [![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.com/donate/?hosted_button_id=5Q6TUMXS2QJW4)
  [![](https://snyk.io/test/github/MihailCosmin/AutoMonkey/badge.svg)](https://snyk.io/test/github/MihailCosmin/AutoMonkey)
  [![HitCount](https://hits.dwyl.com/MihailCosmin/AutoMonkey.svg?style=flat-square&show=unique)](http://hits.dwyl.com/MihailCosmin/AutoMonkey)
  [![build](https://github.com/MihailCosmin/AutoMonkey/actions/workflows/python-package.yml/badge.svg)](https://github.com/MihailCosmin/AutoMonkey/actions/workflows/python-package.yml)
  [![Code Climate](https://codeclimate.com/github/MihailCosmin/AutoMonkey/badges/gpa.svg)](https://codeclimate.com/github/MihailCosmin/AutoMonkey)


  <img alt="AutoMonkey" src="https://github.com/MihailCosmin/AutoMonkey/raw/06181954fa23605583d61843226f5f3997157435/img/monkey.ico" width="100px" height="100px"/>

  Python Automation using Mouse and Keyboard, for the masses



  1. From <a href="https://pypi.org/project/AutoMonkey/">pypi</a>:

  ```
  pip install AutoMonkey
  ```

  2. From <a href="https://github.com/MihailCosmin/AutoMonkey">github</a>:

  ```
  pip install git+https://github.com/MihailCosmin/AutoMonkey
  ```



  - <a href="https://github.com/asweigart/pyautogui">pyautogui</a>


  - PyScreeze
  - pyperclip
  - clipboard
  - keyboard
  - screeninfo
  - pywin32
  - pillow
  - opencv-python
  - numpy
  - pytesseract


  Main function to be used is "chain"

  This will allow you to "chain" together most of the other functions of automonkey.
  Which in turn will enable you to create sequences of mouse and/or keyboard actions in order to automate any given task.

  A step can have this structure:

  ```python

  dict(
      <action> = <target>,  # action can be any of the automonkey functions, target on which the action will be performed
      wait = 1,  # wait is an optional parameter, which will wait for the given amount of seconds before executing the next step
      skip = False,  # if True, will skip this step
      confidence = 0.9, # confidence is an optional parameter, Used only for actions on images. Confidence on locating the image.
      v_offset = 0,  # v_offset is an optional parameter, Used only for actions on images. Vertical offset from the center of the image.
      h_offset = 0,  # h_offset is an optional parameter, Used only for actions on images. Horizontal offset from the center of the image.
      offset = 0, # offset is an optional parameter, Used only for actions on images. Offset from the center of the image.
      monitor = 0,  # monitor is an optional parameter, Used only for actions on images. Monitor on which to search for the image.
  )

  or

  {
      "<action>": "<target>",  # action can be any of the automonkey functions, target on which the action will be performed
      "wait": 1,  # wait is an optional parameter, which will wait for the given amount of seconds before executing the next step
      "skip": False,  # if True, will skip this step
      "confidence": 0.9, # confidence is an optional parameter, Used only for actions on images. Confidence on locating the image.
      "v_offset": 0,  # v_offset is an optional parameter, Used only for actions on images. Vertical offset from the center of the image.
      "h_offset": 0,  # h_offset is an optional parameter, Used only for actions on images. Horizontal offset from the center of the image.
      "offset": 0, # offset is an optional parameter, Used only for actions on images. Offset from the center of the image.
      "monitor": 0,  # monitor is an optional parameter, Used only for actions on images. Monitor on which to search for the image.
  }
  ```

  1. You can connect multiple mouse actions together by using the "chain" function. Just by doing this you can generally automate most of the tasks you would do on a daily basis.

      There are 2 main ways to click, either by giving the coordinates of the position where to click or by giving the filename of the image you want to click on

      1.1. Clicking by coordinates


      1.1.1. In order to find the coordinates of a position on the screen you can use the "track_mouse" function or the PositionTracker class

      ```python
          from automonkey import track_mouse
          track_mouse()
      ```

      <img alt="track_mouse" src="https://github.com/MihailCosmin/AutoMonkey/raw/1fa19ba4517875d00c08cf320e628669d60714dc/demo/track_mouse.gif" width="416px" height="304px"/>


      ```python
          from automonkey import PositionTracker
          tracker = PositionTracker()
          tracker.start()
      ```

      <img alt="PositionTracker" src="https://github.com/MihailCosmin/AutoMonkey/raw/1fa19ba4517875d00c08cf320e628669d60714dc/demo/PositionTracker.gif" width="918px" height="574px"/>

      1.2.1. Now that you have the coordinates of the position you want to click on, you can use the "chain" function to click on it


      ```python
          from automonkey import chain
          chain(
              dict(click=(780, 1175), wait=1),
              dict(click=(444, 194), wait=1),
              dict(click=(1892, 110), wait=1),
              debug=True
          )
      ```

      <img alt="click" src="https://github.com/MihailCosmin/AutoMonkey/raw/1fa19ba4517875d00c08cf320e628669d60714dc/demo/click.gif" width="960px" height="576px"/>

      1.2. Clicking by image

      1.2.1. To click on an image you first need to make a screenshot of the area you want to click on and save it somewhere on your computer.
          For this you can use any screenshot tool you want, or you could use monkeyshot: https://github.com/MihailCosmin/monkeyshot
          For example you can make a screenshot of the Edge icon from your toolbar, then we can click on it by using the "chain" function.

      <img alt="edge_toolbar" src="https://github.com/MihailCosmin/AutoMonkey/raw/25eaed263793bf548d42f616e241f435baa9d719/demo/edge_toolbar.jpg" width="33px" height="33px"/>

      1.2.2. Now that we have the image we want to click on, we can use the "chain" function to click on it

      ```python
          chain(
              dict(click="demo/edge_toolbar.jpg"),
              dict(click="demo/google_create_account", wait=1),
              dict(click="demo/personal_use", wait=1),
              debug=True
          )
      ```

      <img alt="click_image" src="https://github.com/MihailCosmin/AutoMonkey/raw/1fa19ba4517875d00c08cf320e628669d60714dc/demo/click_image.gif" width="918px" height="600px"/>

      1.3. All mouse actions:

          * click
          * rightclick
          * leftclick
          * doubleclick
          * tripleclick
          * scrollup
          * scrolldown
          * scrollleft
          * scrollright

  2. You can also connect multiple keyboard actions together by using the "chain" function.

      2.1. Write text - This doesn't work well with non-english character. For this you can use the "pastetext" function.

      ```python
          chain(
              dict(click="demo/notepad.jpg"),
              dict(write="Hello World!"),
              debug=True
          )
      ```

      <img alt="write" src="https://github.com/MihailCosmin/AutoMonkey/raw/1fa19ba4517875d00c08cf320e628669d60714dc/demo/write.gif" width="918px" height="600px"/>

      2.2. Paste text - This works well with non-english characters

      ```python
          chain(
              dict(click="demo/notepad.jpg"),
              dict(pastetext="Straße"),
              debug=True
          )
      ```

      2.3. Key combinations

      ```python
          chain(
              dict(click="demo/notepad.jpg", wait=1),
              dict(write="Hello World!", wait=1),
              dict(keys2="ctrl+a", wait=1),
              dict(keys2="ctrl+x", wait=1),
              dict(keys2="alt+f4", wait=1),  # close notepad
              debug=True
          )
      ```

      <img alt="keys" src="https://github.com/MihailCosmin/AutoMonkey/raw/1fa19ba4517875d00c08cf320e628669d60714dc/demo/keys.gif" width="918px" height="600px"/>

      2.4. All key actions:

          * write
          * pastetext
          * keys
          * keys2 - best option overall for key combinations
          * keys3
          * keys4
          * copy
          * paste

  3. Wait actions:

      3.1. Wait until an image appears on the screen
      This can used when you are waiting for a window to finish loading completely and you don't know exactly how long that would take.

      ```python
          chain(
              dict(click="demo/notepad.jpg"),
              dict(waituntil="demo/notepad_opened.jpg", wait=1),
              dict(write="Hello World!", wait=1),
              debug=True
          )
      ```

      3.2. Wait while an image is on the screen

  4. App (window) actions:

      4.1. Open an app

      ```python
          chain(
              dict(open_app="notepad++.exe", wait=1),
              dict(waituntil="demo/notepad_opened.jpg", wait=1),
              dict(write="Hello World!", wait=1),
              debug=True
          )
      ```

      4.2. Close an app

      ```python
          chain(
              dict(open_app="notepad++.exe", wait=1),
              dict(write="Hello World!", wait=1),
              dict(close="Notepad", wait=1),
              debug=True
          )
      ```

      4.3. Minimize an app

      ```python
          chain(
              dict(open_app="notepad++.exe", wait=1),
              dict(write="Hello World!", wait=1),
              dict(minimize="Notepad", wait=1),
              debug=True
          )
      ```

      4.4. Maximize an app

      ```python
          chain(
              dict(open_app="notepad++.exe", wait=1),
              dict(write="Hello World!", wait=1),
              dict(maximize="Notepad", wait=1),
              debug=True
          )
      ```

      4.5. Restore an app

      ```python
          chain(
              dict(open_app="notepad++.exe", wait=1),
              dict(write="Hello World!", wait=1),
              dict(minimize="Notepad", wait=1),
              dict(restore="Notepad", wait=1),
              debug=True
          )
      ```

      4.6. All app actions:

          * open_app
          * close
          * startfile
          * focus
          * minimize
          * maximize
          * restore
          * msoffice_replace
          * copy_from
          * copy_from_to

  5. Image actions

      5.1 count_img. With this function you can count how many times one image appears on the screen.

      ```python
          chain(
              dict(count_img="demo/M.jpg", wait=1),  # The result will be copied to the clipboard
              dict(open_app="notepad++.exe", wait=1),
              dict(paste="", wait=1),  # with paste we can paste the text from the clipboard
              debug=True
          )
      ```

      5.2. get_text_from_region

      ```python
          chain(
              dict(get_text_from_region=((136, 121), (189, 140)), wait=1),  # The text will be copied to the clipboard
              dict(open_app="notepad++.exe", wait=1),
              dict(paste="", wait=1),  # with paste we can paste the text from the clipboard
              debug=True
          )
      ```


  1. Check if possible to add <a href="https://github.com/pywinauto/pywinauto">pyautowin</a> functionality



  1. I made an image but it doesn't click on it.

      A: Make sure you have not changed resolution of your screen or the theme (dark/light) of the window.


  2. Keys combination using "keys" function doesn't work.

      A: Try other keys functions. Preferably "keys2". Other options "keys3", "keys4".


pkgId: 3b2df22dcda049d13fb5cbd803d4e6c2cedd140f2a3ae8ec6b0cc263141731a1
name: python-AutoPhysLearn
arch: src
version: 0.2.5
epoch: 0
release: 1
url: https://github.com/pyscaffold/pyscaffold/
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AutoPhysLearn-0.2.5-1.src.rpm
checksum_type: sha256
summary:
  A python package for physics constrained machine learning by the M3-learning research group at Drexel University


pkgId: 2aa987f3f2b04b91a86b6461a53b61ad3a1a51bc00bbf79bde2241dc8d615dce
name: python-AutoPostTelegram
arch: src
version: 1.0.3
epoch: 0
release: 1
summary: An Telegram Auto Post Package
url: https://github.com/AasfCyberKing/AutoPostTelegram/
rpm_license: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AutoPostTelegram-1.0.3-1.src.rpm
checksum_type: sha256
description:
  <div align="center"><img src="https://i.imgur.com/sbrRXkW.jpeg" /></div>

  **A Telegram Auto Posting Package**

  • `A Package Used To Post Memes, Gifs, Facts Etc Automatically To Your Channel On Telegram`

  ```bash
  $ python3 -m pip install -U AutoPostTelegram
  ```




  ```
  from AutoPostTelegram import auto

  x = auto(TOKEN)

  x.animememe(chat="@AnimeMeme")
  ```


  ```
  import asyncio
  from AutoPostTelegram import auto

  x = auto(TOKEN)

  while True:
      x.animememe(chat="@AnimeMeme")
      asyncio.sleep(5) #The Time Gap Of Your Post In Seconds
      x.animememe(chat="@AnimeMeme")
  ```


  ```
  from AutoPostTelegram import auto

  print(auto.endpoints())
  ```


  ```
  Issue: While Using Package To Post Infinity Memes Or Something The Other Function Of The Bot Is Stopped Working ( Because Of asycnio.sleep() )[ Can't Find Alternative To Fix If You Know Comment On This Commit]
  ```


  ```
  Recommended To Use This Pacakge For Only To Auto Posting Feature
  ```


pkgId: 29b7bdb5a0a8059d4a77decdec6c8612f01a93c5bd72b62ea07d46704086d4b9
name: python-AutoQPF
arch: src
version: 0.2.4
epoch: 0
release: 1
summary: Generates QPF frame time codes to be used with x264/x265
url: https://github.com/jlw4049/AutoQPF
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AutoQPF-0.2.4-1.src.rpm
checksum_type: sha256
description:
  Generates QPF frame time codes to be used with x264/x265



  `pip install AutoQPF`



  `pip uninstall AutoQPF`



  ```python
  from auto_qpf.qpf import QpfGenerator, ChapterIndexError, ImproperChapterError, NoChapterDataError



  qpf = QpfGenerator().generate_qpf(file_input="PATH TO FILE.mkv")


  qpf = QpfGenerator().generate_qpf(file_input="PATH TO FILE.txt")



  try:
      qpf = QpfGenerator().generate_qpf(file_input="PATH TO FILE.mkv")

  except ChapterIndexError:
      print("Issue getting the correct index from the chapters")

  except ImproperChapterError:
      print("Input has improper or corrupted chapters")

  except NoChapterDataError:
      print("Input has no chapter data")
  ```



  `file_input` Required, path of the input file

  `file_output` Optional, can specify an output path, if one isn't will automatically create one based on the input

  `write_to_disk` Optional, True/False (default is True), if this is set to false the 'file_output' parameter will be ignored and a list of the converter chapter time codes will be returned

  `fps` Optional, this should be defined when using '.txt' (ogm) format. If it's a media file + has a video track we will automatically detect the FPS. Default is '23.976'

  `auto_detect_fps` Optional, True/False (default is True), this will over ride any user input if the file input is a media file

  `generate_chapters` Optional, True/False (default is True), if enabled the program will automatically output write OGM chapters beside the QPF, correcting improper numbers parsed from source, creating numbered chapters if tagged, and extracting named directly while retaining the same time-codes that align with the QPF file.

  _Generating chapters to text is done with a helper class, if you want to access this helper class and use it directly you can access it below..._



  _At the moment this requires a MediaInfo.parse() object, in the future I might change it to also accept a file input as well_

  `media_info_obj` A parsed pymediainfo object

  `output_path` The output path of the OGM chapters file (suffix must be .txt)

  `chapter_chunks` Optional, float (default is 12.0), this will make chapters for every 12% of the input file

  `extract_tagged` Optional, bool (default is True), this will allow the extraction of detected tagged chapters

  `extract_named` Optional, bool (default is True), this will allow the extraction of detected named chapters

  `extract_numbered` Optional, bool (default is True), this will allow the extraction of detected numbered chapters

  If any of `extract_*` is set to false, when that chapter type is detected the program will generate clean numbered chapters to replace it automatically.



  ```python
  from auto_qpf.qpf import ChapterGenerator
  from pymediainfo import MediaInfo

  parse = MediaInfo.parse(r"file_input.mkv")

  test = ChapterGenerator().generate_ogm_chapters(media_info_obj=parse, output_path="chapter.txt")


  print(test)
  ```


pkgId: 10b82505ba5e047ca22152442c52b4fdcbea7f7ff045f9a5ce95b25b1e3913fa
name: python-AutoQuant
arch: src
version: 1.1.1
epoch: 0
release: 1
summary: Auto Quant
url: https://github.com/marcnuth/AutoQuant
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AutoQuant-1.1.1-1.src.rpm
checksum_type: sha256
description:
  [![PypI Versions](https://img.shields.io/pypi/v/autoquant)](https://pypi.org/project/autoquant/#history)
  ![PyPI - Downloads](https://img.shields.io/pypi/dm/AutoQuant?label=PyPI)
  [![Python Versions](https://img.shields.io/pypi/pyversions/pyqlib.svg?logo=python&logoColor=white)](https://pypi.org/project/pyqlib/#files)
  [![Platform](https://img.shields.io/badge/platform-linux%20%7C%20windows%20%7C%20macos-lightgrey)](https://pypi.org/project/autoquant/#files)




  AutoQuant is an out-of-the-box quantitative investment platform.

  It contains the full ML pipeline of data processing, strategy building(includes AI & traditionals), back-testing, and covers the entire chain of quantitative investment: alpha seeking, risk modeling, portfolio optimization, and order execution.

  With AutoQuant, users can easily try ideas to create better Quant investment strategies.


  - [AutoQuant](#autoquant)
  - [Quick Start](#quick-start)
    - [Installation](#installation)
    - [Data Preparation](#data-preparation)
    - [Backtest](#backtest)
  - [Advanced Topics](#advanced-topics)
    - [Market](#market)
    - [Index](#index)
    - [Indicators](#indicators)
      - [Specific Indicators](#specific-indicators)
      - [Backtrader Indicators](#backtrader-indicators)
    - [Metrics](#metrics)
      - [Specific Metrics](#specific-metrics)
      - [TA-Lib Metrics](#ta-lib-metrics)
    - [Providers](#providers)
      - [Price Provider](#price-provider)
        - [Provides List](#provides-list)
        - [API](#api)
      - [Financial Statement Provider](#financial-statement-provider)
        - [Provides List](#provides-list-1)
        - [API](#api-1)
      - [Index Provider](#index-provider)
        - [Provides List](#provides-list-2)
        - [API](#api-2)
  - [Contribution Guide](#contribution-guide)
    - [Test](#test)
      - [Test all](#test-all)
      - [Test specified test](#test-specified-test)
    - [Development](#development)
      - [Generate Requirements](#generate-requirements)
      - [Package Update](#package-update)








  ```shell
  pip install --upgrade autoquant
  ```




  ```python
  from autoquant.collector import Collector
  from autoquant import Market
  from datetime import date

  collector = Collector.default()

  data = collector.daily_prices(
      market=Market.SZ,
      code='002594',
      start=date(2021, 11, 1),
      end=date(2021, 11, 5)
  )

  data = collector.quarter_statement(
      market=Market.SH,
      code='601318',
      quarter=date(2021, 9, 30)
  )

  ```



  ```python


  from autoquant.collector import Collector
  from autoquant.workflow import Workflow
  from autoquant.broker import Broker
  from autoquant import Market
  from datetime import date

  from autoquant.workflow import Workflow
  from autoquant.strategy import MA_CrossOver


  class SmaCross(MA_CrossOver):
      params = dict(fast=5, slow=20)


  collector = Collector.default()
  broker = Broker.default(kick_start=100000, commission=0.01)

  data = collector.daily_prices(market=Market.SZ, code='002594', start=date(2020, 1, 1), end=date(2021, 11, 1))
  w = Workflow().with_broker(broker).with_strategy(SmaCross).backtest(data)

  w.visualize()
  ```




  AutoQuant support Shanghai, Shenzhen, HongKong and US markets now.
  Use Market Enum in codes:

  ```python
  from autoquant import Market

  Market.SZ
  Market.SH
  Market.HK
  Market.CN
  Market.US
  ```


  AutoQuant support the indexes in multiple markets now.

  Use StocksIndex Enum in codes:
  ```python
  from autoquant import StocksIndex

  StocksIndex.ZZ500
  StocksIndex.HS300
  StocksIndex.SZ50
  ```

  Use FundsIndex Enum in codes:

  ```python
  from autoquant import FundsIndex

  FundsIndex.CN_ALL
  FundsIndex.CN_ETF
  FundsIndex.CN_QDII
  FundsIndex.HUAXIA_SECTOR_ETF
  ```




  - ParityIndex
  - AdjustedMomentum


  All the indicators in Backtrader are available in AutoQuant.

  For Example, if you were using the indicators of Backtrader like this:

  ```python
  from backtrader.indicators import Momentum
  ```

  You can simply change the import sentence to use the indicators in AutoQuant. The codes would be:

  ```python
  from autoquant.indicators import Momentum
  ```






  - Gross Rate Of Return
  - CAGR(Compound Annual Growth Rate)



  All the metrics in TA-Lib are available in AutoQuant.

  For Example, if you were using the metrics of TA-Lib like this:

  ```python
  from talib import SMA

  close = numpy.random.random(100)
  output = MOM(close, timeperiod=5)
  ```

  You can simply change the import sentence to use the metrics in AutoQuant. The codes would be:

  ```python
  from AutoQuant import SMA

  close = numpy.random.random(100)
  output = MOM(close, timeperiod=5)
  ```







  - BaostockProvider
  - TushareProvider
  - EastmoneyProvider


  ```python
  def daily_prices(self, market: Market, code: str, start: date, end: date, **kwargs)

  ```






  - SnowballProvider




  ```python
  def quarter_statement(self, market: Market, code: str, quarter: date, **kwargs)

  def yearly_balance_sheet(self, market: Market, code: str,  years: list, **kwargs)

  def yearly_income_sheets(self, market: Market, code: str, years: list, **kwargs)

  def yearly_flow_sheets(self, market: Market, code: str, years: list, **kwargs)

  ```





  - BaostockProvider
  - EastmoneyProvider




  ```python
  def stocks_of_index(self, index: StocksIndex, **kwargs)

  def funds_of_index(self, index: FundsIndex, **kwargs)
  ```





  ```shell
  PYTHONPATH=./ pytest
  ```


  ```shell
  PYTHONPATH=./ pytest tests/<YOUR_DISIRE_FILE>.py -k "<YOUR_DISIRE_TEST_CASE>" -s
  ```






  ```shell
  pipreqs ./ --encoding=utf8 --force
  ```


  ```shell
  python3 -m build
  python3 -m twine upload dist/*
  ```


pkgId: 08d3bfbc6aadb5aa035949b313895701a35a240aa288a1ed1738939392529434
name: python-AutoRAG
arch: src
version: 0.3.10
epoch: 0
release: 1
url: https://github.com/Marker-Inc-Korea/AutoRAG
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AutoRAG-0.3.10-1.src.rpm
checksum_type: sha256
summary:
  Automatically Evaluate RAG pipelines with your own data. Find optimal structure for new RAG product.

description:
  Do you have any difficulties in optimizing your RAG pipeline?
  Or is it hard to set up things to use AutoRAG?
  Try [**AutoRAG Cloud**](https://tally.so/r/n0jOrZ) beta.
  We will help you to run AutoRAG and optimize.
  Plus, we can help you to build RAG evaluation dataset.

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  http://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: cd663284d1c64304e5421f763dac684a16fa1c9b05931d5f2aef8e027363c04d
name: python-AutoROM
arch: src
version: 0.6.1
epoch: 0
release: 1
summary: Automated installation of Atari ROMs for Gym/ALE-Py
url: https://github.com/Farama-Foundation/AutoROM
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AutoROM-0.6.1-1.src.rpm
checksum_type: sha256
description:
  <p align="center">
      <img src="https://raw.githubusercontent.com/Farama-Foundation/AutoROM/master/autorom-text.png" width="500px"/>
  </p>


  AutoROM automatically installs Atari ROM files for ALE-Py (which Gymnasium Depends on) and multi-agent-ALE (which PettingZoo depends on, but will replaced by ALE-Py in the future).

  AutoROM automatically downloads the needed Atari ROMs from ROM hosting websites into the ALE-Py folder and Multi-Agent-ALE-py folder in a very simple manner:
  ```
  pip install autorom
  AutoROM
  ```

  To specify a specific installation directory for your ROMs, use the `--install-dir` command line flag.
  ```
  AutoROM --install-dir /path/to/install
  ```
  This will install ROMs at "/path/to/install/ROM/".

  Furthermore, you can accept the license agreement from the command-line with:
  ```
  AutoROM --accept-license
  ```
  OR when you are installing the Python package by specifying the extra `accept-rom-license`:
  ```
  pip install "autorom[accept-rom-license]"
  ```
  This command would download the ROMs during installation and make them immediately discoverable to `ale-py`.



  AutoROM requires that you package it as a source distribution. We have a special script to build all our source distributions, i.e., `./scripts/build-dist.sh`. The resulting source distributions will be located in `dist/`. You can directly install this with `pip` even including the extra `accept-rom-license`. For example,

  ```
  pip install --find-links dist/ --no-cache-dir AutoROM[accept-rom-license]
  ```


pkgId: b35ac9bed97c57153dbcf26239e0c8cbcfb60bf0444429bea6e8539ee7e13bed
name: python-AutoSmartAPI
arch: src
version: 0.1
epoch: 0
release: 1
summary: A library for interacting with SmartAPI for historical data, trading sessions, and more.
url: https://github.com/maheshrajbhar90/AutoSmartAPI
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AutoSmartAPI-0.1-1.src.rpm
checksum_type: sha256
description:
  SmartAPI - Python Library for Angel Broking API Integration
  Overview
  This Python library (SmartAPI) is designed to interact with the Angel Broking API for fetching financial data such as instrument details, live market data, historical data, and more. The library makes use of several popular Python libraries, including pandas, requests, and pyotp, to handle data fetching, processing, and API authentication.

  The provided script includes functions for logging in, fetching market data, handling sessions, and calculating live market prices and historical data for specific instruments.

  Features
  Login: Allows users to login with their credentials and store them for API interactions.
  Instrument Data: Fetches instrument details such as tokens, expiry dates, and more.
  Live Market Data: Retrieves the last traded price (LTP) for instruments.
  Historical Data: Fetches OHLC (Open, High, Low, Close) data for instruments.
  Session Handling: Initializes and manages separate sessions for historical and trading APIs.
  Time Zone Management: Provides functionality to fetch the current time in IST (Indian Standard Time).
  Installation
  This library requires several Python packages. You can install the required dependencies using pip.

  Step 1: Install Required Libraries
  To ensure that all necessary libraries are installed, the following Python script checks for and installs the missing libraries:

  $pip install pandas requests pytz pyotp

  $pip install SmartApi

  Usage
  Hereâ€™s how you can use the SmartAPI class in your script:

  1. Initialize the SmartAPI class
  api = SmartAPI()

  2. Login with Your Credentials
  You need to provide your credentials for logging into the API:
  api.login(api_key_hist='YOUR_HISTORICAL_API_KEY',
            api_key_trading='YOUR_TRADING_API_KEY',
            uid='YOUR_USER_ID',
            mpin='YOUR_MPIN',
            totp='YOUR_TOTP_SECRET')


  3. Fetch Instrument Data
  To fetch the instrument details (e.g., symbol, token, exchange segment):
  instrument_df = api.fetch_instrument_df()
  print(instrument_df.head())



  4. Fetch the Last Traded Price (LTP)
  To get the LTP for a specific instrument (e.g., 'WIPRO'):
  ltp = api.get_ltp('WIPRO')
  print(f"Last Traded Price: {ltp}")


  5. Fetch Trading Symbols
  To fetch the trading symbols based on the current spot price:
  symbols_df = api.get_tradingsymbols()
  print(symbols_df.head())


  6. Fetch Historical Data (OHLC)
  To fetch OHLC data for a specific symbol:
  ohlc_data = api.get_ohlc('BANKNIFTY', '5minute', 30)  # 30 days of data
  print(ohlc_data.head())


  8. Get Current Time in IST
  To get the current time in IST:
  current_time = api.get_ist_now()
  print(f"Current IST Time: {current_time}")
  Methods:
  login(api_key_hist, api_key_trading, uid, mpin, totp)
  Logs in with the provided credentials (API keys, user ID, MPIN, and TOTP secret).

  fetch_instrument_df()
  Fetches the instrument details (tokens, expiry dates, etc.) and returns it as a pandas DataFrame.

  get_historical_data_session()
  Generates a session for accessing historical market data.

  get_trading_api_session()
  Generates a session for trading-related API interactions.

  initialize_sessions()
  Initializes both historical and trading API sessions.

  get_ltp(symbol)
  Fetches the Last Traded Price (LTP) for a given symbol.

  get_tradingsymbols()
  Fetches the trading symbols based on the spot price of Nifty or BankNifty.

  get_ohlc(symbol, interval, n)
  Fetches the OHLC data for the given symbol over the specified interval and number of days.

  get_ist_now()
  Fetches the current time in IST (Indian Standard Time).

  Example
  Hereâ€™s an example of how to use the entire class:


  api = SmartAPI()


  api.login(api_key_hist='your_api_key_hist',
            api_key_trading='your_api_key_trading',
            uid='your_user_id',
            mpin='your_mpin',
            totp='your_totp_secret')


  instrument_df = api.fetch_instrument_df()
  print(instrument_df.head())


  ltp = api.get_ltp('Nifty Bank')
  print(f"LTP: {ltp}")


  ohlc_data = api.get_ohlc('BANKNIFTY', '5minute', 30)
  print(ohlc_data.head())


pkgId: e35975d6fc1de58af7e3090dc61020c4017c2e920e2c5a7fcc34f1b19f9243ba
name: python-AutoSteper
arch: src
version: 2.1.1
epoch: 0
release: 1
summary: Automated Stepwise Addition Procedure for Extrafullerene.
url: https://github.com/Franklalalala/AutoSteper
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AutoSteper-2.1.1-1.src.rpm
checksum_type: sha256
description:
   [![PyPI version](https://badge.fury.io/py/autosteper.svg)](https://badge.fury.io/py/autosteper)  [![Downloads](https://pepy.tech/badge/autosteper/month)](https://pepy.tech/project/autosteper)   [![PyPI - License](https://img.shields.io/pypi/l/autosteper)](https://github.com/Franklalalala/AutoSteper/blob/master/LICENSE.txt)  [![Documentation Status](https://readthedocs.org/projects/autosteper/badge/?version=latest)](https://autosteper.readthedocs.io/en/latest/?badge=latest)




  Automated Stepwise Addition Procedure for Extrafullerene.

  A detailed description could be found in the article: Exploring exohedral functionalization of fullerene with Automation and Neural Network Potential. ![overview](./docs/manual/fig/overview.png)

  <center>Overview of the Stepwise model.</center>

  Demonstration of core functions could be found in `./gym`.

  Documentation could be found at https://autosteper.readthedocs.io/.





  Autosteper has an dependency on multiple python packages, namely, the importlib-metadata, ase, numpy, pandas, networkx, tqdm, matplotlib, seaborn, and dpdispatcher. Installation of all of them along with this project has been integrated into a single command line:

  ```
  pip install autosteper
  ```

  Besides, Autosteper relies on open source project [FullereneDataParser](https://github.com/XJTU-ICP/FullereneDataParser) to convert 3D coordinates to graph6str format and properly visualize isomers, pathways, and SWR pairs. [FullereneDataParser](https://github.com/XJTU-ICP/FullereneDataParser) has not been published on Pypi. According to [Pypi policy](https://setuptools.pypa.io/en/latest/userguide/dependency_management.html#direct-url-dependencies), the unpublished project **could not** be used as a dependency for the published package. Therefore, it needs to be installed separately:

  ```
  pip install git+https://github.com/XJTU-ICP/FullereneDataParser
  ```

  Note: [FullereneDataParser](https://github.com/XJTU-ICP/FullereneDataParser) contains part of C++ code, to properly install, an advanced compiler version is required. Simply load the highest available version of compiler will avoid most of the problems. See below.

  Finally, the in-house built C++ project [usenauty](https://github.com/Franklalalala/usenauty) needs to be collected. [usenauty](https://github.com/Franklalalala/usenauty) is a lightweight tool to enumerate non-isomorphic addition patterns with [nauty](https://doi.org/10.1016/j.cpc.2020.107206) algorithm which is created by Brendan D. McKay. The original modification is performed in [usenauty](https://github.com/saltball/usenauty) by XJTU-ICP member Y. B. Han. Here we employ a branch version of it.

  Unlike previously mentioned packages, the installation of [usenauty](https://github.com/Franklalalala/usenauty) is different for Linux and Windows. **There are two pre-compiled** releases for two platforms, users are encouraged to [download](https://github.com/Franklalalala/usenauty/releases) the corresponding releases.

  For example, linux users could download the gcc-8.4.0 version with command line as below:

  ```
  wget https://github.com/Franklalalala/usenauty/releases/download/linux/cagesearch
  ```

  After downloading, users need to assign execution permissions and load a gcc environment:

  ```
  chmod +x path/to/cagesearch
  module load compiler/gcc/8.4.0
  ```

  Note that, any gcc version above 8.4.0 is technically suitable.

  If everything goes well, a gentle notation is expected after executing this binary file:

  ```
  path/to/cagesearch
  ```

  ![image-20221220010149410](./docs/manual/fig/nauty_notation.png)

  <center>The usenauty notation.</center>

  The absolute path of this file corresponds to the `gen_core_path` in the generator module, as demonstrated in [test_step.py](https://github.com/Franklalalala/AutoSteper/blob/b1ae14e734b2013628ffca241ab44eba6510f970/tests/test_step/test_step.py#L38).



  A [GitHub Proxy](https://ghproxy.com/) will speed up the installation from github:

  ```
  pip install git+https://ghproxy.com/https://github.com/XJTU-ICP/FullereneDataParser
  wget https://ghproxy.com/https://github.com/Franklalalala/usenauty/releases/download/linux/cagesearch
  ```



  Any contribution is greatly appreciated. To install from the source code, the AutoSteper package:

  ```
  git clone https://github.com/Franklalalala/AutoSteper
  cd AutoSteper
  pip install . -e
  ```

  The FullereneDataParser package:

  ```
  git clone https://github.com/XJTU-ICP/FullereneDataParser
  cd FullereneDataParser
  pip install . -e
  ```

  To compile the usenauty project, please follow instructions in [usenauty](https://github.com/Franklalalala/usenauty).



  Issues are welcomed if you have any questions.

  Contributions needs to stay in line with [Conventional Commit messages](https://www.conventionalcommits.org/).

  Contact me: 1660810667@qq.com

rpm_license:
  The MIT License (MIT)  Copyright (c) 2022 Franklalalala  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: 196a29188b9d707f073a62f4035fb7595170597d031ab3e2e7645f33248011a4
name: python-AutoStrEnum
arch: src
version: 0.0.10
epoch: 0
release: 1
summary: # AutoStrEnum
url: https://github.com/PttCodingMan/AutoStrEnum
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AutoStrEnum-0.0.10-1.src.rpm
checksum_type: sha256
description:
  This project defines an extended `Enum` class.
  It can automatically assign the value to your Enum member, and the value is just the same as the member name!
  And when you print it, you won't see the Enum name in front of the class member.



  ```shell
  pip install AutoStrEnum
  ```



  ```python
  import json
  import pickle
  from enum import auto

  from AutoStrEnum import AutoStrEnum, AutoJsonEncoder


  class Fruit(AutoStrEnum):
      BANANA = auto()
      WATERMELON = auto()
      DURIAN = auto()
      KIWI = auto()


  class MagicFruit(AutoStrEnum):
      BANANA = auto()
      WATERMELON = auto()
      DURIAN = auto()


  if __name__ == '__main__':
      print(Fruit, MagicFruit)
      print(Fruit.BANANA, Fruit.WATERMELON, Fruit.DURIAN)

      print('should be True:', Fruit.BANANA in Fruit)
      print('should be True:', Fruit.BANANA is Fruit.BANANA)
      print('should be True:', Fruit.BANANA == Fruit.BANANA)
      print('should be True:', isinstance(Fruit.BANANA, Fruit))
      print('should be False:', isinstance(Fruit.BANANA, str))
      print('should be False:', isinstance(Fruit.BANANA, MagicFruit))
      print('should be False:', isinstance(False, Fruit))

      
      test_dict = {
          Fruit: {
              Fruit.BANANA: 2,
              Fruit.DURIAN: 10,
              Fruit.WATERMELON: 0,
              'Love': Fruit.KIWI
          }}

      print(test_dict)

      
      print('json dumps', json.dumps(test_dict, indent=4, cls=AutoJsonEncoder))
  ```

  ```shell
  $ python demo.py
  Fruit MagicFruit
  BANANA WATERMELON DURIAN
  should be True: True
  should be True: True
  should be True: True
  should be True: True
  should be False: False
  should be False: False
  should be False: False
  {Fruit: {BANANA: 2, DURIAN: 10, WATERMELON: 0, 'Love': KIWI}}
  json dumps {
      "Fruit": {
          "Love": "KIWI",
          "BANANA": 2,
          "DURIAN": 10,
          "WATERMELON": 0
      }
  }
  ```


pkgId: bf40ffc73464074f77c9a9bb2ef3b3b3a98a698f59a38acf353d22d82f83cef8
name: python-AutoTrader-Web-API-Stocks-Developer
arch: src
version: 1.3.5
epoch: 0
release: 1
url: https://github.com/Pritesh-Mhatre/python-library
rpm_license: GNU General Public License v3 (GPLv3)
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AutoTrader-Web-API-Stocks-Developer-1.3.5-1.src.rpm
checksum_type: sha256
summary:
  Python trading API library for Zerodha, Upstox, AliceBlue, Finvasia, Angel One, Fyers, IIFL, 5Paisa, Profitmart, Mastertrust, Edelweiss, Motilal Oswal, Kotak Securities

description:
  **[AutoTrader Web](https://stocksdeveloper.in/autotrader-web/)** is our next generation automated trading & PMS software suite. **Most preferred tool by portfolio & fund managers, algorithmic traders as well as sub-brokers.**

  It allows you to **trade & manage multiple trading accounts** across **different stock brokers from a single system**.

  You can trade **manually or automate your trading** strategies using our APIs. We provide easy to use **API libraries in AmiBroker, MetaTrader, Excel, Java, Python, C#**. You can also use our APIs from **any other programming languages via HTTP REST or CSV files**.

  Our aim is to provide advanced features to our users, which are mostly available to HNI or wealthy fund managers in their custom built trading systems.

  Massively reduce trading costs based on following features:
  - **No need to purchase API subscription** from your stock broker
  - Reduced development efforts as you can **change stock broker with just a few clicks**
  - **Multi-account trading from a single system**, so you only need one computer and one datafeed


  - Trade & manage multiple trading accounts from anywhere via browser on mobile or PC
  - Allows your trading strategies to place/modify/cancel orders as well as read live portfolio
  - Low latency (less than 200 milliseconds on average for order placements)
  - Works across all operating systems (Windows, Mac, Unix, Linux)
  - Place bulk orders into one or more trading accounts
  - Truly broker independent. Switch your trading account across any broker without making any code change
    - System handles broker specific implementation internally
    - System also handles broker specific trading symbol formats internally
  - Support for well known brokers
    - Zerodha
    - Upstox
    - AliceBlue
    - Finvasia
    - Fyers
    - Angel Broking
    - IIFL
  - A **[complete list of features](https://stocksdeveloper.in/autotrader-web-features/)**


  - **[User Guide](https://stocksdeveloper.in/documentation/index/)**
  - **[User Guide - Python Library](https://stocksdeveloper.in/documentation/client-setup/python-library/)**
  - **[User Guide - API Docs](https://stocksdeveloper.in/documentation/api/)**


pkgId: db74e1736dd73b4ec9672f53cad32d0e9af8b10e00abc4de5c6e9561d03a7283
name: python-AutoWZRY
arch: src
version: 2.2.8a1
epoch: 0
release: 1
summary: 王者荣耀自动化农活脚本.
url: https://github.com/cndaqiang/WZRY
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AutoWZRY-2.2.8a1-1.src.rpm
checksum_type: sha256
description:
  [WZRY](https://github.com/cndaqiang/WZRY)是基于[airtest-mobileauto](https://github.com/cndaqiang/airtest_mobileauto)开发的王者荣耀农活自动化免费开源脚本.



  真正的无人值守：自动对战、领取礼包、更新游戏、错误纠正

  * 开启关闭模拟器、容器、手机
  * 自动检测处理游戏闪退、模拟器关闭等各种错误
  * 健康系统自动休息启动
  * 自动切换熟练度,优先星耀人机模式,次数达到上限后切换青铜人机
  * 自动调整分路并选择熟练度最低的英雄



  5v5人机单人模式、组队模式、标准模式、快速模式、星耀难度、青铜难度

  - 挂机模式: 适合完成每日任务、战令任务、**提高熟练度**
  - TOUCH模式(移动+平A): 适合完成活动的**标准对战非挂机**对战要求

  王者模拟战单人模式、组队模式

  - 刷信誉分专用, 每日上限+5分.
  - 战令的每期任务: 20场娱乐模式, 可以用模拟战刷齐





  * 友情对战: 友情币领取、奖励兑换
  * 邮件礼包: 好友邮件、系统邮件
  * 妲己一键领奖
  * 战令礼包、战令任务礼包
  * 回忆礼册、灵宝互动
  * 祈愿页面领取祈愿币、玉镖夺魁的飞镖
  * 王者营地礼包
  * 王者体验服礼包
  * KPL观赛战令观赛领取经验升级
  * 战队商店领取英雄碎片
  * 商城每日免费钻石碎片随机礼包



  在全新的[文档页面](https://cndaqiang.github.io/wzry.doc)获得使用方法。


  * [airtest_mobileauto](https://github.com/cndaqiang/airtest_mobileauto)
  * [WZRY_AirtestIDE](https://github.com/XRSec/WZRY_AirtestIDE)
  * [Airtest Project](https://github.com/AirtestProject)



  ![Alt](https://repobeats.axiom.co/api/embed/e3dff17ea7d3c5e7dd3f8ce8b0fd3c09618cd7fc.svg "Repobeats analytics image")


pkgId: 50208b1c9913ee1a8462b38ee08077f82faaa825704bb3f8346c09b2c8b03d27
name: python-AutoWZRY
arch: src
version: 2.2.9a1
epoch: 0
release: 1
summary: 王者荣耀自动化农活脚本.
url: https://github.com/cndaqiang/WZRY
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AutoWZRY-2.2.9a1-1.src.rpm
checksum_type: sha256
description:
  [WZRY](https://github.com/cndaqiang/WZRY)是基于[airtest-mobileauto](https://github.com/cndaqiang/airtest_mobileauto)开发的王者荣耀农活自动化免费开源脚本.



  真正的无人值守：自动对战、领取礼包、更新游戏、错误纠正

  * 开启关闭模拟器、容器、手机
  * 自动检测处理游戏闪退、模拟器关闭等各种错误
  * 健康系统自动休息启动
  * 自动切换熟练度,优先星耀人机模式,次数达到上限后切换青铜人机
  * 自动调整分路并选择熟练度最低的英雄



  5v5人机单人模式、组队模式、标准模式、快速模式、星耀难度、青铜难度

  - 挂机模式: 适合完成每日任务、战令任务、**提高熟练度**
  - TOUCH模式(移动+平A): 适合完成活动的**标准对战非挂机**对战要求

  王者模拟战单人模式、组队模式

  - 刷信誉分专用, 每日上限+5分.
  - 战令的每期任务: 20场娱乐模式, 可以用模拟战刷齐





  * 友情对战: 友情币领取、奖励兑换
  * 邮件礼包: 好友邮件、系统邮件
  * 妲己一键领奖
  * 战令礼包、战令任务礼包
  * 回忆礼册、灵宝互动
  * 祈愿页面领取祈愿币、玉镖夺魁的飞镖
  * 王者营地礼包
  * 王者体验服礼包
  * KPL观赛战令观赛领取经验升级
  * 战队商店领取英雄碎片
  * 商城每日免费钻石碎片随机礼包



  在全新的[文档页面](https://wzry-doc.pages.dev/)获得使用方法。


  * [airtest_mobileauto](https://github.com/cndaqiang/airtest_mobileauto)
  * [WZRY_AirtestIDE](https://github.com/XRSec/WZRY_AirtestIDE)
  * [Airtest Project](https://github.com/AirtestProject)



  ![Alt](https://repobeats.axiom.co/api/embed/e3dff17ea7d3c5e7dd3f8ce8b0fd3c09618cd7fc.svg "Repobeats analytics image")


pkgId: bbe798242dcc9f9e9011abd36274d8278dbc39ff540a1f7e0d1ac8e6352f67bc
name: python-AutoWZRY
arch: src
version: 2.2.9b2
epoch: 0
release: 1
summary: 王者荣耀自动化农活脚本。
url: https://github.com/cndaqiang/WZRY
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AutoWZRY-2.2.9b2-1.src.rpm
checksum_type: sha256
description:
  <div align="center">
    <h1 align="center">
      <img src="http://wzry-doc.pages.dev/wzry.favicon.png" width="140">
      <br/>
      WZRY · 农活自动化助手
    </h1>
  </div>
  <div align="center">
    <img alt="WZRY Release" src="https://img.shields.io/github/v/release/cndaqiang/WZRY?style=flat-square&color=ff7fbf&label=WZRY" />
    <img alt="Stars" src="https://img.shields.io/github/stars/cndaqiang/WZRY?style=flat-square&color=66bb6a&label=Stars" />
    <img alt="Developer" src="https://img.shields.io/badge/cndaqiang-blue?style=flat-square&color=4096d8&label=Developer" />
  </div>

  <div align="center">
  使用方法, 请访问: <a href="https://wzry-doc.pages.dev">使用手册</a>.
  <br/>
  遇到问题, 请在提问前查看: <a href="https://wzry-doc.pages.dev/qa/qa/">常见问题</a>.
  </div>



  [WZRY](https://github.com/cndaqiang/WZRY)是基于[airtest-mobileauto](https://github.com/cndaqiang/airtest_mobileauto)开发的王者荣耀农活自动化免费开源脚本.



  真正的无人值守：自动对战、领取礼包、更新游戏、错误纠正

  * 开启关闭模拟器、容器、手机
  * 自动检测处理游戏闪退、模拟器关闭等各种错误
  * 健康系统自动休息启动
  * 自动切换熟练度,优先星耀人机模式,次数达到上限后切换青铜人机
  * 自动调整分路并选择熟练度最低的英雄



  5v5人机单人模式、组队模式、标准模式、快速模式、星耀难度、青铜难度

  - 挂机模式: 适合完成每日任务、战令任务、**提高熟练度**
  - TOUCH模式(移动+平A): 适合完成活动的**标准对战非挂机**对战要求

  王者模拟战单人模式、组队模式

  - 刷信誉分专用, 每日上限+5分.
  - 战令的每期任务: 20场娱乐模式, 可以用模拟战刷齐





  * 友情对战: 友情币领取、奖励兑换
  * 邮件礼包: 好友邮件、系统邮件
  * 妲己一键领奖
  * 战令礼包、战令任务礼包
  * 回忆礼册、灵宝互动
  * 祈愿页面领取祈愿币、玉镖夺魁的飞镖
  * 王者营地礼包
  * 王者体验服礼包
  * KPL观赛战令观赛领取经验升级
  * 战队商店领取英雄碎片
  * 商城每日免费钻石碎片随机礼包


  - *[Cloudiiink](https://github.com/Cloudiiink) 正在设计制作全新的项目图标，版权归其所有。*
    特别感谢 Cloudiiink 的精心创作！

  - 灵感和支持来自以下项目：
    - [airtest_mobileauto](https://github.com/cndaqiang/airtest_mobileauto)
    - [WZRY_AirtestIDE](https://github.com/XRSec/WZRY_AirtestIDE)
    - [Airtest Project](https://github.com/AirtestProject)

  - 感谢所有提问 issue 和为本项目打星的用户！


pkgId: 1bf0b319814c3af1d56725b0d24b896dc79294da12f49f1c7509c87abba353c0
name: python-AutoWriterLLM
arch: src
version: 0.1.0
epoch: 0
release: 1
summary: Automatic book writing tool using Large Language Models
url: https://github.com/supersheepbear/autowriterllm
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AutoWriterLLM-0.1.0-1.src.rpm
checksum_type: sha256
description:
  A Python tool that helps automatically generate comprehensive book structures and content using Large Language Models (LLMs).



  * Generate detailed table of contents for technical books and guides
  * Create comprehensive book summaries with learning objectives
  * Support for multiple book formats and topics
  * Integration with multiple LLM providers (Anthropic Claude, Yi)


pkgId: 4970289bdb61e8d2ff8feca66339d42af11315f9e9a13383ac16185e1acc9e68
name: python-Autologging
arch: src
version: 1.3.2
epoch: 0
release: 1
summary: Autologging makes logging and tracing Python classes easy.
url: http://ninthtest.info/python-autologging/
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Autologging-1.3.2-1.src.rpm
checksum_type: sha256
description:
  http://ninthtest.info/python-autologging/

  [![PyPI version](https://img.shields.io/pypi/v/Autologging.svg)](https://pypi.python.org/pypi/Autologging)
  [![Python version](https://img.shields.io/pypi/pyversions/Autologging.svg)](https://pypi.python.org/pypi/Autologging)
  [![Python implementation](https://img.shields.io/pypi/implementation/Autologging.svg)](https://pypi.python.org/pypi/Autologging)
  [![License](https://img.shields.io/pypi/l/Autologging.svg)](https://github.com/mzipay/Autologging/blob/master/LICENSE.txt)
  [![Wheel availability](https://img.shields.io/pypi/wheel/Autologging.svg)](https://pypi.python.org/pypi/Autologging)



  Autologging eliminates boilerplate logging setup code and tracing code,
  and provides a means to separate application logging from program flow
  and data tracing.

  Python modules that make use of Autologging are cleaner, leaner, and
  more resilient to changes that would otherwise require updating tracing
  statements.

  Autologging allows for tracing to be configured (and controlled)
  independently from application logging. Toggle tracing on/off, write
  trace log records to a separate log, and use different formatting for
  trace log entries - all via standard Python logging facilities, and
  without affecting your application logging.



  Autologging exposes two decorators and a custom log level:

  **`logged`**
  Decorate a class to create a `__log` member. The logger is named by
  default to match the dotted-name of the containing class. A function
  may also be decorated, creating a `_log` attribute on the function
  object whose default name matches the containing module.
  A specifically-named logger may also be passed to the decorator (i.e.
  `logged(my_logger)`).

  **`traced`**
  Decorate a class to provide **automatic** method call/return tracing. By
  default, all class, static, and instance methods are traced (excluding
  "__special__" methods, with the exception of `__init__` and `__call__`).
  As with the `logged` decorator, the default name of the tracing logger
  matches the dotted-name of the containing class and may be overridden by
  passing a specifically-named logger to the decorator.
  Additionally, this decorator accepts multiple string arguments that
  explicitly name the methods to be traced (and may even name
  "__special__" methods).

  Module-level functions may also be traced using this decorator.

  *New in version 1.2.0:* automatic yield/stop tracing of Python
  [generator iterators](https://docs.python.org/3/glossary.html#term-generator-iterator)
  (if the [generator](https://docs.python.org/3/glossary.html#term-generator)
  function is traced).

  **`TRACE`**
  The `autologging.TRACE` (level 1) log level is registered with the
  Python `logging` module when Autologging is imported so that tracing
  can be configured and controlled independently of application logging.

  Tracing may be disabled entirely by setting the
  `AUTOLOGGING_TRACED_NOOP` environment variable or by calling the
  `autologging.install_traced_noop()` function.



  A simple logged and traced class:

  ```python
   1 import logging
   2 import sys
   3
   4 from autologging import logged, TRACE, traced
   5
   6 @traced
   7 @logged
   8 class Example:
   9
  10     def __init__(self):
  11         self.__log.info("initialized")
  12
  13     def backwards(self, *words):
  14         for word in words:
  15             yield "".join(reversed(word))
  16
  17
  18 if __name__ == "__main__":
  19     logging.basicConfig(
  20             level=TRACE, stream=sys.stderr,
  21             format="s:s,d:s.s:s")
  22     example = Example()
  23     for result in example.backwards("spam", "eggs"):
  24         print(result)
  ```

  Logging and tracing output:

  ```bash
  $ python example.py
  TRACE:example.py,10:__main__.Example.__init__:CALL *() **{}
  INFO:example.py,11:__main__.Example.__init__:initialized
  TRACE:example.py,11:__main__.Example.__init__:RETURN None
  TRACE:example.py,13:__main__.Example.backwards:CALL *('spam', 'eggs') **{}
  TRACE:example.py,15:__main__.Example.backwards:RETURN <generator object backwards at 0x7fa534d61eb0>
  TRACE:example.py,15:__main__.Example.backwards:YIELD 'maps'
  maps
  TRACE:example.py,15:__main__.Example.backwards:YIELD 'sgge'
  sgge
  TRACE:example.py,15:__main__.Example.backwards:STOP
  ```



  The easiest way to install Autologging is to use
  [pip](https://pip.pypa.io/):

  ```bash
  $ pip install Autologging
  ```



  Clone or fork the repository:

  ```bash
  $ git clone https://github.com/mzipay/Autologging.git
  ```

  Alternatively, download and extract a source .zip or .tar.gz archive
  from https://github.com/mzipay/Autologging/releases,
  https://pypi.python.org/pypi/Autologging or
  https://sourceforge.net/projects/autologging/files/.

  Run the test suite and install the `autologging` module: (make sure you
  have [setuptools](https://pypi.python.org/pypi/setuptools) installed!)

  ```bash
  $ cd Autologging
  $ python setup.py test
  $ python setup.py install
  ```



  Download the Python wheel (.whl) or a Windows installer from
  https://pypi.python.org/pypi/Autologging or
  https://sourceforge.net/projects/autologging/files/.

  (Use [pip](https://pip.pypa.io/) or
  [wheel](https://pypi.python.org/pypi/wheel) to install the .whl.)


pkgId: 07e45cfc18acae7e1972e02faa919252b32f4b2e56179329e528a3618d4c488d
name: python-AutomaPy
arch: src
version: 1.3.5
epoch: 0
release: 1
url: https://pypi.org/project/AutomaPy/
rpm_license: UNKNOWN
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AutomaPy-1.3.5-1.src.rpm
checksum_type: sha256
summary:
  This package refers to the topic of automata theory, which includes DFA, NDFA, Mealy machines, Moore machines, Finite state machine and Turing machine.

description:
  For more information, see the [GitHub Repository](https://github.com/Mohammedvaraliya/AutomaPy).



  [![Supported Python versions](https://img.shields.io/pypi/pyversions/AutomaPy.svg)](https://pypi.python.org/pypi/AutomaPy/)
  [![Total downloads](https://pepy.tech/badge/AutomaPy)](https://pepy.tech/project/AutomaPy)

  The package contains a set of tools and algorithms for theoretical computer science, which could include automata theory as well as other topics.



      pip install AutomaPy





  ```py

  from AutomaPy import EndingWithOneZeroOne

  dfa = EndingWithOneZeroOne()

  print(dfa.check_string("101"))

  ```



  ```py

  from AutomaPy import ThreeConsecutiveOne

  dfa = ThreeConsecutiveOne()

  print(dfa.check_string("111")) # True
  print(dfa.check_string("11100")) # True
  print(dfa.check_string("1100")) # False

  ```



  ```py

  from AutomaPy import Tokenizer

  tokenizer = Tokenizer()

  print(tokenizer.tokenize("This is an example of tokenization."))

  ```



  ```py

  from AutomaPy import DecimalNumberDivisibleByTwo

  dfa = DecimalNumberDivisibleByTwo()

  print(dfa.check_string("111")) # True
  print(dfa.check_string("11100")) # True
  print(dfa.check_string("1001")) # False

  ```



  ```py

  from AutomaPy import EqualNumberOfOneZero

  dfa = EqualNumberOfOneZero()

  print(dfa.check_string("111000")) # True
  print(dfa.check_string("111001")) # False
  print(dfa.check_string("1100")) # True

  ```



  ```py

  from AutomaPy import CountNumberOfOneZero

  dfa = CountNumberOfOneZero()

  print(dfa.check_string("111000")) # True
  print(dfa.check_string("111001")) # False
  print(dfa.check_string("1100")) # True

  ```



  ```py

  from AutomaPy import TuringMachineEvenOnes

  dfa = TuringMachineEvenOnes()

  print(dfa.check_string("101111")) #False because 5 is odd (there is 5 1's)
  print(dfa.check_string("101")) #True because 2 is even (there is 2 1's)

  ```



  ```bash
  AutomaPy --help
  ```


pkgId: d619045b48fb5af7f9f5d1b23500a8a174e33630bb079a588175e07219371c2f
name: python-Automat
arch: src
version: 24.8.1
epoch: 0
release: 1
summary: Self-service finite-state machines for the programmer on the go.
url: https://pypi.org/project/Automat/
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Automat-24.8.1-1.src.rpm
checksum_type: sha256
description:
  [![Documentation Status](https://readthedocs.org/projects/automat/badge/?version=latest)](http://automat.readthedocs.io/en/latest/)
  [![Build Status](https://github.com/glyph/automat/actions/workflows/ci.yml/badge.svg?branch=trunk)](https://github.com/glyph/automat/actions/workflows/ci.yml?query=branch%3Atrunk)
  [![Coverage Status](http://codecov.io/github/glyph/automat/coverage.svg?branch=trunk)](http://codecov.io/github/glyph/automat?branch=trunk)



  Automat is a library for concise, idiomatic Python expression of finite-state
  automata (particularly deterministic finite-state transducers).

  Read more here, or on [Read the Docs](https://automat.readthedocs.io/), or watch the following videos for an overview and presentation



  Sometimes you have to create an object whose behavior varies with its state,
  but still wishes to present a consistent interface to its callers.

  For example, let's say you're writing the software for a coffee machine.  It
  has a lid that can be opened or closed, a chamber for water, a chamber for
  coffee beans, and a button for "brew".

  There are a number of possible states for the coffee machine.  It might or
  might not have water.  It might or might not have beans.  The lid might be open
  or closed.  The "brew" button should only actually attempt to brew coffee in
  one of these configurations, and the "open lid" button should only work if the
  coffee is not, in fact, brewing.

  With diligence and attention to detail, you can implement this correctly using
  a collection of attributes on an object; `hasWater`, `hasBeans`, `isLidOpen`
  and so on.  However, you have to keep all these attributes consistent.  As the
  coffee maker becomes more complex - perhaps you add an additional chamber for
  flavorings so you can make hazelnut coffee, for example - you have to keep
  adding more and more checks and more and more reasoning about which
  combinations of states are allowed.

  Rather than adding tedious `if` checks to every single method to make sure that
  each of these flags are exactly what you expect, you can use a state machine to
  ensure that if your code runs at all, it will be run with all the required
  values initialized, because they have to be called in the order you declare
  them.

  You can read about state machines and their advantages for Python programmers
  in more detail [in this excellent article by Jean-Paul
  Calderone](https://web.archive.org/web/20160507053658/https://clusterhq.com/2013/12/05/what-is-a-state-machine/).



  There are
  [dozens of libraries on PyPI implementing state machines](https://pypi.org/search/?q=finite+state+machine).
  So it behooves me to say why yet another one would be a good idea.

  Automat is designed around this principle: while organizing your code around
  state machines is a good idea, your callers don't, and shouldn't have to, care
  that you've done so.  In Python, the "input" to a stateful system is a method
  call; the "output" may be a method call, if you need to invoke a side effect,
  or a return value, if you are just performing a computation in memory.  Most
  other state-machine libraries require you to explicitly create an input object,
  provide that object to a generic "input" method, and then receive results,
  sometimes in terms of that library's interfaces and sometimes in terms of
  classes you define yourself.

  For example, a snippet of the coffee-machine example above might be implemented
  as follows in naive Python:

  ```python
  class CoffeeMachine(object):
      def brewButton(self) -> None:
          if self.hasWater and self.hasBeans and not self.isLidOpen:
              self.heatTheHeatingElement()
              
  ```

  With Automat, you'd begin with a `typing.Protocol` that describes all of your
  inputs:

  ```python
  from typing import Protocol

  class CoffeeBrewer(Protocol):
      def brewButton(self) -> None:
          "The user pressed the 'brew' button."
      def putInBeans(self) -> None:
          "The user put in some beans."
  ```

  We'll then need a concrete class to contain the shared core of state shared
  among the different states:

  ```python
  from dataclasses import dataclass

  @dataclass
  class BrewerCore:
      heatingElement: HeatingElement
  ```

  Next, we need to describe our state machine, including all of our states.  For
  simplicity's sake let's say that the only two states are `noBeans` and
  `haveBeans`:

  ```python
  from automat import TypeMachineBuilder

  builder = TypeMachineBuilder(CoffeeBrewer, BrewerCore)
  noBeans = builder.state("noBeans")
  haveBeans = builder.state("haveBeans")
  ```

  Next we can describe a simple transition; when we put in beans, we move to the
  `haveBeans` state, with no other behavior.

  ```python

  noBeans.upon(CoffeeBrewer.putInBeans).to(haveBeans).returns(None)
  ```

  And then another transition that we describe with a decorator, one that *does*
  have some behavior, that needs to heat up the heating element to brew the
  coffee:

  ```python
  @haveBeans.upon(CoffeeBrewer.brewButton).to(noBeans)
  def heatUp(inputs: CoffeeBrewer, core: BrewerCore) -> None:
      """
      When we have beans, upon pressing the brew button, we will then not have
      beans any more (as they have been entered into the brewing chamber) and
      our output will be heating the heating element.
      """
      print("Brewing the coffee...")
      core.heatingElement.turnOn()
  ```

  Then we finalize the state machine by building it, which gives us a callable
  that takes a `BrewerCore` and returns a synthetic `CoffeeBrewer`

  ```python
  newCoffeeMachine = builder.build()
  ```

  ```python
  >>> coffee = newCoffeeMachine(BrewerCore(HeatingElement()))
  >>> machine.putInBeans()
  >>> machine.brewButton()
  Brewing the coffee...
  ```

  All of the *inputs* are provided by calling them like methods, all of the
  *output behaviors* are automatically invoked when they are produced according
  to the outputs specified to `upon` and all of the states are simply opaque
  tokens.

rpm_license:
  Copyright (c) 2014 Rackspace  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: f22d8d860c119767d4c6ca89638d85786aa3f66838e214712f71c83d2fc0b6f5
name: python-AutomatiseCA-ddecristofaro
arch: src
version: 0.1.2
epoch: 0
release: 1
summary: An automatic trascription system for Conversational Analysis
url: https://github.com/pypa/sampleproject
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-AutomatiseCA-ddecristofaro-0.1.2-1.src.rpm
checksum_type: sha256
description:
  Domenico De Cristofaro



  AutomatizeCA is an automated transcription program for linguists and conversation analyst experts.

  It is designed to be used for generating Conversation Analysis transcripts that can be improved manually.



  AutomatizeCA takes in a recorded speech and uses a Speech to Text API to generate a time-aligned transcript. It uses a system of functions to detect the pauses between the turns, to assign the speaker lables to the transcripts and to report and replace the backchannels.

  AutomatizeCA renders the final transcript in a txt file including the formats of the Jefferson Transcription System.

  **VERSION: 0.0.1**

  This is a beta version, further implementation will be done in the future.



  **Pre-requisites**

  In order to use AutomatizeCA, you should have some familiarity with using the terminal to install and run programs.

  You should also be aware that AutomatiseCA uses [IBM Watson&#39;s STT API]
  (https://cloud.ibm.com/apidocs/speech-to-text)


pkgId: 92038fefd2371f0f0b891638f9b25f9a9ba025efe8e18f29c19a68f0268b7e92
name: python-Automunge
arch: src
version: 8.33
epoch: 0
release: 1
summary: platform for preparing tabular data for machine learning
url: https://github.com/Automunge/AutoMunge
rpm_license: BSD License
rpm_group: Unspecified
rpm_buildhost: localhost
location_href: Packages/python-Automunge-8.33-1.src.rpm
checksum_type: sha256
description:
  ![image](https://user-images.githubusercontent.com/44011748/76485571-4855b280-63f3-11ea-9574-c39a66e45e4e.png)




  * [Introduction](https://github.com/Automunge/AutoMunge#introduction)
  * [Install, Initialize, and Basics](https://github.com/Automunge/AutoMunge#install-initialize-and-basics)
   ___
  * [automunge(.)](https://github.com/Automunge/AutoMunge#automunge-1)
  * [automunge(.) returned sets](https://github.com/Automunge/AutoMunge#automunge-returned-sets)
  * [automunge(.) passed parameters](https://github.com/Automunge/AutoMunge#automunge-passed-parameters)
   ___
  * [postmunge(.)](https://github.com/Automunge/AutoMunge#postmunge)
  * [postmunge(.) returned sets](https://github.com/Automunge/AutoMunge#postmunge-returned-sets)
  * [postmunge(.) passed parameters](https://github.com/Automunge/AutoMunge#postmunge-passed-parameters)
   ___
  * [Default Transformations](https://github.com/Automunge/AutoMunge#default-transformations)
  * [Library of Transformations](https://github.com/Automunge/AutoMunge#library-of-transformations)
  * [Custom Transformation Functions](https://github.com/Automunge/AutoMunge#custom-transformation-functions)
  * [Custom ML Infill Functions](https://github.com/Automunge/AutoMunge#custom-ml-infill-functions)
  * [Final Model Training](https://github.com/Automunge/AutoMunge#final-model-training)
   ___
  * [Conclusion](https://github.com/Automunge/AutoMunge#conclusion)
   ___


  [Automunge](https://automunge.com) is an open source python library that has formalized and automated the data preparations for tabular learning in between the workflow boundaries of received “tidy data” (one column per feature and one row per sample) and returned dataframes suitable for the direct application of machine learning. Under automation numeric features are normalized, categoric features are binarized, and missing data is imputed. Data transformations are fit to properties of a training set for a consistent basis on any partitioned “validation data” or additional “test data”. When preparing training data, a compact python dictionary is returned recording the steps and parameters of transformation, which then may serve as a key for preparing additional data on a consistent basis.

  > In other words, put simply:<br/>
  >  - **automunge(.)** prepares tabular data for machine learning with encodings, missing data infill, and may channel stochastic perturbations into features<br/>
  >  - **postmunge(.)** consistently prepares additional data very efficiently<br/>
  >
  > We make machine learning easy.

  In addition to data preparations under automation, Automunge may also serve as a platform for engineering data pipelines. An extensive internal library of univariate transformations includes options like numeric translations, bin aggregations, date-time encodings, noise injections, categoric encodings, and even “parsed categoric encodings” in which categoric strings are vectorized based on shared grammatical structure between entries. Feature transformations may be mixed and matched in sets that include generations and branches of derivations by use of our “family tree primitives”. Feature transformations fit to properties of a training set may be custom defined from a very simple template for incorporation into a pipeline. Dimensionality reductions may be applied, such as by principal component analysis, feature importance rankings, or categoric consolidations. Missing data receives “ML infill”, in which models are trained for a feature to impute missing entries based on properties of the surrounding features. Random sampling may be channeled into features as stochastic perturbations.

  Be sure to check out our [Tutorial Notebooks](https://github.com/Automunge/AutoMunge/tree/master/Tutorials). If you are looking for something to cite, our paper [Tabular Engineering with Automunge](https://datacentricai.org/papers/15_CameraReady_TabularEngineering_102621_Final.pdf) was accepted to the Data-Centric AI workshop at NeurIPS 2021.



  Automunge is now available for pip install:

  ```
  pip install Automunge
  ```
  Or to upgrade:
  ```
  pip install Automunge --upgrade
  ```

  Once installed, run this in a local session to initialize:

  ```
  from Automunge import *
  am = AutoMunge()
  ```

  Where e.g. for train set processing  with default parameters run:

  ```
  train, train_ID, labels, \
  val, val_ID, val_labels, \
  test, test_ID, test_labels, \
  postprocess_dict = \
  am.automunge(df_train)
  ```
  Importantly, if the df_train set passed to automunge(.) includes a column
  intended for use as labels, it should be designated with the labels_column
  parameter.

  Or for subsequent consistent processing of train or test data, using the
  dictionary returned from original application of automunge(.), run:

  ```
  test, test_ID, test_labels, \
  postreports_dict = \
  am.postmunge(postprocess_dict, df_test)
  ```

  I find it helpful to pass these functions with the full range of arguments
  included for reference, thus a user may simply copy and past this form.

  ```


  train, train_ID, labels, \
  val, val_ID, val_labels, \
  test, test_ID, test_labels, \
  postprocess_dict = \
  am.automunge(df_train, df_test = False,
               labels_column = False, trainID_column = False, testID_column = False,
               valpercent=0.0, floatprecision = 32, cat_type = False, shuffletrain = True, noise_augment = 0,
               dupl_rows = False, TrainLabelFreqLevel = False, powertransform = False, binstransform = False,
               MLinfill = True, infilliterate=1, randomseed = False, eval_ratio = .5,
               numbercategoryheuristic = 255, pandasoutput = 'dataframe', NArw_marker = True,
               featureselection = False, featurethreshold = 0., inplace = False, orig_headers = False,
               Binary = False, PCAn_components = False, PCAexcl = [], excl_suffix = False,
               ML_cmnd = {'autoML_type':'randomforest',
                          'MLinfill_cmnd':{'RandomForestClassifier':{}, 'RandomForestRegressor':{}},
                          'PCA_type':'default',
                          'PCA_cmnd':{}},
               assigncat = {'1010':[], 'onht':[], 'ordl':[], 'bnry':[], 'hash':[], 'hsh2':[],
                            'DP10':[], 'DPoh':[], 'DPod':[], 'DPbn':[], 'DPhs':[], 'DPh2':[],
                            'nmbr':[], 'mnmx':[], 'retn':[], 'DPnb':[], 'DPmm':[], 'DPrt':[],
                            'bins':[], 'pwr2':[], 'bnep':[], 'bsor':[], 'por2':[], 'bneo':[],
                            'ntgr':[], 'srch':[], 'or19':[], 'tlbn':[], 'excl':[], 'exc2':[]},
               assignparam = {'global_assignparam'  : {'(parameter)': 42},
                              'default_assignparam' : {'(category)' : {'(parameter)' : 42}},
                                       '(category)' : {'(column)'   : {'(parameter)' : 42}}},
               assigninfill = {'stdrdinfill':[], 'MLinfill':[], 'zeroinfill':[], 'oneinfill':[],
                               'adjinfill':[], 'meaninfill':[], 'medianinfill':[], 'negzeroinfill':[],
                               'interpinfill':[], 'modeinfill':[], 'lcinfill':[], 'naninfill':[]},
               assignnan = {'categories':{}, 'columns':{}, 'global':[]},
               transformdict = {}, processdict = {}, evalcat = False, ppd_append = False,
               entropy_seeds = False, random_generator = False, sampling_dict = False,
               privacy_encode = False, encrypt_key = False, printstatus = 'summary', logger = {})
  ```

  Please remember to save the automunge(.) returned object postprocess_dict
  such as using pickle library, which can then be later passed to the postmunge(.)
  function to consistently prepare subsequently available data.

  ```



  import pickle
  with open('filename.pickle', 'wb') as handle:
    pickle.dump(postprocess_dict, handle, protocol=pickle.HIGHEST_PROTOCOL)


  import pickle
  with open('filename.pickle', 'rb') as handle:
    postprocess_dict = pickle.load(handle)




  ```

  We can then apply the postprocess_dict saved from a prior application of automunge
  for consistent processing of additional data.
  ```



  test, test_ID, test_labels, \
  postreports_dict = \
  am.postmunge(postprocess_dict, df_test,
               testID_column = False,
               pandasoutput = 'dataframe', printstatus = 'summary',
               dupl_rows = False, TrainLabelFreqLevel = False,
               featureeval = False, traindata = False, noise_augment = 0,
               driftreport = False, inversion = False,
               returnedsets = True, shuffletrain = False,
               entropy_seeds = False, random_generator = False, sampling_dict = False,
               randomseed = False, encrypt_key = False, logger = {})
  ```

  The functions accept pandas dataframe or numpy array input and return encoded dataframes
  with consistent order of columns between train and test data.
  (For input numpy arrays any label column should be positioned as final column in set.)
  The functions return data with categoric features translated to numerical encodings
  and normalized numeric such as to make them suitable for direct application to a
  machine learning model in the framework of a user's choice, including sets for
  the various activities of a generic machine learning project such as training (train),
  validation (val), and inference (test). The automunge(.) function also returns a
  python dictionary (the "postprocess_dict") that can be used as a key to prepare additional
  data with postmunge(.).

  When left to automation, automunge(.) evaluates properties of a feature to select
  the type of encoding, for example whether a column is numeric, categoric, high cardinality,
  binary, date time, etc. Alternately, a user can
  assign specific processing functions to distinct columns (via assigncat parameter) -
  which may be pulled from the internal [Library of Transformations](https://github.com/Automunge/AutoMunge#library-of-transformations) or alternately [custom
  defined](https://github.com/Automunge/AutoMunge#custom-transformation-functions).

  The feature engineering transformations are recorded with suffixes
  appended to the column header title in the returned sets, for one example the
  application of z-score normalization returns a column with header origname + '\_nmbr'.
  As another example, for binary encoded sets the set of columns are returned with
  header origname + '\_1010_#' where # is integer to distinguish columns in same set.
  In most cases, the suffix appenders are derived from the transformation category
  identifier (which is by convention a 4 letter string).

  The default transforms applied under automation are detailed below in section
  [Default Transforms](https://github.com/Automunge/AutoMunge#default-transformations).
  Missing data receives ML infill (defaulting to random forest models) and missing marker aggregation.
  Other features of the library are detailed in the [tutorial notebooks](https://github.com/Automunge/AutoMunge/tree/master/Tutorials)
  and with their associated parameters below.

  Other options available in the library include feature importance (via featureselection parameter),
  oversampling (via the TrainLabelFreqLevel parameter), dimensionality reductions (via PCAn_components, Binary, or featurethreshold parameters), and stochastic perturbations (by the DP family of transformations detailed in the library of transformations and tutorials). Further detail provided with parameter writeups below.

  Note that there is a potential source of error if the returned column header
  title strings, which will include suffix appenders based on transformations applied,
  match any of the original column header titles passed to automunge. This is an edge
  case not expected to occur in common practice and will return error message at
  conclusion of printouts and a logged validation result as postprocess_dict['miscparameters_results']['suffixoverlap_aggregated_result']. This channel can
  be eliminated by omitting the underscore character in received column headers.

  Please note that we consider the postmunge(.) latency a key performance
  metric since it is the function that may be called under repetition in production.
  The automunge(.) latency can be improved by manual assignment of root categories with the assigncat parameter
  or by deactivating ML infill with the MLinfill parameter.



  The application of the automunge and postmunge functions requires the
  assignment of the function to a series of named sets. We suggest using
  consistent naming convention as follows:

  ```

  from Automunge import *
  am = AutoMunge()


  train, train_ID, labels, \
  val, val_ID, val_labels, \
  test, test_ID, test_labels, \
  postprocess_dict = \
  am.automunge(df_train)
  ```

  The full set of parameters available to be passed are given here, with
  explanations provided below:

  ```

  from Automunge import *
  am = AutoMunge()




  train, train_ID, labels, \
  val, val_ID, val_labels, \
  test, test_ID, test_labels, \
  postprocess_dict = \
  am.automunge(df_train, df_test = False,
               labels_column = False, trainID_column = False, testID_column = False,
               valpercent=0.0, floatprecision = 32, cat_type = False, shuffletrain = True, noise_augment = 0,
               dupl_rows = False, TrainLabelFreqLevel = False, powertransform = False, binstransform = False,
               MLinfill = True, infilliterate=1, randomseed = False, eval_ratio = .5,
               numbercategoryheuristic = 255, pandasoutput = 'dataframe', NArw_marker = True,
               featureselection = False, featurethreshold = 0., inplace = False, orig_headers = False,
               Binary = False, PCAn_components = False, PCAexcl = [], excl_suffix = False,
               ML_cmnd = {'autoML_type':'randomforest',
                          'MLinfill_cmnd':{'RandomForestClassifier':{}, 'RandomForestRegressor':{}},
                          'PCA_type':'default',
                          'PCA_cmnd':{}},
               assigncat = {'1010':[], 'onht':[], 'ordl':[], 'bnry':[], 'hash':[], 'hsh2':[],
                            'DP10':[], 'DPoh':[], 'DPod':[], 'DPbn':[], 'DPhs':[], 'DPh2':[],
                            'nmbr':[], 'mnmx':[], 'retn':[], 'DPnb':[], 'DPmm':[], 'DPrt':[],
                            'bins':[], 'pwr2':[], 'bnep':[], 'bsor':[], 'por2':[], 'bneo':[],
                            'ntgr':[], 'srch':[], 'or19':[], 'tlbn':[], 'excl':[], 'exc2':[]},
               assignparam = {'global_assignparam'  : {'(parameter)': 42},
                              'default_assignparam' : {'(category)' : {'(parameter)' : 42}},
                                       '(category)' : {'(column)'   : {'(parameter)' : 42}}},
               assigninfill = {'stdrdinfill':[], 'MLinfill':[], 'zeroinfill':[], 'oneinfill':[],
                               'adjinfill':[], 'meaninfill':[], 'medianinfill':[],
                               'interpinfill':[], 'modeinfill':[], 'lcinfill':[], 'naninfill':[]},
               assignnan = {'categories':{}, 'columns':{}, 'global':[]},
               transformdict = {}, processdict = {}, evalcat = False, ppd_append = False,
               entropy_seeds = False, random_generator = False, sampling_dict = False,
               privacy_encode = False, encrypt_key = False, printstatus = 'summary', logger = {})
  ```

  Or for the postmunge function:

  ```




  from Automunge import *
  am = AutoMunge()


  test, test_ID, test_labels, \
  postreports_dict = \
  am.postmunge(postprocess_dict, df_test)
  ```

  With the full set of arguments available to be passed as:

  ```

  from Automunge import *
  am = AutoMunge()





  test, test_ID, test_labels, \
  postreports_dict = \
  am.postmunge(postprocess_dict, df_test,
               testID_column = False,
               pandasoutput = 'dataframe', printstatus = 'summary', inplace = False,
               dupl_rows = False, TrainLabelFreqLevel = False,
               featureeval = False, traindata = False, noise_augment = 0,
               driftreport = False, inversion = False,
               returnedsets = True, shuffletrain = False,
               entropy_seeds = False, random_generator = False, sampling_dict = False,
               randomseed = False, encrypt_key = False, logger = {})
  ```

  Note that the only required argument to the automunge function is the
  train set dataframe, the other arguments all have default values if
  nothing is passed. The postmunge function requires as minimum the
  postprocess_dict object (a python dictionary returned from the application of
  automunge) and a dataframe test set consistently formatted as those sets
  that were originally applied to automunge.

  ...

  Here now are descriptions for the returned sets from automunge, which
  will be followed by descriptions of the parameters which can be passed to
  the function, followed by similar treatment for postmunge returned sets
  and arguments. Further below is documentation for the library of transformations.

  ...



  Automunge defaults to returning data sets as pandas dataframes, or for
  single column sets as pandas series.

  For dataframes, data types of returned columns are based on the transformation applied,
  for example columns with boolean integers are cast as int8, ordinal encoded
  columns are given a conditional type based on the size of encoding space as either
  uint8, uint16, or uint32. Continuous sets are cast as float16, float32, or float64
  based on the automunge(.) floatprecision parameter. And direct passthrough columns
  via excl transform retain the received data type.

  * train: a numerically encoded set of data intended to be used to train a
  downstream machine learning model in the framework of a user's choice

  * train_ID: the set of ID values corresponding to the train set if a ID
  column(s) was passed to the function. This set may be useful if the shuffle
  option was applied. Note that an ID column may serve multiple purposes such
  as row identifiers or for pairing tabular data rows with a corresponding
  image file for instance. Also included in this set is a derived column
  titled 'Automunge_index', this column serves as an index identifier for order
  of rows as they were received in passed data, such as may be beneficial
  when data is shuffled. If the received df_train had a non-ranged integer index,
  it is extracted and returned in this set. For more information please refer to writeup for the
  trainID_column parameter.

  * labels: a set of numerically encoded labels corresponding to the
  train set if a label column was passed. Note that the function
  assumes the label column is originally included in the train set. Note
  that if the labels set is a single column a returned dataframe is flattened
  to a pandas Series or a returned Numpy array is also
  flattened (e.g. [[1,2,3]] converted to [1,2,3] ).

  * val: a set of training data carved out from the train set
  that is intended for use in hyperparameter tuning of a downstream model.

  * val_ID: the set of ID values corresponding to the val
  set. Comparable to columns returned in train_ID.

  * val_labels: the set of labels corresponding to the val
  set

  * test: the set of features, consistently encoded and normalized as the
  training data, that can be used to generate predictions from a
  downstream model trained with train. Note that if no test data is
  available during initial address this processing will take place in the
  postmunge(.) function.

  * test_ID: the set of ID values corresponding to the test set. Comparable
  to columns returned in train_ID unless otherwise specified. For more
  information please refer to writeup for the testID_column parameter.

  * test_labels: a set of numerically encoded labels corresponding to the
  test set if a label column was passed.

  * postprocess_dict: a returned python dictionary that includes
  normalization parameters and trained ML infill models used to
  generate consistent processing of additional train or test data such as
  may not have been available at initial application of automunge. It is
  recommended that this dictionary be externally saved on each application
  used to train a downstream model so that it may be passed to postmunge(.)
  to consistently process subsequently available test data, such as
  demonstrated with the pickle library above.

  A few useful entries in the postprocess_dict include:
  - postprocess_dict['finalcolumns_train']: list of returned column headers for train set including suffix appenders
  - postprocess_dict['columntype_report']: a report classifying the returned column types, including lists of all categoric and all numeric returned columns
  - postprocess_dict['column_map']:  a report mapping the input columns to their associated returned columns (excluding those consolidated as part of a dimensionality reduction). May be useful to inspect sets returned for a specific feature e.g. train[postprocess_dict['column_map']['input_column_header']]
  - postprocess_dict['FS_sorted]: sorted results of feature importance evaluation if elected
  - postprocess_dict['miscparameters_results']: reporting results of validation tests performed on parameters and passed data

  ...



  ```
  train, train_ID, labels, \
  val, val_ID, val_labels, \
  test, test_ID, test_labels, \
  postprocess_dict = \
  am.automunge(df_train, df_test = False,
               labels_column = False, trainID_column = False, testID_column = False,
               valpercent=0.0, floatprecision = 32, cat_type = False, shuffletrain = True, noise_augment = 0,
               dupl_rows = False, TrainLabelFreqLevel = False, powertransform = False, binstransform = False,
               MLinfill = True, infilliterate=1, randomseed = False, eval_ratio = .5,
               numbercategoryheuristic = 255, pandasoutput = 'dataframe', NArw_marker = True,
               featureselection = False, featurethreshold = 0., inplace = False, orig_headers = False,
               Binary = False, PCAn_components = False, PCAexcl = [], excl_suffix = False,
               ML_cmnd = {'autoML_type':'randomforest',
                          'MLinfill_cmnd':{'RandomForestClassifier':{}, 'RandomForestRegressor':{}},
                          'PCA_type':'default',
                          'PCA_cmnd':{}},
               assigncat = {'1010':[], 'onht':[], 'ordl':[], 'bnry':[], 'hash':[], 'hsh2':[],
                            'DP10':[], 'DPoh':[], 'DPod':[], 'DPbn':[], 'DPhs':[], 'DPh2':[],
                            'nmbr':[], 'mnmx':[], 'retn':[], 'DPnb':[], 'DPmm':[], 'DPrt':[],
                            'bins':[], 'pwr2':[], 'bnep':[], 'bsor':[], 'por2':[], 'bneo':[],
                            'ntgr':[], 'srch':[], 'or19':[], 'tlbn':[], 'excl':[], 'exc2':[]},
               assignparam = {'global_assignparam'  : {'(parameter)': 42},
                              'default_assignparam' : {'(category)' : {'(parameter)' : 42}},
                                       '(category)' : {'(column)'   : {'(parameter)' : 42}}},
               assigninfill = {'stdrdinfill':[], 'MLinfill':[], 'zeroinfill':[], 'oneinfill':[],
                               'adjinfill':[], 'meaninfill':[], 'medianinfill':[], 'negzeroinfill':[],
                               'interpinfill':[], 'modeinfill':[], 'lcinfill':[], 'naninfill':[]},
               assignnan = {'categories':{}, 'columns':{}, 'global':[]},
               transformdict = {}, processdict = {}, evalcat = False, ppd_append = False,
               entropy_seeds = False, random_generator = False, sampling_dict = False,
               privacy_encode = False, encrypt_key = False, printstatus = 'summary', logger = {})
  ```

  * df_train: a pandas dataframe or numpy array containing a structured
  dataset intended for use to subsequently train a machine learning model.
  The set at a minimum should be 'tidy' meaning a single column per feature
  and a single row per observation, with all unique string column headers. If
  desired the set may include one are more
  "ID" columns (intended to be carved out and consistently shuffled or partitioned
  such as an index column) and zero or one column intended to be used as labels
  for a downstream training operation. The tool supports the inclusion of
  non-index-range column as index or multicolumn index (requires named index
  columns). Such index types are added to the returned "ID" sets which are
  consistently shuffled and partitioned as the train and test sets. For passed
  numpy array any label column should be the final column.

  * df_test: a pandas dataframe or numpy array containing a structured
  dataset intended for use to generate predictions from a downstream machine
  learning model trained from the automunge returned sets. The set must be
  consistently formatted as the train set with consistent column headers and
  order of columns. (This set may optionally contain a labels column if one
  was included in the train set although its inclusion is not required). If
  desired the set may include one or more ID column(s) or column(s) intended
  for use as labels. A user may pass False if this set is not available. The tool
  supports the inclusion of non-index-range column as index or multicolumn index
  (requires named index columns). Such index types are added to the returned
  "ID" sets which are consistently shuffled and partitioned as the train and
  test sets.

  * labels_column: a string of the column title for the column from the
  df_train set intended for use as labels in training a downstream machine
  learning model. The function defaults to False for cases where the
  train set does not include a label column. An integer column index may
  also be passed such as if the source dataset was a numpy array. A user can
  also pass True in which case the label set will be taken from the final
  column of the train set (including cases of single column in train set).
  A label column for df_train data is partitioned and returned in the labels set.
  Note that a designated labels column will automatically be checked for in
  corresponding df_test data and partitioned to the returned test_labels set when
  included. Note that labels_column can also be passed as a list of multiple
  label columns. Note that when labels_column is passed as a list, a first entry
  set bracket specification comparable to as available for the Binary parameter
  can be applied to designate that multiple categoric labels in the list may be consolidated to a
  single categoric label, such as to train a single classification model for multiple classification targets,
  which form may then be recovered in a postmunge inversion='labels' operation, such as to convert the
  consolidated form after an inference operation back to the form of separate inferred labels.
  When passing data as numpy arrays the label column needs to be the final column (on far right of dataframe).

  * trainID_column:  defaults to False, user can pass a column header or list of column headers
  for columns that are to be segregated from the df_train set for return in the train_ID
  set (consistently shuffled and partitioned when applicable). For example this may
  be desired for an index column or any other column that the user wishes to exclude from
  the ML infill basis. Defaults to False for cases where no ID columns are desired. Note
  that when designating ID columns for df_train if that set of ID columns is present in df_test
  they will automatically be given comparable treatment unless otherwise specified. An integer
  column index or list of integer column indexes may also be passed such as if the source dataset
  was a numpy array. Note that the returned ID sets (such as train_ID, val_ID, and test_ID) are automatically
  populated with an additional column with header 'Automunge_index' which may serve as an
  index column in cases of shuffling, validation partitioning, or oversampling. In cases of unnamed
  non-range integer indexes, they are automatically extracted and returned in the ID sets as 'Orig_index'.
  If a user would like to include a column both in the features for encoding and the ID sets for original form
  retention, they can pass trainID_column as a list of two lists, e.g. [list1, list2], where the first
  list may include ID columns to be struck from the features and the second list may include ID columns
  to be retained in the features.

  * testID_column: defaults to False, user can pass a column header or list of column headers
  for columns that are to be segregated from the df_test set for return in the test_ID
  set (consistently shuffled and partitioned when applicable). For example this may
  be desired for an index column or any other column that the user wishes to exclude from
  the ML infill basis. Defaults to False, which can be used for cases where the df_test
  set does not contain any ID columns, or may also be passed as the default of False when
  the df_test ID columns match those passed in the trainID_column parameter,
  in which case they are automatically given comparable treatment. Thus, the primary intended use
  of the testID_column parameter is for cases where a df_test has ID columns
  different from those passed with df_train. Note that an integer column index
  or list of integer column indexes may also be passed such as if the source dataset was a numpy array.
  (When passing data as numpy arrays one should match ID partitioning between df_test and df_train.) In cases of unnamed
  non-range integer indexes, they are automatically extracted and returned in the ID sets as 'Orig_index'.
  If a user would like to include a column both in the features for encoding and the ID sets for original form
  retention, they can pass testID_column as a list of two lists, e.g. [list1, list2], where the first
  list may include ID columns to be struck from the features and the second list may include ID columns
  to be retained in the features. (We recommend only using testID_column specification for cases where df_test
  includes columns that aren't present in df_train, otehrwise it is automatic.)

  * valpercent: a float value between 0 and 1 which designates the percent
  of the training data which will be set aside for the validation
  set (generally used for hyperparameter tuning of a downstream model).
  This value defaults to 0 for no validation set returned. Note that when
  shuffletrain parameter is activated (which is default for train sets) validation
  sets will contain random rows.  If shuffletrain parameter is set to False then any
  validation set will be pulled from the bottom sequential rows of the df_train dataframe.

  valpercent can also be passed as a two entry tuple in the form valpercent=(start, end),
  where start is a float in the range 0<=start<1, end is a float in the range 0<end<=1, and start < end.
  For example, if specified as valpercent=(0.2, 0.4), the returned training data would consist of the first 20% of rows and the last 60% of rows, while the validation set would consist of the remaining rows, and
  where the train and validation sets may then be subsequently individually shuffled when activated by the shuffletrain parameter. The purpose of this valpercent tuple option is to support integration into a cross validation operation, for example for a cross validation with k=3, automunge(.) could be called three times with valpercent passed for each as (0,0.33), (0.33,0.66), (0.66,1) respectively. Please note that when using automunge(.) in a cross-validation operation, we recommend using the postprocess_dict['final_assigncat'] entry populated in the first automunge(.) call associated with the first train/validation split as the assigncat entry passed to the automunge(.) assigncat parameter in each subsequent automunge(.) call associated with the remaining train/validation splits, which will speed up the remaining calls by eliminating the automated evaluation of data properties as well as mitigate risk of (remote) edge case when category assignment to a column under automation may differ between different validation set partitions due to deviations in aggregate data properties associated with a column.
  ```

  k=3
  for i in range(k):
    print('processing fold #', i)

    
    valpercent = (i/k, (i+1)/k)

    if i == 0:
      
      assigncat = {}
    elif i > 0:
      
      
      
      assigncat = postprocess_dict['final_assigncat']

    train, train_ID, labels, \
    val, val_ID, val_labels, \
    test, test_ID, test_labels, \
    postprocess_dict = \
    am.automunge(df_train,
                 labels_column = labels_column,
                 valpercent = valpercent,
                 assigncat = assigncat)

    














  ```

  * floatprecision: an integer with acceptable values of _16/32/64_ designating
  the memory precision for returned float values. (A tradeoff between memory
  usage and floating point precision, smaller for smaller footprint.)
  This currently defaults to 32 for 32-bit precision of float values. Note
  that there may be energy efficiency benefits at scale to basing this to 16.
  Note that integer data types are still retained with this option.

  * cat_type: accepts boolean defaulting to False, when True returned integer encoded categoric
  features are converted to pandas categorical data type based on the transform's MLinfill_type.
  In some cases this may actually slightly increase dataframe memory usage and
  is redundant with information stored in the postprocess_dict, however we expect there
  are potential downstream workflows where a user may prefer categoric data type which
  is the reason for the option. Note that for cases where a categoric transform feature
  did not have full representation in the training data set (e.g. as could be the case for fixed width bins with bnwd/bnwo/variants),
  it is possible that this option will result in test data returned with missing values designated
  as NaN entries (which is partly why this is not the default). Note that this same basis is carried through to postmunge.

  * shuffletrain: can be passed as one of _{True, False, 'traintest'}_ which
  indicates if the returned sets will have their rows shuffled. Defaults to True
  for shuffling the train data but not the test data. False deactivates. To shuffle
  both train and test data can pass as 'traintest'. Note that this impacts the
  validation split if a valpercent was passed, where under the default of True
  validation data will be randomly sampled and shuffled, or when shuffletrain is
  deactivated validation data will be based on a partition of sequential rows from
  the bottom of the train set. Note that row correspondence with shuffling is
  maintained between train / ID / label sets. Note that we recommend deactivating
  shuffletrain for sequential (time-series) data.

  * noise_augment: accepts type int or float(int) >=0, defaults to 0. Used to specify
  a count of additional duplicates of training data prepared and concatenated with the
  original train set. Intended for use in conjunction with noise injection, such that
  the increased size of training corpus can be a form of data augmentation. (Noise injection
  still needs to be assigned, e.g. by assigning root categories in assigncat or could
  turn on automated noise with powertransform = 'DP1'). Note that
  injected noise will be uniquely randomly sampled with each duplicate. When noise_augment
  is received as a dtype of int, one of the duplicates will be prepared without noise. When
  noise_augment is received as a dtype of float(int), all of the duplicates will be prepared
  with noise. When shuffletrain is activated the duplicates are collectively shuffled, and can distinguish
  between duplicates by the original df_train.shape in comparison to the ID set's Automunge_index.
  Please be aware that with large dataframes a large duplicate count may run into memory constraints,
  in which case additional duplicates can be prepared separately in postmunge(.). Note that the entropy seed budget only accounts for preparing one set of data, for the noise_augment option with entropy seeding we recommend passing a custom extra_seed_generator with a sampling_type specification, which will result in internal samplings of additional entropy seeds for each additional noise_augment duplicate (or for the bulk_seeds case with external sampling can increase entropy_seed budget proportional to the number of additional duplicates with noise).

  * dupl_rows: can be passed as _(True/False/'traintest'/'test')_ which indicates
  if duplicate rows will be consolidated to single instance in returned sets. (In
  other words, if same row included more than once, it will only be returned once.)
  Defaults to False for not activated. True applies consolidation to train set only,
  'test' applies consolidation to test set only, 'traintest' applies consolidation
  to both train and test sets separately. Note this is applied prior to
  TrainLabelFreqLevel if elected. As implemented this does not take into account
  duplicate rows in train/test data which have different labels, only one version
  of features/label pair is returned.

  * TrainLabelFreqLevel: can be passed as _(True/False/'traintest'/'test')_
  which indicates if the TrainLabelFreqLevel method will be applied to prepare for
  oversampling training data associated with underrepresented labels (aka class
  imbalance). The method adds multiples of training data rows for those labels with
  lower frequency resulting in an (approximately) levelized frequency. This defaults
  to False. Note that this feature may be applied to numerical label sets if
  the processing applied to the set includes aggregated bins, such as for example
  by passing a label column to the 'exc3' category in assigncat for pass-through
  force to numeric with inclusion of standard deviation bins or to 'exc4' for
  inclusion of powers of ten bins. For cases where labels are included in the
  test set, this may also be passed as _'traintest'_ to apply levelizing to both
  train and test sets or be passed as _'test'_ to only apply levelizing to test set.
  (If a label set includes multiple configurations of the labels, the levelizing
  will be based on the first categoric / binned set (either one-hot or ordinal)
  based on order of columns.) For more on the class imbalance problem see "A
  systematic study of the class imbalance problem in convolutional neural
  networks" - Buda, Maki, Mazurowski.

  * powertransform: _(False/True/'excl'/'exc2'/'infill'/'infill2'/'DP1'/'DP2'/'DT1'/'DT2'/'DB1'/'DB2')_, defaults to False.
  The powertransform parameter is used to select between options for derived
  category assignments under automation based on received feature set properties.
    - Under the default scenario, category assignments under automation are consistent with section
    [Default Transformations](https://github.com/Automunge/AutoMunge#default-transformations).
    - Under the True scenario, an evaluation will be performed of distribution properties to select between
    box-cox (bxcx), z-score (nmbr), min-max scaling (mnmx), or mean absolute deviation scaling (MAD3) normalization
    of numerical data. Please note that under automation label columns do not receive this treatment, if desired they can be assigned to category ptfm in assigncat.
    - Under the 'excl' scenario, columns not explicitly assigned in assigncat are subject to excl transform
    for full pass-through, including data type retention and exclusion from ML infill basis.
    - Under the 'exc2' scenario, columns not explicitly assigned in assigncat are subject to exc2 transform
    for pass-through with force to numeric and adjinfill, and included in ML infill basis.
    - The 'infill' scenario may be used when data is already numerically encoded and user just desires
    ML infill without transformations. 'infill' treats sets with any non-integer
    floats with exc2 (pass-through numeric), integer sets with any negative entries or unique ratio >0.75 with exc8
    (for pass-through continuous integer sets subject to ml infill regression), and otherwise
    integer sets with exc5 (pass-through integer subject to ml infill classification). Of course the rule of treating
    integer sets with >0.75 ratio of unique entries as targets for ML infill regression or otherwise
    for classification is an imperfect heuristic. If some particular
    feature set has integers intended for regression below this threshold, the defaults under
    automation can be overwritten to a specific column with the assigncat parameter, such as to
    assign the column to exc8 instead of exc5. Note that 'infill'
    includes support for NArw aggregation with NArw_marker parameter.
    - The 'infill2' scenario is similar to the 'infill' scenario, with added allowance for inclusion of
    non-numeric sets, which are given an excl pass-through and excluded from ML infill basis. (May return sets not suitable for direct application of ML.)
  DP1 and DP2 are used for defaulting to noise injection for numeric and (non-hashed) categoric
    - 'DP1' is similar to the defaults but default numerical replaced with DPnb, categoric with DP10, binary with DPbn, hash with DPhs, hsh2 with DPh2 (labels do not receive noise in this configuration)
    - 'DP2' is similar to the defaults but default numerical replaced with DPrt, categoric with DPod, binary with DPbn, hash with DPhs, hsh2 with DPh2 (labels do not receive noise in this configuration)
    - 'DT1'/'DT2' are comparable to 'DP1'/'DP2' but inject noise to just test data instead of just train data
    - 'DB1'/'DB2' are comparable to 'DP1'/'DP2' but inject noise to both train and test data instead of just train data

  * binstransform: a boolean identifier _(True/False)_ which indicates if all
  default numerical sets will receive bin processing such as to generate child
  columns with boolean identifiers for number of standard deviations from
  the mean, with groups for values <-2, -2-1, -10, 01, 12, and >2. This value
  defaults to False.

  * MLinfill: a boolean identifier _(True/False)_ defaulting to True which indicates if the ML
  infill method will be applied (to columns not otherwise designated in assigninfill) to predict infill for missing
  or improperly formatted data using machine learning models trained on the
  rest of the df\_train set. ML infill may alternatively
  be assigned to distinct columns in assigninfill when MLinfill passed as False. Note that even if sets passed
  to automunge(.) have no points needing infill, when activated ML infill models will still be trained for potential use
  to subsequent data passed through postmunge(.). ML infill
  by default applies scikit-learn random forest machine learning models to predict infill,
  which may be changed to other available auto ML frameworks via the ML_cmnd parameter.
  Parameters and tuning may also be passed to the model training as demonstrated
  with ML_cmnd parameter below. Order of infill model training is based on a
  reverse sorting of columns by count of missing entries in the df_train set.
  (As a helpful hint, if data is already numerically encoded and just want to perform
  ML infill without preprocessing transformations, can pass in conjunction parameter
  powertransform = 'infill')

  To bidirectionally exclude particular features from each other's imputation model bases
  (such as may be desired in expectation of data leakage), a user can designate via
  entries to ML_cmnd['leakage_sets'], documented further below with ML_cmnd parameter.
  Or to unidirectionally exclude features from another's basis, a user can designate
  via entries to ML_cmnd['leakage_dict'], also documented below. To exclude a feature from
  all ML infill and PCA basis, can pass as entries to a list in ML_cmnd['full_exclude'].
  Please note that columns returned from transforms with MLinfilltype 'totalexclude' (such as
  for the excl passthrough transform) are automatically excluded from ML infill basis.

  Please note that an assessment is performed to evaluate for cases of a kind of data
  leakage across features associated with correlated presence of missing data
  across rows for exclusion, documented further below with ML_cmnd parameter. This assessment
  can be deactivated by passing ML_cmnd['leakage_tolerance'] = False.

  Please note that for incorporating stochastic injections into the derived imputations, an
  option is on by default which is further documented below in the ML_cmnd entries for 'stochastic_impute_categoric'
  and 'stochastic_impute_numeric'. Please note that by default the random seed passed to model
  training is stochastic between applications, as further documented below in the ML_cmnd entry for
  'stochastic_training_seed'.

  Further detail on ML infill provided in the paper [Missing Data Infill with Automunge](https://medium.com/automunge/missing-data-infill-with-automunge-ec94d6b13433).

  * infilliterate: an integer indicating how many applications of the ML
  infill processing are to be performed for purposes of predicting infill.
  The assumption is that for sets with high frequency of missing values
  that multiple applications of ML infill may improve accuracy although
  note this is not an extensively tested hypothesis. This defaults to 1.
  Note that due to the sequence of model training / application, a comparable
  set prepared in automunge and postmunge with this option may vary slightly in
  output (as automunge(.) will train separate models on each iteration and
  postmunge will just apply the final model on each iteration).

  Please note that early stopping is available for infilliterate based on a comparison
  on imputations of a current iteration to the preceding, with a halt when reaching both
  of tolerances associated with numeric features in aggregate and categoric
  features in aggregate.
  Early stopping evaluation can be activated by passing to ML_cmnd
  ML_cmnd['halt_iterate']=True. The tolerances can be updated from the shown defaults
  as ML_cmnd['categoric_tol']=0.05 and ML_cmnd['numeric_tol']=0.03. Further detail
  on early stopping criteria is that the numeric halting criteria is based on comparing
  for each numeric feature the ratio of mean(abs(delta)) between imputation iterations to
  the mean(abs(entries)) of the current iteration, which are then weighted between features
  by the quantity of imputations associated with each feature and compared to a numeric
  tolerance value, and the categoric halting criteria is based on comparing the ratio of
  number of inequal imputations between iterations to the total number of imputations across
  categoric features to a categoric tolerance value. Early stopping is applied as soon as
  the tolerances are met for both numeric and categoric features. If early stopping criteria
  is not reached the specified infilliterate will serve as the maximum number of iterations.
  (Be aware that stochastic noise from stochastic_impute_numeric
  and stochastic_impute_categoric has potential to interfere with early stopping criteria.
  Each of these can be deactivated in ML_cmnd if desired.)

  * randomseed: defaults as False, also accepts integers within 0:2\*\*31-1. When not specified,
  randomseed is based on a uniform randomly sampled integer within that range using an entropy_seeds when available.
  Can be manually specified such as for repeatable data set shuffling, feature importance, and other algorithms.
  Although ML infill by default samples a new random seed with each model training, to apply this random seed
  to all model training operations can set a ML_cmnd entry as ML_cmnd['stochastic_training_seed']=False.

  * eval_ratio: a 0-1 float or integer for number of rows, defaults to 0.5, serves
  to reduce the overhead of the category evaluation functions under automation by only
  evaluating this sampled ratio of rows instead from the full set. Makes automunge faster.
  To accommodate small data sets, the convention is that eval_ratio is only applied
  when training set has > 2,000 rows.

  * numbercategoryheuristic: an integer used as a heuristic. When a
  categorical set has more unique values than this heuristic, it defaults
  to categorical treatment via hashing processing via 'hsh2', otherwise
  categorical sets default to binary encoding via '1010'. This defaults to 255.
  Heuristic can be deactivated by passing as False.

  * pandasoutput: selects format of returned sets. Defaults to _'dataframe'_
  for returned pandas dataframe for all sets. Dataframes index is not always preserved, non-integer indexes are extracted to the ID sets,
  and automunge(.) generates an application specific range integer index in ID sets
  corresponding to the order of rows as they were passed to function). If set to _True_, features and ID sets are comparable, and single column label sets are converted to Pandas Series instead of dataframe. If set to _False_
  returns numpy arrays instead of dataframes. Note that the dataframes will have column
  specific data types, or returned numpy arrays will have a single data type.

  * NArw_marker: a boolean identifier _(True/False)_ which indicates if the
  returned sets will include columns with markers for source column entries subject to
  infill (columns with suffix '\_NArw'). This value defaults to True. Note
  that the properties of cells qualifying as candidate for infill are based
  on the 'NArowtype' of the root category of transformations associated with
  the column, see Library of Transformations section below for catalog, the
  various NArowtype options (such as justNaN, numeric, positivenumeric, etc)
  are also further clarified below in discussion around the processdict parameter.

  * featureselection: applied to activate a feature importance evaluation.
  Defaults to False, accepts {False, True, 'pct', 'metric', 'report'}.
  If selected automunge will return a summary of feature importance findings in the featureimportance
  returned dictionary. False turns off, True turns on, 'pct' performs the evaluation followed by
  a dimensionality reduction based on the featurethreshold parameter to retain a % of top features.
  'metric' performs the evaluation followed by a dimensionality reduction to retain features above a metric value based on featurethreshold parameter. 'report' performs the evaluation and returns a report with no
  further processing of data. Feature importance evaluation requires the inclusion of a
  designated label column in the train set. Note that sorted
  feature importance results are returned in postprocess_dict['FS_sorted'],
  including columns sorted by metric and metric2. Note that feature importance
  model training inspects same ML_cmnd parameters as ML infill. (Note that any user-specified size of validationratios
  if passed are used in this method, otherwise defaults to 0.2.) Note that as currently implemented
  feature selection does not take into account dimensionality reductions (like PCA or Binary).
  Permutation importance method was inspired by a fast.ai lecture and more information can be found in
  the paper "Beware Default Random Forest Importances" by Terrence Parr, Kerem
  Turgutlu, Christopher Csiszar, and Jeremy Howard. This method currently makes
  use of Scikit-Learn's Random Forest predictors.

  * featurethreshold: defaults to 0., accepts float in range of 0-1. Inspected when
  featureselection passed as 'pct' or 'metric'. Used to designate the threshold for feature
  importance dimensionality reduction. Where e.g. for 'pct' 0.9 would retain 90% of top
  features, or e.g. for 'metric' 0.03 would retain features whose metric was >0.03. Note that
  NArw columns are only retained for those sets corresponding to columns that "made the cut".

  * inplace: defaults to False, when True the df_train (and df_test) passed to automunge(.)
  are overwritten with the returned train and test sets. This reduces memory overhead.
  For example, to take advantage with reduced memory overhead you could call automunge(.) as:
  ```
  df_train, train_ID, labels, \
  val, val_ID, val_labels, \
  df_test, test_ID, test_labels, \
  postprocess_dict = \
  am.automunge(df_train, df_test=df_test, inplace=True)
  ```
  Note that this "inplace" option is not to be confused with the default inplace conduction of transforms
  that may impact grouping coherence of columns derived from same feature.
  That other inplace option can be deactivated in assignparam, as may be desired for grouping coherence.
  Note that all custom_train transforms have built in support for optional deactivating of inplace parameter
  through assignparam which is applied external to function call. Further detail on this other inplace
  option is provided in the essay [Automunge Inplace](https://medium.com/automunge/automunge-inplace-a85766404bb7).
  ```
  assignparam = {'global_assignparam' : {'inplace' : False}}
  ```

  * Binary: a dimensionality reduction technique whereby the set of columns from
  categoric encodings are collectively encoded with binary encoding such
  as may reduce the column count. This has many benefits such as
  memory bandwidth and energy cost for inference I suspect, however, there
  may be tradeoffs associated with ability of the model to handle outliers,
  as for any new combination of boolean set in the test data the collection
  will be subject to zeroinfill.
  Defaults to _False_, can be passed as one of
  _{False, True, 'retain', 'ordinal', 'ordinalretain', 'onehot', 'onehotretain', [list of column headers]}_.
  - False: the default, Binary dimensionality reduction not performed
  - True: consolidates Boolean integer sets into a single common binarization encoding with replacement
  - 'retain': comparable to True, but original columns are retained instead of replaced
  - 'ordinal': comparable to True, but consolidates into an ordinal encoding instead of binarization
  - 'ordinalretain': comparable to 'ordinal', but original columns are retained instead of replaced
  - 'onehot': comparable to True, but consolidates into a one hot encoding instead of binarization
  - 'ordinalretain': comparable to 'onehot', but original columns are retained instead of replaced
  A user can also pass a list of target column headers if consolidation is only desired on
  a subset of the categoric features. The column headers may be as received column headers or returned column headers with suffix appenders included. To allow distinguishing between the other conventions
  such as 'retain', 'ordinal', etc. in conjunction with passing a subset list of column headers,
  a user may optionally include the specification embedded in set brackets {} as the first entry to the list, e.g. [{'ordinal'}, 'targetcolumn', ...], where specification may be one of
  True, 'retain', 'ordinal', etc. Otherwise when the first value in list is just a column
  header string the binarization convention consistent with Binary=True is applied.
  In order to separately consolidate multiple sets of categoric features, one
  can pass Binary as a list of lists, with the sub lists matching criteria noted preceding (such as allowance for first entry to embed specification in set brackets). For cases where a consolidation with replacement is performed these sets should be nonoverlapping. Note that each sub list may include a distinct specification convention.
  Note that postmunge(.) inversion is supported in conjunction with any of these Binary options. When applying inversion based on a specified list of columns (as opposed to inversion='test' for instance), if the specification includes a Binary returned column it should include the entire set of Binary columns associated with that consolidation, and if the Binary application was in the retain convention the inversion list should specify the Binary input columns instead of the Binary output columns.
  (One may wish to abstain from stochastic_impute_categoric in conjunction with Binary since it may
  interfere with the extent of contraction by expanding the number of activation sets.)
  Some additional detail on Binary provided in the essay [Tabular Engineering with Automunge](https://medium.com/automunge/tabular-engineering-with-automunge-4cf9c43510e).

  * PCAn_components: defaults to False for no PCA dimensionality reduction performed.
  A user can pass _an integer_ to define the number of PCA returned features for
  purposes of dimensionality reduction, such integer to be less than the otherwise
  returned number of sets. Function will default to kernel PCA for all non-negative
  sets or otherwise Sparse PCA. Also if this value is passed as a _float <1.0_ then
  linear PCA will be applied such that the returned number of sets are the minimum
  number that can reproduce that percent of the variance.
  Note this can also be passed in conjunction with assigned PCA type or parameters in
  the ML_cmnd object. Note that by default boolean integer and ordinal encoded returned
  columns are excluded from PCA, which convention can be updated in ML_cmnd if desired.
  These methods apply PCA with the scikit-learn library.
  As a special convention, if PCAn_components passed as _None_ PCA is performed when # features exceeds 0.5 # rows (as a heuristic).
  (The 0.5 value can also be updated in ML_cmnd by passing to ML_cmnd['PCA_cmnd']['col_row_ratio'].)
  Note that inversion as can be performed with postmunge(.) is not currently supported for columns returned from PCA.

  * PCAexcl: a _list_ of column headers for columns that are to be excluded from
  any application of PCA, defaults to _[]_ (an empty list) for cases where no numeric columns are desired to
  be excluded from PCA. Note that column headers can be passed as consistent with the passed df_train
  to exclude from PCA all columns derived from a particular input column or alternatively can be
  passed with the returned column headers which include the suffix appenders to exclude just those
  specific columns from PCA.

  * orig_headers: accepts boolean defaults to False, when activated the returned columns have suffix appenders stripped to return consistent column headers as input. Note that this may result in redundent column headers in the returned dataframe and privacy_encode when activated takes precedence. Was created for use in workflows supporting integration of noise injection into existing data pipelines. Consistent basis applied in postmunge.

  * excl_suffix: boolean selector _{True, False}_ for whether columns headers from 'excl'
  transform are returned with suffix appender '\_excl' included. Defaults to False for
  no suffix. For advanced users setting this to True makes navigating data structures a
  little easier at small cost of aesthetics of any 'excl' pass-through column headers.
  ('excl' transform is for direct pass-through with no transforms, no infill, and no data type conversion.
  Note that 'excl' can be cast as the default category under automation to columns not otherwise assigned by setting powertransform='excl'.)

  * ML_cmnd:
  The ML_cmnd allows a user to set options or pass parameters to model training
  operations associated with ML infill, feature importance, or PCA. ML_cmnd is passed
  as a dictionary with first tier valid keys of:
  {'autoML_type', 'MLinfill_cmnd', 'customML', 'PCA_type', 'PCA_cmnd', 'PCA_retain', 'leakage_tolerance',
  'leakage_sets', 'leakage_dict', 'full_exclude', 'hyperparam_tuner', 'randomCV_n_iter',
  'stochastic_training_seed', 'stochastic_impute_numeric', 'stochastic_impute_numeric_mu',
  'stochastic_impute_numeric_sigma', 'stochastic_impute_numeric_flip_prob', 'stochastic_impute_numeric_noisedistribution', 'stochastic_impute_categoric', 'stochastic_impute_categoric_flip_prob', 'stochastic_impute_categoric_weighted', 'halt_iterate', 'categoric_tol', 'numeric_tol', 'automungeversion', 'optuna_n_iter', 'optuna_timeout', 'optuna_kfolds', 'optuna_fasttune', 'optuna_early_stop', 'optuna_max_depth_tuning_stepsize', 'xgboost_gpu_id'}

  When a user passed ML_cmnd as an empty dictionary, any default values are populated internally.

  The most relevant entries here are 'autoML_type' to choose the autoML framework for predictive
  models, and ML_cmnd to pass parameters to the models. The default option for 'autoML_type' is 'randomforest' which uses a Scikit-learn Random
  Forest implementation, other options are supported as one of {'randomforest', 'customML',
  'catboost', 'flaml'}, each discussed further below. The customML scenario is for user defined
  machine learning algorithms, and documented separately later in this document in the section [Custom ML Infill Functions](https://github.com/Automunge/AutoMunge#custom-ml-infill-functions).

  (Other ML_cmnd options beside autoML_type, like for early stopping through iterations, stochastic noise injections, hyperparpameter tuning, leakage assessment, etc, are documented a few paragraphs down after discussing the autoML_type scenarios.)

  Here is an example of the core components of specification, which include the
  autoML_type to specify the learning library, the MLinfill_cmnd to pass parameters
  to the learning library, and similar options for PCA via PCA_type and PCA_cmnd.
  ```
  ML_cmnd = {'autoML_type':'randomforest',
             'MLinfill_cmnd':{'RandomForestClassifier':{}, 'RandomForestRegressor':{}},
             'PCA_type':'default',
             'PCA_cmnd':{}}
  ```
  For example, a user who doesn't mind a little extra training time for ML infill
  could increase the passed n_estimators beyond the scikit default of 100.

  ```
  ML_cmnd = {'autoML_type':'randomforest',
             'MLinfill_cmnd':{'RandomForestClassifier':{'n_estimators':1000},
                              'RandomForestRegressor':{'n_estimators':1000}}}

  ```
  A user can also perform hyperparameter tuning of the parameters passed to the
  predictive algorithms by instead of passing distinct values passing lists or
  range of values. This is currently supported for randomforest.
  The hyperparameter tuning defaults to grid search for cases
  where user passes any of fit parameters as lists or ranges, for example:
  ```
  ML_cmnd = {'autoML_type':'randomforest',
             'hyperparam_tuner':'gridCV',
             'MLinfill_cmnd':{'RandomForestClassifier':{'max_depth':range(4,6)},
                              'RandomForestRegressor' :{'max_depth':[3,6,12]}}}
  ```
  A user can also perform randomized search via ML_cmnd, and pass parameters as
  distributions via scipy stats module such as:
  ```
  from scipy import stats
  ML_cmnd = {'autoML_type':'randomforest',
             'hyperparam_tuner' : 'randomCV',
             'randomCV_n_iter'  : 15,
             'MLinfill_cmnd':{'RandomForestClassifier':{'max_depth':stats.randint(3,6)},
                              'RandomForestRegressor' :{'max_depth':[3,6,12]}}}
  ```
  Other autoML options besides random forest are also supported, each of which requires installing
  the associated library (which aren't listed in the automunge dependencies). Citations associated with each
  of these libraries are provided for reference.

  One autoML option for ML infill and feature importance is by the CatBoost library.
  Requires externally installing CatBoost library. Uses early stopping by default for regression
  and no early stopping by default for classifier. Note that the random_seed
  parameter is already passed based on the automunge(.) randomseed. Further information
  on the CatBoost library is available on arxiv as Anna Veronika Dorogush, Vasily Ershov, Andrey Gulin. CatBoost: gradient
  boosting with categorical features support [arXiv:1810.11363](https://arxiv.org/abs/1810.11363).
  ```

  ML_cmnd = {'autoML_type':'catboost'}
  ```
  Can pass parameters to model initialization and fit operation as:
  ```



  ML_cmnd = {'autoML_type':'catboost',
             'MLinfill_cmnd' : {'catboost_classifier_model' : {},
                                'catboost_classifier_fit'   : {'eval_ratio' : 0.15 },
                                'catboost_regressor_model'  : {},
                                'catboost_regressor_fit'    : {}}}
  ```

  Another ML infill option is available by the FLAML library. Further information
  on the FLAML library is available on arxiv as Chi Wang, Qingyun Wu, Markus Weimer,
  Erkang Zhu. FLAML: A Fast and Lightweight AutoML Library [arXiv:1911.04706](https://arxiv.org/abs/1911.04706).
  ```

  ML_cmnd = {'autoML_type':'flaml'}
  ```
  Can pass parameters to fit operation as:
  ```

  ML_cmnd = {'autoML_type':'flaml',
             'MLinfill_cmnd' : {'flaml_classifier_fit'   : {'time_budget' : 15 },
                                'flaml_regressor_fit'    : {'time_budget' : 15}}}
  ```
  Another option is available for gradient boosting via the XGBoost library. Further information
  on the XGBoost library is available on arxiv as Tianqi Chen, Carlos Guestrin. XGBoost: A Scalable
  Tree Boosting System [arXiv:1603.02754](https://arxiv.org/abs/1603.02754).
  ```

  ML_cmnd = {'autoML_type':'xgboost'}
  ```

  The XGBoost implementation has Bayesian hyperparameter tuning available by way of the Optuna library by activating ML_cmnd['hyperparam_tuner'] = 'optuna_XGB1'. Optuna tuning accepts parameters for designating the max number of tuning iterations ('optuna_n_iter'), max tuning time in seconds ('optuna_timeout'), selecting a count for k-fold cross validation for tuning ('optuna_kfolds'), activating only evaluating one k-fold per trial ('optuna_fasttune'), selecting an early stopping criteria for max number of tuning cycles without improved performance ('optuna_early_stop'), and selecting a step size for max_depth tuning (with longer tuning times it may be beneficial to change from 2 to 1) ('optuna_max_depth_tuning_stepsize'). The early stopping criteria optuna_n_iter/optuna_timeout/optuna_early_stop are the values applied per target feature (tuning for a feature is halted when one of these conditions are met). Can pass specific parameters (such as selecting whether to run inference with GPU or CPU with 'predictor'), activate GPU training, tune other hyperparameters with optuna, and set tuning options from the shown defaults as:
  ```
  ML_cmnd = {'autoML_type'      : 'xgboost',
             'MLinfill_cmnd'    : {'xgboost_classifier_fit'   : {'predictor' : 'cpu_predictor' },
                                   'xgboost_regressor_fit'    : {'predictor' : 'cpu_predictor' }},
             'xgboost_gpu_id'   : 0,
             'hyperparam_tuner' : 'optuna_XG1',
             'optuna_n_iter'    : 100,
             'optuna_timeout'   : 600,
             'optuna_kfolds'    : 5,
             'optuna_fasttune'  : True,
             'optuna_early_stop': 50,
             'optuna_max_depth_tuning_stepsize' : 2,
             }
  ```
  The implementation makes of XGBoost's "scikit-learn API", so accepted parameters are consistent with XGBClassifier and XGBRegressor. Please note that we recommend setting the gpu_id with ML_cmnd['xgboost_gpu_id'] (rather than passing through parameters) for consistent treatment between tuning and training, which automatically sets tree_method as gpu_hist. (If you intend to put the automunge(.) returned postprocess_dict into production you may want to set the predicter to cpu_predictor as shown so can run ML infill inference without a GPU.) If you don't know your gpu device id, they are usually integers (e.g. if you have one CUDA gpu the device id is usually the integer 0, you can verify this by passing "nvidia-smi" in a terminal window). 'xgboost_gpu_id' defaults to False when not specified, meaning training and inference are conducted on CPU.

  Further information on the Optuna library is available on arxiv as Takuya Akiba, Shotaro Sano, Toshihiko Yanase, Takeru Ohta, Masanori Koyama. Optuna: A Next-generation Hyperparameter Optimization Framework. [arXiv:1907.10902](https://arxiv.org/abs/1907.10902#). Our tuning implementation owes a thank you to a tutorial provided by Optuna.

  Please note that model training by default incorporates a random random seed with each application,
  as can be deactivated by passing ML_cmnd['stochastic_training_seed'] = False to defer to the
  automunge(.) randomseed parameter.

  Please note that there is a defaulted option to inject stochastic noise into derived imputations that
  can be deactivated for numeric features by passing ML_cmnd['stochastic_impute_numeric'] = False
  and/or categoric features by passing ML_cmnd['stochastic_impute_categoric'] = False.

  Numeric noise injections sample from either a default laplace distribution or optionally a normal
  distribution. Default noise profile is mu=0, sigma=0.03, and flip_prob=0.06 (where flip_prob is ratio
  of a feature set's imputations receiving injections). Please note that this scale is based on a
  min/max scaled representation of the imputations. Parameters can be configured by passing
  ML_cmnd entries as floats to ML_cmnd['stochastic_impute_numeric_mu'],
  ML_cmnd['stochastic_impute_numeric_sigma'],
  ML_cmnd['stochastic_impute_numeric_flip_prob'] or as a string to
  ML_cmnd['stochastic_impute_numeric_noisedistribution'] as one of {'normal', 'laplace', 'abs_normal', 'negabs_normal', 'abs_laplace', 'negabs_laplace'}.

  Categoric noise injections sample from a uniform random draw from the set of unique
  activation sets in the training data (as may include one or more columns for
  categoric representations), such that for a ratio of a feature's set's imputations based on
  the flip_prob (defaulting to 0.03 for categoric), each target imputation activation set is replaced with
  the randomly drawn activation set. Parameter can be configured by passing
  an ML_cmnd entry as a float to ML_cmnd['stochastic_impute_categoric_flip_prob'].
  Categoric noise injections by default weight injections per distribution of activations as found in train set.
  This can be deactivated by setting ML_cmnd['stochastic_impute_categoric_weighted'] as False.

  (Please note that we suspect stochastic injections to imputations may have potential to interfere
  with infilliterate early stopping criteria associated with ML_cmnd['halt_iterate'] documented
  above with the infilliterate parameter.)

  To bidirectionally exclude particular features from each other's imputation model bases
  (such as may be desired in expectation of data leakage), a user can designate via
  entries to ML_cmnd['leakage_sets'], which accepts entry of a list of column headers
  or as a list of lists of column headers, where for each list of column headers,
  entries will be excluded from each other's imputation model basis. We suggest
  populating with column headers in form of data passed to automunge(.) (before suffix
  appenders) although specific returned column headers can also be included if desired.

  To unidirectionally exclude particular features from another feature's imputation model basis,
  a user can designate via entries to ML_cmnd['leakage_dict'], which accepts entry of a dictionary
  with target feature keys and values of a set of features to exclude from the target feature's
  basis. This also accepts headers in either of input or returned convention.

  To exclude a feature from ML infill basis of all other features, can pass as a list of entries to
  ML_cmnd['full_exclude']. This also accepts headers in either of input or returned convention.
  Please note that columns returned from transforms with MLinfilltype 'totalexclude' (such as
  for the excl passthrough transform) are automatically excluded from model training basis.
  Note that entries to 'full_exclude' are also excluded from PCA.

  Please note that an operation is performed to evaluate for cases of a kind of data
  leakage across features associated with correlated presence of missing data
  across rows. Leakage tolerance is associated with an automated evaluation for a
  potential source of data leakage across features in their respective imputation
  model basis. The method compares aggregated NArw activations from a target feature
  in a train set to the surrounding features in a train set and for cases where
  separate features share a high correlation of missing data based on the shown
  formula we exclude those surrounding features from the imputation model basis
  for the target feature.

  ((Narw1 + Narw2) == 2).sum() / NArw1.sum() > leakage_tolerance

  Where target features are those input columns with some returned column serving
  as target for ML infill. ML_cmnd['leakage_tolerance'] defaults to 0.85 when not
  specified, and can be set as 1 or False to deactivate the assessment.

  If no ML infill model is trained due to insufficient features remaining after leakage carveouts for a target feature, a validation result is recorded in postprocess_dict['miscparameters_results']['not_enough_samples_or_features_for_MLinfill_result']['(feature)'].

  A user can also assign specific methods for PCA transforms. Current PCA_types
  supported include one of {'PCA', 'SparsePCA', 'KernelPCA'}, all via Scikit-Learn.
  Note that the n_components are passed separately with the PCAn_components
  argument noted above. A user can also pass parameters to the PCA functions
  through the PCA_cmnd, for example one could pass a kernel type for KernelPCA
  as:
  ```
  ML_cmnd = {'PCA_type':'KernelPCA',
             'PCA_cmnd':{'kernel':'sigmoid'}}

  ```
  Note that for the default of ML_cmnd['PCA_type'] = 'default', PCA will default to KernelPCA
  for all non-negative sets or otherwise Sparse PCA (unless PCAn_components was passed as float
  between 0-1 in which case will apply as 'PCA'.

  By default, ML_cmnd['PCA_cmnd'] is initialized internal to library with {'bool_ordl_PCAexcl':True},
  which designates that returned ordinal and boolean encoded columns are to be excluded from PCA.
  This convention by be turned off by passing as False, or to only exclude boolean integer but
  not ordinal encoded columns can pass ML_cmnd['PCA_cmnd'] as {'bool_PCA_excl':True}.

  For the PCA aggregation to be performed without replacement, can pass ML_cmnd['PCA_retain']=True.

  * assigncat: assigncat accepts a dictionary used to assign root categories of transformation to
  input features. The keys of the dictionary accept root transformation categories and the corresponding
  values should be assigned as a string or list of strings representing column headers of input features.

  ```







  assigncat = {'1010':[], 'onht':[], 'ordl':[], 'bnry':[], 'hash':[], 'hsh2':[],
               'DP10':[], 'DPoh':[], 'DPod':[], 'DPbn':[], 'DPhs':[], 'DPh2':[],
               'nmbr':[], 'mnmx':[], 'retn':[], 'DPnb':[], 'DPmm':[], 'DPrt':[],
               'bins':[], 'pwr2':[], 'bnep':[], 'bsor':[], 'por2':[], 'bneo':[],
               'ntgr':[], 'srch':[], 'or19':[], 'tlbn':[], 'excl':[], 'exc2':[]}
  ```

  Full options are provided in document below (in section
  titled "Library of Transformations"). [Library of Transformations](https://github.com/Automunge/AutoMunge#library-of-transformations)

  A user may add column header identifier strings to each of these lists to assign
  a distinct specific processing approach to any column (including labels). Note
  that this processing category will serve as the "root" of the tree of transforms
  as defined in the transformdict. Note that additional categories may be passed if
  defined in the passed transformdict and processdict. An example of usage here
  could be to assign the numeric noise injection transform 'DPnb' to two input features
  we'll call 'input_column_1' and 'input_column_2'.
  ```
  assigncat = {'DPnb':['input_column_1', 'input_column_2']}
  ```
  Note that for single entry column assignments a user can just pass the string or integer
  of the column header without the list brackets.

  Note tht a small number of transforms, such as DPmp or DPse, support assigncat specification
  with multiple input columns treated as a single feature, available by in the assigncat
  specification replacing a single input header string with a {set} of input header strings.
  ```
  assigncat = {'DPmp':[{'input_column_1', 'input_column_2'}]}
  ```

  * assignparam:
  A user may pass column-specific or category specific parameters to those transformation
  functions that accept parameters. Any parameters passed to automunge(.) will be saved in
  the postprocess_dict and consistently applied in postmunge(.). assignparam is
  a dictionary that should be formatted per following example:
  ```

  assignparam = {'global_assignparam'  : {'(parameter)': 42},
                 'default_assignparam' : {'(category)' : {'(parameter)' : 42}},
                          '(category)' : {'(column)'   : {'(parameter)' : 42}}}


  assignparam = {'category1' : {'column1' : {'param1' : 123}, 'column2' : {'param1' : 456}},
                 'category2' : {'column3' : {'param2' : 'abc', 'param3' : 'def'}}}
  ```

  In other words: The first layer keys are the transformation category for
  which parameters are intended. The second layer keys are string identifiers
  for the columns for which the parameters are intended. The third layer keys
  are the parameters whose values are to be passed. To specify new default
  parameters for a given transformation category 'default_assignparam' can
  be applied, or to specify global parameters for all transformation functions
  'global_assignparam' can be applied. Transforms that do not accept a particular
  parameter will just ignore the specification.

  As an example with actual parameters, consider the transformation category
  'splt' intended for 'column1', which accepts parameter 'minsplit' for minimum
  character length of detected overlaps. If we wanted to pass 4 instead of the
  default of 5:
  ```
  assignparam = {'splt' : {'column1' : {'minsplit' : 4}}}
  ```
  Note that the category identifier should be the category entry to the family
  tree primitive associated with the transform, which may be different than the
  root category of the family tree assigned in assigncat. The set of family
  tree definitions for root categories are included below for reference. Generally
  speaking, the transformation category to serve as a target for asisgnparam
  assignment will match the recorded suffix appender of the returned column headers.

  As an example, to demonstrate edge case for cases where the transformation category does not match
  the transformation function  (based on entries to transformdict and
  processdict), if we want to pass a parameter to turn off UPCS transform included
  in or19 family tree and associated with the or19 transformation category for
  instance, we would pass the parameter to or19 instead of UPCS because assignparam
  inspects the transformation category associated with the transformation function,
  and UPCS function is the processdict entry for or19 category entry in the family
  tree primitives associated with the or19 root category, even though 'activate' is
  an UPCS transformation function parameter. A helpful rule of thumb to help distinguish is that
  the suffix appender recorded in the returned column associated with an applied transformation
  function should match the transformation category serving as target for assignparam assignment,
  as in this case the UPCS transform records a 'or19' suffix appender. (This clarification
  intended for advanced users to avoid ambiguity.)

  ```
  assignparam = {'or19' : {'column1' : {'activate' : False}}}
  ```
  Note that column string identifiers may just be the source column string or may
  include the suffix appenders for downstream columns serving as input to the
  target transformation function, such as may be useful if multiple versions of
  the same transformation are applied within the same family tree. If more than
  one column identifier matches a column in assignparam entry to a transformation
  category (such as both the source column and the derived column serving as input
  to the transformation function), the derived column (such as may include suffix
  appenders) will take precedence.

  Note that if a user wishes to overwrite the default parameters associated with a
  particular category for all columns without specifying them individually they can
  pass a 'default_assignparam' entry as follows (this only overwrites those parameters
  that are not otherwise specified in assignparam).
  ```
  assignparam = {'category1' : {'column1' : {'param1' : 123}, 'column2' : {'param1' : 456}},
                 'category2' : {'column3' : {'param2' : 'abc', 'param3' : 'def'}},
                 'default_assignparam' : {'category3' : {'param4' : 789}}}
  ```
  Or to pass the same parameter to all transformations to all columns, can use the
  'global_assignparam'. The global_assignparam may be useful for instance to turn off
  inplace transformations such as to retain family tree column grouping correspondence
  in returned set. Transformations that do not accept a particular parameter will just
  ignore.
  ```
  assignparam = {'global_assignparam' : {'inplace' : False}}
  ```
  In order of precedence, parameter assignments may be designated targeting a transformation
  category as applied to a specific column header with suffix appenders, a transformation
  category as applied to an input column header (which may include multiple instances),
  all instances of a specific transformation category, all transformation categories, or may
  be initialized as default parameters when defining a transformation category.

  See the Library of Transformations section below for those transformations that
  accept parameters.

  * assigninfill
  ```


  assigninfill = {'stdrdinfill':[], 'MLinfill':[], 'zeroinfill':[], 'oneinfill':[],
                  'adjinfill':[], 'meaninfill':[], 'medianinfill':[], 'negzeroinfill':[],
                  'modeinfill':[], 'lcinfill':[], 'naninfill':[]}
  ```
  A user may add column identifier strings to each of these lists to designate the
  column-specific infill approach for missing or improperly formatted values. The
  source column identifier strings may be passed for assignment of common infill
  approach to all columns derived from same source column, or derived column identifier
  strings (including the suffix appenders from transformations) may be passed to assign
  infill approach to a specific derived column. Note that passed derived column headers
  take precedence in case of overlap with passed source column headers. Note that infill
  defaults to MLinfill if nothing assigned and the MLinfill argument to automunge is set
  to True. Note that for single entry column assignments a user can just pass the string
  or integer of the column header without the list brackets. Note that the infilled cells
  are based on the rows corresponding to activations from the NArw_marker parameter.
  ```
























  assigninfill = {'MLinfill':['column1_bxcx_nmbr'], 'meaninfill':['column1']}
  ```

  * assignnan: for use to designate data set entries that will be targets for infill, such as
  may be entries not covered by NArowtype definitions from processdict. For example, we have
  general convention that NaN (as np.nan) is a target for infill, but a data set may be passed with a custom
  string signal for infill, such as 'unknown'. This assignment operator saves the step of manual
  munging prior to passing data to functions by allowing user to specify custom targets for infill.

  assignnan accepts following form, populated in first tier with any of 'categories'/'columns'/'global'
  ```
  assignnan = {'categories':{}, 'columns':{}, 'global':[]}
  ```
  Note that global takes entry as a list, while categories and columns take entries as a dictionary
  with values of the target assignments and corresponding lists of terms, which could be populated
  with entries as e.g.:
  ```
  assignnan = {'categories' : {'cat1' : ['unknown1']},
               'columns' : {'col1' : ['unknown2']},
               'global' : ['unknown3']}
  ```
  Where 'cat1' is example of root category, 'col1' is example of source column header, and 'unknown1'/2/3
  are examples of entries intended for infill corresponding to each. In cases of redundant specification,
  global takes precedence over columns which takes precedence over categories. Note that lists of terms
  can also be passed as single values such as string / number for internal conversion to list.

  assignnan also supports stochastic and range based injections, such as to target for infill specific
  segments of a set's distribution. 'injections' can be passed to assignnan as:
  ```
  assignnan =     {'injections' : {'(column)' : {'inject_ratio' : (float),
                                                 'range' : {'ratio'  : (float),
                                                            'ranges' : [[min1, max1], [min2, max2]]},
                                                 'minmax_range' : {'ratio'  : (float),
                                                                   'ranges' : [[min1, max1], [min2, max2]]},
                                                 'entries' : ['(entry1)', '(entry2)'],
                                                 'entry_ratio' : {'(entry1)' : (float),
                                                                  '(entry2)' : (float)}
                                                }
                                  }
                  }








  ```

  * transformdict: a dictionary allowing a user to pass a custom tree of transformations or to overwrite
  family trees defined in the transform_dict internal to the library. Defaults to _{}_ (an empty dictionary).
  Note that a user may define their own (traditionally 4 character) string "root categories"
  by populating a "family tree" of transformation categories associated with that root category,
  which are a way of specifying the type and order of transformation functions to be applied.
  Each category populated in a family tree requires its own transformdict root category family tree definition
  as well as an entry in the processdict described below for assigning associated transformation functions and data properties.
  Note that the library has an internally defined library of transformation categories prepopulated in the
  internal transform_dict which are detailed below in the Library of Transformations section of this document.
  For clarity transformdict refers to the user passed data structure which is subsequently consolidated into the internal "transform_dict" (with underscore) data structure. The returned version in postprocess_dict['transform_dict'] records entries that were inspected in the associated automunge(.) call.

  ```
      
      
      
      
      

      
      
      

      
      

      
      
      

      
      

      
      
      

      
      
      
      

      
      

      
      
      

      
      

      
      

      
      

      
      

      
      

      
      

      
      
      

      
      

      
      

      
      
      

      
      
      
      
      

      
      
      
      
      
      
      

      
      
      
      
      
  ```

  Once a root category has been defined, it can be assigned to a received column in assigncat.
  For example, a user wishing to define a new set of transformations for a numerical set can define a new root category 'newt'
  that combines NArw, min-max, box-cox, z-score, and standard deviation bins by passing a
  transformdict as:
  ```
  transformdict =  {'newt' : {'parents' : ['bxc4'],
                              'siblings': [],
                              'auntsuncles' : ['mnmx', 'bins'],
                              'cousins' : ['NArw'],
                              'children' : [],
                              'niecesnephews' : [],
                              'coworkers' : [],
                              'friends' : []}}





  transform_dict.update({'bxc4' : {'parents' : ['bxcx'],
                                   'siblings': [],
                                   'auntsuncles' : [],
                                   'cousins' : ['NArw'],
                                   'children' : [],
                                   'niecesnephews' : [],
                                   'coworkers' : ['nbr2'],
                                   'friends' : []}})








  assigncat = {'newt':['targetcolumn']}




  transformdict =  {'newt' : {'parents'     : 'bxc4',
                              'auntsuncles' : ['mnmx', 'bins'],
                              'cousins'     : 'NArw'}}

  ```
  Basically here 'newt' is the root category key and once defined can be assigned as a root category in assigncat
  to be applied to a column or can also be passed to one of the family primitives associated with itself or some other root category
  to apply the corresponding transformation functions populated in the processdict entry. Once a transformation category is accessed
  based on an entry to a family tree primitive associated with a root category assigned to a column,
  the corresponding processdict transformation function is applied, and if it was accessed as a family tree
  primitive with downstream offspring then those offspring keys are pulled from
  that key's family tree. For example, here mnmx is passed as an auntsuncles which
  means the mnmx processing function is applied with no downstream offspring. The
  bxc4 key is passed as a parent which means the transform associated with the bxc4 category is applied followed
  by any downstream transforms from the bxc4 key family tree, which we also show.
  Note the family primitives tree can be summarized as:
  ```
  'parents' :           upstream / first generation / replaces column / with offspring
  'siblings':           upstream / first generation / supplements column / with offspring
  'auntsuncles' :       upstream / first generation / replaces column / no offspring
  'cousins' :           upstream / first generation / supplements column / no offspring
  'children' :          downstream parents / offspring generations / replaces column / with offspring
  'niecesnephews' :     downstream siblings / offspring generations / supplements column / with offspring
  'coworkers' :         downstream auntsuncles / offspring generations / replaces column / no offspring
  'friends' :           downstream cousins / offspring generations / supplements column / no offspring
  ```

  ![image](https://user-images.githubusercontent.com/44011748/76485331-a2a24380-63f2-11ea-8559-08bb1c3be395.png)

  Note that a user should avoid redundant entries across a set of upstream or downstream primitives.
  If a redundant transformation function is desired to a distinct upstream or downstream inputcolumn (such as may be desired
  to apply same transform but with different parameters), each of the redundant applications needs a distinct transformation category defined in
  the processdict (and a distinct suffix appender which is automatic based on the transformation category).
  Since there is recursion involved a user should be careful of creating infinite loops from passing
  downstream primitive entries with offspring whose own offspring coincide with an earlier generation.
  (The presence of infinite loops is tested for to a max depth of 1111 offspring, an arbitrary figure.)

  Note that transformdict entries can be defined to overwrite existing root category entries defined in the internal library.
  For example, if we wanted our default numerical scaling to be by min-max instead of z-score normalization, one way we could accomplish
  that is to overwrite the 'nmbr' family tree which is the default root category applied to numeric sets under automation. (Other default
  root categories under automation are detailed further below in the
  "[Default Tranformations](https://github.com/Automunge/AutoMunge#default-transformations)" section.) An alternate approach could be to
  overwrite the nmbr processdict entry which we'll demonstrate shortly.
  ```
  transformdict =  {'nmbr' : {'auntsuncles' : 'mnmx',
                              'cousins'     : 'NArw'}}
  ```

  Note that when we define a new root category family tree such as the 'newt' example shown above, we also need
  to define a corresponding processdict entry for the new category, which we detail next.

  Further detail on the transformdict data format provided in the essay [Data Structure](https://medium.com/automunge/data-structure-59e52f141dd6). For tutorials on defining a family tree, see also the essay [Specification of Derivations with Automunge](https://medium.com/automunge/specification-of-derivations-with-automunge-6174ca227184).

  * processdict: a dictionary allowing a user to specify transformation category properties corresponding
  to new categories defined in transformdict or to overwrite process_dict entries defined internal to the library.
  Defaults to _{}_ (an empty dictionary). The types of properties specified include the associated transformation
  functions, types of data that will be targets for infill, a classification of data types (such as between numeric, integer, categoric, etc),
  and more detailed below. All transformation categories used in transformdict, including
  those used as root categories as well as transformation category entries to family tree primitives associated
  with a root category, require a corresponding entry in the processdict to define transformation category
  properties. Only in cases where a transformdict entry is being passed to overwrite an existing category internal
  to the library is a corresponding processdict entry not required. However note that a processdict entry can be passed
  without a corresponding root category definition in transformdict, which may be used when passing a custom transformation category to a family tree primitive without offspring.

  We'll describe the options for processdict entries here. For clarity processdict refers to the user passed data structure which is subsequently consolidated into the internal "process_dict" (with underscore) data structure.
  The returned version in postprocess_dict['process_dict'] records entries that were inspected in the
  associated automunge(.) call.

  ```















































































































































































  ```

  For example, to populate a custom transformation category 'newt' that uses internally defined transformation functions _process_mnmx and _postprocess_mnmx:

  ```
  processdict =  {'newt' : {'dualprocess'   : am._process_mnmx,
                            'singleprocess' : None,
                            'postprocess'   : am._postprocess_mnmx,
                            'NArowtype'     : 'numeric',
                            'MLinfilltype'  : 'numeric'}}
  ```

  Note that these processing functions won't be applied when 'newt' is assigned as a root category to a column in assigncat, unless the category is also populated as an entry to one of the associated family tree primitives in the transformdict entry.

  Note that all of the processing functions can be omitted or populated with values of None, as may be desired when the category is primarily intended for use as a root category and not a tree category. (If in such case the category is applied as a tree category when accessed no transforms will be applied and no downstream offspring will be inspected when applicable).

  Optionally, some additional values can be incorporated into the processdict to
  support inversion for a transformation category:
  ```

  processdict =  {'newt' : {'dualprocess'    : am._process_mnmx,
                            'singleprocess'  : None,
                            'postprocess'    : am._postprocess_mnmx,
                            'inverseprocess' : am._inverseprocess_mnmx,
                            'info_retention' : True,
                            'NArowtype'      : 'numeric',
                            'MLinfilltype'   : 'numeric'}}




  ```

  Optionally, a user can set alternate default assignparam parameters to be passed to the associated
  transformation functions by including the 'defaultparams' key. These updates to default
  parameters will still be overwritten if user manually specifies parameters in assignparam.
  ```

  processdict =  {'DLmm' : {'dualprocess'    : am._process_DPmm,
                            'singleprocess'  : None,
                            'postprocess'    : am._postprocess_DPmm,
                            'inverseprocess' : am._inverseprocess_UPCS,
                            'info_retention' : True,
                            'defaultparams'  : {'noisedistribution' : 'laplace'},
                            'NArowtype'      : 'numeric',
                            'MLinfilltype'   : 'numeric'}}
  ```

  Since specification of transformation functions and other processdict entries can be kind of cumbersome in order
  to dig out from the codebase naming conventions e.g. for internally defined functions, a
  simplification is available when populating a processdict for a user passed entry by
  way of the 'functionpointer' entry. When a functionpointer category entry is included,
  the transformation functions and other entries that are not already specified are
  automatically populated based on entries found in processdict entries of the pointer.
  For cases where a functionpointer points to a processdict entry that itself has a functionpointer
  entry, chains of pointers are followed until an entry without functionpointer is reached.
  defaultparams entries of each pointer link are also accessed for update, and if the prior category
  specification contains any redundant defaultparams entries with those found in a pointer target
  category the prior category entries take precedence. Similarly for chains of pointers the entries
  specified in nearer links take precedence over entries further down the chain.

  In other words, if you are populating a new processdict transformation
  category and you want the transformation functions and other entries to match an existing category, you
  can simply pass the existing category as a functionpointer entry to the new category.
  Here is an example if we want to match the DLmm category demonstrated above for a new
  category 'newt' but with an alternate 'NArowtype' as an arbitrary example, such as would be useful if we
  wanted to define an alternate DLmm family tree in a corresponding newt transformdict entry.
  ```
  processdict =  {'newt' : {'functionpointer' : 'DLmm',
                            'NArowtype'       : 'positivenumeric'}}
  ```
  Or an even simpler approach if no overwrites are desired could just be to copy everything.
  ```
  processdict =  {'newt' : {'functionpointer' : 'DLmm'}}
  ```
  We can also use functionpointer when overwriting a category defined internal to library. For
  example, if we wanted to change the default parameters applied with the mnmx category, we
  could overwrite the mnmx process_dict entry such as to match the current entry but with
  updated defaultparams.
  ```
  processdict =  {'mnmx' : {'functionpointer' : 'mnmx',
                            'defaultparams'   : {'floor' : True}}}
  ```

  Note that processdict entries can be defined to overwrite existing category entries defined in the internal library.
  For example, if we wanted our default numerical scaling to be by min-max instead of z-score normalization, one way we could accomplish
  this is to overwrite the 'nmbr' transformation functions accessed from processdict, where nmbr is the default root category applied to
  numeric sets under automation, whose family tree has nmbr as a tree category entry for accessing the transformation functions.
  (Other default root categories under automation are detailed further below in the
  "[Default Tranformations](https://github.com/Automunge/AutoMunge#default-transformations)" section.) This approach differs
  from overwriting the nmbr transformdict entry as demonstrated above in that the update would be carried through to all instances where nmbr is
  accessed as a tree category across the library of family trees.
  ```
  processdict =  {'nmbr' : {'functionpointer' : 'mnmx'}}
  ```

  Processing functions following the conventions of those defined internal to the library
  can be passed to dualprocess / singleprocess / postprocess / inverseprocess

  Or for the greatly simplified conventions available
  for custom externally defined transformation functions
  can be passed to custom_train / custom_test / custom_inversion.
  Demonstrations for custom transformation functions are documented further below in the
  section Custom Transformation Functions. (Note that in cases of redundancy, populated
  custom_train functions take precedence over the dualprocess / singleprocess conventions).
  Note that the defaultinfill option is specific to the custom_train convention and also documented below.

  Note that many of the transformation functions in the library have support for distinguishing between
  inplace operations vs returning a column copied from the input. Inplace operations are expected to
  reduce memory overhead. When not specified the library assumes a function supports the inplace option. Function passed in the custom_train convention automatically support inplace so specification is not required with user defined functions. For functions following the dualprocess/singleprocess conventions, some transforms may not support inplace, in which case a user will need to specify (although if using functionpointer to access the transforms this will be automatic).

  ```

  processdict =  {'newt' : {'dualprocess'    : am._process_text,
                            'singleprocess'  : None,
                            'postprocess'    : am._postprocess_text,
                            'inverseprocess' : am._inverseprocess_text,
                            'info_retention' : True,
                            'inplace_option' : False,
                            'NArowtype'      : 'justNaN',
                            'MLinfilltype'   : 'multirt'}}
  ```

  The optional labelctgy specification for a category's processdict entry is intended for use in featureselection when the category is applied as a root category to a label set and the category's family tree returns the labels in multiple configurations. The labelcty entry serves as a specification of a specific primitive entry category either as entered in the upstream primitives of the root category or one of the downstream primitives of subsequent generations, which primitive entry category will serve as the label basis when applying feature selection. (labelctgy is also inspected with oversampling in current implementation.)

  Further detail on the processdict data format provided in the essay [Data Structure](https://medium.com/automunge/data-structure-59e52f141dd6).

  * evalcat: modularizes the automated evaluation of column properties for assignment
  of root transformation categories, allowing user to pass custom functions for this
  purpose. Passed functions should follow format:

  ```
  def evalcat(df, column, randomseed, eval_ratio, numbercategoryheuristic, powertransform, labels = False):
    """
    
    
    
    
    """
    ...
    return category
  ```
  And could then be passed to automunge function call such as:
  ```
  evalcat = evalcat
  ```
  I recommend using the \_evalcategory function defined in master file as starting point.
  (Minus the 'self' parameter since defining external to class.) Note that the
  parameters eval_ratio, numbercategoryheuristic, powertransform, and labels are passed as user
  parameters in automunge(.) call and only used in \_evalcategory function, so if user wants
  to repurpose them totally can do so. (They default to .5, 255, False, False.) Note evalcat
  defaults to False to use built-in \_evalcategory function. Note evalcat will only be
  applied to columns not assigned in assigncat. (Note that columns assigned to 'eval' / 'ptfm'
  in assigncat will be passed to this function for evaluation with powertransform = False / True
  respectively.) Note that function currently uses python collections library and datetime as dt.

  * ppd_append: defaults to False, accepts as input a prior populated postprocess_dict for
  purposes of adding new features to a prior trained model. Basically the intent is that there
  are some specialized workflows where models in decision tree paradigms may have new features
  incorporated without retraining the model with the prior training data.
  In such cases a user may desire to add new features to a prior populated postprocess_dict to enable
  pushbutton preprocessing including the original training data basis coupled with basis of newly added features.
  In order to do so, automunge(.) should be called with just the new features passed as df_train, and the prior
  populated postprocess_dict passed to ppd_append. This will result in the newly populated postprocess_dict being saved
  as a new subentry in the returned original postprocess_dict, such that to prepare additional data including the original
  features and new features, they combined features can be colletively passed as df_test to postmunge(.) (which should
  have new features appended on right side of original features). postmunge(.) will prepare the original features
  and new features seperately, including a seperate basis for ML infill, Binary, and etc, and will return a
  combined prepared test data. Includes inversion support and support for performing more than one round of new
  feature appendings. Note that newly added features are
  limited to training features, labels and ID input should be excluded. Note that inversion numpy support not available with
  combined features and test feature inversion support is limited to the inversion='test' case. (If it is desired to include
  new features in the prior features' ML infill basis and visa versa, instead of applying ppd_append just pass everything
  to automunge(.) and populate a new postprocess_dict - noting this might justify retraining the original model due to
  a new ML infill basis of original features). (Note that when applied in conjunction with entropy_seeding for noise injection the same seeds will be applied with each set, for sampling_type's other than default we recommend sampling internally with a custom generator as opposed to passing externally sampled seeds.). Please note that ppd_append not supported in conjunction with activating dupl_rows postmunge parameter.

  * entropy_seeds: defaults to False, accepts integer or list / flattened array of integers which may serve as supplemental sources of entropy for noise injections with DP transforms, we suggest integers in range {0:(2 \*\* 31 - 1)} to align with int32 dtype. entropy_seeds are specific to an automunge(.) or postmunge(.) call, in other words they are not returned in the populated postprocess_dict. Please note that for determinatino of how many entropy seeds are needed for various sampling_dict['sampling_type'] scenarios, can inspect postprocess_dict['sampling_report_dict'], where if insufficient seeds are available for these scenarios additional seeds will be derived with the extra_seed_generator.  Note that the sampling_report_dict will report requirements separately for train and test data and in the bulk_seeds case will have a row count basis. (If not passing test data to automunge(.) the test budget can be omitted.) Note that the entropy seed budget only accounts for preparing one set of data, for the noise_augment option we recommend passing a custom extra_seed_generator with a sampling_type specification, which will result in internal samplings of additional entropy seeds for each additional noise_augment duplicate (or for the bulk_seeds case with external sampling can increased entropy_seed budget proportional to the number of additional duplicates with noise).

  * random_generator: defaults to False, accepts numpy.random.Generator formatted random samplers which are applied for noise injections with DP transforms. Note that random_generator may optionally be applied in conjunction with entropy_seeds. When not specified applies numpy.random.PCG64. Examples of alternate generators could be a generator initialized with the [QRAND](https://github.com/pedrorrivero/qrand) library to sample from a quantum circuit. Or if the alternate library does not have numpy.random support, their output can be channeled as entropy_seeds for a similar benefit. random_generator is specific to an automunge(.) or postmunge(.) call, in other words it is not returned in the populated postprocess_dict. Please note that numpy formatted generators of both forms e.g. np.random.PCG64 or np.random.PCG64() may be passed, in the latter case any entropy seeding to this generator will be turned off automatically.

  * sampling_dict: defaults to False, accepts a dictionary including possible keys of {sampling_type, seeding_type, sampling_report_dict, stochastic_count_safety_factor, extra_seed_generator, sampling_generator}. sampling_dict is specific to an automunge(.) or postmunge(.) call, in other words they are not returned in the populated postprocess_dict.
    - sampling_dict['sampling_type'] accepts a string as one of {'default', 'bulk_seeds', 'sampling_seed', 'transform_seed'}
      - default: every sampling receives a common set of entropy_seeds per user specification which are shuffled and passed to each call
      - bulk_seeds: every sampling receives a unique supplemental seed for every sampled entry for sampling from sampling_generator (expended seed counts dependent on train/test/both configuration and numbers of rows). This scenario also defaults to sampling_dict['seeding_type'] = 'primary_seeds'
      - sampling_seed: every sampling operation receives one supplemental seed for sampling from sampling_generator (expended seed counts dependent on train/test/both configuration)
      - transform_seed: every noise transform receives one supplemental seed for sampling from sampling_generator (expended seed counts are the same independant of train/test/both configuration)
    - sampling_dict['seeding_type'] defaults to 'supplemental_seeds' or 'primary_seeds' as described below, where 'supplemental_seeds' means that entropy seeds are integrated into np.random.SeedSequence with entropy seeding from the operating system. Also accepts 'primary_seeds', in which user passed entropy seeds are the only source of seeding. Please note that 'primary_seeds' is used as the default for the bulk_seeds sampling_type and 'supplemental_seeds' is used as the default for other sampling_type options.
    - sampling_dict['sampling_report_dict'] defaults as False, accepts a prior populated postprocess_dict['sampling_report_dict'] from an automunge(.), call if this is not received it will be generated internally. sampling_report_dict is a resource for determining how many entropy_seeds are needed for various sampling_type scnearios.
    - sampling_dict['stochastic_count_safety_factor']: defaults to 0.15, accepts float 0-1, is associated with the bulk_seeds sampling_type case and is used as a multiplier for number of seeds populated for sampling operations with a stochastic number of entries
    - sampling_dict['sampling_generator']: used to specify which generator will be used for sampling operations other than generation of additional entropy_seeds. defaults to 'custom' (meaning the passed random_generator or when unspecified the default PCG64), and accepts one of {'custom', 'PCG64', 'MersenneTwister'}
    - sampling_dict['extra_seed_generator']: used to specify which generator will be used to sample additional entropy_seeds when more are needed to meet requirements of sampling_report_dict, defaults to 'custom' (meaning the passed random_generator or when unspecified the default PCG64), and accepts one of {'custom', 'PCG64', 'MersenneTwister', 'off', 'sampling_generator'}, where sampling_generator matches specification for sampling_generator, and 'off' turns off sampling of additional entropy seeds.

  * privacy_encode: a boolean marker _{True, False, 'private'}_ defaults to False. For cases where sets
  are returned as pandas dataframe, a user may desire privacy preserving encodings in which
  column headers of received data are anonymized. This parameter when activated as True shuffles the order of columns and
  replaces headers and suffixes with integers. ID sets are not anonymized. Label sets are only anonymized in the 'private' scenario. Note that conversion information is available in returned postprocess_dict under
  privacy reports (in other words, privacy can be circumvented if user has access to an unencrypted postprocess_dict).
  When activated the postprocess_dict returned columntype_report captures the privacy encodings and the column_map is erased.
  Note that when activated consistent convention is applied in postmunge and inversion is supported.
  When privacy_encode is activated postmunge(.) printstatus is only available as False or 'silent'.
  The 'private' option also activates shuffling of rows in train and test data for both automunge(.) and postmunge(.)
  and resets the dataframe indexes (although retains the Automunge_index column returned in the ID set).
  Thus prepared data in the 'private' option can be kept row-wise anonymous by not sharing the returned ID set.
  We recommend considering use of the encrypt_key parameter in conjunction with privacy_encode. Please note that when
  privacy_encode is activated postmunge options for featureeval and driftreport are not available to avoid data leakage channel.
  It may be beneficial in privacy sensitive applications to inject noise via DP transforms and apply distribution conversions to
  numeric features e.g. via DPqt or DPbx. Further detail on privacy encoding provided in the essay [Private Encodings with Automunge](https://medium.com/automunge/private-encodings-with-automunge-f73dcdb57289).

  * encrypt_key: as one of {False, 16, 24, 32, bytes} (where bytes means a bytes type object with length of 16, 24, or 32) defaults to False, other scenarios all result in an encryption of the returned postprocess_dict. 16, 24, and 32 refer to the block size, where block size of 16 aligns with 128 bit encryption, 32 aligns with 256 bit. When encrypt_key is passed as an integer, a returned encrypt_key is derived and returned in the closing printouts. This returned printout should be copied and saved for use with the postmunge(.) encrypt_key parameter. In other words, without this encryption key, user will not be able to prepare additional data in postmunge(.) with the returned postprocess_dict. When encrypt_key is passed as a bytes object (of length 16, 24, or 32), it is treated as a user specified encryption key and not returned in printouts. When data is encrypted, the postprocess_dict returned from automunge(.) is still a dictionary that can be downloaded and uploaded with pickle, and based on which scenario was selected by the privacy_encode parameter (for scenarios other than 'private'), the returned postprocess_dict will contain some public entries that are not encrypted, such as ['columntype_report', 'label_columntype_report', 'privacy_encode', 'automungeversion', 'labelsencoding_dict', 'FS_sorted', 'column_map', 'sampling_report_dict'] - where FS_sorted and column_map are ommitted when privacy_encode is not False and all public entries are omitted when privacy_encode = 'private'. The encryption key, as either returned in printouts or based on user specification, can then be passed to the postmunge(.) encrypt_key parameter to prepare additional data. The only postmunge operation available without the encryption key is for label inverison (unless privacy_encode is 'private'). Thus privacy_encode may be fully private, and a user with access to the returned postprocess_dict will not be able to invert training data without the encryption key. Please note that the AES encryption is applied with the [pycrypto](https://github.com/pycrypto/pycrypto) python library which requires installation in order to run (we found there were installations available via conda install).

  * printstatus: user can pass _True/False/'summary'/'silent'_ indicating whether the function will print
  status of processing during operation. Defaults to 'summary' to return a summary of returned sets and any feature importance or drift reports. True returns all printouts. When False only error
  message printouts generated. When 'summary' only reports and summary are printed. When 'silent' no printouts are generated. Note that all of these scenarios are also available by the logger parameter regardless of printstatus setting.

  * logger: user can initialize a dictionary externally, e.g. logger={}, and pass it to this parameter, e.g. logger=logger. automunge(.) will then log every printout scenario and validation result as they are being accessed in this external dictionary, which can then either be inspected for troubleshooting in cases of a halt scenario or archived. The report scenarios are loosely aligned with python logging module and also related to the tiers of printstatus.
  ```
  logger = {}

  train, train_ID, labels, \
  val, val_ID, val_labels, \
  test, test_ID, test_labels, \
  postprocess_dict = \
  am.automunge(df_train,
               logger=logger,
               printstatus='silent')


  print(logger['debug_report'])
  print(logger['info_report'])
  print(logger['warning_report'])


  ```

  Ok well we'll demonstrate further below how to build custom transformation functions,
  for now you should have sufficient tools to build sets of transformation categories
  using the family tree primitives and etc.

  ...



  The postmunge(.) function is intended to consistently prepare subsequently available
  and consistently formatted train or test data with just a single function call. It
  requires passing the postprocess_dict object returned from the original application
  of automunge and that the passed test data have consistent column header labeling as
  the original train set (or for Numpy arrays consistent order of columns). Processing
  data with postmunge(.) is considerably more efficient than automunge(.) since it does
  not require the overhead of the evaluation methods, the derivation of transformation
  normalization parameters, and/or the training of models for ML infill.

  ```





  from Automunge import *
  am = AutoMunge()




  test, test_ID, test_labels, \
  postreports_dict = \
  am.postmunge(postprocess_dict, df_test,
               testID_column = False,
               pandasoutput = 'dataframe', printstatus = 'summary', inplace = False,
               dupl_rows = False, TrainLabelFreqLevel = False,
               featureeval = False, traindata = False, noise_augment = 0,
               driftreport = False, inversion = False,
               returnedsets = True, shuffletrain = False,
               entropy_seeds = False, random_generator = False, sampling_dict = False,
               randomseed = False, encrypt_key = False, logger = {})
  ```

  Or to run postmunge(.) with default parameters we simply need the postprocess_dict
  object returned from the corresponding automunge(.) call and a consistently formatted
  additional data set.

  ```
  test, test_ID, test_labels, \
  postreports_dict = \
  am.postmunge(postprocess_dict, df_test)
  ```


  Here now are descriptions for the returned sets from postmunge, which
  will be followed by descriptions of the parameters which can be passed to
  the function. Default is that returned sets are pandas dataframes, with
  single column sets returned as pandas series.

  For dataframes, data types of returned columns are based on the transformation applied,
  for example columns with boolean integers are cast as int8, ordinal encoded
  columns are given a conditional type based on the size of encoding space as either
  uint8, uint16, or uint32. Continuous sets are cast as float16, float32, or float64
  based on the automunge(.) floatprecision parameter. And direct passthrough columns
  via excl transform retain the received data type.

  * test: the set of features, consistently encoded and normalized as the
  training data, that can be used to generate predictions from a model
  trained with the train set from automunge.

  * test_ID: the set of ID values corresponding to the test set. Also included
  in this set is a derived column titled 'Automunge_index',
  this column serves as an index identifier for order of rows as they were
  received in passed data, such as may be beneficial when data is shuffled.
  For more information please refer to writeup for the testID_column parameter.
  If the received df_test had a non-ranged integer index,
  it is extracted and returned in this set.

  * test_labels: a set of numerically encoded labels corresponding to the
  test set if a label column was passed. Note that the function
  assumes the label column is originally included in the train set. Note
  that if the labels set is a single column a returned dataframe is flattened
  to a pandas Series or a returned Numpy array is also
  flattened (e.g. [[1,2,3]] converted to [1,2,3] ).

  * postreports_dict: a dictionary containing entries for following:
    - postreports_dict['featureimportance']: results of optional feature
    importance evaluation based on parameter featureeval. (See automunge(.)
    notes above for feature importance printout methods.)
    - postreports_dict['finalcolumns_test']: list of columns returned from
    postmunge
    - postreports_dict['driftreport']: results of optional drift report
    evaluation tracking properties of postmunge data in comparison to the
    original data from automunge call associated with the postprocess_dict
    presumably used to train a model. Results aggregated by entries for the
    original (pre-transform) list of columns, and include the normalization
    parameters from the automunge call saved in postprocess_dict as well
    as the corresponding parameters from the new data consistently derived
    in postmunge
    - postreports_dict['sourcecolumn_drift']: results of optional drift report
    evaluation tracking properties of postmunge data derived from source
    columns in comparison to the original data from automunge(.) call associated
    with the postprocess_dict presumably used to train a model.
    - postreports_dict['pm_miscparameters_results']: reporting results of validation tests performed on parameters and passed data

  ```



  postreports_dict = \
  {'featureimportance':{(not shown here for brevity)},
  'finalcolumns_test':[(derivedcolumns)],
  'driftreport': {(sourcecolumn) : {'origreturnedcolumns_list':[(derivedcolumns)],
                             'newreturnedcolumns_list':[(derivedcolumns)],
                             'drift_category':(category),
                             'orignotinnew': {(derivedcolumn):{'orignormparam':{(stats)}},
                             'newnotinorig': {(derivedcolumn):{'newnormparam':{(stats)}},
                             'newreturnedcolumn':{(derivedcolumn):{'orignormparam':{(stats)},
                                                                   'newnormparam':{(stats)}}}},
  'rowcount_basis': {'automunge_train_rowcount':#, 'postmunge_test_rowcount':#},
  'sourcecolumn_drift': {'orig_driftstats': {(sourcecolumn) : (stats)},
                         'new_driftstats' : {(sourcecolumn) : (stats)}}}





  postreports_dict['sourcecolumn_drift']['new_driftstats'] = \
  {(sourcecolumn) : {'max'         : (stat),
                     'quantile_99' : (stat),
                     'quantile_90' : (stat),
                     'quantile_66' : (stat),
                     'median'      : (stat),
                     'quantile_33' : (stat),
                     'quantile_10' : (stat),
                     'quantile_01' : (stat),
                     'min'         : (stat),
                     'mean'        : (stat),
                     'std'         : (stat),
                     'MAD'         : (stat),
                     'skew'        : (stat),
                     'shapiro_W'   : (stat),
                     'shapiro_p'   : (stat),
                     'nonpositive_ratio' : (stat),
                     'nan_ratio'   : (stat)}}
  ```

  ...




  ```





  from Automunge import *
  am = AutoMunge()




  test, test_ID, test_labels, \
  postreports_dict = \
  am.postmunge(postprocess_dict, df_test,
               testID_column = False,
               pandasoutput = 'dataframe', printstatus = 'summary', inplace = False,
               dupl_rows = False, TrainLabelFreqLevel = False,
               featureeval = False, traindata = False, noise_augment = 0,
               driftreport = False, inversion = False,
               returnedsets = True, shuffletrain = False,
               entropy_seeds = False, random_generator = False, sampling_dict = False,
               randomseed = False, encrypt_key = False, logger = {})
  ```

  * postprocess_dict: this is the dictionary returned from the initial
  application of automunge(.) which included normalization parameters to
  facilitate consistent processing of additional train or test data to the
  original processing of the train set. This requires a user to remember
  to download the dictionary at the original application of automunge,
  otherwise if this dictionary is not available a user can feed this
  subsequent test data to the automunge along with the original train data
  exactly as was used in the original automunge(.) call.

  * df_test: a pandas dataframe or numpy array containing a structured
  dataset intended for use to generate predictions from a machine learning
  model trained from the automunge returned sets. The set must be consistently
  formatted as the train set with consistent order of columns and if labels are
  included consistent labels. If desired the set may include an ID column. The
  tool supports the inclusion of non-index-range column as index or multicolumn
  index (requires named index columns). Such index types are added to the
  returned "ID" sets which are consistently shuffled and partitioned as the
  train and test sets. If numpy array passed any ID columns from train set should
  be included. Note that if a label column is included consistent with label column from
  automunge(.) call it will be automatically applied as label and similarly for ID columns.
  If desired can also be passed as a dataframe with only the label columns and features ommitted.

  * testID_column: defaults to False, user can pass a column header or list of column headers
  for columns that are to be segregated from the df_test set for return in the test_ID
  set (consistently shuffled and partitioned when applicable). For example this may
  be desired for an index column or any other column that the user wishes to exclude from
  the ML infill basis. Defaults to False, which can be used for cases where the df_test
  set does not contain any ID columns, or may also be passed as the default of False when
  the df_test ID columns match those passed to automunge(.) in the trainID_column parameter,
  in which case they are automatically given comparable treatment. Thus, the primary intended use
  of the postmunge(.) testID_column parameter is for cases where a df_test has ID columns
  different from those passed with df_train in automunge(.). Note that an integer column index
  or list of integer column indexes may also be passed such as if the source dataset was a numpy array.
  (In general though when passing data as numpy arrays we recommend matching ID columns to df_train.) In cases of unnamed
  non-range integer indexes, they are automatically extracted and returned in the ID sets as 'Orig_index'.
  If a user would like to include a column both in the features for encoding and the ID sets for original form
  retention, they can pass testID_column as a list of two lists, e.g. [list1, list2], where the first
  list may include ID columns to be struck from the features and the second list may include ID columns
  to be retained in the features. (We recommend only using testID_column specification for cases where df_test
  includes columns that weren't present in the original df_train, otehrwise it is automatic.)

  * pandasoutput: selects format of returned sets. Defaults to _'dataframe'_
  for returned pandas dataframe for all sets. Dataframes index is not always preserved, non-integer indexes are extracted to the ID sets,
  and automunge(.) generates an application specific range integer index in ID sets
  corresponding to the order of rows as they were passed to function). If set to _True_, features and ID sets are comparable, and single column label sets are converted to Pandas Series instead of dataframe. If set to _False_
  returns numpy arrays instead of dataframes. Note that the dataframes will have column
  specific data types, or returned numpy arrays will have a single data type.

  * printstatus: user can pass _True/False/'summary'/'silent'_ indicating whether the function will print
  status of processing during operation. Defaults to 'summary' to return a summary of returned sets and any feature importance or drift reports. True returns all printouts. When False only error
  message printouts generated. When 'summary' only reports and summary are printed. When 'silent' no printouts are generated.

  * inplace: defaults to False, when True the df_test passed to postmunge(.)
  is overwritten with the returned test set. This reduces memory overhead.
  For example, to take advantage with reduced memory overhead you could call postmunge(.) as:
  ```
  df_test, test_ID, test_labels, \
  postreports_dict = \
  am.postmunge(postprocess_dict, df_test, inplace = True)
  ```

  * dupl_rows: can be passed as _(True/False\)_ which indicates
  if duplicate rows will be consolidated to single instance in returned sets. (In
  other words, if same row included more than once, it will only be returned once.)
  Defaults to False for not activated. True applies consolidation to test set. Note
  this is applied prior to TrainLabelFreqLevel if elected. As implemented this does
  not take into account duplicate rows in test data which have different labels,
  only one version of features/label pair is returned. Please note dupl_rows option
  not recommended in cases where automunge(.) applied the ppd_append option
  and will return a printout and validation result as dupl_rows_ppd_append_postmunge_valresult.

  * TrainLabelFreqLevel: a boolean identifier _(True/False)_ which indicates
  if the TrainLabelFreqLevel method will be applied to oversample test
  data associated with underrepresented labels. The method adds multiples
  to test data rows for those labels with lower frequency resulting in
  an (approximately) levelized frequency. This defaults to False. Note that
  this feature may be applied to numerical label sets if the assigncat processing
  applied to the set in automunge(.) had included aggregated bins, such
  as for example 'exc3' for pass-through numeric with standard deviation bins,
  or 'exc4' for pass-through numeric with powers of ten bins. Note this
  method requires the inclusion of a designated label column. Further detail
  on oversampling provided in the essay [Oversampling with Automunge](https://medium.com/automunge/oversampling-with-automunge-3e69e500a32e).

  * featureeval: a boolean identifier _(True/False)_ to activate a feature
  importance evaluation, comparable to one performed in automunge but based on the
  test set passed to postmunge. Defaults to False. The results are returned in the
  postreports_dict object returned from postmunge as postreports_dict['featureimportance'].
  The results will also be printed out if printstatus is activated.  Note that sorted
  feature importance results are returned in postreports_dict['FS_sorted'], including
  columns sorted by metric and metric2. Relies on ML_cmnd parameters from original
  automunge(.) call.

  * driftreport: defaults to False, accepts one of {False, True, 'efficient', 'report_effic', 'report_full'}.
  Activates a drift report evaluation, in which drift statistics are collected
  for comparison between features in the train data that was passed to automunge(.) verses test data
  passed to postmunge(.). May include drift statistics associated with the raw data found
  in the input features, and may also include drift statistics associated with the returned
  data derived features as collected during derivations and recorded in the normalization
  parameters of a transformation. The results are returned in the
  postreports_dict object returned from postmunge as postreports_dict['driftreport'] and postreports_dict['sourcecolumn_drift'].
  Additional drift statistics for columns returned from a PCA or Binary dimensionality reduction are
  available in conjunction with the driftreport = True scenario, which are returned in postreports_dict['dimensionality_reduction_driftstats'].
  The results will also be printed out if printstatus is activated. Defaults to _False_, and:
    - _False_ means no postmunge drift assessment is performed
    - _True_ means an assessment is performed for both the source column and derived column
    stats
    - _'efficient'_ means that a postmunge drift assessment is only performed on the source
    columns (less information but better latency / computational efficiency)
    - _'report_effic'_ means that the efficient assessment is performed (only source column stats) and returned with
    no processing of data
    - _'report_full'_ means that the full assessment is performed for both the source column and derived column
    and returned with no processing of data
  Note that for transforms returning multi column sets, the drift stats will only be reported for first
  column in the categorylist.  Note that driftreport is not available in conjunction with privacy encoding.
  Further detail on drift reports are provided in the essay [Drift Reporting with Automunge](https://medium.com/automunge/drift-reporting-with-automunge-6a83eecbb253).

  * inversion: defaults to False, may be passed as one of {False, 'test', 'labels', 'denselabels', a list, or a set},
  where ‘test’ or ‘labels’ activate an inversion operation to recover, by a set of transformations
  mirroring the inversion of those applied in automunge(.), the form of test data or labels
  data to consistency with the source columns as were originally passed to automunge(.). As further clarification,
  passing inversion='test' should be in conjunction with passing df_test = test (where test is a dataframe of train
  or test data returned from an automunge or postmunge call), and passing inversion='labels' should be in conjunction
  with passing df_test = test_labels (where test_labels is a dataframe of labels or test_labels returned from an
  automunge or postmunge call). When inversion is passed as a list, accepts list of source column or returned column
  headers for inversion targets. When inversion is passed as a set, accepts a set with single entry of a returned
  column header serving as a custom target for the inversion path. (inversion list or set specification not supported when the automunge(.) privacy_encode option was activated.) 'denselabels' is for label set inversion in which
  labels were prepared in multiple formats, such as to recover the original form on each basis for comparison (currently supported for single labels_column case).
  The inversion operation is supported by the optional process_dict entry 'info_retention' and required for inversion process_dict entry
  'inverseprocess' (or 'custom_inversion'). Note that columns are only recovered for those sets in which a path of
  inversion was available by these processdict entries. Note that the path of
  inversion is prioritized to those returned sets with information retention and availability
  of inverseprocess functions. Note that both feature importance and Binary dimensionality
  reduction is supported, support is not expected for PCA. Note that recovery of label
  sets with label smoothing is supported. Note that during an inversion operation the
  postmunge function only considers the parameters postprocess_dict, df_test, inversion,
  pandasoutput, and/or printstatus. Note that in an inversion operation the
  postmunge(.) function returns three sets: a recovered set, a list of recovered columns, and
  a dictionary logging results of the path selection process and validation results. Please note that the general
  convention in library is that entries not successfully recovered from inversion may be recorded
  corresponding to the imputation value from the forward pass, NaN, or some other transformation function specific convention. Further
  details on inversion is provided in the essay [Announcing Automunge Inversion](https://medium.com/automunge/announcing-automunge-inversion-18226956dc).

  Here is an example of a postmunge call with inversion.
  ```
  df_invert, recovered_list, inversion_info_dict = \
  am.postmunge(postprocess_dict, test_labels, inversion='labels',
               pandasoutput=True, printstatus='summary', encrypt_key = False)
  ```

  Here is an example of a process_dict entry with the optional inversion entries included, such
  as may be defined by user for custom functions and passed to automunge(.) in the processdict
  parameter:
  ```
  process_dict.update({'mnmx' : {'dualprocess'    : self.process_mnmx,
                                 'singleprocess'  : None,
                                 'postprocess'    : self.postprocess_mnmx,
                                 'inverseprocess' : self.inverseprocess_mnmx,
                                 'info_retention' : True,
                                 'NArowtype'      : 'numeric',
                                 'MLinfilltype'   : 'numeric',
                                 'labelctgy'      : 'mnmx'}})
  ```

  * traindata: boolean _{True, False, 'train_no_noise', 'test_no_noise'}_, defaults to False. Only inspected when a transformation
  is called that treats train data different than test data (currently only relevant to
  DP family of transforms for noise injection to train sets or label smoothing transforms in smth family). When passed
  as True treats df_test as a train set for purposes of these specific transforms, otherwise
  default of False treats df_test as a test set (which turns off noise injection for DP transforms). As you would expect, 'train_no_noise' and 'test_no_noise' designates data passed to postmunge(.) as train or test data but turns off noise injections.

  * noise_augment: accepts type int or float(int) >=0. Defaults to 0. Used to specify
  a count of additional duplicates of test data prepared and concatenated with the
  original test set. Intended for use in conjunction with noise injection, such that
  the increased size of training corpus can be a form of data augmentation.
  Takes into account the traindata parameter passed to postmunge(.) for
  distinguishing whether to treat the duplicates as train or test data for purposes of noise injections.
  Note that injected noise will be uniquely randomly sampled with each duplicate. When noise_augment
  is received as a dtype of int, one of the duplicates will be prepared without noise. When
  noise_augment is received as a dtype of float(int), all of the duplicates will be prepared
  with noise. When shuffletrain is activated the duplicates are collectively shuffled, and can distinguish
  between duplicates by the original df_test.shape in comparison to the ID set's Automunge_index.
  Please be aware that with large dataframes a large duplicate count may run into memory constraints,
  in which case additional duplicates can be prepared in additional postmunge(.) calls. Note that the entropy seed budget only accounts for preparing one set of data, for the noise_augment option with entropy seeding we recommend passing a custom extra_seed_generator with a sampling_type specification, which will result in internal samplings of additional entropy seeds for each additional noise_augment duplicate (or for the bulk_seeds case with external sampling can increase entropy_seed budget proportional to the number of additional duplicates with noise).

  * returnedsets: Can be passed as one of _{True, False, 'test_ID', 'test_labels', 'test_ID_labels'}_.
  Designates the composition of the sets returned
  from a postmunge(.) call. Defaults to True for the full composition of five returned sets.
  With other options postmunge(.) only returns a single set, where for False that set consists
  of the test set, or for the other options returns the test set concatenated with the ID,
  labels, or both. For example:

  ```

  test, test_ID, test_labels, \
  postreports_dict = \
  am.postmunge(postprocess_dict, df_test, returnedsets = True)


  test = \
  am.postmunge(postprocess_dict, df_test, returnedsets = False)



  postprocess_dict['finalcolumns_labels']
  postprocess_dict['finalcolumns_trainID']
  ```

  * shuffletrain: can be passed as one of _{True, False}_ which indicates if the rows in
  the returned sets will be (consistently) shuffled. This value defaults to False.

  * entropy_seeds: defaults to False, accepts integer or list / flattened array of integers which may serve as supplemental sources of entropy for noise injections with DP transforms, we suggest integers in range {0:(2 \*\* 31 - 1)} to align with int32 dtype. entropy_seeds are specific to an automunge(.) or postmunge(.) call, in other words they are not returned in the populated postprocess_dict. Please note that for determinatino of how many entropy seeds are needed for various sampling_dict['sampling_type'] scenarios, can inspect postprocess_dict['sampling_report_dict'], where if insufficient seeds are available for these scenarios additional seeds will be derived with the extra_seed_generator.  Note that the sampling_report_dict will report requirements separately for train and test data and in the bulk_seeds case will have a row count basis. (If not passing test data to automunge(.) the test budget can be omitted.) Note that the entropy seed budget only accounts for preparing one set of data, for the noise_augment option we recommend passing a custom extra_seed_generator with a sampling_type specification, which will result in internal samplings of additional entropy seeds for each additional noise_augment duplicate (or for the bulk_seeds case with external sampling can increased entropy_seed budget proportional to the number of additional duplicates with noise).

  * random_generator: defaults to False, accepts numpy.random.Generator formatted random samplers which are applied for noise injections with DP transforms. Note that random_generator may optionally be applied in conjunction with entropy_seeds. When not specified applies numpy.random.PCG64. Examples of alternate generators could be a generator initialized with the [QRAND](https://github.com/pedrorrivero/qrand) library to sample from a quantum circuit. Or if the alternate library does not have numpy.random support, their output can be channeled as entropy_seeds for a similar benefit. random_generator is specific to an automunge(.) or postmunge(.) call, in other words it is not returned in the populated postprocess_dict. Please note that numpy formatted generators of both forms e.g. np.random.PCG64 or np.random.PCG64() may be passed, in the latter case any entropy seeding to this generator will be turned off automatically.

  * sampling_dict: defaults to False, accepts a dictionary including possible keys of {sampling_type, seeding_type, sampling_report_dict, stochastic_count_safety_factor, extra_seed_generator, sampling_generator}. sampling_dict is specific to an automunge(.) or postmunge(.) call, in other words they are not returned in the populated postprocess_dict.
    - sampling_dict['sampling_type'] accepts a string as one of {'default', 'bulk_seeds', 'sampling_seed', 'transform_seed'}
      - default: every sampling receives a common set of entropy_seeds per user specification which are shuffled and passed to each call
      - bulk_seeds: every sampling receives a unique supplemental seed for every sampled entry for sampling from sampling_generator (expended seed counts dependent on train/test/both configuration and numbers of rows). This scenario also defaults to sampling_dict['seeding_type'] = 'primary_seeds'
      - sampling_seed: every sampling operation receives one supplemental seed for sampling from sampling_generator (expended seed counts dependent on train/test/both configuration)
      - transform_seed: every noise transform receives one supplemental seed for sampling from sampling_generator (expended seed counts are the same independant of train/test/both configuration)
    - sampling_dict['seeding_type'] defaults to 'supplemental_seeds' or 'primary_seeds' as described below, where 'supplemental_seeds' means that entropy seeds are integrated into np.random.SeedSequence with entropy seeding from the operating system. Also accepts 'primary_seeds', in which user passed entropy seeds are the only source of seeding. Please note that 'primary_seeds' is used as the default for the bulk_seeds sampling_type and 'supplemental_seeds' is used as the default for other sampling_type options.
    - sampling_dict['sampling_report_dict'] defaults as False, accepts a prior populated postprocess_dict['sampling_report_dict'] from an automunge(.), call if this is not received it will be generated internally. sampling_report_dict is a resource for determining how many entropy_seeds are needed for various sampling_type scnearios.
    - sampling_dict['stochastic_count_safety_factor']: defaults to 0.15, accepts float 0-1, is associated with the bulk_seeds sampling_type case and is used as a multiplier for number of seeds populated for sampling operations with a stochastic number of entries
    - sampling_dict['sampling_generator']: used to specify which generator will be used for sampling operations other than generation of additional entropy_seeds. defaults to 'custom' (meaning the passed random_generator or when unspecified the default PCG64), and accepts one of {'custom', 'PCG64', 'MersenneTwister'}
    - sampling_dict['extra_seed_generator']: used to specify which generator will be used to sample additional entropy_seeds when more are needed to meet requirements of sampling_report_dict, defaults to 'custom' (meaning the passed random_generator or when unspecified the default PCG64), and accepts one of {'custom', 'PCG64', 'MersenneTwister', 'off', 'sampling_generator'}, where sampling_generator matches specification for sampling_generator, and 'off' turns off sampling of additional entropy seeds.

  * randomseed: defaults as False, also accepts integers within 0:2\*\*31-1. When not specified, randomseed is based on a uniform randomly sampled integer within that range using an entropy_seeds when available.
  This value is used as the postmunge(.) seed of randomness for operations that don't require matched random seeding to automunge(.).

  * encrypt_key: when the postprocess_dict was encrypted by way of the corresponding automunge(.) encrypt_key parameter, a key is either derived and returned in the closing automunge(.) printouts, or a key is based on user specification. To prepare additional data in postmunge(.) with the encrypted postprocess_dict requires passing that key to the postmunge(.) encrypt_key parameter. Defaults to False for when encryption was not performed, other accepts a bytes type object with expected length of 16, 24, or 32. Please note that the AES encryption is applied with the [pycrypto](https://github.com/pycrypto/pycrypto) python library which requires installation in order to run (we found there were installations available via conda install).

  * logger: user can initialize a dictionary externally (e.g. logger={}) and then pass it to this parameter (e.g. logger=logger). postmunge(.) will then log every printout scenario and validation result as they are being accessed in this external dictionary, which can then either be inspected for troubleshooting in cases of a halt scenario or archived. The report scenarios are loosely aligned with python logging module and also related to the tiers of printstatus.
  ```
  logger = {}

  test, test_ID, test_labels, \
  postreports_dict = \
  am.postmunge(postprocess_dict,
               df_test,
               logger=logger,
               printstatus='silent')


  print(logger['debug_report'])
  print(logger['info_report'])
  print(logger['warning_report'])


  ```



  When root categories of transformations are not assigned for a given column in
  assigncat, automunge performs an evaluation of data properties to infer
  appropriate means of feature engineering and numerical encoding. The default
  categories of transformations are as follows:
  - nmbr: for numeric data, columns are treated with z-score normalization. If
  binstransform parameter was activated this will be supplemented by a collection
  of bins indicating number of standard deviations from the mean. Note that default infill
  performed prior to ML infill is imputation with negative zero. The exception is for
  numeric data received in a column with pandas 'categoric' data type, which are instead binarized
  consistent to categoric sets (as 1010 or bnry). Note that numerical sets with 2 unique values in train
  set default to bnry. Note that features with majority str(int/float) entries are also treated as numeric.
  - 1010: for categorical data excluding special cases described following, columns are
  subject to binarization encoding via '1010' (e.g. for majority str or bytes type entries). If the
  number of unique entries in the column exceeds the parameter 'numbercategoryheuristic'
  (which defaults to 255), the encoding will instead be by hashing. Note that for default
  infill missing data has a distinct representation in the encoding space. Note that features with
  majority str(int/float) entries are treated as numeric.
  - bnry: for categorical data of <=2 unique values excluding infill (e.g. NaN), the
  column is encoded to 0/1. Note that numerical sets with 2 unique values in train
  set also default to bnry.
  - hsh2: for categorical data, if the number of unique entries in the column exceeds
  the parameter 'numbercategoryheuristic' (which defaults to 255), the encoding will
  instead be by 'hsh2' which is an ordinal (integer) encoding based on hashing.
  hsh2 is excluded from ML infill.
  - hash: for all unique entry categoric sets (based on sets with >75% unique entries),
  the encoding will be by hash which extracts distinct words within entries returned in
  a set of columns with an integer hashing. hash is excluded from ML infill. Note that for edge
  cases with large string entries resulting in too high dimensionality, the max_column_count
  parameter can be passed to default_assignparam in assignparam to put a cap on returned column count.
  - dat6: for time-series data, a set of derivations are performed returning
  'year', 'mdsn', 'mdcs', 'hmss', 'hmsc', 'bshr', 'wkdy', 'hldy' (these are defined
  in next section)
  - null: for columns without any valid values in training set (e.g. all NaN) column is deleted

  For label sets, we use a distinct set of root categories under automation. These are in
  some cases comparable to those listed above for training data, but differ in that the label
  sets will not include a returned 'NArw' (infill marker) even when parameter NArw_marker
  passed as True.
  - lbnb: for numerical data, a label set is treated with an 'nmbr' z-score normalization.
  - lbor: for categoric data of >2 unique values, a label set is treated with an ordinal encoding similar to 'ord3' ordinal encoding (frequency sorted order of encodings). lbor differs from ord3 in that missing data does not receive a distinct encoding and is instead grouped into the 0 activation (consistent with the ord3 parameter setting null_activation=False).
  - lbbn: for categoric data of <3 unique values, a label set is treated with an 'bnry' binary encoding (single column binary), also applied to numeric sets with 2 unique values

  Other label categories are available for assignment in assigncat, described below in the
  library of transforms section for label set encodings.

  Note that if a user wishes to avoid the automated assignment of default transformations,
  such as to leave those columns not specifically assigned to transformation categories in
  assigncat as unchanged, the powertransform parameter may be passed as values 'excl' or
  'exc2', where for 'excl' columns not explicitly assigned to a root category in assigncat
  will be left untouched, or for 'exc2' columns not explicitly assigned to a root category
  in assigncat will be forced to numeric and subject to default modeinfill. (These two excl
  arguments may be useful if a user wants to experiment with specific transforms on a
  subset of the columns without incurring processing time of an entire set.) This option may
  interfere with ML infill if data is not all numerically encoded.

  If the data is already numerically encoded with NaN entries for missing data, ML infill
  can be applied without further preprocessing transformations by passing powertransform = 'infill'.

  Note that for columns designated for label sets as a special case categorical data will
  default to 'ordl' (ordinal encoding) instead of '1010'. Also, numerical data will default
  to 'excl2' (pass-through) instead of 'nmbr'.

  - powertransform: if the powertransform parameter is activated, a statistical evaluation
  will be performed on numerical sets to distinguish between columns to be subject to
  bxcx, nmbr, or mnmx. Please note that we intend to further refine the specifics of this
  process in future implementations. Additionally, powertransform may be passed as values 'excl'
  or 'exc2', where for 'excl' columns not explicitly assigned to a root category in assigncat
  will be left untouched, or for 'exc2' columns not explicitly assigned to a root category in
  assigncat will be forced to numeric and subject to default modeinfill. (These two excl
  arguments may be useful if a user wants to experiment with specific transforms on a subset of
  the columns without incurring processing time of an entire set for instance.) To default to
  noise injection to numeric and (non-hashed) categoric, can apply 'DP1' or 'DP2', (or 'DT1','DT2', 'DB1', 'DB2').

  - floatprecision: parameter indicates the precision of floats in returned sets (16/32/64)
  such as for memory considerations.

  In all cases, if the parameter NArw_marker is activated returned sets will be
  supplemented with a NArw column indicating rows that were subject to infill. Each
  transformation category has a default infill approach detailed below.

  Note that default transformations can be overwritten within an automunge(.) call by way
  of passing custom transformdict family tree definitions which overwrite the family tree
  of the default root categories listed above. For instance, if a user wishes to process
  numerical columns with a default mean scaling ('mean') instead of z-score
  normalization ('nmbr'), the user may copy the transform_dict entries from the code-base
  for 'mean' root category and assign as a definition of the 'nmbr' root category, and then
  pass that defined transformdict in the automunge call. (Note that we don't need to
  overwrite the processdict for nmbr if we don't intend to overwrite its use as an entry
  in other root category family trees. Also it is good practice to retain any downstream
  entries such as in case the default for nmbr is used as an entry in some other root
  category's family tree.) Here's a demonstration.

  ```


  transformdict = {'nmbr' : {'parents' : [],
                             'siblings': [],
                             'auntsuncles' : ['mean'],
                             'cousins' : ['NArw'],
                             'children' : [],
                             'niecesnephews' : [],
                             'coworkers' : [],
                             'friends' : []}}



  train, train_ID, labels, \
  val, val_ID, val_labels, \
  test, test_ID, test_labels, \
  postprocess_dict = \
  am.automunge(df_train,
               transformdict = transformdict)

  ```

  Note if any of default transformation automation categories (nmbr/1010/ord3/text/bnry/dat6/null)
  are overwritten in this fashion, a user can still assign original default categories to distinct
  columns in assigncat by using corresponding alternates of (nmbd/101d/ordd/texd/bnrd/datd/nuld).

  ...




  * [Intro](https://github.com/Automunge/AutoMunge/blob/master/README.md#intro)
  * [Label Set Encodings](https://github.com/Automunge/AutoMunge/blob/master/README.md#label-set-encodings)
  * [Numeric Set Normalizations](https://github.com/Automunge/AutoMunge/blob/master/README.md#numeric-set-normalizations)
  * [Numeric Set Transformations](https://github.com/Automunge/AutoMunge/blob/master/README.md#numeric-set-transformations)
  * [Numeric Set Bins and Grainings](https://github.com/Automunge/AutoMunge/blob/master/README.md#numeric-set-bins-and-grainings)
  * [Sequential Numerical Set Transformations](https://github.com/Automunge/AutoMunge/blob/master/README.md#sequential-numerical-set-transformations)
  * [Categorical Set Encodings](https://github.com/Automunge/AutoMunge/blob/master/README.md#categorical-set-encodings)
  * [Date-Time Data Normalizations](https://github.com/Automunge/AutoMunge/blob/master/README.md#date-time-data-normalizations)
  * [Date-Time Data Bins](https://github.com/Automunge/AutoMunge/blob/master/README.md#date-time-data-bins)
  * [Differential Privacy Noise Injections](https://github.com/Automunge/AutoMunge/blob/master/README.md#differential-privacy-noise-injections)
  * [Misc. Functions](https://github.com/Automunge/AutoMunge/blob/master/README.md#misc-functions)
  * [Parsed Categoric Encodings](https://github.com/Automunge/AutoMunge/blob/master/README.md#Parsed-Categoric-Encodings)
  * [More Efficient Parsed Categoric Encodings](https://github.com/Automunge/AutoMunge/blob/master/README.md#more-efficient-Parsed-Categoric-Encodings)
  * [Multi-tier Parsed-Categoric-Encodings](https://github.com/Automunge/AutoMunge/blob/master/README.md#multi-tier-Parsed-Categoric-Encodings)
  * [List of Root Categories](https://github.com/Automunge/AutoMunge/blob/master/README.md#list-of-root-categories)
  * [List of Suffix Appenders](https://github.com/Automunge/AutoMunge/blob/master/README.md#list-of-suffix-appenders)
  * [Other Reserved Strings](https://github.com/Automunge/AutoMunge/blob/master/README.md#other-reserved-strings)
  * [Root Category Family Tree Definitions](https://github.com/Automunge/AutoMunge/blob/master/README.md#root-category-family-tree-definitions)
   ___

  Automunge has a built in library of transformations that can be passed for
  specific columns with assigncat. (A column if left unassigned will defer to
  the automated default methods to evaluate properties of the data to infer
  appropriate methods of numerical encoding.)  For example, a user can pass a
  min-max scaling method to a list of specific columns with headers 'column1',
  'column2' with:
  ```
  assigncat = {'mnmx':['column1', 'column2']}
  ```
  When a user assigns a column to a specific category, that category is treated
  as the root category for the tree of transformations. Each key has an
  associated transformation function (where the root category transformation function
  is only applied if the root key is also found in the tree of family primitives).
  The tree of family primitives, as introduced earlier, applies first the keys found
  in upstream primitives i.e. parents/siblings/auntsuncles/cousins. If a transform
  is applied for a primitive that includes downstream offspring, such as parents/
  siblings, then the family tree for that key with offspring is inspected to determine
  downstream offspring categories, for example if we have a parents key of 'mnmx',
  then any children/niecesnephews/coworkers/friends in the 'mnmx' family tree will
  be applied as parents/siblings/auntsuncles/cousins, respectively. Note that the
  designation for supplements/replaces refers purely to the question of whether the
  column to which the transform is being applied is kept in place or removed.

  Now we'll start here by listing again the family tree primitives for those root
  categories built into the automunge library. After that we'll give a quick
  narrative for each of the associated transformation functions. First here again
  are the family tree primitives.

  ```
  'parents' :
  upstream / first generation / replaces column / with offspring

  'siblings':
  upstream / first generation / supplements column / with offspring

  'auntsuncles' :
  upstream / first generation / replaces column / no offspring

  'cousins' :
  upstream / first generation / supplements column / no offspring

  'children' :
  downstream parents / offspring generations / replaces column / with offspring

  'niecesnephews' :
  downstream siblings / offspring generations / supplements column / with offspring

  'coworkers' :
  downstream auntsuncles / offspring generations / replaces column / no offspring

  'friends' :
  downstream cousins / offspring generations / supplements column / no offspring
  ```

  Here is a quick description of the transformation functions associated
  with each key which can either be assigned to a family tree primitive (or used
  as a root key). We're continuing to build out this library of transformations.
  In some cases different transformation categories may be associated with the
  same set of transformation functions, but may be distinguished by different
  family tree aggregations of transformation category sets.

  Note the design philosophy is that any transform can be applied to any type
  of data and if the data is not suited (such as applying a numeric transform
  to a categorical set) the transform will just return all zeros. Note the
  default infill refers to the infill applied under 'standardinfill'. Note the
  default NArowtype refers to the categories of data that won't be subject to
  infill.


  Label set encodings are unique in that they don't include an aggregated NArw missing data markers
  based on NArw_marker parameter. Missing data in label sets are subject to row deletions. Note that inversion of
  label set encodings is support by the postmunge(.) inversion parameter.
  * lbnm: for numeric label sets, entries are given a pass-through transform via 'exc2' (the numeric default under automation)
  * lbnb: for numeric label sets, entries are given a z-score normalization via 'nmbr'
  * lbor: for categoric label sets, entries are given an ordinal encoding via 'ordl' (the categoric default under automation)
  * lb10: for categoric label sets, entries are given a binary encoding via '1010'
  * lbos: for categoric label sets, entries are given an ordinal encoding via 'ordl' followed by a conversion to
  string by 'strg' (some ML libraries prefer string encoded labels to recognize the classification application)
  * lbte: for categoric label sets, entries are given a one-hot encoding (this has some interpretability benefits over ordinal)
  * lbbn: for categoric label sets with 2 unique values, entries are given a binarization via 'bnry'
  * lbsm: for categoric encoding with smoothed labels (i.e. "label smoothing"), further described in smth transform below (accepts activation parameter for activation threshold)
  * lbfs: for categoric encoding with fitted smoothed labels (i.e. fitted label smoothing), further described in fsmh transform below (accepts activation parameter for activation threshold)
  * lbda: for date-time label sets, entries are encoded comparable to 'dat6' described further below


  Please note that a survey of numeric transforms was provided in the paper [Numeric Encoding Options with Automunge](https://medium.com/automunge/a-numbers-game-b68ac261c40d).
  * nmbr/nbr2/nbr3/nmdx/nmd2/nmd3: z-score normalization<br/>
  (x - mean) / (standard deviation)
    - useful for: normalizing numeric sets of unknown distribution
    - default infill: negzeroinfill
    - default NArowtype: numeric
    - suffix appender: '\_nmbr' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'cap' and 'floor', default to False for no floor or cap,
        True means floor/cap based on training set min/max, otherwise passed values serve as floor/cap to scaling,
        noting that if cap<max then max reset to cap and if floor>min then min reset to floor
        cap and floor based on pre-transform values
      - 'stdev_cap', defaults to False, when cap and floor aren't specified, can pass an integer or float
        to serve a cap/floor based on this number of standard deviations from the mean
      - 'multiplier' and 'offset' to apply multiplier and offset to post-transform values, default to 1,0,
        note that multiplier is applied prior to offset
      - 'abs_zero', defaults to True, deactivate to turn off conversion of negative zeros to positive zeros applied prior to infill (this is included to supplement negzeroinfill)
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: mean / std / max / min / median / MAD
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes with full recovery
  * nbr4: z-score normalization similar to nmbr but with defaultinfill of zeroinfill instead of negzeroinfill and with abs_zero parameter deactivated<br/>
  * mean/mea2/mea3: mean normalization (like z-score in the numerator and min-max in the denominator)<br/>
  (x - mean) / (max - min)
  My intuition says z-score has some benefits but really up to the user which they prefer.
    - useful for: similar to z-score except data remains in fixed range
    - default infill: mean
    - default NArowtype: numeric
    - suffix appender: '_mean' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'cap' and 'floor', default to False for no floor or cap,
        True means floor/cap based on training set min/max, otherwise passed values serve as floor/cap to scaling,
        noting that if cap<max then max reset to cap and if floor>min then min reset to floor
        cap and floor based on pre-transform values
      - 'stdev_cap', defaults to False, when cap and floor aren't specified, can pass an integer or float
        to serve a cap/floor based on this number of standard deviations from the mean
      - 'multiplier' and 'offset' to apply multiplier and offset to post-transform values, default to 1,0,
        note that multiplier is applied prior to offset
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: minimum / maximum / mean / std / median / MAD
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes with full recovery
  * mnmx/mnm2/mnm5/mmdx/mmd2/mmd3: vanilla min-max scaling<br/>
  (x - min) / (max - min)
    - useful for: normalizing numeric sets where all non-negative output is preferred
    - default infill: mean
    - default NArowtype: numeric
    - suffix appender: '_mnmx' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'cap' and 'floor', default to False for no floor or cap,
        True means floor/cap based on training set min/max, otherwise passed values serve as floor/cap to scaling,
        noting that if cap<max then max reset to cap and if floor>min then min reset to floor
        cap and floor based on pre-transform values
      - 'stdev_cap', defaults to False, when cap and floor aren't specified, can pass an integer or float
        to serve a cap/floor based on this number of standard deviations from the mean
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: minimum / maximum / maxminusmin / mean / std / cap / floor / median / MAD
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes with full recovery
  * mnm3/mnm4: min-max scaling with outliers capped at 0.01 and 0.99 quantiles
    - useful for: normalizing numeric sets where all non-negative output is preferred, and outliers capped
    - default infill: mean
    - default NArowtype: numeric
    - suffix appender: '_mnm3' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - qmax or qmin to change the quantiles from 0.99/0.01
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: quantilemin / quantilemax / mean / std / median / MAD
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes
  * mnm6: min-max scaling with test floor set capped at min of train set (ensures
  test set returned values >= 0, such as might be useful for kernel PCA for instance)
    - useful for: normalizing numeric sets where all non-negative output is preferred, guarantees nonnegative in postmunge
    - default infill: mean
    - default NArowtype: numeric
    - suffix appender: '_mnm6' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: minimum / maximum / mean / std / median / MAD
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes
  * retn: related to min/max scaling but retains +/- of values, based on conditions
  if max>=0 and min<=0, x=x/(max-min), elif max>=0 and min>=0 x=(x-min)/(max-min),
  elif max<=0 and min<=0 x=(x-max)/(max-min)
    - useful for: normalization with sign retention for interpretability
    - default infill: mean
    - default NArowtype: numeric
    - suffix appender: '_retn' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'cap' and 'floor', default to False for no floor or cap,
        True means floor/cap based on training set min/max, otherwise passed values serve as floor/cap to scaling,
        noting that if cap<max then max reset to cap and if floor>min then min reset to floor
        cap and floor based on pre-transform values
      - 'stdev_cap', defaults to False, when cap and floor aren't specified, can pass an integer or float
        to serve a cap/floor based on this number of standard deviations from the mean
      - 'multiplier' and 'offset' to apply multiplier and offset to post-transform values, default to 1,0,
        note that multiplier is applied prior to offset
      - 'divisor' to select between default of 'minmax' or 'mad, 'std', where minmax means scaling by divisor of max-min
  	std based on scaling by divisor of standard deviation and mad by median absolute deviation
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: minimum / maximum / mean / std / median / MAD
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes with full recovery
  * rtbn: retain normalization supplemented by ordinal encoded standard deviation bins
  * rtb2: retain normalization supplemented by one-hot encoded standard deviation bins
  * MADn/MAD2: mean absolute deviation normalization, subtract set mean <br/>
  (x - mean) / (mean absolute deviation)
    - useful for: normalizing sets with fat-tailed distribution
    - default infill: mean
    - default NArowtype: numeric
    - suffix appender: '_MADn' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: mean / MAD / maximum / minimum / median
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes with full recovery
  * MAD3: mean absolute deviation normalization, subtract set maximum<br/>
  (x - maximum) / (mean absolute deviation)
    - useful for: normalizing sets with fat-tailed distribution
    - default infill: mean
    - default NArowtype: numeric
    - suffix appender: '_MAD3' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: mean / MAD / datamax / maximum / minimum / median
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes with full recovery
  * mxab: max absolute scaling normalization (just including this one for completeness, retn is a much better option to ensure consistent scaling between sets)<br/>
  (x) / max absolute
    - useful for: normalizing sets by dividing by max, commonly used in some circles
    - default infill: mean
    - default NArowtype: numeric
    - suffix appender: '_mxab' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: minimum / maximum / maxabs / mean / std
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes with full recovery
  * lgnm: normalization intended for lognormal distributed numerical sets,
  achieved by performing a logn transform upstream of a nmbr normalization.
    - useful for: normalizing sets within proximity of lognormal distribution
    - default infill: mean
    - default NArowtype: positivenumeric
    - suffix appender: '_lgnm_nmbr'
    - assignparam parameters accepted: can pass params to nmbr consistent with nmbr documentation above
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: consistent with both logn and nmbr
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes with full recovery


  * bxcx/bxc2/bxc3/bxc4/bxc5: performs Box-Cox power law transformation. Applies infill to
  values <= 0. Note we currently have a test for overflow in returned results and if found
  set to 0. Please note that this method makes use of scipy.stats.boxcox. Please refer to
  family trees below for full set of transformation categories associated with these roots.
    - useful for: translates power law distributions to closer approximate gaussian
    - default infill: mean (i.e. mean of values > 0)
    - default NArowtype: positivenumeric
    - suffix appender: '_bxcx' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: trnsfrm_mean / bxcx_lmbda / bxcxerrorcorrect / mean
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: no
  * qttf/qtt2: performs quantile transformation to transform distribution properties of feature set.
  Please note this method makes use of sklearn.preprocessing.QuantileTransformer from Scikit-Learn.
  qttf converts to a normal output distribution, qtt2 converts to a uniform output distribution. When received data is all non-numeric returns as 0.
    - useful for: translates distributions to closer approximate gaussian (may be applied as alternative to bxcx)
    - default infill: mean
    - default NArowtype: numeric
    - suffix appender: '_qttf' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'output_distribution': defualts to 'normal' for qttf, or 'uniform' for qtt2
      - 'random_state': based on automunge(.) randomseed
      - other parameters and their type requirements consistent with scikit documentation (n_quantiles, ignore_implicit_zeros, subsample)
      - note that copy parameter not supported, fit parameters not supported
    - driftreport postmunge metrics: input_max / input_min / input_stdev / input_mean
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes
  * log0/log1: performs logarithmic transform (base 10). Applies infill to values <= 0.
    - useful for: sets with mixed range of large and small values
    - default infill: meanlog
    - default NArowtype: positivenumeric
    - suffix appender: '_log0' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: meanlog
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes with full recovery
  * logn: performs natural logarithmic transform (base e). Applies infill to values <= 0.
    - useful for: sets with mixed range of large and small values
    - default infill: meanlog
    - default NArowtype: positivenumeric
    - suffix appender: '_logn' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: meanlog
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes with full recovery
  * sqrt: performs square root transform. Applies infill to values < 0.
    - useful for: common mathematic transform
    - default infill: mean
    - default NArowtype: nonnegativenumeric
    - suffix appender: '_sqrt' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: meansqrt
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes with full recovery
  * addd: performs addition of an integer or float to a set
    - useful for: common mathematic transform
    - default infill: mean
    - default NArowtype: numeric
    - suffix appender: '_addd' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'add' for value added (default to 1)
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: mean, add
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes with full recovery
  * sbtr: performs subtraction of an integer or float to a set
    - useful for: common mathematic transform
    - default infill: mean
    - default NArowtype: numeric
    - suffix appender: '_sbtr' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'subtract' for value subtracted (default to 1)
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: mean, subtract
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes with full recovery
  * mltp: performs multiplication of an integer or float to a set
    - useful for: common mathematic transform
    - default infill: mean
    - default NArowtype: numeric
    - suffix appender: '_mltp' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'multiply' for value multiplied (default to 2)
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: mean, multiply
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes with full recovery
  * divd: performs division of an integer or float to a set
    - useful for: common mathematic transform
    - default infill: mean
    - default NArowtype: numeric
    - suffix appender: '_divd' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'divide' for value subtracted (default to 2)
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: mean, divide
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes with full recovery
  * rais: performs raising to a power of an integer or float to a set
    - useful for: common mathematic transform
    - default infill: mean
    - default NArowtype: numeric
    - suffix appender: '_rais' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'raiser' for value raised (default to 2)
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: mean, raiser
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes with full recovery
  * absl: performs absolute value transform to a set
    - useful for: common mathematic transform
    - default infill: mean
    - default NArowtype: numeric
    - suffix appender: '_absl' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: mean
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes with partial recovery
  * trigometric functions sint/cost/tant/arsn/arcs/artn: performs trigometric transformations.
  Transforms are built on top of numpy np.sin/np.cos/np.tan/np.arcsin/np.arccos/np.arctan respectively.
    - useful for: common mathematic transform
    - default infill: adjinfill
    - default NArowtype: numeric
    - suffix appender: based on the family tree category
    - assignparam parameters accepted:
      - 'operation': defaults to operation associated with the function, accepts {'sin', 'cos', 'tan', 'arsn', 'arcs', 'artn'}
    - driftreport postmunge metrics: maximum, minimum
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes with partial recovery

  Q Notation family of transforms return a multicolumn binary encoded set with registers for sign, integers, and fractionals.
  Transforms accept parameters integer_bits / fractional_bits / sign_bit for register sizes, care should be taken for
  adequate registers to avoid overflow (overflow entries have values replaced with max or min capacity based on register sizes).
  Default register sizes were selected to accommodate z-score normalized data with +/-6
  standard deviations from mean and approximately 4 significant figures in decimals. For example, with default parameters an input column 'floats' will return columns: ['floats_qbt1_sign', 'floats_qbt1_2^2', 'floats_qbt1_2^1', 'floats_qbt1_2^0', 'floats_qbt1_2^-1', 'floats_qbt1_2^-2', 'floats_qbt1_2^-3', 'floats_qbt1_2^-4', 'floats_qbt1_2^-5', 'floats_qbt1_2^-6', 'floats_qbt1_2^-7', 'floats_qbt1_2^-8', 'floats_qbt1_2^-9', 'floats_qbt1_2^-10', 'floats_qbt1_2^-11', 'floats_qbt1_2^-12'].
  Further details on the Q notation family of transforms provided in the essay [A New Kind of Data](https://medium.com/automunge/a-new-kind-of-data-1f1bcf90822d).
  * qbt1: binary encoded signed floats with registers for sign, integers, and fractionals, default overflow at +/- 8.000
    - useful for: feeding normalized floats to quantum circuits
    - default infill: negative zero
    - default NArowtype: numeric
    - suffix appender: '_qbt1_2^#' where # integer associated with register and also '_qbt1_sign'
    - assignparam parameters accepted:
      - suffix: defaults to 'qbt1'
      - sign_bit: boolean defaults to True to include sign register
      - integer_bits: defaults to 3 for number of bits in register
      - fractional_bits: defaults to 12 for number of bits in register
      - angle_bits: boolean, defaults to False, when activated records activations as angles 0/pi instead of 0/1
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: maximum, minimum, mean, stdev
    - returned datatype: int8
    - inversion available: yes with full recovery
  * qbt2: binary encoded signed integers with registers for sign and integers, default overflow at +/-32,767
    - useful for: feeding floats to quantum circuits
    - default infill: zero
    - default NArowtype: negative zero
    - suffix appender: '_qbt2_2^#' where # integer associated with register and also '_qbt2_sign'
    - assignparam parameters accepted:
      - suffix: defaults to 'qbt2'
      - sign_bit: boolean defaults to True to include sign register
      - integer_bits: defaults to 15 for number of bits in register
      - fractional_bits: defaults to 0 for number of bits in register
      - angle_bits: boolean, defaults to False, when activated records activations as angles 0/pi instead of 0/1
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: maximum, minimum, mean, stdev
    - returned datatype: int8
    - inversion available: yes with full recovery
  * qbt3: binary encoded unsigned floats with registers for integers and fractionals, default overflow at 8.000 and <0
    - useful for: feeding unsigned normalized floats to quantum circuits
    - default infill: zero
    - default NArowtype: numeric
    - suffix appender: '_qbt3_2^#' where # integer associated with register
    - assignparam parameters accepted:
      - suffix: defaults to 'qbt3'
      - sign_bit: boolean defaults to False, activate to include sign register
      - integer_bits: defaults to 3 for number of bits in register
      - fractional_bits: defaults to 13 for number of bits in register
      - angle_bits: boolean, defaults to False, when activated records activations as angles 0/pi instead of 0/1
    - driftreport postmunge metrics: maximum, minimum, mean, stdev
    - returned datatype: int8
    - inversion available: yes with full recovery
  * qbt4: binary encoded unsigned integers with registers for integers, default overflow at 65,535 and <0
    - useful for: feeding unsigned floats to quantum circuits
    - default infill: zero
    - default NArowtype: numeric
    - suffix appender: '_qbt4_2^#' where # integer associated with register
    - assignparam parameters accepted:
      - suffix: defaults to 'qbt4'
      - sign_bit: boolean defaults to False, activate to include sign register
      - integer_bits: defaults to 16 for number of bits in register
      - fractional_bits: defaults to 0 for number of bits in register
      - angle_bits: boolean, defaults to False, when activated records activations as angles 0/pi instead of 0/1
    - driftreport postmunge metrics: maximum, minimum, mean, stdev
    - returned datatype: int8
    - inversion available: yes with full recovery

  Other Q Notation root categories:
  - nmqb has upstream z score to qbt1 and z score not retained
  - nmq2 has upstream z score to qbt1 and z score is retained
  - mmqb has upstream min max to qbt3 and min max not retained
  - mmq2 has upstream min max to qbt3 and min max is retained
  - lgnr logarithmic number representation, registers 1 for sign, 1 for log sign, 4 log integer registers, 3 log fractional registers


  * pwrs: bins groupings by powers of 10 (for values >0)
    - useful for: feature engineering for linear models, also for oversampling bins with TrainFreqLevelizer parameter
    - default infill: no activation (defaultinfill not supported)
    - default NArowtype: positivenumeric
    - suffix appender: '\_pwrs_10^#' where # is integer indicating target powers of 10 for column
    - assignparam parameters accepted:
      - 'negvalues', boolean defaults to False, True bins values <0
        (recommend using pwr2 instead of this parameter since won't update NArowtype)
      - 'suffix': to change suffix appender (leading underscore added internally)
      - 'zeroset': boolean defaults to False, when True the number zero receives a distinct activation instead of grouping with missing data (recommend also updating NArowtype, such as to nonnegativenumeric)
      - 'cap': defaults to False for no cap, can pass as integer or float and > values replaced with this figure
      - 'floor': defaults to False for no floor, can pass as integer or float and < values replaced with this figure
    - driftreport postmunge metrics: powerlabelsdict / meanlog / maxlog / activation_ratios
    - returned datatype: int8
    - inversion available: yes with partial recovery
  * pwr2: bins groupings by powers of 10 (comparable to pwrs with negvalues parameter activated for values >0 & <0)
    - useful for: feature engineering for linear models, also for oversampling bins with TrainFreqLevelizer parameter
    - default infill: no activation (defaultinfill not supported)
    - default NArowtype: nonzeronumeric
    - suffix appender: '\_pwr2_10^#' or '\_pwr2_-10^#' where # is integer indicating target powers of 10 for column
    - assignparam parameters accepted:
      - 'negvalues', boolean defaults to True, True bins values <0
        (recommend using pwrs instead of this parameter since won't update NArowtype)
      - 'zeroset': boolean defaults to False, when True the number zero receives a distinct activation instead of grouping with missing data (recommend also updating NArowtype, such as to numeric)
      - 'suffix': to change suffix appender (leading underscore added internally)
      - 'cap': defaults to False for no cap, can pass as integer or float and > values replaced with this figure
      - 'floor': defaults to False for no floor, can pass as integer or float and < values replaced with this figure
    - driftreport postmunge metrics: powerlabelsdict / labels_train / missing_cols / activation_ratios
    - returned datatype: int8
    - inversion available: yes with partial recovery
  * pwor: for numerical sets, outputs an ordinal encoding indicating where a
  value fell with respect to powers of 10
    - useful for: ordinal version of pwrs
    - default infill: zero (defaultinfill not supported)
    - default NArowtype: positivenumeric
    - suffix appender: '_pwor' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'negvalues', boolean defaults to False, True bins values <0 (recommend using por2 instead of this parameter since won't update NArowtype)
      - 'zeroset': boolean defaults to False, when True the number zero receives a distinct activation instead of grouping with missing data (recommend also updating NArowtype, such as to nonnegativenumeric)
      - 'suffix': to change suffix appender (leading underscore added internally)
      - 'cap': defaults to False for no cap, can pass as integer or float and > values replaced with this figure
      - 'floor': defaults to False for no floor, can pass as integer or float and < values replaced with this figure
    - driftreport postmunge metrics: meanlog / maxlog / ordl_activations_dict
    - returned datatype: conditional based on size of encoding space (uint8 / uint16 / uint32)
    - inversion available: yes with partial recovery
  * por2: for numerical sets, outputs an ordinal encoding indicating where a
  value fell with respect to powers of 10 (comparable to pwor with negvalues parameter activated)
    - useful for: ordinal version of pwr2
    - default infill: zero (a distinct encoding) (defaultinfill not supported)
    - default NArowtype: nonzeronumeric
    - suffix appender: '_por2' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'negvalues', boolean defaults to True, True bins values <0 (recommend using pwor instead of this parameter since won't update NArowtype)
      - 'zeroset': boolean defaults to False, when True the number zero receives a distinct activation instead of grouping with missing data (recommend also updating NArowtype, such as to numeric)
      - 'suffix': to change suffix appender (leading underscore added internally)
      - 'cap': defaults to False for no cap, can pass as integer or float and > values replaced with this figure
      - 'floor': defaults to False for no floor, can pass as integer or float and < values replaced with this figure
    - driftreport postmunge metrics: train_replace_dict / test_replace_dict / ordl_activations_dict
    - returned datatype: conditional based on size of encoding space (uint8 / uint16 / uint32)
    - inversion available: yes with partial recovery
  * pwbn: comparable to pwor but followed by a binary encoding, such as may be useful for data with
  high variability
    - useful for: ordinal version of pwrs
    - default infill: zero (a distinct encoding)
    - default NArowtype: nonzeronumeric
    - suffix appender: '_pwbn_1010_#' (where # is integer for binary encoding activation number)
    - assignparam parameters accepted:
      - accepts parameters comparable to pwor
    - driftreport postmunge metrics: train_replace_dict / test_replace_dict / ordl_activations_dict
    - returned datatype: int8
    - inversion available: yes with partial recovery
  * por3: comparable to por2 but followed by a binary encoding, such as may be useful for data with
  high variability
    - useful for: ordinal version of pwr2
    - default infill: zero (a distinct encoding)
    - default NArowtype: nonzeronumeric
    - suffix appender: '_por3_1010_#' (where # is integer for binary encoding activation number)
    - assignparam parameters accepted:
      - accepts parameters comparable to pwor
    - driftreport postmunge metrics: train_replace_dict / test_replace_dict / ordl_activations_dict
    - returned datatype: int8
    - inversion available: yes with partial recovery
  * bins: for numerical sets, outputs a set of columns (defaults to 6) indicating where a
  value fell with respect to number of standard deviations from the mean of the
  set (i.e. integer suffix represent # from mean as <-2:0, -2-1:1, -10:2, 01:3, 12:4, >2:5)
  Note this can be activated to supplement numeric sets with binstransform automunge parameter.
    - useful for: feature engineering for linear models, also for oversampling bins with TrainFreqLevelizer parameter
    - default infill: mean
    - default NArowtype: numeric
    - suffix appender: '\_bins\_#' where # is integer identifier of bin
    - assignparam parameters accepted:
      - bincount integer for number of bins, defaults to 6
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: binsmean / binsstd / activation_ratios
    - returned datatype: int8
    - inversion available: yes with partial recovery
  * bsor: for numerical sets, outputs an ordinal encoding indicating where a
  value fell with respect to number of standard deviations from the mean of the
  set (i.e. integer encoding represent # from mean as <-2:0, -2-1:1, -10:2, 01:3, 12:4, >2:5)
    - useful for: ordinal version of bins
    - default infill: mean
    - default NArowtype: numeric
    - suffix appender: '_bsor' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - bincount as integer for # of bins (defaults to 6)
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: ordinal_dict / ordl_activations_dict / binsmean / binsstd
    - returned datatype: conditional based on size of encoding space (uint8 / uint16 / uint32)
    - inversion available: yes with partial recovery
  * bnwd/bnwK/bnwM: for numerical set graining to fixed width bins for one-hot encoded bins
  (columns without activations in train set excluded in train and test data).
  bins default to width of 1/1000/1000000 e.g. for bnwd/bnwK/bnwM
    - useful for: bins for sets with known recurring demarcations
    - default infill: mean
    - default NArowtype: numeric
    - suffix appender: '\_bnwd\_#1\_#2' where #1 is the width and #2 is the bin identifier (# from min)
                       and 'bnwd' as bnwK or bnwM based on variant
    - assignparam parameters accepted:
      - 'width' to set bin width
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: binsmean / bn_min / bn_max / bn_delta / bn_count / bins_id /
  			           bins_cuts / bn_width_bnwd (or bnwK/bnwM) / textcolumns / activation_ratios
    - returned datatype: int8
    - inversion available: yes with partial recovery
  * bnwo/bnKo/bnMo: for numerical set graining to fixed width bins for ordinal encoded bins
  (integers without train set activations still included in test set).
  bins default to width of 1/1000/1000000 e.g. for bnwd/bnwK/bnwM
    - useful for: ordinal version of preceding
    - default infill: mean
    - default NArowtype: numeric
    - suffix appender: '_bnwo' (or '_bnKo', '_bnMo')
    - assignparam parameters accepted:
      - 'width' to set bin width
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: binsmean / bn_min / bn_max / bn_delta / bn_count / bins_id /
  			           bins_cuts / bn_width / ordl_activations_dict
    - returned datatype: conditional based on size of encoding space (uint8 / uint16 / uint32)
    - inversion available: yes with partial recovery
  * bnep/bne7/bne9: for numerical set graining to equal population bins for one-hot encoded bins.
  bin count defaults to 5/7/9 e.g. for bnep/bne7/bne9
    - useful for: bins for sets with unknown demarcations
    - default infill: no activation (defaultinfill not supported)
    - default NArowtype: numeric
    - suffix appender: '\_bnep\_#1' where #1 is the bin identifier (# from min) (or bne7/bne9 instead of bnep)
    - assignparam parameters accepted:
      - 'bincount' to set number of bins
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: binsmean / bn_min / bn_max / bn_delta / bn_count / bins_id /
                                     bins_cuts / bincount_bnep (or bne7/bne9) / textcolumns /
                                     activation_ratios
    - returned datatype: int8
    - inversion available: yes with partial recovery
  * bneo/bn7o/bn9o: for numerical set graining to equal population bins for ordinal encoded bins.
  bin count defaults to 5/7/9 e.g. for bneo/bn7o/bn9o
    - useful for: ordinal version of preceding
    - default infill: adjacent cell
    - default NArowtype: numeric
    - suffix appender: '\_bneo' (or bn7o/bn9o)
    - assignparam parameters accepted:
      - 'bincount' to set number of bins
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: binsmean / bn_min / bn_max / bn_delta / bn_count / bins_id /
  			           bins_cuts / bincount / ordl_activations_dict
    - returned datatype: conditional based on size of encoding space (uint8 / uint16 / uint32)
    - inversion available: yes with partial recovery
  * bkt1: for numerical set graining to user specified encoded bins. First and last bins unconstrained.
    - useful for: bins for sets with known irregular demarcations
    - default infill: no activation (defaultinfill not supported)
    - default NArowtype: numeric
    - suffix appender: '\_bkt1\_#1' where #1 is the bin identifier (# from min)
    - assignparam parameters accepted:
      - 'buckets', a list of numbers, to set bucket boundaries (leave out +/-'inf')
        defaults to [0,1,2] (arbitrary plug values), can also pass buckets values as percent of range by framing as a set instead of list e.g. {0,0.25,0.50,1}
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: binsmean / buckets_bkt1 / bins_cuts / bins_id / textcolumns /
  					   activation_ratios
    - returned datatype: int8
    - inversion available: yes with partial recovery
  * bkt2: for numerical set graining to user specified encoded bins. First and last bins bounded.
    - useful for: bins for sets with known irregular demarcations, similar to preceding but first and last bins bounded
    - default infill: no activation (defaultinfill not supported)
    - default NArowtype: numeric
    - suffix appender: '\_bkt2\_#1' where #1 is the bin identifier (# from min)
    - assignparam parameters accepted:
      - 'buckets', a list of numbers, to set bucket boundaries
        defaults to [0,1,2] (arbitrary plug values), can also pass buckets values as percent of range by framing as a set instead of list e.g. {0,0.25,0.50,1}
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: binsmean / buckets_bkt2 / bins_cuts / bins_id / textcolumns /
  					   activation_ratios
    - returned datatype: int8
    - inversion available: yes with partial recovery
  * bkt3: for numerical set graining to user specified ordinal encoded bins. First and last bins unconstrained.
    - useful for: ordinal version of bkt1
    - default infill: unique activation
    - default NArowtype: numeric
    - suffix appender: '_bkt3' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'buckets', a list of numbers, to set bucket boundaries (leave out +/-'inf')
        defaults to [0,1,2] (arbitrary plug values), can also pass buckets values as percent of range by framing as a set instead of list e.g. {0,0.25,0.50,1}
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: binsmean / buckets / bins_cuts / bins_id / ordl_activations_dict
    - returned datatype: conditional based on size of encoding space (uint8 / uint16 / uint32)
    - inversion available: yes with partial recovery
  * bkt4: for numerical set graining to user specified ordinal encoded bins. First and last bins bounded.
    - useful for: ordinal version of bkt2
    - default infill: unique activation
    - default NArowtype: numeric
    - suffix appender: '_bkt4' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'buckets', a list of numbers, to set bucket boundaries
        defaults to [0,1,2] (arbitrary plug values), can also pass buckets values as percent of range by framing as a set instead of list e.g. {0,0.25,0.50,1}
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: binsmean / buckets / bins_cuts / bins_id / ordl_activations_dict
    - returned datatype: conditional based on size of encoding space (uint8 / uint16 / uint32)
    - inversion available: yes with partial recovery
  * note that bins each have variants for one-hot vs ordinal vs binary encodings
  one-hot : bkt1, bkt2, bins, bnwd, bnwK, bnwM, bnep, bne7, bne9, pwrs, pwr2
  ordinal : bkt3, bkt4, bsor, bnwo, bnKo, bnMo, bneo, bn7o, bn9o, pwor, por2
  binary  : bkb3, bkb4, bsbn, bnwb, bnKb, bnMb, bneb, bn7b, bn9b, pwbn, por3
  * tlbn: returns equal population bins in separate columns with activations replaced by min-max scaled
  values within that segment's range (between 0-1) and other values subject to an infill of -1
  (intended for use to evaluate feature importance of different segments of a numerical set's distribution
  with metric2 results from a feature importance evaluation). Further detail on the tlbn transform provided
  in the essay [Automunge Influence](https://medium.com/automunge/automunge-influence-382d44786e43).
    - useful for: evaluating relative feature importance between different segments of a numeric set distribution
    - default infill: no activation (this is the recommended infill for this transform)
    - default NArowtype: numeric
    - suffix appender: '\_tlbn\_#' where # is the bin identifier,  and max# is right tail / min# is left tail
    - assignparam parameters accepted:
      - 'bincount' to set number of bins (defaults to 9)
      - 'buckets', defaults to False, can pass as a list of bucket boundaries for custom distribution segments
        which will take precedence over bincount (leave out -/+inf which will be added for first and last bins internally)
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: binsmean / bn_min / bn_max / bn_delta / bn_count / bins_id /
  			           bins_cuts / bincount_tlbn / textcolumns / activation_ratios
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes


  Please note that sequential transforms assume the forward progression of time towards direction of bottom of dataframe.
  Please note that only stdrdinfill (adjinfill) are supported for shft transforms.
  * dxdt/d2dt/d3dt/d4dt/d5dt/d6dt: rate of change (row value minus value in preceding row), high orders
  return lower orders (e.g. d2dt returns original set, dxdt, and d2dt), all returned sets include 'retn'
  normalization which scales data with min/max while retaining +/- sign
    - useful for: time series data, also bounding sequential sets
    - default infill: adjacent cells
    - default NArowtype: numeric
    - suffix appender: '_dxdt' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'periods' sets number of time steps offset to evaluate, defaults to 1
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: positiveratio / negativeratio / zeroratio / minimum / maximum / mean / std
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: no
  * dxd2/d2d2/d3d2/d4d2/d5d2/d6d2: denoised rate of change (average of last two or more rows minus average
  of preceding two or more rows), high orders return lower orders (e.g. d2d2 returns original set, dxd2,
  and d2d2), all returned sets include 'retn' normalization
    - useful for: time series data, also bounding sequential sets
    - default infill: adjacent cells
    - default NArowtype: numeric
    - suffix appender: '_dxd2' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'periods' sets number of time steps offset to evaluate, defaults to 2
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: positiveratio / negativeratio / zeroratio / minimum / maximum / mean / std
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: no
  * nmdx/nmd2/nmd3/nmd4/nmd5/nmd6: comparable to dxdt but includes upstream of sequential transforms a
  nmrc numeric string parsing top extract numbers from string sets
  * mmdx/mmd2/mmd3/mmd4/mmd5/mmd6: comparable to dxdt but uses z-score normalizations via 'nbr2' instead of 'retn'
  * dddt/ddd2/ddd3/ddd4/ddd5/ddd6: comparable to dxdt but no normalizations applied
  * dedt/ded2/ded3/ded4/ded5/ded6: comparable to dxd2 but no normalizations applied
    - inversion available: no
  * shft/shf2/shf3: shifted data forward by a period number of time steps defaulting to 1/2/3. Note that NArw aggregation
  not supported for shift transforms, infill only available as adjacent cell
    - useful for: time series data, carrying prior time steps forward
    - default infill: adjacent cells (defaultinfill not supported)
    - default NArowtype: numeric
    - suffix appender: '_shft'  in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'periods' sets number of time steps offset to evaluate, defaults to 1/2/3
      - 'suffix' sets the suffix appender of returned column
        as may be useful to distinguish if applying this multiple times
    - driftreport postmunge metrics: positiveratio / negativeratio / zeroratio / minimum / maximum / mean / std
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes


  * bnry: converts sets with two values to boolean identifiers. Defaults to assigning
  1 to most common value and 0 to second most common, unless 1 or 0 is already included
  in most common of the set then defaults to maintaining those designations. If applied
  to set with >2 entries applies infill to those entries beyond two most common.
    - useful for: binarizing sets with two unique values (differs from 1010 in that distinct encoding isn't registered for missing data to return single column)
    - default infill: most common value
    - default NArowtype: justNaN
    - suffix appender: '_bnry' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'str_convert': boolean defaults as False for distinct encodings between numbers and string equivalents
        e.g. 2 != '2', or when passed as True e.g. 2 == '2'. Also can be passed as 'conditional_on_bytes' which resets to True when bytes entries are present in train set otherwise resets to False.
      - 'suffix': to change suffix appender (leading underscore added internally)
      - 'invert': reverses the 0/1 convention (results in most common value having 0 activation which is default for lbbn label processing to resolve a remote edge case for labels)
    - driftreport postmunge metrics: missing / 1 / 0 / extravalues / oneratio / zeroratio
    - returned datatype: int8
    - inversion available: yes with full recovery
  * bnr2: (Same as bnry except for default infill.)
    - useful for: similar to bnry preceding but with different default infill
    - default infill: least common value
    - default NArowtype: justNaN
    - suffix appender: '_bnr2' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'str_convert': boolean defaults as False for distinct encodings between numbers and string equivalents
        e.g. 2 != '2', or when passed as True e.g. 2 == '2'. Also can be passed as 'conditional_on_bytes' which resets to True when bytes entries are present in train set otherwise resets to False.
      - 'suffix': to change suffix appender (leading underscore added internally)
      - 'invert': reverses the 0/1 convention (results in most common value having 0 activation which is default for lbbn label processing to resolve a remote edge case for labels)
    - driftreport postmunge metrics: missing / 1 / 0 / extravalues / oneratio / zeroratio
    - returned datatype: int8
    - inversion available: yes with full recovery
  * text/txt2: converts categorical sets to one-hot encoded set of boolean identifiers
  (consistently encodings numbers and numerical string equivalents due to column labeling convention, e.g. 12 == '12').
  Note that text and onht are implemented with the same functions by updates to the suffix_convention parameter.
    - useful for: one hot encoding, returns distinct column activation per unique entry
    - default infill: no activation in row
    - default NArowtype: justNaN
    - suffix appender:
      - '_text\_(entry)' where entry is the categoric entry target of column activations (one of the unique values found in received column)
    - assignparam parameters accepted:
      - 'suffix_convention', accepts one of {'text', 'onht'} for suffix convention, defaults to 'text'. Note that 'str_convert' and 'null_activation' parameters only accepted in 'onht' configuration.
      - 'str_convert', applied as True in text suffix_convention for common encodings between numbers and string equivalents e.g. 2 == '2'. (text does not support other str_convert scenarios due to column header conventions)
      - 'null_activation': applied as False in text suffix_convention for no activations for missing data
      - 'all_activations': defaults to False, can pass as a list of all entries that will be targets for activations (which may have fewer or more entries than the set of unique values found in the train set, including entries not found in the train set)
      - 'add_activations': defaults to False, user can pass as a list of entries that will be added as targets for activations (resulting in extra returned columns if those entries aren't present in the train set)
      - 'less_activations': defaults to False, user can pass as a list of entries that won't be treated as targets for activation (these entries will instead receive no activation)
      - 'consolidated_activations': defaults to False, user can pass a list of entries (or a list of lists of entries) that will have their activations consolidated to a single common activation
      - 'ordered_overide': default to True, accepts boolean indicating if columns received as pandas ordered categoric will use that basis for order of the returned columns. Note this is deactivated when activation parameters are specified (all/add/less/consolidated).
      - 'frequency_sort': boolean defaults to True, when activated the order of returned columns is sorted by frequency of entries as found in the train set, when deactivated sorting is alphabetic
  * onht: converts categorical sets to one-hot encoded set of boolean identifiers
  (like text but different convention for returned column headers and distinct encodings for numbers and numerical string equivalents). Note that text and onht are implemented with the same functions by updates to the suffix_convention parameter. To apply onht to a "messy" feature with multiple columns in input headers can apply assigncat set bracket specification to root category 'cns2'.
    - useful for: similar to text transform preceding but with numbered column header convention
    - default infill: no activation in row
    - default NArowtype: justNaN
    - suffix appender: '_onht\_#' where # integer corresponds to the target entry of a column
    - assignparam parameters accepted:
      - 'suffix_convention', accepts one of {'text', 'onht'} for suffix convention, defaults to 'text' (onht process_dict specification overwrites this to 'onht'). Note that 'str_convert' and 'null_activation' parameters only accepted in 'onht' configuration.
      - 'str_convert', boolean defaults as True for common encodings between numbers and string equivalents
        e.g. 2 != '2', when passed as True e.g. 2 == '2' (the False scenario does not support bytes type entries). Also can be passed as 'conditional_on_bytes' which resets to True when bytes entries are present in train set otherwise resets to False.
      - 'null_activation': defaults to False, when True missing data is returned with distinct activation in final column in set.  (Also accepts as 'Binary' which is for internal use.)
      - 'all_activations': defaults to False, can pass as a list of all entries that will be targets for activations (which may have fewer or more entries than the set of unique values found in the train set, including entries not found in the train set)
      - 'add_activations': defaults to False, user can pass as a list of entries that will be added as targets for activations (resulting in extra returned columns if those entries aren't present in the train set)
      - 'less_activations': defaults to False, user can pass as a list of entries that won't be treated as targets for activation (these entries will instead receive no activation)
      - 'consolidated_activations': defaults to False, user can pass a list of entries (or a list of lists of entries) that will have their activations consolidated to a single common activation
      - 'ordered_overide': default to True, accepts boolean indicating if columns received as pandas ordered categoric will use that basis for order of the returned columns. Note this is deactivated when activation parameters are specified (all/add/less/consolidated).
      - 'frequency_sort': boolean defaults to True, when activated the order of returned columns is sorted by frequency of entries as found in the train set, when deactivated sorting is alphabetic
    - driftreport postmunge metrics: textlabelsdict_text / <column> + '_ratio' (column specific)
  			           text_categorylist is key between columns and target entries
    - returned datatype: int8
    - inversion available: yes with full recovery
  * ordl/ord2/ord5: converts categoric sets to ordinal integer encoded set, encodings sorted alphabetically
    - useful for: categoric sets with high cardinality where one-hot or binarization may result in high dimensionality. Also default for categoric labels.
    - default infill: naninfill, with returned distinct activation of integer 0
    - default NArowtype: justNaN
    - suffix appender: '_ordl' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'str_convert', boolean defaults as True for common encodings between numbers and string equivalents
        e.g. 2 == '2'. Also can be passed as 'conditional_on_bytes' which resets to True when bytes entries are present in train set otherwise resets to False.
      - 'null_activation': defaults to True for a distinct missing data encoding, when False missing data is grouped with another entry in the 0 integer encoding. (Also accepts as 'Binary' which is for internal use.)
      - 'all_activations': defaults to False, can pass as a list of all entries that will be targets for activations (which may have fewer or more entries than the set of unique values found in the train set, including entries not found in the train set)
      - 'add_activations': defaults to False, user can pass as a list of entries that will be added as targets for activations (resulting in extra returned columns if those entries aren't present in the train set)
      - 'less_activations': defaults to False, user can pass as a list of entries that won't be treated as targets for activation (these entries will instead receive no activation)
      - 'consolidated_activations': defaults to False, user can pass a list of entries (or a list of lists of entries) that will have their activations consolidated to a single common activation
      - 'ordered_overide': default to True, accepts boolean indicating if columns received as pandas ordered categoric will use that basis for order of the returned columns. Note this is deactivated when activation parameters are specified (all/add/less/consolidated).
      - 'frequency_sort': boolean defaults to True but set as False for ordl, when activated the order of integer activations is sorted by frequency of entries as found in the train set, when deactivated sorting is alphabetic.  The 0 activation is reserved for missing data.
    - driftreport postmunge metrics: ordinal_dict / ordinal_overlap_replace / ordinal_activations_dict
    - returned datatype: conditional based on size of encoding space (uint8 / uint16 / uint32)
    - inversion available: yes with full recovery
  * ord3: converts categoric sets to ordinal integer encoded set, sorted first by frequency of category
  occurrence, second basis for common count entries is alphabetical. To apply ord3 to a "messy" feature with multiple columns in input headers can apply assigncat set bracket specification to root category 'cns3'.
    - useful for: similar to ordl preceding but activations are sorted by entry frequency instead of alphabetical
    - default infill: unique activation
    - default NArowtype: justNaN
    - suffix appender: '_ord3' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'ordered_overide', boolean defaults True, when True inspects for Pandas ordered categorical and
        if found integer encoding order defers to that basis
      - 'str_convert', boolean defaults as True for common encodings between numbers and string equivalents
        e.g. 2 == '2' (the False scenario does not support bytes type entries). Also can be passed as 'conditional_on_bytes' which resets to True when bytes entries are present in train set otherwise resets to False.
      - 'null_activation': defaults to True for a distinct missing data encoding, when False missing data is grouped with another entry in the 0 integer encoding. (Also accepts as 'Binary' which is for internal use.)
      - 'all_activations': defaults to False, can pass as a list of all entries that will be targets for activations (which may have fewer or more entries than the set of unique values found in the train set, including entries not found in the train set)
      - 'add_activations': defaults to False, user can pass as a list of entries that will be added as targets for activations (resulting in extra returned columns if those entries aren't present in the train set)
      - 'less_activations': defaults to False, user can pass as a list of entries that won't be treated as targets for activation (these entries will instead receive no activation)
      - 'consolidated_activations': defaults to False, user can pass a list of entries (or a list of lists of entries) that will have their activations consolidated to a single common activation
      - 'ordered_overide': default to True, accepts boolean indicating if columns received as pandas ordered categoric will use that basis for order of the returned columns. Note this is deactivated when activation parameters are specified (all/add/less/consolidated).
      - 'frequency_sort': boolean defaults to True, when activated the order of integer activations is sorted by frequency of entries as found in the train set, when deactivated sorting is alphabetic. The 0 activation is reserved for missing data.
    - driftreport postmunge metrics: ordinal_dict / ordinal_overlap_replace / ordinal_activations_dict
    - returned datatype: conditional based on size of encoding space (uint8 / uint16 / uint32)
    - inversion available: yes with full recovery
  * ord4: derived by an ord3 transform followed by a mnmx transform. Useful as a scaled metric
  (numeric in range 0-1) which ranks any redundant entries by frequency of occurrence.
  * lbos: an ord3 encoding followed by downstream conversion to string dtype. This may be useful for
  label sets passed to downstream libraries to ensure they treat labels as target for classification instead
  of regression.
  * 1010: converts categorical sets of >2 unique values to binary encoding (more memory
  efficient than one-hot encoding). To apply 1010 to a "messy" feature with multiple columns in input headers can apply assigncat set bracket specification to root category 'cnsl'.
    - useful for: our default categoric encoding for sets with number of entries below numbercategoryheustic (defaulting to 255)
    - default infill: naninfill, with returned distinct activation set of all 0's
    - default NArowtype: justNaN
    - suffix appender: '\_1010\_#' where # is integer indicating order of 1010 columns
    - assignparam parameters accepted:
      - 'str_convert', boolean defaults as True for common encodings between numbers and string equivalents
        e.g. 2 == '2'. Also can be passed as 'conditional_on_bytes' which resets to True when bytes entries are present in train set otherwise resets to False.
      - 'null_activation': defaults to True for a distinct missing data encoding, when False missing data is grouped with another entry in the all 0 encoding. (Also accepts as 'Binary' which is for internal use.)
      - 'all_activations': defaults to False, can pass as a list of all entries that will be targets for activations (which may have fewer or more entries than the set of unique values found in the train set, including entries not found in the train set), note NaN missing data representation will be added
      - 'add_activations': defaults to False, user can pass as a list of entries that will be added as targets for activations (resulting in extra returned columns if those entries aren't present in the train set)
      - 'less_activations': defaults to False, user can pass as a list of entries that won't be treated as targets for activation (these entries will instead receive no activation)
      - 'consolidated_activations': defaults to False, user can pass a list of entries (or a list of lists of entries) that will have their activations consolidated to a single common activation. For consolidation with NaN missing data representation user should instead apply an assignnan conversion.
      - 'max_zero': defaults to False, when activated the encodings are conducted to maximize 0 encoding representation for unique entries as sorted by frequency (e.g. most frequent entries have most zeros in their encoding.) This was implemented since 0 is the low energy state for quantum circuits. The root category '10mz' applies 1010 with this parameter defaulting to activated.
    - driftreport postmunge metrics: _1010_binary_encoding_dict / _1010_overlap_replace /
  	                           _1010_binary_column_count / _1010_activations_dict
    (for example if 1010 encoded to three columns based on number of categories <8,
    it would return three columns with suffix appenders 1010_1, 1010_2, 1010_3)
    - returned datatype: int8
    - inversion available: yes with full recovery
  * maxb / matx / ma10: categoric encodings that allow user to cap the number activations in the set.
  maxb (ordinal), matx (one hot), and ma10 (binary).
    - useful for: categoric sets where some outlier entries may not occur with enough frequency for training purposes
    - default infill: plug value unique activation
    - default NArowtype: justNaN
    - suffix appender: '\_maxb' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'maxbincount': set a maximum number of activations (integer) default False
      - 'minentrycount': set a minimum number of entries in train set to register an activation (integer) default False
      - 'minentryratio': set a minimum ratio of entries in train set to register an activation (float between 0-1)
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: new_maxactivation / consolidation_count
    - returned datatype: matx and ma10 as int8, maxb as conditional based on size of encoding space (uint8 / uint16 / uint32)
    - inversion available: yes with full recovery
  * ucct: converts categorical sets to a normalized float of unique class count,
  for example, a 10 row train set with two instances of 'circle' would replace 'circle' with 0.2
  and comparable to test set independent of test set row count
    - useful for: supplementing categoric sets with a proxy for activation frequency
    - default infill: ratio of infill in train set
    - default NArowtype: justNaN
    - suffix appender: '_ucct' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: ordinal_dict / ordinal_overlap_replace / ordinal_activations_dict
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: no
  * lngt/lngm/lnlg: returns string length of categoric entries (lngm followed by mnmx, lnlg by logn)
    - useful for: supplementing categoric sets with a proxy for information content (based on string length)
    - default infill: plug value of 3 (based on len(str(np.nan)) )
    - default NArowtype: justNaN
    - suffix appender: '_lngt' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: maximum, minimum, mean, std
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: no
  * aggt: consolidate categoric entries based on user passed aggregate parameter
    - useful for: performing upstream of categoric encoding when some entries are redundant
    - default infill: none
    - default NArowtype: justNaN
    - suffix appender: '_aggt' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'aggregate' as a list or as a list of lists of aggregation sets
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: aggregate
    - returned datatype: str (other categoric encodings can be returned downstream to return numeric)
    - inversion available: yes with partial recovery
  * smth: applies a one-hot encoding followed by a label smoothing operation to reduce activation value and increase null value. The smoothing is applied to train data but not validation or test data. Smoothing can be applied to test data in postmunge(.) by activating the traindata parameter.
    - useful for: label smoothing, speculate there may be benefit for categoric encodings with noisy entries of some error rate
    - default infill: none
    - default NArowtype: justNaN
    - suffix appender: '_smt0\_(entry)\_smth\_#' where # is integer in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - note that parameters for the upstream onehot encoding can be passed in assignparam to the smt0 category (consistent to text transform), and smoothing parameters can be passed to the smth category
      - 'activation' defaults to 0.9, a float between 0.5-1 to designate activation value
      - 'LSfit' defaults to False, when True applies fitted label smoothing (consistent with fsmh)
      - 'testsmooth' defaults to False, when True applies smoothing to test data in both automunge and postmunge
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: comparable to onht
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes with full recovery
  * fsmh: comparable to smth but applies by default a fitted label smoothing, in which null values are fit to ratio of activations corresponding to current activation. The smoothing is applied to train data but not validation or test data. Smoothing can be applied to test data in postmunge(.) by activating the traindata parameter. (Note that parameters for the upstream onehot encoding can be passed in assignparam to the fsm0 category (consistent to text transform), and smoothing parameters can be passed to the fsmh category
  * hash: applies "the hashing trick" to convert high cardinality categoric sets to set of columns with integer word encodings
  e.g. for an entry "Three word quote" may return three columns with integers corresponding to each of three words
  where integer is determined by hashing, and also based on passed parameter vocab_size.
  Note that hash strips out special characters. Uhsh is available if upstream uppercase conversion desired. Note that there is a possibility
  of encoding overlap between entries with this transform. Also note that hash is excluded from ML infill
  vocab_size calculated based on number of unique words found in train set times a multiplier (defaulting to 2), where if that
  is greater than cap then reverts to cap. The hashing transforms are intended as an alternative to other categoric
  encodings which doesn't require a conversion dictionary assembly for consistent processing of subsequent data, as
  may benefit sets with high cardinality (i.e. high number of unique entries). The tradeoff is that inversion
  is not supported as there is possibility of redundant encodings for different unique entries. Further detail on hashing
  provided in the essay [Hashed Categoric Encodings with Automunge](https://medium.com/automunge/hashed-categoric-encodings-with-automunge-92c0c4b7668c).
    - useful for: categoric sets with very high cardinality, default for categoric sets with (nearly) all unique entries
    - default infill: none
    - default NArowtype: justNaN
    - suffix appender: '\_hash\_#' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'heuristic_multiplier', float defaults to 2
      - 'heuristic_cap', integer defaults to 1024
      - 'vocab_size', integer defaults to False, when assigned overrides heuristic
      - 'space', defaults to ' ', this is used to extract words by space separator
      - 'excluded_characters', defaults to [',', '.', '?', '!', '(', ')'], these characters are stripped prior to encoding
      - 'salt', arbitrary string, defaults to empty string '', appended to entries to perturb encoding basis for privacy
      - 'hash_alg', defaults to 'hash' for use of native python hash function for speed, 'md5' uses hashlib md5 function instead
      - 'max_column_count', defaults to False, can pass as integer to cap the number of returned columns, in which case when
        words are extracted the final column's encodings will be based on all remaining word and space characters inclusive
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: col_count (number of columns), vocab_size
    - returned datatype: conditional based on size of encoding space (uint8 / uint16 / uint32)
    - inversion available: no
  * hsh2: similar to hash but does not partition entries by space separator, so only returns one column. Note this version doesn't scrub special characters prior to encoding.
    - useful for: categoric sets with very high cardinality, default for categoric sets with number of entries exceeding numbercategoryheuristic (defaulting to 255)
    - default infill: none
    - default NArowtype: justNaN
    - suffix appender: '_hsh2' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'heuristic_multiplier', float defaults to 2
      - 'heuristic_cap', integer defaults to 1024
      - 'vocab_size', integer defaults to False, when assigned overrides heuristic
      - 'excluded_characters', a list of strings, defaults to [] (an empty set), these characters are stripped prior to encoding
      - 'salt', arbitrary string, defaults to empty string '', appended to entries to perturb encoding basis for privacy
      - 'hash_alg', defaults to 'hash' for use of native python hash function for speed, 'md5' uses hashlib md5 function instead
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: col_count (number of columns), vocab_size
    - returned datatype: conditional based on size of encoding space (uint8 / uint16 / uint32)
    - inversion available: no
  * hs10: similar to hsh2 but returns activations in a set of columns with binary encodings, similar to 1010
    - useful for: binary version of hsh2
    - default infill: none
    - default NArowtype: justNaN
    - suffix appender: '\_hs10\_#' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'heuristic_multiplier', float defaults to 2
      - 'heuristic_cap', integer defaults to 1024
      - 'vocab_size', integer defaults to False, when assigned overrides heuristic
      - 'excluded_characters', a list of strings, defaults to [] (an empty set), these characters are stripped prior to encoding
      - 'salt', arbitrary string, defaults to empty string '', appended to entries to perturb encoding basis for privacy
      - 'hash_alg', defaults to 'hash' for use of native python hash function for speed, 'md5' uses hashlib md5 function instead
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: col_count (number of columns), vocab_size
    - returned datatype: int8
    - inversion available: no
  * UPCS: convert string entries to all uppercase characters
    - useful for: performing upstream of categoric encodings when case configuration is irrelevant
    - default infill: none
    - default NArowtype: justNaN
    - suffix appender: '_UPCS' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'activate', boolean defaults to True, False makes this a passthrough without conversion
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: activate
    - returned datatype: str (other categoric encodings can be returned downstream to return numeric)
    - inversion available: yes with partial recovery
  * new processing functions Unht / Utxt / Utx2 / Utx3 / Uord / Uor2 / Uor3 / Uor6 / U101 / Ucct / Uhsh / Uhs2 / Uh10
    - comparable to functions onht / text / txt2 / txt3 / ordl / ord2 / ord3 / ors6 / 1010 / ucct / hash / hsh2 / hs10
    - but upstream conversion of all strings to uppercase characters prior to encoding
    - (e.g. 'USA' and 'usa' would be consistently encoded)
    - default infill: in uppercase conversion NaN's are assigned distinct encoding 'NAN'
    - and may be assigned other infill methods in assigninfill
    - default NArowtype: 'justNaN'
    - suffix appender: '_UPCS' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: comparable to functions text / txt2 / txt3 / ordl / ord2 / ord3 / ors6 / 1010 / ucct
    - returned datatype: comparable to functions onht / text / txt2 / txt3 / ordl / ord2 / ord3 / ors6 / 1010 / ucct / hash / hsh2 / hs10
    - inversion available: yes
  * ntgr/ntg2/ntg3: sets of transformations intended for application to integer sets of unknown interpretation
  (such as may be continuous variables, discrete relational variables, or categoric). The ntgr family encodes
  in multiple forms appropriate for each of these different types, such as to allow the ML training to identify
  which is most useful. Reference the family trees below for composition details (can do a control-F search for ntgr etc).
    - useful for: encoding integer sets of unknown interpretation
    - default NArowtype: 'integer'
    - ntgr set includes: ord4, retn, 1010, ordl
    - ntg2 set includes: ord4, retn, 1010, ordl, pwr2
    - ntg3 set includes: ord4, retn, ordl, por2


  Date time processing transforms are implementations of two master functions: time and tmcs, which accept
  various parameters associated with suffix, time scale, and sin/cos periodicity, etc. They segment time stamps by
  time scale returned in separate columns. If a particular time scale is not present in training data it is omitted.
  * date/dat2: for datetime formatted data, segregates data by time scale to multiple
  columns (year/month/day/hour/minute/second) and then performs z-score normalization
    - useful for: datetime entries of mixed time scales where periodicity is not relevant
    - default infill: adjinfill
    - default NArowtype: datetime
    - suffix appender: includes appenders for (_year, _mnth, _days, _hour, _mint, _scnd)
    - assignparam parameters accepted:
      - timezone: defaults to False as passthrough, otherwise can pass time zone abbreviation
        (useful to consolidate different time zones such as for bus hr bins)
        for list of pandas accepted abbreviations see pytz.all_timezones
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: meanyear / stdyear / meanmonth / stdmonth / meanday / stdday /
  			           meanhour / stdhour / meanmint / stdmint / meanscnd / stdscnd
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: pending
  * year/mnth/days/hour/mint/scnd: segregated by time scale and z-score normalization
    - useful for: datetime entries of single time scale where periodicity is not relevant
    - default infill: adjinfill
    - default NArowtype: datetime
    - suffix appender: includes appenders for (_year, _mnth, _days, _hour, _mint, _scnd)
    - driftreport postmunge metrics: timemean / timemax / timemin / timestd
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: pending
  * mnsn/mncs/dysn/dycs/hrsn/hrcs/misn/mics/scsn/sccs: segregated by time scale and
  dual columns with sin and cos transformations for time scale period (e.g. 12 months, 24 hrs, 7 days, etc)
    - useful for: datetime entries of single time scale where periodicity is relevant
    - default infill: adjinfill
    - default NArowtype: datetime
    - suffix appender: includes appenders for (mnsn/mncs/dysn/dycs/hrsn/hrcs/misn/mics/scsn/sccs)
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: timemean / timemax / timemin / timestd
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: pending
  * mdsn/mdcs: similar sin/cos treatment, but for combined month/day, note that periodicity is based on
  number of days in specific months, including account for leap year, with 12 month periodicity
    - useful for: datetime entries of single time scale combining months and days where periodicity is relevant
    - default infill: adjinfill
    - default NArowtype: datetime
    - suffix appender: includes appenders for (mdsn/mdcs)
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: timemean / timemax / timemin / timestd
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: pending
  * dhms/dhmc: similar sin/cos treatment, but for combined day/hour/min, with 7 day periodicity
    - default infill: adjinfill
    - default NArowtype: datetime
    - suffix appender: includes appenders for (dhms/dhmc)
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: timemean / timemax / timemin / timestd
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: pending
  * hmss/hmsc: similar sin/cos treatment, but for combined hour/minute/second, with 24 hour periodicity
    - useful for: datetime entries of single time scale combining time scales where periodicity is relevant
    - default infill: adjinfill
    - default NArowtype: datetime
    - suffix appender: includes appenders for (hmss/hmsc)
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: timemean / timemax / timemin / timestd
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: pending
  * mssn/mscs: similar sin/cos treatment, but for combined minute/second, with 1 hour periodicity
    - useful for: datetime entries of single time scale combining time scales below minute threshold where periodicity is relevant
    - default infill: adjinfill
    - default NArowtype: datetime
    - suffix appender: includes appenders for (hmss/hmsc)
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: timemean / timemax / timemin / timestd
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: pending
  * dat6: default transformation set for time series data, returns:
  'year', 'mdsn', 'mdcs', 'hmss', 'hmsc', 'bshr', 'wkdy', 'hldy'
    - useful for: datetime entries of multiple time scales where periodicity is relevant, default date-time encoding, includes bins for holidays, business hours, and weekdays
    - default infill: adjinfill
    - default NArowtype: datetime
    - suffix appender: includes appenders for ('year', 'mdsn', 'mdcs', 'hmss', 'hmsc', 'bshr', 'wkdy', 'hldy')
    - assignparam parameters accepted:
      - timezone: defaults to False as passthrough, otherwise can pass time zone abbreviation
        (useful to consolidate different time zones such as for bus hr bins)
        for list of pandas accepted abbreviations see pytz.all_timezones
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: meanyear / stdyear / mean_mdsn / mean_mdcs / mean_hmss / mean_hmsc
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: pending


  * wkdy: boolean identifier indicating whether a datetime object is a weekday
    - useful for: supplementing datetime encodings with weekday bins
    - default infill: adjinfill
    - default NArowtype: datetime
    - suffix appender: '_wkdy' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: activationratio
    - returned datatype: int8
    - inversion available: pending
  * wkds/wkdo: encoded weekdays 0-6, 'wkds' for one-hot via 'text', 'wkdo' for ordinal via 'ord3'
    - useful for: ordinal version of preceding wkdy
    - default infill: 7 (e.g. eight days a week)
    - default NArowtype: datetime
    - suffix appender: '_wkds' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: mon_ratio / tue_ratio / wed_ratio / thr_ratio / fri_ratio / sat_ratio /
  	  sun_ratio / infill_ratio
    - returned datatype: wkds as int8, wkdo as uint8
    - inversion available: pending
  * mnts/mnto: encoded months 1-12, 'mnts' for one-hot via 'text', 'mnto' for ordinal via 'ord3'
    - useful for: supplementing datetime encodings with month bins
    - default infill: adjinfill
    - default NArowtype: datetime
    - suffix appender: '_mnts' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: infill_ratio / jan_ratio / feb_ratio / mar_ratio / apr_ratio / may_ratio /
  	  jun_ratio / jul_ratio / aug_ratio / sep_ratio / oct_ratio / nov_ratio / dec_ratio
    - returned datatype: mnts as int8, mnto as uint8
    - inversion available: pending
  * bshr: boolean identifier indicating whether a datetime object falls within business
  hours (9-5, time zone unaware)
    - useful for: supplementing datetime encodings with business hour bins
    - default infill: adjinfill
    - default NArowtype: datetime
    - suffix appender: '_bshr' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'start' and 'end', which default to 9 and 17
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: activationratio
    - returned datatype: int8
    - inversion available: pending
  * hldy: boolean identifier indicating whether a datetime object is a US Federal
  holiday
    - useful for: supplementing datetime encodings with holiday bins
    - default infill: adjinfill
    - default NArowtype: datetime
    - suffix appender: '_hldy' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'holiday_list', should be passed as a list of strings of dates of additional holidays to be recognized
        e.g. ['2020/03/30']
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: activationratio
    - returned datatype: int8
    - inversion available: pending


  The DP family of transformations are for purposes of stochastic noise injection to train and/or test features. Noise is sampled by default with support of numpy.random (which as of version 1.17.0 defaults to the PCG pseudo random number generator). Supplemental entropy seedings or alternate random samplers can be applied with the automunge(.)/postmunge(.) parameters entropy_seeds and random_generator. The transforms default to injecting noise to training data and not test data, although trainnoise/testnoise parameters can be activated for any combination of the two. For cases where test data injections are not defaulted with the testnoise parameter, test data can be treated as train data for purposes of noise with the postmunge(.) traindata parameter. Please refer to the essay [Noise Injections with Automunge](https://medium.com/automunge/noise-injections-with-automunge-7ebb672216e2) for further detail.

  Each of the DP root categories (e.g. DPnb, DPmm, DP**, etc) defaults to injecting noise to train data and not to test data (i.e. trainnoise=True, testnoise=False), however each have otherwise equivalent variations as DT root categories (e.g. DTnb, DTmm, DT**, etc) which default to injecting to test data and not to train data (i.e. trainnoise=False, testnoise=True), or as DB root categories (e.g. DBnb, DBmm, DB**, etc) which default to injecting to both train and test data (i.e. trainnoise=True, testnoise=True). In each case these defaults can be updated by parameter assigment.

  Note that when passing parameters to a few of these functions (specifically the hashing variants), the transformation
  category associated with the transformation function may be different than the root category, as noted below DPh1/DPh2/DPhs.
  Note that DP transforms can be applied in conjunction with the automunge(.) or postmunge(.) noise_augment
  parameter to automatically prepare additional concatenated duplicates as a form of data augmentation.

  For distribution sampled numeric or weighted sampling categoric categories, the DP transforms have an option to scale different segments of a feature's noise profile to correspond to different attribute segments of an adjacent protected categoric feature, which is expected to benefit loss discrepency for the attributes of that protected feature.

  * DPnb: applies a z-score normalization followed by a noise injection to train data sampled
  from a Gaussian which defaults to 0 mu and 0.06 sigma, but only to a subset of the data based
  on flip_prob parameter.
    - useful for: noise injection for data augmentation, model perturbation for ensembles, differential privacy
    - default infill: the DP function does not apply a default infill assume upstream nmbr (as DPn3) cleans data
    - default NArowtype: numeric
    - suffix appender: '_DPn3_DPnb'
    - assignparam parameters accepted:
      - 'noisedistribution' as {'normal', 'laplace', 'uniform'}, defaults to normal, used to select between gaussian (normal), laplace, and uniform distributed noise, also accepts one of {'abs_normal', 'abs_laplace', 'abs_uniform', 'negabs_normal', 'negabs_laplace', 'negabs_uniform'}, where the prefix 'abs' refers to injecting only positive noise by taking absolute value of sampled noise, and the prefix negabs refers to injecting only negative noise by taking the negative absolute value of sampled noise
      - 'flip_prob' for percent of entries receiving noise injection, defaults to 0.03
      - 'mu' for noise mean, defaults to 0
      - 'sigma' for noise scale, defaults to 0.06 - note that for uniform sampling high is (sigma-mu) and  low is (mu-sigma)
      - 'trainnoise' defaults to True, when False noise is not injected to training data in automunge or postmunge
      - 'testnoise' defaults to False, when True noise is injected to test data in both automunge and postmunge by default
      - parameters should be passed to 'DPnb' transformation category from family tree
      - 'suffix': to change suffix appender (leading underscore added internally)
      - 'rescale_sigmas': defaults as False, True rescales sigma specifications based on standard deviation of feature in training set (this option intended for use in conjunction with DPne which injects numeric noise without applying a preceding normalization)
      - when activating testnoise, test data specific noise distribution parameters can be passed to {test_noisedistribution, test_flip_prob, test_mu, test_sigma}, which otherwise default to test_noisedistribution, test_mu, and test_flip_prob matching the train data parameters and test_sigma=0.03
      - please note that each of the noise distribution parameters {sigma, flip_prob, test_sigma, test_flip_prob} can be passed as list of candidate values for a unique sampling applied in automunge and postmunge.
      - please note that each of the noise distribution parameters {mu, sigma, flip_prob, test_mu, test_sigma, test_flip_prob} can be passed as scipy.stats distribution for a uniquely sampled value with each application (this was implemented to support some experiments associated with noise_augment).
      - 'retain_basis' accepts boolean defaulting to False, the use is associated with parameters passed as lists or distributions, when True the sampled basis from automunge(.) is carried through to postmunge(.) instead of a unique sampling for each
      - the DP transforms also accept parameters random_generator and sampling_resource_dict which are derived internally based on automunge or postmunge parameters
      - 'protected_feature' defaults to False, accepts input column header string specifiation, scales different segments of this transform's target feature's noise profile to correspond to different attribute segments of specified adjacent protected categoric feature, which the hypothesis is that this may benefit loss discrepency for the attributes of that protected feature
    - driftreport postmunge metrics: mu, sigma for DPnm, upstream z score via nmbr for others
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes
  * DPmm: applies a min-max scaling followed by a noise injection to train data sampled
  from a Gaussian which defaults to 0 mu and 0.03 sigma. Note that noise is scaled to ensure output
  remains in range 0-1 (by scaling neg noise when scaled input <0.5 and scaling pos noise when scaled input >0.5)
    - useful for: noise injection for data augmentation, model perturbation for ensembles, differential privacy
    - default infill: the DP function does not apply a default infill assume upstream mnmx (as DPm2) cleans data
    - default NArowtype: numeric
    - suffix appender: '_DPm2_DPmm'
    - assignparam parameters accepted:
      - 'noisedistribution' as {'normal', 'laplace', 'uniform'}, defaults to normal, used to select between gaussian (normal), laplace, and uniform distributed noise, also accepts one of {'abs_normal', 'abs_laplace', 'abs_uniform', 'negabs_normal', 'negabs_laplace', 'negabs_uniform'}, where the prefix 'abs' refers to injecting only positive noise by taking absolute value of sampled noise, and the prefix negabs refers to injecting only negative noise by taking the negative absolute value of sampled noise. *Note that we recommend deactivating parameter noise_scaling_bias_offset in conjunction with abs or negabs scenarios, otherwise the sampled mean will be shifted resulting in noise with zero mean.
      - 'flip_prob' for percent of entries receiving noise injection, defaults to 0.03
      - 'mu' for noise mean, defaults to 0
      - 'sigma' for noise scale, defaults to 0.03 - note that for uniform sampling high is (sigma-mu) and  low is (mu-sigma)
      - 'noise_scaling_bias_offset', boolean defaulting to True, activates an evaluation of scaled noise to offset the sampled noise mean to closer approximate a resulting zero mean for the scaled noise (helps to mitigate potential for bias from noise scaling in cases of imbalanced feature distribution).
      - 'trainnoise' defaults to True, when False noise is not injected to training data in automunge or postmunge
      - 'testnoise' defaults to False, when True noise is injected to test data in both automunge and postmunge by default
      - parameters should be passed to 'DPmm' transformation category from family tree
      - 'suffix': to change suffix appender (leading underscore added internally)
      - when activating testnoise, test data specific noise distribution parameters can be passed to {test_noisedistribution, test_flip_prob, test_mu, test_sigma}, which otherwise default to test_noisedistribution, test_mu, and test_flip_prob matching the train data parameters and test_sigma=0.02
      - please note that each of the noise distribution parameters {sigma, flip_prob, test_sigma, test_flip_prob} can be passed as list of candidate values  for a unique sampling applied in automunge and postmunge.
      - please note that each of the noise distribution parameters {mu, sigma, flip_prob, test_mu, test_sigma, test_flip_prob} can be passed as scipy.stats distribution for a uniquely sampled value with each application (this was implemented to support some experiments associated with noise_augment).
      - 'retain_basis' accepts boolean defaulting to False, the use is associated with parameters passed as lists or distributions, when True the sampled basis from automunge(.) is carried through to postmunge(.) instead of a unique sampling for each
      - the DP transforms also accept parameters random_generator and sampling_resource_dict which are derived internally based on automunge or postmunge parameters
      - 'protected_feature' defaults to False, accepts input column header string specifiation, scales different segments of this transform's target feature's noise profile to correspond to different attribute segments of specified adjacent protected categoric feature, which the hypothesis is that this may benefit loss discrepency for the attributes of that protected feature
    - driftreport postmunge metrics: mu, sigma for DPnm, upstream minmax via mnmx for others
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes
  * DPrt: applies a retn normalization with a noise injection to train data sampled
  from a Gaussian which defaults to 0 mu and 0.03 sigma. Note that noise is scaled to ensure output
  remains in range 0-1 (by scaling neg noise when scaled and centered input <0.5 and scaling pos noise when scaled and centered input >0.5)
    - useful for: noise injection for data augmentation, model perturbation for ensembles, differential privacy
    - default infill: comparable to retn with mean (calculated before noise injection)
    - suffix appender: '_DPrt' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - parameters comparable to retn divisor / offset / multiplier / cap / floor / stdev_cap defaulting to 'minmax'/0/1/False/False/False, also
      - 'noisedistribution' as {'normal', 'laplace', 'uniform'}, defaults to normal, used to select between gaussian (normal), laplace, and uniform distributed noise, also accepts one of {'abs_normal', 'abs_laplace', 'abs_uniform', 'negabs_normal', 'negabs_laplace', 'negabs_uniform'}, where the prefix 'abs' refers to injecting only positive noise by taking absolute value of sampled noise, and the prefix negabs refers to injecting only negative noise by taking the negative absolute value of sampled noise. *Note that we recommend deactivating parameter noise_scaling_bias_offset in conjunction with abs or negabs scenarios, otherwise the sampled mean will be shifted resulting in noise with zero mean.
      - 'mu' for noise mean, defaults to 0,
      - 'sigma' for noise scale, defaults to 0.03 - note that for uniform sampling high is (sigma-mu) and  low is (mu-sigma)
      - 'flip_prob' for percent of entries receiving noise injection, defaults to 0.03
      - 'noise_scaling_bias_offset', boolean defaulting to True, activates an evaluation of scaled noise to offset the sampled noise mean to closer approximate a resulting zero mean for the scaled noise (helps to mitigate potential for bias from noise scaling in cases of imbalanced feature distribution)
      - 'trainnoise' defaults to True, when False noise is not injected to training data in automunge or postmunge
      - 'testnoise' defaults to False, when True noise is injected to test data in both automunge and postmunge by default
      - Parameters should be passed to 'DPrt' transformation category from family tree.
      - 'suffix': to change suffix appender (leading underscore added internally)
      - when activating testnoise, test data specific noise distribution parameters can be passed to {test_noisedistribution, test_flip_prob, test_mu, test_sigma}, which otherwise default to test_noisedistribution, test_mu, and test_flip_prob matching the train data parameters and test_sigma=0.02
      - please note that each of the noise distribution parameters {sigma, flip_prob, test_sigma, test_flip_prob} can be passed as list of candidate values  for a unique sampling applied in automunge and postmunge.
      - please note that each of the noise distribution parameters {mu, sigma, flip_prob, test_mu, test_sigma, test_flip_prob} can be passed as scipy.stats distribution for a uniquely sampled value with each application (this was implemented to support some experiments associated with noise_augment).
      - 'retain_basis' accepts boolean defaulting to False, the use is associated with parameters passed as lists or distributions, when True the sampled basis from automunge(.) is carried through to postmunge(.) instead of a unique sampling for each
      - the DP transforms also accept parameters random_generator and sampling_resource_dict which are derived internally based on automunge or postmunge parameters
      - 'protected_feature' defaults to False, accepts input column header string specifiation, scales different segments of this transform's target feature's noise profile to correspond to different attribute segments of specified adjacent protected categoric feature, which the hypothesis is that this may benefit loss discrepency for the attributes of that protected feature
    - driftreport postmunge metrics: mu, sigma, flip_prob for DPrt, also metrics comparable to retn
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes
  * DLmm/DLnb/DLrt: comparable to DPmm/DPnb/DPrt but defaults to laplace distributed noise instead of gaussian (normal)
  with same parameters accepted (where mu is center of noise, sigma is scale, and flip-prob is ratio)
  and with same default parameter values
  * DPqt/DPbx: numeric noise injections with distribution conversions by the qttf/bxcx transforms
  * DPbn: applies a two value binary encoding (bnry) followed by a noise injection to train data which
  flips the activation per parameter flip_prob which defaults to 0.03
    - useful for: noise injection for data augmentation, model perturbation for ensembles, differential privacy
    - default infill: the DP function does not apply a default infill assume upstream bnry (as DPb2) cleans data
    - default NArowtype: justNaN
    - suffix appender: '_DPb2_DPbn'
    - assignparam parameters accepted:
      - 'flip_prob' for percent of activation flips (defaults to 0.03),
      - 'weighted' boolean defaults to True for weighted noise sampling from set of unique entries in train data. When False
      noise sampling is by a uniform draw from set of unique entries as found in train data (which is a little more computationally efficient).
      - 'trainnoise' defaults to True, when False noise is not injected to training data in automunge or postmunge
      - 'testnoise' defaults to False, when True noise is injected to test data in both automunge and postmunge by default
      - noise injection parameters should be passed to 'DPbn' transformation category from family tree
      - 'suffix': to change suffix appender (leading underscore added internally)
      - when activating testnoise, test data specific noise distribution parameters can be passed to {test_flip_prob, test_weighted}, which otherwise default to test_weighted matching the train data and test_flip_prob = 0.01
      - please note that each of the noise distribution parameters {flip_prob, test_flip_prob} can be passed as list of candidate values  for a unique sampling applied in automunge and postmunge.
      - please note that each of the noise distribution parameters {flip_prob, test_flip_prob} can be passed as scipy.stats distribution for a uniquely sampled value with each application (this was implemented to support some experiments associated with noise_augment).
      - 'retain_basis' accepts boolean defaulting to False, the use is associated with parameters passed as lists or distributions, when True the sampled basis from automunge(.) is carried through to postmunge(.) instead of a unique sampling for each
      - the DP transforms also accept parameters random_generator and sampling_resource_dict which are derived internally based on automunge or postmunge parameters
      - 'protected_feature' defaults to False, accepts input column header string specifiation, scales different segments of this transform's target feature's noise profile to correspond to different attribute segments of specified adjacent protected categoric feature, which the hypothesis is that this may benefit loss discrepency for the attributes of that protected feature
    - driftreport postmunge metrics: flip_prob for DPbn, upstream binary via bnry for others
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes
  * DPod: applies an ordinal encoding (ord3) followed by a noise injection to train data which
  flips the activations per parameter flip_prob which defaults to 0.03 to a weighted random draw from the
  set of activations (including the current activation so actual flip percent is < flip_prob based
  on number of activations)
    - useful for: noise injection for data augmentation, model perturbation for ensembles, differential privacy
    - default infill: the DP function does not apply a default infill assume upstream ord3 (as DPo4) cleans data
    - default NArowtype: justNaN
    - suffix appender: '_DPo4_DPod'
    - assignparam parameters accepted:
      - 'flip_prob' for percent of activation flips (defaults to 0.03),
      - 'weighted' boolean defaults to True for weighted noise sampling from set of unique entries in train data. When False
      noise sampling is by a uniform draw from set of unique entries as found in train data (which is a little more computationally efficient).
      - 'trainnoise' defaults to True, when False noise is not injected to training data in automunge or postmunge
      - 'testnoise' defaults to False, when True noise is injected to test data in both automunge and postmunge by default
      - noise injection parameters should be passed to 'DPod' transformation category from family tree
      - 'suffix': to change suffix appender (leading underscore added internally)
      - 'passthrough': defaults to False, when True the data type conversion is turned off to allow DPod to be applie for pass-through categoric
      - when activating testnoise, test data specific noise distribution parameters can be passed to {test_flip_prob, test_weighted}, which otherwise default to test_weighted matching the train data and test_flip_prob = 0.01
      - please note that each of the noise distribution parameters {flip_prob, test_flip_prob} can be passed as list of candidate values for a unique sampling applied in automunge and postmunge.
      - please note that each of the noise distribution parameters {flip_prob, test_flip_prob} can be passed as scipy.stats distribution for a uniquely sampled value with each application (this was implemented to support some experiments associated with noise_augment).
      - 'retain_basis' accepts boolean defaulting to False, the use is associated with parameters passed as lists or distributions, when True the sampled basis from automunge(.) is carried through to postmunge(.) instead of a unique sampling for each
      - the DP transforms also accept parameters random_generator and sampling_resource_dict which are derived internally based on automunge or postmunge parameters
      - 'protected_feature' defaults to False, accepts input column header string specifiation, scales different segments of this transform's target feature's noise profile to correspond to different attribute segments of specified adjacent protected categoric feature, which the hypothesis is that this may benefit loss discrepency for the attributes of that protected feature
    - driftreport postmunge metrics: flip_prob for DPod, upstream ordinal via ord3 for others
    - returned datatype: conditional based on size of encoding space (uint8 / uint16 / uint32)
    - inversion available: yes
  * DPoh: applies a one hot encoding followed by a noise injection to train data which
  flips the activations per parameter flip_prob which defaults to 0.03 to a weighted random draw from the
  set of activations (including the current activation so actual flip percent is < flip_prob based
  on number of activations). Note that assignparam for noise injection
  can be passed directly to DPoh.
    - useful for: noise injection for data augmentation, model perturbation for ensembles, differential privacy
    - default infill: the DP function does not apply a default infill assume upstream ord3 (as DPo5) cleans data
    - default NArowtype: justNaN
    - suffix appender: 'DPo5\_#\_DPoh' where # is integer for each categoric entry
    - assignparam parameters accepted:
      - 'flip_prob' for percent of activation flips (defaults to 0.03),
      - 'weighted' boolean defaults to True for weighted noise sampling from set of unique entries in train data. When False
      noise sampling is by a uniform draw from set of unique entries as found in train data (which is a little more computationally efficient).
      - 'swap_noise' boolean defaults False, instead of a random flip to alternate activation, randomly samples from feature rows. Has a similar effect as weighted sampling, however when injecting to test data requires multiple samples for comparable effect
      - 'trainnoise' defaults to True, when False noise is not injected to training data in automunge or postmunge
      - 'testnoise' defaults to False, when True noise is injected to test data in both automunge and postmunge by default
      - noise injection parameters should be passed to 'DPo2' transformation category from family tree
      - 'suffix': to change suffix appender (leading underscore added internally)
      - when activating testnoise, test data specific noise distribution parameters can be passed to {test_flip_prob, test_weighted}, which otherwise default to test_weighted matching the train data and test_flip_prob = 0.01
      - please note that each of the noise distribution parameters {flip_prob, test_flip_prob} can be passed as list of candidate values for a unique sampling applied in automunge and postmunge.
      - please note that each of the noise distribution parameters {flip_prob, test_flip_prob} can be passed as scipy.stats distribution for a uniquely sampled value with each application (this was implemented to support some experiments associated with noise_augment).
      - 'retain_basis' accepts boolean defaulting to False, the use is associated with parameters passed as lists or distributions, when True the sampled basis from automunge(.) is carried through to postmunge(.) instead of a unique sampling for each
      - the DP transforms also accept parameters random_generator and sampling_resource_dict which are derived internally based on automunge or postmunge parameters
      - 'protected_feature' defaults to False, accepts input column header string specifiation, scales different segments of this transform's target feature's noise profile to correspond to different attribute segments of specified adjacent protected categoric feature, which the hypothesis is that this may benefit loss discrepency for the attributes of that protected feature
    - driftreport postmunge metrics: comparable to onht
    - returned datatype: int8
    - inversion available: yes
  * DP10: applies a binarization followed by a noise injection to train data which
  flips the activations per parameter flip_prob which defaults to 0.03 to a weighted random draw from the
  set of activations (including the current activation so actual flip percent is < flip_prob based
  on number of activations).  Note that assignparam for noise injection
  can be passed directly to DP10.
    - useful for: noise injection for data augmentation, model perturbation for ensembles, differential privacy
    - default infill: the DP function does not apply a default infill assume upstream ord3 (as DPo6) cleans data
    - default NArowtype: justNaN
    - suffix appender: 'DPo6\_#\_DP10' where # is integer for each column which collectively encode categoric entries
    - assignparam parameters accepted:
      - 'flip_prob' for percent of activation flips (defaults to 0.03),
      - 'weighted' boolean defaults to True for weighted noise sampling from set of unique entries in train data. When False
      noise sampling is by a uniform draw from set of unique entries as found in train data (which is a little more computationally efficient).
      - 'swap_noise' boolean defaults False, instead of a random flip to alternate activation, randomly samples from feature rows. Has a similar effect as weighted sampling, however when injecting to test data requires multiple samples for comparable effect
      - 'trainnoise' defaults to True, when False noise is not injected to training data in automunge or postmunge
      - 'testnoise' defaults to False, when True noise is injected to test data in both automunge and postmunge by default
      - noise injection parameters should be passed to 'DPo3' transformation category from family tree
      - 'suffix': to change suffix appender (leading underscore added internally)
      - when activating testnoise, test data specific noise distribution parameters can be passed to {test_flip_prob, test_weighted}, which otherwise default to test_weighted matching the train data and test_flip_prob = 0.01
      - please note that each of the noise distribution parameters {flip_prob, test_flip_prob} can be passed as list of candidate values for a unique sampling applied in automunge and postmunge.
      - please note that each of the noise distribution parameters {flip_prob, test_flip_prob} can be passed as scipy.stats distribution for a uniquely sampled value with each application (this was implemented to support some experiments associated with noise_augment).
      - 'retain_basis' accepts boolean defaulting to False, the use is associated with parameters passed as lists or distributions, when True the sampled basis from automunge(.) is carried through to postmunge(.) instead of a unique sampling for each
      - the DP transforms also accept parameters random_generator and sampling_resource_dict which are derived internally based on automunge or postmunge parameters
      - 'protected_feature' defaults to False, accepts input column header string specifiation, scales different segments of this transform's target feature's noise profile to correspond to different attribute segments of specified adjacent protected categoric feature, which the hypothesis is that this may benefit loss discrepency for the attributes of that protected feature
    - driftreport postmunge metrics: comparable to 1010
    - returned datatype: int8
    - inversion available: yes
  * DPh1: applies a multi column hash binarization via hs10 followed by a multi column categoric noise injection via DPmc,  which
  flips the activation sets per parameter flip_prob which defaults to 0.03 to a weighted random draw from the
  set of activation sets (including the current activation set so actual flip percent is < flip_prob based
  on number of activations).  Note that assignparam for noise injection
  can be passed to the intermediate category DPo3 which applies the DPod transform. Defaults to weighted sampling.
    - useful for: noise injection for data augmentation, model perturbation for ensembles, differential privacy
    - default infill: the DP function does not apply a default infill assume upstream hs10 cleans data
    - default NArowtype: justNaN
    - suffix appender: '\DPh1\_#\_DPmc' where # is integer for each column which collectively encode categoric entries
    - assignparam parameters accepted:
      - 'flip_prob' for percent of activation flips (defaults to 0.03),
      - 'swap_noise' boolean defaults False, instead of a random flip to alternate activation, randomly samples from feature rows. Has a similar effect as weighted sampling, however when injecting to test data requires multiple samples for comparable effect
      - 'weighted' boolean defaults to True for weighted noise sampling from set of unique entries in train data. When False
      noise sampling is by a uniform draw from set of unique entries as found in train data (which is a little more computationally efficient).
      - 'trainnoise' defaults to True, when False noise is not injected to training data in automunge or postmunge
      - 'testnoise' defaults to False, when True noise is injected to test data in both automunge and postmunge by default
      - noise injection parameters should be passed to 'DPmc' transformation category from family tree
      - 'suffix': to change suffix appender (leading underscore added internally)
      - when activating testnoise, test data specific noise distribution parameters can be passed to {test_flip_prob, test_weighted}, which otherwise default to test_weighted matching the train data and test_flip_prob = 0.01
      - please note that each of the noise distribution parameters {flip_prob, test_flip_prob} can be passed as list of candidate values for a unique sampling applied in automunge and postmunge.
      - please note that each of the noise distribution parameters {flip_prob, test_flip_prob} can be passed as scipy.stats distribution for a uniquely sampled value with each application (this was implemented to support some experiments associated with noise_augment).
      - 'retain_basis' accepts boolean defaulting to False, the use is associated with parameters passed as lists or distributions, when True the sampled basis from automunge(.) is carried through to postmunge(.) instead of a unique sampling for each
      - the DP transforms also accept parameters random_generator and sampling_resource_dict which are derived internally based on automunge or postmunge parameters
      - 'protected_feature' defaults to False, accepts input column header string specifiation, scales different segments of this transform's target feature's noise profile to correspond to different attribute segments of specified adjacent protected categoric feature, which the hypothesis is that this may benefit loss discrepency for the attributes of that protected feature
    - driftreport postmunge metrics: hs10 metrics
    - returned datatype: int8
    - inversion available: yes
  * DPhs: applies a multi column hash binarization via hash followed by a multi column categoric noise injection via mlhs, which
  flips the activations in each column individually per parameter flip_prob which defaults to 0.03 to a weighted random draw from the
  set of activations (including the current activation so actual flip percent is < flip_prob based
  on number of activations). assign_param for mlhs requires passing parameters to DPod through the mlti assignparam norm_params as noted below, and any noise distribution parameters should be redundantly passed to the mlhs call for purposes of setting entropy seeds. For example:
  ```
  assignparam = {'mlhs' :
                  {'targetinputcolumn' :
                    {'testnoise' : True,
                     'norm_params' : {'testnoise' : True}}}}
  ```
    - useful for: noise injection for data augmentation, model perturbation for ensembles, differential privacy
    - default infill: the DP function does not apply a default infill assume upstream hs10 cleans data
    - default NArowtype: justNaN
    - suffix appender: '\DPhs\_#\_mlhs\_DPod' where # is integer for each column which collectively encode categoric entries
    - assignparam parameters accepted:
      - 'flip_prob' for percent of activation flips (defaults to 0.03),
      - 'weighted' boolean defaults to True for weighted noise sampling from set of unique entries in train data. When False
      noise sampling is by a uniform draw from set of unique entries as found in train data (which is a little more computationally efficient).
      - 'trainnoise' defaults to True, when False noise is not injected to training data in automunge or postmunge
      - 'testnoise' defaults to False, when True noise is injected to test data in both automunge and postmunge by default
      - DPod noise injection assignparam parameters can be passed to the mlhs parameter 'norm_params' embedded in a dictionary (e.g. assignparam = {'mlhs' : {inputcolumn : {'norm_params' : {'flip_prob' : 0.05}}}} ) Defaults to weighted sampling. (The norm_params approach is associated with use of the mlti transform which is what mlhs applies)
      - 'suffix': to change suffix appender (leading underscore added internally)
      - when activating testnoise, test data specific noise distribution parameters can be passed to {test_flip_prob, test_weighted}, which otherwise default to test_weighted matching the train data and test_flip_prob = 0.01
      - please note that each of the noise distribution parameters {flip_prob, test_flip_prob} can be passed as list of candidate values for a unique sampling applied in automunge and postmunge.
      - please note that each of the noise distribution parameters {flip_prob, test_flip_prob} can be passed as scipy.stats distribution for a uniquely sampled value with each application (this was implemented to support some experiments associated with noise_augment).
      - 'retain_basis' accepts boolean defaulting to False, the use is associated with parameters passed as lists or distributions, when True the sampled basis from automunge(.) is carried through to postmunge(.) instead of a unique sampling for each
      - the DP transforms also accept parameters random_generator and sampling_resource_dict which are derived internally based on automunge or postmunge parameters
      - 'protected_feature' defaults to False, accepts input column header string specifiation, scales different segments of this transform's target feature's noise profile to correspond to different attribute segments of specified adjacent protected categoric feature, which the hypothesis is that this may benefit loss discrepency for the attributes of that protected feature
    - driftreport postmunge metrics: hash metrics
    - returned datatype: conditional integer based on hashing vocab size
    - inversion available: yes
  * DPh2: applies a single column hash binarization via hsh2 followed by a single column categoric noise injection via DPod function (as DPo7), which
  flips the activations per parameter flip_prob which defaults to 0.03 to a weighted random draw from the
  set of activations (including the current activation so actual flip percent is < flip_prob based
  on number of activations).
    - useful for: noise injection for data augmentation, model perturbation for ensembles, differential privacy
    - default infill: the DP function does not apply a default infill assume upstream hs10 cleans data
    - default NArowtype: justNaN
    - suffix appender: '\DPh2\_DPo7'
    - assignparam parameters accepted:
      - 'flip_prob' for percent of activation flips (defaults to 0.03),
      - 'weighted' boolean defaults to True for weighted noise sampling from set of unique entries in train data. When False
      noise sampling is by a uniform draw from set of unique entries as found in train data (which is a little more computationally efficient).
      - 'trainnoise' defaults to True, when False noise is not injected to training data in automunge or postmunge
      - 'testnoise' defaults to False, when True noise is injected to test data in both automunge and postmunge by default
      - noise injection parameters should be passed to 'DPo7' transformation category from family tree
      - 'suffix': to change suffix appender (leading underscore added internally)
      - when activating testnoise, test data specific noise distribution parameters can be passed to {test_flip_prob, test_weighted}, which otherwise default to test_weighted matching the train data and test_flip_prob = 0.01
      - please note that each of the noise distribution parameters {flip_prob, test_flip_prob} can be passed as list of candidate values for a unique sampling applied in automunge and postmunge.
      - please note that each of the noise distribution parameters {flip_prob, test_flip_prob} can be passed as scipy.stats distribution for a uniquely sampled value with each application (this was implemented to support some experiments associated with noise_augment).
      - 'retain_basis' accepts boolean defaulting to False, the use is associated with parameters passed as lists or distributions, when True the sampled basis from automunge(.) is carried through to postmunge(.) instead of a unique sampling for each
      - the DP transforms also accept parameters random_generator and sampling_resource_dict which are derived internally based on automunge or postmunge parameters
      - 'protected_feature' defaults to False, accepts input column header string specifiation, scales different segments of this transform's target feature's noise profile to correspond to different attribute segments of specified adjacent protected categoric feature, which the hypothesis is that this may benefit loss discrepency for the attributes of that protected feature
    - driftreport postmunge metrics: hash metrics
    - returned datatype: conditional integer based on hashing vocab size
    - inversion available: yes
  * DPns: applies a z-score normalization via nmbr followed by a swap_noise injection by DPmc, which for noise targets randomly samples between other rows in the feature. Swap noise is an alternate convention than the distribution sampling applied in DPnb.
    - useful for: noise injection for data augmentation, model perturbation for ensembles, differential privacy
    - default infill: the DP function does not apply a default infill assume upstream transform cleans data
    - default NArowtype: justNaN
    - suffix appender: '\DPn4\_DPns'
    - assignparam parameters accepted:
      - 'flip_prob' for percent of activation flips (defaults to 0.03),
      - 'swap_noise' boolean defaults True, randomly samples from rows (we don't recommend the False scenario when applied downstream of continuous features which is intended for injection to categoric features)
      - 'weighted' - not supported in conjunction with swap_noise = True
      - 'trainnoise' defaults to True, when False noise is not injected to training data in automunge or postmunge
      - 'testnoise' defaults to False, when True noise is injected to test data in both automunge and postmunge by default
      - noise injection parameters should be passed to 'DPmc' transformation category from family tree
      - 'suffix': to change suffix appender (leading underscore added internally)
      - when activating testnoise, test data specific noise distribution parameters can be passed to {test_flip_prob, test_weighted}, which otherwise default to test_weighted matching the train data and test_flip_prob = 0.01
      - please note that each of the noise distribution parameters {flip_prob, test_flip_prob} can be passed as list of candidate values for a unique sampling applied in automunge and postmunge.
      - please note that each of the noise distribution parameters {flip_prob, test_flip_prob} can be passed as scipy.stats distribution for a uniquely sampled value with each application (this was implemented to support some experiments associated with noise_augment).
      - 'retain_basis' accepts boolean defaulting to False, the use is associated with parameters passed as lists or distributions, when True the sampled basis from automunge(.) is carried through to postmunge(.) instead of a unique sampling for each
      - the DP transforms also accept parameters random_generator and sampling_resource_dict which are derived internally based on automunge or postmunge parameters
    - driftreport postmunge metrics: nmbr metrics
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes
  * DP1s: applies a 1010 binarization followed by a swap_noise injection by DPmc, which for noise targets randomly samples between other rows in the feature. Swap noise is an alternate convention than the weighted sampling applied in DP10.
    - useful for: noise injection for data augmentation, model perturbation for ensembles, differential privacy
    - default infill: the DP function does not apply a default infill assume upstream transform cleans data
    - default NArowtype: justNaN
    - suffix appender: 'DPo8\_#\_DP1s' where # is integer for each column which collectively encode categoric entries
    - assignparam parameters accepted:
      - 'flip_prob' for percent of activation flips (defaults to 0.03),
      - 'swap_noise' boolean defaults True, randomly samples from rows (the False scenario results in an encoding comparable to DP10)
      - 'weighted' - not supported in conjunction with swap_noise = True
      - 'trainnoise' defaults to True, when False noise is not injected to training data in automunge or postmunge
      - 'testnoise' defaults to False, when True noise is injected to test data in both automunge and postmunge by default
      - noise injection parameters should be passed to 'DPmc' transformation category from family tree
      - 'suffix': to change suffix appender (leading underscore added internally)
      - when activating testnoise, test data specific noise distribution parameters can be passed to {test_flip_prob, test_weighted}, which otherwise default to test_weighted matching the train data and test_flip_prob = 0.01
      - please note that each of the noise distribution parameters {flip_prob, test_flip_prob} can be passed as list of candidate values for a unique sampling applied in automunge and postmunge.
      - please note that each of the noise distribution parameters {flip_prob, test_flip_prob} can be passed as scipy.stats distribution for a uniquely sampled value with each application (this was implemented to support some experiments associated with noise_augment).
      - 'retain_basis' accepts boolean defaulting to False, the use is associated with parameters passed as lists or distributions, when True the sampled basis from automunge(.) is carried through to postmunge(.) instead of a unique sampling for each
      - the DP transforms also accept parameters random_generator and sampling_resource_dict which are derived internally based on automunge or postmunge parameters
    - driftreport postmunge metrics: 1010 metrics
    - returned datatype: int8
    - inversion available: yes
  * DPsk: applies a masking of sampled entries with a mask_value defaulting to the integer 0. As configured in default process_dict specification treats data as full pass-through without NArow aggregation or infill, similar to DPne and DPse noted below. Can also be used to add discrete noise to continuous features by the additive parameter.
    - useful for: noise injection for data augmentation, model perturbation for ensembles, differential privacy
    - default infill: does notapply infill
    - default NArowtype: exclude
    - suffix appender: '_DPsk'
    - assignparam parameters accepted:
      - 'mask_value' the value injected to masked entries, defaults to integer 0
      - 'additive' boolean defaults as False, for adding discrete noise to continuous numeric features, results in mask value being added to selected entries instead of replaced
      - 'flip_prob' for percent of activation flips (defaults to 0.03),
      - 'trainnoise' defaults to True, when False noise is not injected to training data in automunge or postmunge
      - 'testnoise' defaults to False, when True noise is injected to test data in both automunge and postmunge by default
      - noise injection parameters should be passed to 'DPsk' transformation category from family tree
      - 'suffix': to change suffix appender (leading underscore added internally)
      - when activating testnoise, test data specific noise distribution parameters can be passed to {test_flip_prob}, which otherwise default to test_flip_prob = 0.01
      - please note that each of the noise distribution parameters {flip_prob, test_flip_prob} can be passed as list of candidate values for a unique sampling applied in automunge and postmunge.
      - please note that each of the noise distribution parameters {flip_prob, test_flip_prob} can be passed as scipy.stats distribution for a uniquely sampled value with each application (this was implemented to support some experiments associated with noise_augment).
      - 'retain_basis' accepts boolean defaulting to False, the use is associated with parameters passed as lists or distributions, when True the sampled basis from automunge(.) is carried through to postmunge(.) instead of a unique sampling for each
      - the DP transforms also accept parameters random_generator and sampling_resource_dict which are derived internally based on automunge or postmunge parameters
    - driftreport postmunge metrics: mask_value, other noise parameters
    - returned datatype: consistent with input
    - inversion available: yes
  * DPse: for full pass-through other than swap noise injection (i.e. may be applied to numeric or categoric features with string entries). Comparable parameters supported to DPmc (swap_noise defaults to True). Only other edits are suffix appender on the returned column header. Excluded from ML infill and NArw aggregation. DPse may be suitable for incorporating noise injections to categoric test features into a prior prepared pipeline. A similar pass-through transform for numeric features with distribution sampled injections is available as DPne as noted above. Note that this can be applied to multi-column input sets by assigncat specification that replaces a single input header string with a {set} of input header strings.
  * DPpc: for full pass-through other than weighted categoric injection (may be applie to categoric features with both numeric and string entries). Comparable parameter support to DPod (passthrough defaults to True). Excluded from ML infill and NArw aggregation. DPpc is an alternate to DPse for passthrough noise to categoric sets that fits the noise weightings to the train data as opposed to mathcing the train or test profile. Also has benefit fo protected_feature support.
  * DPmp: similar to DPpc but can be applied to multi-column sets, such as e.g. to inject noise into one hot encoded categoric features. Can be applied to multi-column input sets by assigncat specification that replaces a single input header string with a {set} of input header strings.
  * DPne: for full pass-through other than numeric noise injection (i.e. no normalization applied). Comparable parameters supported to DPnb, samples gaussian by default also has laplace support. Note that for DPne the rescale_sigmas option defaults to True such that specified sigma parameters are rescaled by multiplication with the training set standard deviation, thus allowing common default sigma options independant of feature scale. For user specified sigma parameters they will also be rescaled unless rescale_sigmas has been deactivated. Only other edits to returned feature other than noise injection are conversion to float dtype / non numeric to NaN and suffix appender on the returned column header. Excluded from ML infill and NArw aggregation. DPne may be suitable for incorporating noise injections to numeric test features into a prior prepared pipeline. Includes protected_feature support.

  Please note that DPse (passthrough swap noise e.g. for categoric), DPne (passthrough gaussian or laplace noise for numeric), DPsk (passthrough mask noise for numeric or categoric), and excl (passthrough without noise) can be used in tandem to pass a dataframe to automunge(.) for noise injection without other edits or infill, such as could be used to incorporate noise into an existing tabular pipeline. When limited to these three root categories the returned dataframe will match the same order of columns with only edits other than noise as updated column headers and DPne will overide any data types other than float. (To retain same order of rows can deactivate shuffletrain parameter.)


  * excl: passes source column un-altered, no transforms, data type conversion, or infill. The feature is excluded from ML infill basis of all other features. If a passthrough column is desired to be included in ML infill basis for surrounding features, it should instead be passed to one of the other passthrough transforms, such as exc2 for continuous numeric, exc5 for ordinal encoded integers, or exc8 for continuous integers. Data returned from excl may be non-numeric. excl has a special suffix convention in the library in that the column is returned without a suffix appender (to signify full pass-through), if suffix retention is desired it is available by the automunge(.) excl_suffix parameter.
  Note that for assignnan designation of infill conversions, excl is excluded from 'global' assignments
  (although may still be assigned explicitly under assignnan columns or categories entries). excl also retains original form of entries that for other transforms are converted to missing data markers, such as None or inf.
    - useful for: full passthrough sets
    - default infill: none
    - default NArowtype: exclude
    - suffix appender: None or '\_excl' (dependent on automunge(.) excl_suffix parameter)
    - assignparam parameters accepted: none
    - driftreport postmunge metrics: none
    - returned datatype: retains data type of received data
    - inversion available: yes
  * exc2/exc3/exc4/exc6: passes source column unaltered other than force to numeric, adjinfill applied
  (exc3 and exc4 have downstream standard deviation or power of 10 bins aggregated such as may be beneficial
  when applying TrainLabelFreqLevel to a numeric label set). For use without NArw aggregation use exc6/
    - useful for: numeric pass-through sets, feature included in surrounding ML infill models
    - default infill: adjinfill
    - default NArowtype: numeric
    - suffix appender: '_exc2' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: none
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes
  * exc5/exc8: passes source column unaltered other than force to numeric, adjinfill applied for non-integers. exc5 is for ordinal encoded integers, exc8 is for continuous integers. For use without NArw aggregation use exc7/exc9
    - useful for: passthrough integer sets, feature included in surrounding ML infill models
    - default infill: adjinfill
    - default NArowtype: integer
    - suffix appender: '_exc5' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
      - 'integertype': sets the convention for returned datatype exc5 defaults to 'singlct', exc8 defaults to 'integer'
    - driftreport postmunge metrics: none
    - returned datatype: exc5 is conditional uint based on size of encoding space, exc8 is int32
    - inversion available: yes
  * eval: performs data property evaluation consistent with default automation to designated column
    - useful for: applying automated evaluation to distinct columns for cases where default automated evaluation turned off by powertransform='excl'
    - default infill: based on evaluation
    - default NArowtype: based on evaluation
    - suffix appender: based on evaluation
    - assignparam parameters accepted: none
    - driftreport postmunge metrics: none
    - returned datatype: based on transformation applied
    - inversion available: contingent on result
  * ptfm: performs distribution property evaluation consistent with the automunge powertransform
  parameter activated to designated column
    - useful for: applying automated powertransform evaluation to distinct columns
    - default infill: based on evaluation
    - default NArowtype: based on evaluation
    - suffix appender: based on evaluation
    - assignparam parameters accepted: none
    - driftreport postmunge metrics: none
    - returned datatype: based on transformation applied
    - inversion available: contingent on result
  * copy: create new copy of column, may be used when applying the same transform to same column more
  than once with different parameters as an alternate to defining a distinct category processdict entry for each redundant application.
  This also may be useful when defining a family tree where the shortest path isn't the desired inversion path, in which case
  can add some intermediate copy operations to shortest path until inversion selects the desired path
  (as inversion operates on heuristic of selecting shortest transformation path with full information retention,
  unless full information retention isn't available then the shortest path without full information retention).
  Does not prepare column for ML on its own (e.g. returned data will carry forward non-numeric entries and will not conduct infill).
    - default infill: exclude
    - default NArowtype: exclude
    - suffix appender: '_copy' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: none
    - returned datatype: consistent with input
    - inversion available: yes
  * shfl: shuffles the values of a column based on passed randomseed (Note that returned data may not
  be numeric and predictive methods like ML infill and feature selection may not work for that scenario
  unless an additional transform is applied downstream.)
    - useful for: shuffle useful to negate feature from influencing inference
    - default infill: naninfill
    - default NArowtype: justNAN
    - suffix appender: '_shfl' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: none
    - returned datatype: consistent with input
    - inversion available: no
  * mlti: mlti is a category that may take as input a set of one or more columns returned from an upstream transform, for example this could be a multi-column set returned from a concurrent_nmbr containing multiple columns of continuous numeric entries (or otherwise take a single column input when applied to an upstream primitive). mlti applies a normalization to each of the columns on an independent basis. The normalization defaults to z-score via nmbr or alternate transforms may be designated by assignparam. (Currently mlti is not defined as a root category, but is available for use as a tree category.) mlti is defined in process_dict based on concurrent_nmbr MLinfilltype. mlti may be used to apply an arbitrary transformation category to each column from a set of columns returned from a transform (such as for a concurrent MLinfilltype). The MLinfilltype basis for mlti is concurrent_nmbr, meaning it assumes returned columns are continuous numeric. For concurrent_ordl MLinfilltype can either overwrite processdict or make use of mlto. Returned concurrent_act support is available by overwriting the processdict entry.
    - useful for: normalizing a set of numeric features returned from an upstream transform
    - default infill: consistent with the type of normalization selected
    - default NArowtype: justNaN
    - suffix appender: '\_mlti\_' + suffix associated with the normalization
    - assignparam parameters accepted:
      - 'norm_category': defaults to 'nmbr', used to specify type of normalization applied to each column. Used to access transformation functions from process_dict.
      - 'norm_params': defaults to empty dictionary {}, used to pass parameters to the normalization transform, e.g. as {parameter : value}. Note that parameters can also be passed to the norm_category through the assignparam automunge(.) parameter, with any specifications (such as to global_assignparam or default_assignparam) taking precedence over specifications through norm_params.
      - 'dtype': accepts one of {'float', 'conditionalinteger', 'mlhs'}, defaults to float. conditionalinteger is for use with mlto. 'mlhs' is for use with mlhs.
    - driftreport postmunge metrics: records drift report metrics included with the normalization transform
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: based on normalization transform inversion (if norm_category does not support inversion a passthrough inversion is applied)
  * mlto: comparable to mlti but intended for use with returning multiple ordinal encoded columns. mlto is defined in process_dict based on concurrent_ordl MLinfilltype.
    - useful for: ordinal encoding a set of categoric features returned from an upstream transform
    - default infill: consistent with the type of ordinal encoding selected
    - default NArowtype: justNaN
    - suffix appender: '\_mlto\_' + suffix associated with the normalization
    - assignparam parameters accepted:
      - 'norm_category': defaults to 'ord3', used to specify type of ordinal encoding applied to each column. Used to access transformation functions from process_dict.
      - 'norm_params': defaults to empty dictionary {}, used to pass parameters to the normalization transform, e.g. as {parameter : value}
      - 'dtype': accepts one of {'float', 'conditionalinteger', 'mlhs'}, defaults to conditionalinteger.
    - driftreport postmunge metrics: records drift report metrics included with the normalization transform
    - returned datatype: conditional based on size of encoding space (uint8 / uint16 / uint32)
    - inversion available: based on normalization transform inversion (if norm_category does not support inversion a passthrough inversion is applied)
  * bnst/bnso: intended for use downstream of multicolumn boolean integer sets, such as those returned from MLinfilltype multirt, 1010, concurrent_act. bnst serves to aggregate the multicolumn  representation into a single column encoding. bnst returns a string representation, bnso performs a downstream ordinal encoding. Intended for sets with boolean integer entries.
    - useful for: some downstream libraries prefer label sets in single column representations. This allows user to convert a multicolumn to single column for this or some other purpose.
    - default infill: zeroinfill (assumes infill performed upstream.)
    - default NArowtype: justNaN
    - suffix appender: '_bnst'
    - assignparam parameters accepted:
      - suffix: defaults to tree category, accepts string
      - upstreaminteger: defaults to True for boolean integer input, when False can receive other single character entries, although inversion not supported for the False scenario
    - driftreport postmunge metrics: none
    - returned datatype: bnst returns string, bnso conditional integer per downstream ordinal encoding
    - inversion available: supported for upstreaminteger True scenario, False performs a passthrough inversion without recovery
  * GPS1: for converting sets of GPS coordinates to normalized latitude and longitude, relies on comma separated inputs, with latitude/longitude reported as DDMM.... or DDDMM.... and direction as one of 'N'/'S' or 'E'/'W'. Note that with GPS data, depending on the application, there may be benefit to setting the automunge(.) floatprecision parameter to 64 instead of the default 32. If you want to apply ML infill or some other assigninfill on the returned sets, we recommend ensuring missing data is received as NaN, otherwise missing entries will receive adjinfill.
    - useful for: converting GPS coordinates to normalized latitude and normalized longitude
    - default infill: adjinfill
    - default NArowtype: justNaN
    - suffix appender: \_GPS1\_latt\_mlti\_nmbr and \_GPS1\_long\_mlti\_nmbr
    - assignparam parameters accepted:
      - 'GPS_convention': accept one of {'default', 'nonunique'}, under default all rows are individually parsed. nonunique is used in GPS3 and GPS4.
      - 'comma_addresses': accepts as list of 4 integers, defaulting to [2,3,4,5], which corresponds to default where latitude located after comma 2, latitude direction after comma 3, longitude after comma 4, longitude direction after comma 5
      - 'comma_count': an integer, defaulting to 14, used in inversion to pad out commas on the recovered data format
    - driftreport postmunge metrics: metrics included with the downstream normalization transforms
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes with partial recovery e.g. for default configuration recovers data in the form ",,DDMM.MMMMMMM,C,DDMM.MMMMMMM,C,,,,,,,,," (where C is the direction)
  * GPS2: comparable to GPS1 but without the downstream normalization, so returns floats in units of arc minutes. (If you want missing data returned as NaN instead of adjinfill, can set process_dict entry NArowtype to 'exclude'.)
  * GPS3: comparable to GPS1, including downstream normalization, but only unique entries are parsed instead of all rows. Parses unique entries in both the train and test set. This may benefit latency in cases of redundant entries.
  * GPS4: comparable to GPS1, including downstream normalization, but only unique entries are parsed instead of all rows. Parses unique entries in the train set and relies on assumption that the set of unique entries in test set will be the same or a subset of the train set, which may benefit latency for this scenario.
  * GPS5: comparable to GPS3 but performs a downstream ordinal encoding instead of normalization, as may be desired when treating a fixed range of GPS coordinates as a categoric feature, latitude and longitude encoded separately.
  * GPS6: comparable to GPS3 but performs both a downstream ordinal encoding and a downstream normalization, such as to treat latitude and longitude both as categoric and continuous numeric features. This is probably a better default than GPS3 or GPS5 for fixed range of entries.
  * NArw: produces a column of boolean integer identifiers for rows in the source
  column with missing or improperly formatted values. Note that when NArw
  is assigned in a family tree it bases NArowtype on the root category,
  when NArw is passed as the root category it bases NArowtype on default.
    - useful for: supplementing any transform with marker for missing entries. On by default by NArw_marker parameter
    - default infill: not applicable
    - default NArowtype: justNaN
    - suffix appender: '_NArw' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: pct_NArw
    - returned datatype: int8
    - inversion available: no
  * NAr2: produces a column of boolean identifiers for rows in the source
  column with missing or improperly formatted values.
    - useful for: similar to NArw but different default NArwtype for when used as a root category
    - default infill: not applicable
    - default NArowtype: numeric
    - suffix appender: '_NAr2' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: pct_NArw
    - returned datatype: int8
    - inversion available: no
  * NAr3: produces a column of boolean identifiers for rows in the source
  column with missing or improperly formatted values.
    - useful for: similar to NArw but different default NArwtype for when used as a root category
    - default infill: not applicable
    - default NArowtype: positivenumeric
    - suffix appender: '_NAr3' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: pct_NArw
    - returned datatype: int8
    - inversion available: no
  * NAr4: produces a column of boolean identifiers for rows in the source
  column with missing or improperly formatted values.
    - useful for: similar to NArw but different default NArwtype for when used as a root category
    - default infill: not applicable
    - default NArowtype: nonnegativenumeric
    - suffix appender: '_NAr4' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: pct_NArw
    - returned datatype: int8
    - inversion available: no
  * NAr5: produces a column of boolean identifiers for rows in the source
  column with missing or improperly formatted values.
    - useful for: similar to NArw but different default NArwtype for when used as a root category
    - default infill: not applicable
    - default NArowtype: integer
    - suffix appender: '_NAr5' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: pct_NArw
    - returned datatype: int8
    - inversion available: no
  * null: deletes source column
    - default infill: none
    - default NArowtype: exclude
    - no suffix appender, column deleted
    - assignparam parameters accepted: none
    - driftreport postmunge metrics: none
    - returned datatype: N/A
    - inversion available: no


  Please note I recommend caution on using splt/spl2/spl5/spl6 transforms on categorical
  sets that may include scientific units for instance, as prefixes will not be noted
  for overlaps, e.g. this wouldn't distinguish between kilometer and meter for instance.
  Note that overlap lengths below 5 characters are ignored unless that value is overridden
  by passing 'minsplit' parameter through assignparam. Further detail on parsed categoric
  encodings provided in the essay [Parsed Categoric Encodings with Automunge](https://medium.com/automunge/string-theory-acbd208eb8ca).
  * splt: searches categorical sets for overlaps between string character subsets and returns new boolean column
  for identified overlap categories. Note this treats numeric values as strings e.g. 1.3 = '1.3'.
  Note that priority is given to overlaps of higher length, and by default overlap go down to 5 character length.
    - useful for: extracting grammatical structure shared between entries
    - default infill: none
    - default NArowtype: justNaN
    - suffix appender: '\_splt\_##*##' where ##*## is target identified string overlap
    - assignparam parameters accepted:
      - 'minsplit': indicating lowest character length for recognized overlaps
      - 'space_and_punctuation': True/False, defaults to True, when passed as
        False character overlaps are not recorded which include space or punctuation
        based on characters in excluded_characters parameter
      - 'excluded_characters': a list of strings which are excluded from overlap
        identification when space_and_punctuation set as False, defaults to
        `[' ', ',', '.', '?', '!', '(', ')']`
      - 'concurrent_activations': defaults as False, True makes comparable to sp15,
        although recommend using sp15 instead for correct MLinfilltype
      - 'suffix': returned column suffix appender, defaults to 'splt'
      - 'int_headers': True/False, defaults as False, when True returned column headers
        are encoded with integers, such as for privacy preserving of data contents
      - 'test_same_as_train': defaults False, True makes this comparable to spl8
    - driftreport postmunge metrics: overlap_dict / splt_newcolumns_splt / minsplit
    - returned datatype: int8
    - inversion available: yes with partial recovery
  * sp15: similar to splt, but allows concurrent activations for multiple detected overlaps (spelled sp-fifteen)
  Note that this version runs risk of high dimensionality of returned data in comparison to splt.
    - useful for: extracting grammatical structure shared between entries with increased information retention vs splt
    - default infill: none
    - default NArowtype: justNaN
    - suffix appender: '\_sp15\_##*##' where ##*## is target identified string overlap
    - assignparam parameters accepted:
      - comparable to splt, with concurrent_activations as True
    - driftreport postmunge metrics: overlap_dict / splt_newcolumns_sp15 / minsplit
    - returned datatype: int8
    - inversion available: yes with partial recovery
  * sp19: comparable to sp15, but with returned columns aggregated by a binary encoding to reduce dimensionality
    - useful for: extracting grammatical structure shared between entries with decreased dimensionality vs sp15
    - default infill: distinct encoding
    - default NArowtype: justNaN
    - suffix appender: '\_sp19\_#' where # is integer associated with the encoding
    - assignparam parameters accepted: comparable to sp15
    - driftreport postmunge metrics: comparable to sp15 with addition of _1010_activations_dict for activation ratios
    - returned datatype: int8
    - inversion available: yes with partial recovery
  * sbst: similar to sp15, but only detects string overlaps shared between full unique entries and subsets of longer character length entries
    - useful for: extracting cases of overlap between full entries and subsets of other entries
    - default infill: none
    - default NArowtype: justNaN
    - suffix appender: '\_sbst\_##*##' where ##*## is target identified string overlap
    - assignparam parameters accepted:
      - 'int_headers': True/False, defaults as False, when True returned column headers
        are encoded with integers, such as for privacy preserving of data contents
      - 'minsplit': indicating lowest character length for recognized overlaps, defaults to 1
      - 'concurrent_activations':  True/False, defaults to True, when True
        entries may have activations for multiple simultaneous overlaps
      - 'test_same_as_train': defaults False, True makes this comparable to sbs2
      - 'suffix': returned column suffix appender, defaults to 'sbst'
    - driftreport postmunge metrics: overlap_dict / splt_newcolumns_sbst / minsplit
    - returned datatype: int8
    - inversion available: yes with partial recovery
  * sbs3: comparable to sbst, but with returned columns aggregated by a binary encoding to reduce dimensionality
    - useful for: binary version of sbst for reduced dimensionality
    - default infill: distinct encoding
    - default NArowtype: justNaN
    - suffix appender: '\_sbs3\_#' where # is integer associated with the encoding
    - assignparam parameters accepted: comparable to sbst
    - driftreport postmunge metrics: comparable to sbst with addition of _1010_activations_dict for activation ratios
    - returned datatype: int8
    - inversion available: yes with partial recovery
  * spl2/ors2/ors6/txt3: similar to splt, but instead of creating new column identifier it replaces categorical
  entries with the abbreviated string overlap
    - useful for: similar to splt but returns single column, used in aggregations like or19
    - default infill: none
    - default NArowtype: justNaN
    - suffix appender: '_spl2' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'minsplit': indicating lowest character length for recognized overlaps
      - 'space_and_punctuation': True/False, defaults to True, when passed as
        False character overlaps are not recorded which include space or punctuation
        based on characters in excluded_characters parameter
      - 'excluded_characters': a list of strings which are excluded from overlap
        identification when space_and_punctuation set as False, defaults to
        `[' ', ',', '.', '?', '!', '(', ')']`
      - 'test_same_as_train': defaults False, True makes this comparable to spl9
      - 'suffix': returned column suffix appender, defaults to 'spl2'
      - 'consolidate_nonoverlaps': defaults to False, True makes this comparable to spl5
    - driftreport postmunge metrics: overlap_dict / spl2_newcolumns / spl2_overlap_dict / spl2_test_overlap_dict /
                                     minsplit
    - returned datatype: str (other categoric encodings can be returned downstream to return numeric)
    - inversion available: yes with partial recovery
  * spl5/ors5: similar to spl2, but those entries without identified string overlap are set to 0,
  (used in ors5 in conjunction with ord3)
    - useful for: final tier of spl2 aggregations such as in or19
    - default infill: none
    - default NArowtype: justNaN
    - suffix appender: '_spl5' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - comparable to spl2, consolidate_nonoverlaps as True
    - driftreport postmunge metrics: overlap_dict / spl2_newcolumns / spl2_overlap_dict / spl2_test_overlap_dict /
                                     spl5_zero_dict / minsplit
    - returned datatype: str (other categoric encodings can be returned downstream to return numeric)
    - inversion available: yes with partial recovery
  * spl6: similar to spl5, but with a splt performed downstream for identification of overlaps
  within the overlaps
    - useful for: just a variation on parsing aggregations
    - default infill: none
    - default NArowtype: justNaN
    - suffix appender: '_spl6' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - comparable to spl2
    - driftreport postmunge metrics: overlap_dict / spl2_newcolumns / spl2_overlap_dict / spl2_test_overlap_dict /
                                     spl5_zero_dict / minsplit
    - returned datatype: int8
    - inversion available: yes with partial recovery
  * spl7: similar to spl5, but recognizes string character overlaps down to minimum 2 instead of 5
    - useful for: just a variation on parsing aggregations
    - default infill: none
    - default NArowtype: justNaN
    - suffix appender: '_spl7' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - comparable to spl5, minsplit defaults to 2
    - driftreport postmunge metrics: overlap_dict / srch_newcolumns_srch / search
    - returned datatype: int8
    - inversion available: yes with partial recovery
  * srch: searches categorical sets for overlaps with user passed search string and returns new boolean column
  for identified overlap entries.
    - useful for: identifying specific entry character subsets by search
    - default infill: none
    - default NArowtype: justNaN
    - suffix appender: '\_srch\_##*##' where ##*## is target identified search string
    - assignparam parameters accepted:
      - 'search': a list of strings, defaults as empty set
        (note search parameter list can included embedded lists of terms for
        aggregated activations of terms in the sub-list)
      - 'case': bool to indicate case sensitivity of search, defaults True
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: overlap_dict / splt_newcolumns_splt / minsplit
    - returned datatype: int8
    - inversion available: yes with partial recovery
  * src2: comparable to srch but expected to be more efficient when target set has narrow range of entries
    - useful for: similar to srch slight variation on implementation
    - default infill: none
    - default NArowtype: justNaN
    - suffix appender: '\_src2_##*##' where ##*## is target identified search string
    - assignparam parameters accepted:
      - 'search': a list of strings, defaults as empty set
        (note search parameter list can included embedded lists of terms for
        aggregated activations of terms in the sub-list)
      - 'case': bool to indicate case sensitivity of search, defaults True
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: overlap_dict / splt_newcolumns_splt / minsplit
    - returned datatype: int8
    - inversion available: yes with partial recovery
  * src3: comparable to src2 with additional support for test set entries not found in train set
  * src4: searches categorical sets for overlaps with user passed search string and returns ordinal column
  for identified overlap entries. (Note for multiple activations encoding priority given to end of list entries).
    - useful for: ordinal version of srch
    - default infill: none
    - default NArowtype: justNaN
    - suffix appender: '\_src4' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'search': a list of strings, defaults as empty set
        (note search parameter list can included embedded lists of terms for
        aggregated activations of terms in the sub-list)
      - 'case': bool to indicate case sensitivity of search, defaults True
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: overlap_dict / splt_newcolumns_splt / minsplit
    - returned datatype: conditional based on size of encoding space (uint8 / uint16 / uint32)
    - inversion available: yes with partial recovery
  * nmrc/nmr2/nmr3: parses strings and returns any number groupings, prioritized by longest length
    - useful for: extracting numeric character subsets of entries
    - default infill: mean
    - default NArowtype: parsenumeric
    - suffix appender: '_nmrc' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: overlap_dict / mean / maximum / minimum
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes with full recovery
  * nmcm/nmc2/nmc3: similar to nmrc, but recognizes numbers with commas, returns numbers stripped of commas
    - useful for: extracting numeric character subsets of entries, recognizes commas
    - default infill: mean
    - default NArowtype: parsenumeric
    - suffix appender: '_nmcm' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: overlap_dict / mean / maximum / minimum
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes with full recovery
  * nmEU/nmE2/nmE3: similar to nmcm, but recognizes numbers with period or space thousands delimiter and comma decimal
    - useful for: extracting numeric character subsets of entries, recognizes EU format
    - default infill: mean
    - default NArowtype: parsenumeric
    - suffix appender: '_nmEU' in base configuration or based on the family tree category
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: overlap_dict / mean / maximum / minimum
    - returned datatype: based on automunge(.) floatprecision parameter (defaults to float32)
    - inversion available: yes with full recovery
  * strn: parses strings and returns any non-number groupings, prioritized by longest length, followed by ord3 ordinal encoding
    - useful for: extracting nonnumeric character subsets of entries
    - default infill: naninfill
    - default NArowtype: justNaN
    - suffix appender: '_strn_ord3'
    - assignparam parameters accepted:
      - 'suffix': to change suffix appender (leading underscore added internally)
    - driftreport postmunge metrics: overlap_dict
    - returned datatype: conditional based on size of encoding space (uint8 / uint16 / uint32)
    - inversion available: pending

  * new processing functions nmr4/nmr5/nmr6/nmc4/nmc5/nmc6/nmE4/nmE5/nmE6/spl8/spl9/sp10 (spelled sp"ten")/sp16/src2/sbs2/sp20/sbs4:
    - comparable to functions nmrc/nmr2/nmr3/nmcm/nmc2/nmc3/nmEU/nmE2/nmE3/splt/spl2/spl5/sp15/srch/sbst/sp19/sbs3
    - but make use of new assumption that set of unique values in test set is same or a subset of those values
      from the train set, which allows for a more efficient application (no more string parsing of test sets)
    - default infill: comparable
    - default NArowtype: comparable
    - suffix appender: same format, updated per the new category
    - assignparam parameters accepted: comparable
    - driftreport postmunge metrics: comparable
    - returned datatype: comparable
    - inversion available: yes
  * new processing functions nmr7/nmr8/nmr9/nmc7/nmc8/nmc9/nmE7/nmE8/nmE9:
    - comparable to functions nmrc/nmr2/nmr3/nmcm/nmc2/nmc3/nmEU/nmE2/nmE3
    - but implements string parsing only for unique test set entries not found in train set
    - for more efficient test set processing in automunge and postmunge
    - (less efficient than nmr4/nmc4 etc but captures outlier points as may not be unusual in continuous distributions)
    - default infill: comparable
    - default NArowtype: comparable
    - suffix appender: same format, updated per the new category
    - assignparam parameters accepted: comparable
    - driftreport postmunge metrics: overlap_dict / mean / maximum / minimum / unique_list / maxlength
    - returned datatype: comparable
    - inversion available: no


  The following are a few variations of parsed categoric encoding aggregations. We recommend the or19 variant and
  have written about in paper [Parsed Categoric Encodings with Automunge](https://medium.com/automunge/string-theory-acbd208eb8ca).
  * new processing root categories or11 / or12 / or13 / or14 / or15 / or16 / or17 / or18 / or19 / or20
    - or11 / or13 intended for categorical sets that may include multiple tiers of overlaps
    and include base binary encoding via 1010 supplemented by tiers of string parsing for
    overlaps using spl2 and spl5, or11 has two tiers of overlap string parsing, or13 has three,
    each parsing returned with an ordinal encoding sorted by frequency (ord3)
    - or12 / or14 are comparable to or11 / or13 but include an additional supplemental
    transform of string parsing for numerical entries with nmrc followed by a z-score normalization
    of returned numbers via nmbr
    - or15 / or16 / or17 / or18 comparable to or11 / or12 / or13 / or14 but incorporate an
    UPCS transform upstream and make use of spl9/sp10 instead of spl2/spl5 for assumption that
    set of unique values in test set is same or subset of train set for more efficient postmunge
    - or19 / or20 comparable to or16 / or18 but replace the 'nmrc' string parsing for numeric entries
    with nmc8 which allows comma characters in numbers and makes use of consistent assumption to
    spl9/sp10 that set of unique values in test set is same or subset of train for efficient postmunge
    - or21 / or22 comparable to or19 / or20 but use spl2/spl5 instead of spl9/sp10,
    which allows string parsing to handle test set entries not found in the train set
    - or23 similar to or19 but instead of spl2/spl5 chain applies a sp19 for binary encoded string parsing with concurrent activations
    - assignparam parameters accepted: 'minsplit': indicating lowest character length for recognized overlaps
    (note that parameter has to be assigned to specific categories such as spl2/spl5 etc), also other parameters
  associated with constituent functions
    - driftreport postmunge metrics: comparable to constituent functions
    - inversion available: yes with full recovery

   ___

  Here are those root categories presented again in a concise sorted list, intended as reference so user can
  avoid unintentional duplication.
  - '1010',
  - '101d',
  - '10mz',
  - 'DB10',
  - 'DB1s',
  - 'DBb2',
  - 'DBbn',
  - 'DBbx',
  - 'DBh1',
  - 'DBh2',
  - 'DBhs',
  - 'DBm2',
  - 'DBmc',
  - 'DBmm',
  - 'DBmp',
  - 'DBn2',
  - 'DBn3',
  - 'DBn4',
  - 'DBnb',
  - 'DBne',
  - 'DBnm',
  - 'DBns',
  - 'DBo4',
  - 'DBo5',
  - 'DBo6',
  - 'DBo7',
  - 'DBo8',
  - 'DBod',
  - 'DBoh',
  - 'DBqt',
  - 'DBrt',
  - 'DBse',
  - 'DBsk',
  - 'DLmm',
  - 'DLnb',
  - 'DLrt',
  - 'DP10',
  - 'DP1s',
  - 'DPb2',
  - 'DPbn',
  - 'DPbx',
  - 'DPh1',
  - 'DPh2',
  - 'DPhs',
  - 'DPm2',
  - 'DPmc',
  - 'DPmm',
  - 'DPmp',
  - 'DPn2',
  - 'DPn3',
  - 'DPn4',
  - 'DPnb',
  - 'DPne',
  - 'DPnm',
  - 'DPns',
  - 'DPo4',
  - 'DPo5',
  - 'DPo6',
  - 'DPo7',
  - 'DPo8',
  - 'DPod',
  - 'DPoh',
  - 'DPpc',
  - 'DPqt',
  - 'DPrt',
  - 'DPse',
  - 'DPsk',
  - 'DT10',
  - 'DT1s',
  - 'DTb2',
  - 'DTbn',
  - 'DTbx',
  - 'DTh1',
  - 'DTh2',
  - 'DThs',
  - 'DTm2',
  - 'DTmc',
  - 'DTmm',
  - 'DTmp',
  - 'DTn2',
  - 'DTn3',
  - 'DTn4',
  - 'DTnb',
  - 'DTne',
  - 'DTnm',
  - 'DTns',
  - 'DTo4',
  - 'DTo5',
  - 'DTo6',
  - 'DTo7',
  - 'DTo8',
  - 'DTod',
  - 'DToh',
  - 'DTqt',
  - 'DTrt',
  - 'DTse',
  - 'DTsk',
  - 'GPS1',
  - 'GPS2',
  - 'GPS3',
  - 'GPS4',
  - 'GPS5',
  - 'GPS6',
  - 'MAD2',
  - 'MAD3',
  - 'MADn',
  - 'NAr2',
  - 'NAr3',
  - 'NAr4',
  - 'NAr5',
  - 'NArw',
  - 'U101',
  - 'Ucct',
  - 'Uh10',
  - 'Uhs2',
  - 'Uhsh',
  - 'UPCS',
  - 'Unht',
  - 'Uor2',
  - 'Uor3',
  - 'Uor6',
  - 'Uord',
  - 'Utx2',
  - 'Utx3',
  - 'Utxt',
  - 'absl',
  - 'addd',
  - 'aggt',
  - 'arcs',
  - 'arsn',
  - 'artn',
  - 'bins',
  - 'bkb3',
  - 'bkb4',
  - 'bkt1',
  - 'bkt2',
  - 'bkt3',
  - 'bkt4',
  - 'bn7b',
  - 'bn7o',
  - 'bn9b',
  - 'bn9o',
  - 'bnKo',
  - 'bnMo',
  - 'bne7',
  - 'bne9',
  - 'bneb',
  - 'bneo',
  - 'bnep',
  - 'bnKb',
  - 'bnMb',
  - 'bnr2',
  - 'bnrd',
  - 'bnry',
  - 'bnso',
  - 'bnst',
  - 'bnwb',
  - 'bnwK',
  - 'bnwM',
  - 'bnwd',
  - 'bnwo',
  - 'bsbn',
  - 'bshr',
  - 'bsor',
  - 'bxc2',
  - 'bxc3',
  - 'bxc4',
  - 'bxc5',
  - 'bxc6',
  - 'bxc7',
  - 'bxcx',
  - 'cnsl',
  - 'cns2',
  - 'cns3',
  - 'copy',
  - 'cost',
  - 'd2d2',
  - 'd2dt',
  - 'd3d2',
  - 'd3dt',
  - 'd4d2',
  - 'd4dt',
  - 'd5d2',
  - 'd5dt',
  - 'd6d2',
  - 'd6dt',
  - 'dat2',
  - 'dat3',
  - 'dat4',
  - 'dat5',
  - 'dat6',
  - 'datd',
  - 'date',
  - 'day2',
  - 'day3',
  - 'day4',
  - 'day5',
  - 'days',
  - 'ddd2',
  - 'ddd3',
  - 'ddd4',
  - 'ddd5',
  - 'ddd6',
  - 'dddt',
  - 'ded2',
  - 'ded3',
  - 'ded4',
  - 'ded5',
  - 'ded6',
  - 'dedt',
  - 'dhmc',
  - 'dhms',
  - 'divd',
  - 'dxd2',
  - 'dxdt',
  - 'dycs',
  - 'dysn',
  - 'exc2',
  - 'exc3',
  - 'exc4',
  - 'exc5',
  - 'exc6',
  - 'exc7',
  - 'exc8',
  - 'exc9',
  - 'excl',
  - 'fsmh',
  - 'hash',
  - 'hldy',
  - 'hmsc',
  - 'hmss',
  - 'hour',
  - 'hrcs',
  - 'hrs2',
  - 'hrs3',
  - 'hrs4',
  - 'hrsn',
  - 'hs10',
  - 'hsh2',
  - 'lb10',
  - 'lbbn',
  - 'lbda',
  - 'lbfs',
  - 'lbnm',
  - 'lbo5',
  - 'lbor',
  - 'lbos',
  - 'lbsm',
  - 'lbte',
  - 'lgn2',
  - 'lgnm',
  - 'lgnr',
  - 'lngt',
  - 'lngm',
  - 'lnlg',
  - 'log0',
  - 'log1',
  - 'logn',
  - 'ma10',
  - 'matx',
  - 'maxb',
  - 'mdcs',
  - 'mdsn',
  - 'mea2',
  - 'mea3',
  - 'mean',
  - 'mics',
  - 'min2',
  - 'min3',
  - 'min4',
  - 'mint',
  - 'misn',
  - 'mlhs',
  - 'mltG',
  - 'mlti',
  - 'mlto',
  - 'mltp',
  - 'mmd2',
  - 'mmd3',
  - 'mmd4',
  - 'mmd5',
  - 'mmd6',
  - 'mmdx',
  - 'mmor',
  - 'mmq2',
  - 'mmqb',
  - 'mncs',
  - 'mnm2',
  - 'mnm3',
  - 'mnm4',
  - 'mnm5',
  - 'mnm6',
  - 'mnm7',
  - 'mnmx',
  - 'mnsn',
  - 'mnt2',
  - 'mnt3',
  - 'mnt4',
  - 'mnt5',
  - 'mnt6',
  - 'mnth',
  - 'mnto',
  - 'mnts',
  - 'mscs',
  - 'mssn',
  - 'mxab',
  - 'nbr2',
  - 'nbr3',
  - 'nbr4',
  - 'nmbd',
  - 'nmbr',
  - 'nmc2',
  - 'nmc3',
  - 'nmc4',
  - 'nmc5',
  - 'nmc6',
  - 'nmc7',
  - 'nmc8',
  - 'nmc9',
  - 'nmcm',
  - 'nmd2',
  - 'nmd3',
  - 'nmd4',
  - 'nmd5',
  - 'nmd6',
  - 'nmdx',
  - 'nmE2',
  - 'nmE3',
  - 'nmE4',
  - 'nmE5',
  - 'nmE6',
  - 'nmE7',
  - 'nmE8',
  - 'nmE9',
  - 'nmEU',
  - 'nmq2',
  - 'nmqb',
  - 'nmr2',
  - 'nmr3',
  - 'nmr4',
  - 'nmr5',
  - 'nmr6',
  - 'nmr7',
  - 'nmr8',
  - 'nmr9',
  - 'nmrc',
  - 'ntg2',
  - 'ntg3',
  - 'ntgr',
  - 'nuld',
  - 'null',
  - 'om10',
  - 'onht',
  - 'or10',
  - 'or11',
  - 'or12',
  - 'or13',
  - 'or14',
  - 'or15',
  - 'or16',
  - 'or17',
  - 'or18',
  - 'or19',
  - 'or20',
  - 'or21',
  - 'or22',
  - 'or23',
  - 'or3b',
  - 'or3c',
  - 'or3d',
  - 'ord2',
  - 'ord3',
  - 'ord4',
  - 'ord5',
  - 'ordd',
  - 'ordl',
  - 'ors2',
  - 'ors5',
  - 'ors6',
  - 'ors7',
  - 'por2',
  - 'por3',
  - 'pwbn',
  - 'pwor',
  - 'pwr2',
  - 'pwrs',
  - 'qbt1',
  - 'qbt2',
  - 'qbt3',
  - 'qbt4',
  - 'qbt5',
  - 'qtt1',
  - 'qttf',
  - 'qtt2',
  - 'rais',
  - 'retn',
  - 'rtb2',
  - 'rtbn',
  - 'sbs2',
  - 'sbs3',
  - 'sbs4',
  - 'sbst',
  - 'sbtr',
  - 'sccs',
  - 'scn2',
  - 'scnd',
  - 'scsn',
  - 'sgn1',
  - 'sgn2',
  - 'sgn3',
  - 'sgn4',
  - 'shf2',
  - 'shf3',
  - 'shf4',
  - 'shf5',
  - 'shf6',
  - 'shf7',
  - 'shf8',
  - 'shfl',
  - 'shft',
  - 'sint',
  - 'smth',
  - 'sp10',
  - 'sp11',
  - 'sp12',
  - 'sp13',
  - 'sp14',
  - 'sp15',
  - 'sp16',
  - 'sp17',
  - 'sp18',
  - 'sp19',
  - 'sp20',
  - 'spl2',
  - 'spl5',
  - 'spl6',
  - 'spl7',
  - 'spl8',
  - 'spl9',
  - 'splt',
  - 'sqrt',
  - 'src2',
  - 'src3',
  - 'src4',
  - 'srch',
  - 'strn',
  - 'strg',
  - 'tant',
  - 'texd',
  - 'text',
  - 'tlbn',
  - 'tmzn',
  - 'txt2',
  - 'txt3',
  - 'ucct',
  - 'wkdo',
  - 'wkds',
  - 'wkdy',
  - 'yea2',
  - 'year'
   ___

  The convention is that each transform returns a derived column or set of columns which are distinguished
  from the source column by suffix appenders to the header strings. Note that in cases of root categories
  whose family trees include multiple generations, there may be multiple inclusions of different suffix
  appenders in a single returned column. A list of included suffix appenders would be too long to include here
  since every transformation category serves as a distinct suffix appender. Note that
  the transformation functions test for suffix overlap error from creating new column with headers already
  present in dataframe and return results in final printouts and postprocess_dict['miscparameters_results']['suffixoverlap_results'].
  (Or for comparable validation results for PCA, Binary, and excl transforms see 'PCA_suffixoverlap_results',
  'Binary_suffixoverlap_results', 'excl_suffixoverlap_results'.)

   ___

  Note that as Automunge applies transformations, new column headers are derived with addition of suffix appenders with leading underscore. There is an edge case where a new column header may be derived matching one already found in the set, which would be a channel for error. All new header configurations are validated for this overlap channel and if found, reported in final printouts and aggregated in the validation result postprocess_dict['miscparameters_results']['suffixoverlap_aggregated_result']. To eliminate risk of column header overlap edge cases, one can pass column headers in df_train that omit the underscore character '\_' or otherwise inspect this validation result upon automunge(.) completion.

  - 'Binary__1010_#' / 'Binary__ord3': The columns returned from Binary transform have headers per one of these conventions. Note that if this header is already present in the data, it will instead populate as 'Binary_############_1010_#' / 'Binary_############_ord3' which includes the 12 digit random integer associated with the application number and this adjustment will be reported with validation results.
  - 'PCA__#': The columns returned from PCA dimensionality reduction have headers per this convention. Note that if this header is already present in the data, it will instead populate as 'PCA_############_#' which includes the 12 digit random integer associated with the application number and this adjustment will be reported with validation results.
  - 'Automunge_index': a reserved column header for index columns returned in ID sets. When automunge(.) is run the returned ID sets are
  populated with an index matching order of rows from original returned set, note that if this header is already present in the ID sets
  it will instead populate as 'Automunge_index_' + a 12 digit random integer associated with the application number and will be reported with validation results.

  Note that results of various validation checks such as for column header overlaps and other potential bugs are returned from
  automunge(.) in closing printouts and in the postprocess_dict as postprocess_dict['miscparameters_results'], and returned
  from postmunge(.) in the postreports_dict as postreports_dict['pm_miscparameters_results']. (If the function fails to compile
  check the printouts.) It is not a requirement, but we also recommend omitting underscore characters in strings used for
  transformation category identifiers for interpretation purposes.
   ___

  The family tree definitions reference documentation are now recorded in a separate file in the github repo titled "FamilyTrees.md".

   ___



  Ok another item on the agenda, we're going to demonstrate methods to create custom
  transformation functions, such that a user may customize the feature engineering
  while building on all of the extremely useful built in features of automunge such
  as infill methods including ML infill, feature importance, dimensionality reduction,
  preparation for class imbalance oversampling, and perhaps most importantly the
  simplest possible way for consistent processing of additional data with just a single
  function call. The transformation functions will need to be channeled through pandas
  and incorporate a handful of simple data structures, which we'll demonstrate below.

  To give a simple example, we'll demonstrate defining a custom transformation for
  z-score normalization, with an added parameter of a user configurable multiplier to
  demonstrate how we can access parameters passed through assignparam. We'll associate
  the transform with a new category we'll call 'newt' which we'll define with entries
  passed in the transformdict and processdict data structures.

  Let's create a really simple family tree for the new root category 'newt' which
  simply creates a column identifying any rows subject to infill (NArw), performs
  the z-score normalization we'll define below, and separately aggregates a collection
  of standard deviation bins with the 'bins' transform.

  ```
  transformdict = {'newt' : {'parents'       : [],
                             'siblings'      : [],
                             'auntsuncles'   : ['newt', 'bins'],
                             'cousins'       : ['NArw'],
                             'children'      : [],
                             'niecesnephews' : [],
                             'coworkers'     : [],
                             'friends'       : []}}
  ```

  Note that since this newt requires passing normalization parameters derived
  from the train set to process the test set, we'll need to create two separate
  transformation functions, the first a "custom_train" function that processes
  the train set and records normalization parameters, and the second
  a "custom_test" that only processes the test set on its own using the parameters
  derived during custom_train. (Note that if we don't need properties from the
  train set to process the test set we would only need to define a custom_train.)

  So what's being demonstrated here is that we're populating a processdict entry
  which will pass the custom transformation functions that we'll define below
  to associate them with the category for use when that category is entered in one
  of the family tree primitives associated with a root category. Note that the entries
  for custom_test and custom_inversion are both optional, and info_retention is associated
  with the inversion.

  ```
  processdict = {'newt' : {'custom_train'     : custom_train_template,
                           'custom_test'      : custom_test_template,
                           'custom_inversion' : custom_inversion_template,
                           'info_retention'   : True,
                           'NArowtype'        : 'numeric',
                           'MLinfilltype'     : 'numeric'}}
  ```
  Note that for the processdict entry key, shown here as 'newt', the convention in library
  is that this key serves as the default suffix appender for columns returned from
  the transform unless otherwise specified in assignparam.

  Note that for transforms in the custom_train convention, an initial infill is automatically
  applied as adjacent cell infill to serve as precursor to ML infill. A user may also specify
  by a 'defaultinfill' processdict entry other conventions for this initial infill associated
  with the transformation category, as one of {'adjinfill', 'meaninfill', 'medianinfill',
  'modeinfill', 'interpinfill', 'lcinfill', 'zeroinfill', 'oneinfill', 'naninfill', 'negzeroinfill'}. naninfill may be suitable
  when a custom infill is applied as part of the custom transform. If naninfill retention is
  desired for the returned data, either it may be assigned in assigninfill, or the 'NArowtype'
  processdict entry can be cast as 'exclude', noting that the latter may interfere with ML infill
  unless the feature is excluded from ML infill bases through ML_cmnd['full_exclude'].

  Note that for transforms in the custom_train convention, after the transformation function
  is applied, a data type casting is performed based on the MLinfilltype
  unless deactivated with a dtype_convert processdict entry.

  Now we have to define the custom processing functions which we are passing through
  the processdict to automunge.

  Here we'll define a "custom_train" function intended to process a train set and
  derive any properties need to process test data, which will be returned in a dictionary
  we'll refer to as the normalization_dict. Note that the normalization_dict can also
  be used to store any drift statistics we want to collect for a postmunge driftreport.
  The test data can then be prepared with the custom_test we'll demonstrate next
  (unless custom_test is omitted in the processdict in which case test data
  will be prepared with the same custom_train function).

  Now we'll define the function. (Note that if defining for the internal library
  an additional self parameter required as first argument.) Note that pandas is available
  as pd and numpy as np.
  ```
  def custom_train_template(df, column, normalization_dict):
    """
    

    
    
    

    
    

    
    

    
    

    

    
    
    
    
    

    
    
    
    
    

    
    
    

    
    

    
    

    
    
    """

    
    

    
    
    
    

    
    

    
    if 'multiplier' in normalization_dict:
      multiplier = normalization_dict['multiplier']

    
    else:
      multiplier = 1
      normalization_dict.update({'multiplier' : multiplier})

    
    mean = df[column].mean()
    stdev = df[column].std()

    
    
    if mean != mean:
      mean = 0
    if stdev != stdev or stdev == 0:
      stdev = 1

    
    normalization_dict.update({'mean' : mean,
                               'stdev': stdev})

    
    
    minimum = df[column].min()
    maximum = df[column].max()
    normalization_dict.update({'minimum' : minimum,
                               'maximum' : maximum})

    

    
    
    df[column] = (df[column] - mean) * multiplier / stdev

    

    
    
    
    

    
    
    

    
    
    
    
    

    return df, normalization_dict
  ```

  And then since this is a method that passes values between the train
  and test sets, we'll need to define a corresponding "custom_test" function
  intended for use on test data.

  ```
  def custom_test_template(df, column, normalization_dict):
    """
    
    
    
    

    
    

    
    
    
    

    
    

    
    
    
    

    
    
    """

    
    
    

    
    
    

    
    mean = normalization_dict['mean']
    stdev = normalization_dict['stdev']
    multiplier = normalization_dict['multiplier']

    
    df[column] = (df[column] - mean) * multiplier / stdev

    return df
  ```

  And finally here is an example of the convention for inverseprocess functions,
  such as may be passed to a processdict entry to support an inversion operation
  on a custom transformation function (associated with postmunge(.) inversion parameter).

  ```
  def custom_inversion_template(df, returnedcolumn_list, inputcolumn, normalization_dict):
    """
    
    

    
    
    
    
    
    

    
    

    

    
    
    """

    
    
    

    
    
    

    
    mean = normalization_dict['mean']
    stdev = normalization_dict['stdev']
    multiplier = normalization_dict['multiplier']

    
    df[inputcolumn] = 0

    
    
    returnedcolumn = returnedcolumn_list[0]

    
    df[inputcolumn] = (df[returnedcolumn] * stdev / multiplier) + mean

    return df
  ```
  Please note that if you included externally initialized functions in an automunge(.) call,
  like for custom_train transformation functions, they will need
  to be reinitialized by user prior to uploading an externally saved postprocess_dict with pickle
  in a new notebook. (This was a design decision for security considerations.) Please note that
  if you assign a multicolumn input feature set to a single root category with tree categories in
  custom_train convention by assigncat {set} bracket specification e.g. assigncat = {'newt':[{'column1', 'column2'}]} then your custom_train transform will recieve those headers as a list through normalization_dict['messy_data_headers'].

  Further details on custom transformations provided in the essay [Custom Transformations with Automunge](https://medium.com/automunge/custom-transformations-with-automunge-ae694c635a7e).

   ___



  Ok final item on the agenda, we're going to demonstrate methods to create custom
  ML infill functions for model training and inference, such that a user may integrate their
  own machine learning algorithms into the platform. We have tried to balance our options
  for alternate learning libraries from the default random forest, but recognize that
  sophisticate hyperparameter tuning is not our forte, so want to leave the option
  open for users to integrate their own implementations, such as may be for example built on
  top of XGBoost or other learning libraries.

  We'll demonstrate here templates for defining training and inference functions for
  classification and regression. These functions can be initialized externally and
  applied for ML infill and feature importance. Please note that if you included externally
  initialized functions in an automunge(.) call, like for customML inference functions
  (but not customML training functions), they will need to be reinitialized by user prior to
  uploading an externally saved postprocess_dict with pickle in a new notebook. These demonstrations
  are shown with scikit Random Forest models for simplicity. Further details on Custom ML is
  provided in the essay [Custom ML Infill with Automunge](https://medium.com/automunge/custom-ml-infill-with-automunge-5b31d7cfd4d2).

  ```
  def customML_train_classifier(labels, features, columntype_report, commands, randomseed):
    """
    

    
    
    

    
    
    
    

    
    
    
    
    

    
    

    
    
    
    
    
    

    

    
    
    
    
    
    """

    model = RandomForestClassifier(**commands)

    
    labels = labels.astype(int)

    model.fit(features, labels)

    return model

  def customML_train_regressor(labels, features, columntype_report, commands, randomseed):
    """
    

    
    

    
    

    
    

    
    
    
    

    
    
    
    """

    model = RandomForestRegressor(**commands)

    model.fit(features, labels)

    return model

  def customML_predict_classifier(features, model, commands):
    """
    

    
    
    

    

    
    """

    infill = model.predict(features)

    return infill

  def customML_predict_regressor(features, model, commands):
    """
    

    
    
    

    

    
    """

    infill = model.predict(features)

    return infill
  ```

  Having defined our custom functions, we can then pass them to an automunge(.) call through the ML_cmnd parameter.
  We can activate their use by setting ML_cmnd['autoML_type'] = 'customML'. We can pass parameters to our functions
  through ML_cmnd['autoML_type']['MLinfill_cmnd']. And we can pass our defined functions through
  ML_cmnd['autoML_type']['customML'].

  ```
  ML_cmnd = {'autoML_type' : 'customML',
             'MLinfill_cmnd' : {'customML_Classifier':{'parameter1' : value1},
                                'customML_Regressor' :{'parameter2' : value2}},
             'customML' : {'customML_Classifier_train'  : customML_train_classifier,
                           'customML_Classifier_predict': customML_predict_classifier,
                           'customML_Regressor_train'   : customML_train_regressor,
                           'customML_Regressor_predict' : customML_predict_regressor}}
  ```
  Please note that for customML autoML_type, feature importance in postmunge is performed with the default random forest. (This was a design decision that benefits privacy of custom model training when sharing postprocess_dict with third party, this way only customML inference needs to be re-initialized when uploading postprocess_dict in a separate notebook.)

  Note that the library has an internal suite of inference functions for different ML libraries
  that can optionally be used in place of a user defined customML inference function. These can
  be activated by passing a string to entries for 'customML_Classifier_predict' or  'customML_Regressor_predict'
  as one of {'tensorflow', 'xgboost', 'catboost', 'flaml', 'randomforest'}. Use of the
  internally defined inference functions allows a user to upload a postprocess_dict in a separate notebook
  without needing to first reinitialize the customML inference functions. For example, to apply a
  default inference function for the XGBoost library could apply:
  ```
  ML_cmnd = {'autoML_type' : 'customML',
             'MLinfill_cmnd' : {'customML_Classifier':{'parameter1' : value1},
                                'customML_Regressor' :{'parameter2' : value2}},
             'customML' : {'customML_Classifier_train'  : customML_train_classifier,
                           'customML_Classifier_predict': 'xgboost',
                           'customML_Regressor_train'   : customML_train_regressor,
                           'customML_Regressor_predict' : 'xgboost'}}
  ```

  And thus ML infill can run with any tabular learning library or algorithm. BYOML.
   ___



  * Please note that Automunge with 8.13 introduced what is currently an experimental implementation for final model training and inference. For example, they are well suited for training a final model in conjunction with our optuna_XG1 hyperparameter tuner using the same ML_cmnd API to select tuning options. Note that this option can apply a different model architecture or tuning options than those used for ML infill.

  - automodel(.) accepts a training set and postprocess_dict as returned from automunge(.) to automatically train a model which is saved in the postprocess_dict
  - autoinference(.) accepts a test set prepared in automunge(.) or postmunge(.) and a postprocess_dict which has been populated by automodel and returns the results of inference.
  - Note that when a model from automodel(.) is populated in a postprocess_dict, then when additional test data is prepared with that postprocess_dict in postmunge(.), if the test set does not include label features, then autoinference will automatically be called within postmunge(.) with the results of inference returned in the returned labels set we call test_labels.

  Here is an example of an automodel pipeline using gradient boosting with optuna tuning to train the final model and then running inference in postmunge:
  ```

  train, train_ID, labels, \
  val, val_ID, val_labels, \
  test, test_ID, test_labels, \
  postprocess_dict = \
  am.automunge(df_train,
               labels_column = labels_column)


  ML_cmnd = {'autoML_type'      : 'xgboost',

             'hyperparam_tuner' : 'optuna_XG1',
             'optuna_n_iter'    : 1000,
             'optuna_timeout'   : 3600,
             'optuna_kfolds'    : 5,
             'optuna_fasttune'  : True,
             'optuna_early_stop': 150,
             'optuna_max_depth_tuning_stepsize' : 1,
             }


  postprocess_dict = \
  am.automodel(train, labels, postprocess_dict,
                  ML_cmnd = ML_cmnd, encrypt_key = False,
                  printstatus = True, randomseed = False)









  val_predictions = \
  am.autoinference(val, postprocess_dict, encrypt_key = False,
                   printstatus = True, randomseed = False)



  test, test_ID, test_labels, \
  postreports_dict = \
  am.postmunge(postprocess_dict, df_test)


  df_invert, recovered_list, inversion_info_dict = \
  am.postmunge(postprocess_dict, test_labels, inversion='labels')
  ```

  We consider the final model functions automodel(.) and autoinference(.) in Beta.

   ___



  And there you have it; you now have all you need to prepare data for
  machine learning with the Automunge platform. Feedback is welcome.

  ...

  As a citation, please note that the Automunge package makes use of
  the Pandas, Scikit-learn, SciPy stats, and NumPy libraries. In addition
  to the default of Scikit-learn's Random Forest predictive models,
  Automunge also has options for ML infill using the CatBoost, FLAML,
  or XGboost libraries, and includes a hyperparameter tuning option by
  the Optuna library.

  Wes McKinney. Data Structures for Statistical Computing in Python,
  Proceedings of the 9th Python in Science Conference, 51-56 (2010)
  [publisher
  link](http://conference.scipy.org/proceedings/scipy2010/mckinney.html)

  Fabian Pedregosa, Gaël Varoquaux, Alexandre Gramfort, Vincent Michel,
  Bertrand Thirion, Olivier Grisel, Mathieu Blondel, Peter Prettenhofer,
  Ron Weiss, Vincent Dubourg, Jake Vanderplas, Alexandre Passos, David
  Cournapeau, Matthieu Brucher, Matthieu Perrot, Édouard Duchesnay.
  Scikit-learn: Machine Learning in Python, Journal of Machine Learning
  Research, 12, 2825-2830 (2011) [publisher
  link](http://jmlr.org/papers/v12/pedregosa11a.html)

  Pauli Virtanen, Ralf Gommers, Travis E. Oliphant, Matt Haberland, Tyler
  Reddy, David Cournapeau, Evgeni Burovski, Pearu Peterson, Warren
  Weckesser, Jonathan Bright, St ́efan J. van der Walt, Matthew Brett,
  Joshua Wilson, K. Jarrod Millman, Nikolay Mayorov, Andrew R. J. Nelson,
  Eric Jones, Robert Kern, Eric Larson, CJ Carey, Ilhan Polat, Yu Feng,
  Eric W. Moore, Jake Vand erPlas, Denis Laxalde, Josef Perktold, Robert
  Cim- rman, Ian Henriksen, E. A. Quintero, Charles R Harris, Anne M.
  Archibald, Antˆonio H. Ribeiro, Fabian Pedregosa, Paul van Mulbregt, and
  SciPy 1. 0 Contributors. SciPy 1.0: Fundamental Algorithms for Scientific
  Computing in Python. Nature Methods, 17:261– 272, 2020.
  doi: https://doi.org/10.1038/s41592-019-0686-2.

  S. van der Walt, S. Colbert, and G. Varoquaux. The numpy array: A
  structure for efficient numerical computation. Computing in Science
  & Engineering, 13:22–30, 2011.

  Anna Veronika Dorogush, Vasily Ershov, Andrey Gulin. CatBoost: gradient
  boosting with categorical features support [arXiv:1810.11363](https://arxiv.org/abs/1810.11363)

  Chi Wang, Qingyun Wu, Markus Weimer, Erkang Zhu. FLAML: A Fast and Lightweight AutoML Library
  [arXiv:1911.04706](https://arxiv.org/abs/1911.04706)

  Tianqi Chen, Carlos Guestrin. XGBoost: A Scalable Tree Boosting System
  [arXiv:1603.02754](https://arxiv.org/abs/1603.02754)

  Takuya Akiba, Shotaro Sano, Toshihiko Yanase, Takeru Ohta, Masanori Koyama. Optuna: A Next-generation Hyperparameter Optimization Framework. Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (2019). [arXiv:1907.10902](https://arxiv.org/abs/1907.10902#)

  ...

  Please note that this list of citations is not exhaustive, we have had several additional influences that are cited in the papers of the [Automunge Medium Publication](https://medium.com/automunge).

  ...

  As a quick clarification on the various permutations of the term “Automunge” used in codebase:

  Automunge - The name of the library which prepares data for machine learning. Note that Automunge Inc. is doing business as Automunge. Note that imports are conducted by “pip install Automunge”. Note that Automunge is also the name of a folder in the GitHub repository. "Automunge" is a registered trademark.

  AutoMunge - name of a defined class in the Automunge library. Note that jupyter notebook initializations are recommended as
  ```
  from Automunge import *
  am = AutoMunge()
  ```

  Note that AutoMunge is also used as the title of a GitHub repository published by the Automunge account where we have been sharing code.

  Automunger - name of a file published in GitHub repository (as Automunger.py) which is saved in the folder titled Automunge

  automunge(.) - name of a function defined in the AutoMunge class in the Automunge library which is the central interface for initial preparations of data.

  postmunge(.) - name of a function defined in the AutoMunge class in the Automunge library which is the central interface for subsequent preparations of additional data on the same basis.

  ...

  Please note that the pickle library has a security vulnerability when loading an object of unknown origin. We do not use pickle in our codebase but suggested use above for downloading a returned postprocess_dict because of its ability to serialize and download arbitrary python objects. If you intend to distribute a pickled postprocess_dict publicly, the [python docs](https://docs.python.org/3/library/pickle.html) suggest signing the data with [hmac](https://docs.python.org/3/library/hmac.html#module-hmac) to ensure that it has not been tampered with.

  ...

  Please note that Automunge imports make use of the Pandas, Scikit-Learn, Numpy, and Scipy Stats libraries
  which are released under a 3-Clause BSD license. We include options that may import the
  Catboost or XGBoost libraries which are released under the Apache License 2.0, as well as options for the FLAML and Optuna libraries which are released under a MIT License.

  ...

  Have fun munging!!

  ...

  You can read more about the tool through the blog posts documenting the
  development online at the [Automunge Medium Publication](https://medium.com/automunge)
  or for more writing there is a related collection of essays titled [From
  the Diaries of John Henry](https://turingsquared.com).

  The Automunge website is helpfully located at
  [automunge.com](https://automunge.com).

  If you are looking for something to cite, our paper [Tabular Engineering with Automunge](https://datacentricai.org/papers/15_CameraReady_TabularEngineering_102621_Final.pdf) was accepted to the 2021 NeurIPS Data-Centric AI workshop.

  ...

  This file is part of Automunge which is released under the BSD-3-Clause license.
  See file LICENSE or go to https://github.com/Automunge/AutoMunge for full license details.

  contact available via [automunge.com](https://automunge.com)

  Copyright (C) 2018, 2019, 2020, 2021, 2022, 2023 - All Rights Reserved

  Patent Pending


